nexscope-ai/nexscope-ecommerce-skills / ecommerce-amazon-product-research-api
ecommerce.amazon-product-research-api
VerifiedRoute Amazon product-selection work across market, keyword, competitor, trend, review, and profitability capabilities. Use this skill when the user asks for this exact ecommerce workflow, analysis, data lookup, or deliverable.
scripts/sorftime_product_search.py
View on GitHub#!/usr/bin/env python3
import sys as _nexscope_help_sys
if "--help" in _nexscope_help_sys.argv or "-h" in _nexscope_help_sys.argv:
print('Usage: python sorftime_product_search.py [arguments]')
raise SystemExit(0)
"""Provider-neutral implementation documentation."""
import json
import hashlib
import os
import sys
import time
import secrets
from urllib.request import urlopen, Request
from urllib.error import HTTPError, URLError
API_PATH = "/api/v1/tools/research/sorftime/amazon/productQuery"
SLUG = "nexscope-sorftime-amazon-product-query"
# implementation,implementation,implementation
SMALL_THRESHOLD = 8000
CACHE_TTL_SEC = 24 * 60 * 60
_SESSION_CACHE: dict[str, str] = {}
def get_api_base() -> str:
"""value:env NEXSCOPE_PROXY_BASE value,value。"""
base = (os.environ.get("NEXSCOPE_PROXY_BASE") or "").rstrip("/")
if not base:
raise RuntimeError("Set NEXSCOPE_PROXY_BASE before running this gateway client")
return base
def get_api_url():
return get_api_base() + API_PATH
def get_api_key():
"""Provider-neutral implementation documentation."""
key = os.environ.get("NEXSCOPE_API_KEY") or os.environ.get("NEXSCOPE_API_KEY")
if not key:
print(
"API Key value",
file=sys.stderr,
)
sys.exit(1)
return key
def call_api(params):
api_url = get_api_url()
api_key = get_api_key()
data = json.dumps(params).encode("utf-8")
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"User-Agent": "Nexscope-Skill/2.0",
"SESSION_ID": os.environ.get("SESSION_ID", ""),
"MESSAGE_ID": os.environ.get("MESSAGE_ID", ""),
"MODE_ID": os.environ.get("MODE_ID", ""),
"APP_NAME": os.environ.get("APP_NAME", ""),
}
req = Request(
api_url,
data=data,
headers=headers,
method="POST",
)
try:
with urlopen(req, timeout=120) as response:
return json.loads(response.read().decode("utf-8"))
except HTTPError as e:
body = e.read().decode("utf-8") if e.fp else ""
try:
return json.loads(body) if body else {"error": f"HTTP {e.code}: {e.reason}"}
except Exception:
return {"error": f"HTTP {e.code}: {e.reason}", "details": body}
except URLError as e:
return {"error": f"Connection failed: {e.reason}"}
def _cache_key(params):
raw = json.dumps(params, ensure_ascii=False, sort_keys=True)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
def _cache_path(params):
cwd = os.getcwd()
path = os.path.join(cwd, "nexscope", ".cache", SLUG)
os.makedirs(path, exist_ok=True)
return os.path.join(path, f"{SLUG}-{_cache_key(params)}.json")
def _load_cache(path):
if not os.path.isfile(path):
return None
if time.time() - os.path.getmtime(path) > CACHE_TTL_SEC:
return None
try:
with open(path, encoding="utf-8") as f:
payload = json.load(f)
if isinstance(payload, dict):
payload.setdefault("_cache", {})["hit"] = True
return payload
except (OSError, json.JSONDecodeError):
return None
def _save_cache(path, payload):
try:
with open(path, "w", encoding="utf-8") as f:
json.dump(payload, f, ensure_ascii=False, indent=2)
except OSError:
pass
def _find_main_list(obj):
"""value list value。value,value。"""
best = (None, None, -1)
def walk(node, path):
nonlocal best
if isinstance(node, list):
if len(node) > best[2]:
best = (path, node, len(node))
elif isinstance(node, dict):
for k, v in node.items():
walk(v, f"{path}.{k}" if path else k)
walk(obj, "")
return best[0], best[1]
def summarize(result):
"""value。"""
if not isinstance(result, dict):
print(f"Response type: {type(result).__name__}")
print(json.dumps(result, ensure_ascii=False)[:500])
return
print(f"Top-level keys: {list(result.keys())}")
for k in ("errcode", "errorCode", "code", "errmsg", "msg",
"total", "totalCount", "count", "currentPage", "perPage",
"costToken", "costTime", "success"):
if k in result:
v = result[k]
if isinstance(v, (int, float, bool, str)):
print(f" {k}: {v}")
list_path, main_list = _find_main_list(result)
if list_path is not None and main_list:
print(f"\nMain list field: `{list_path}` (length={len(main_list)})")
sample = main_list[:3]
print(f"Sample (first {len(sample)} of {len(main_list)}):")
print(json.dumps(sample, indent=2, ensure_ascii=False))
def _ensure_meta(root: str, session_dir: str, date_str: str, sid: str, ts: float) -> None:
"""value _meta.json,value index.jsonl value。"""
meta_path = os.path.join(session_dir, "_meta.json")
if os.path.exists(meta_path):
return
meta = {
"session_id": sid,
"date": date_str,
"started_at": _format_iso(ts),
"skills_called": [],
"deliverables": [],
"data_files": [],
"media_files": [],
}
with open(meta_path, "w", encoding="utf-8") as f:
json.dump(meta, f, ensure_ascii=False, indent=2)
try:
with open(os.path.join(root, "index.jsonl"), "a", encoding="utf-8") as f:
f.write(
json.dumps(
{
"session_id": sid,
"date": date_str,
"path": os.path.relpath(session_dir, root),
"started_at": _format_iso(ts),
},
ensure_ascii=False,
)
+ "\n"
)
except OSError:
pass
def _nexscope_root() -> str:
"""Provider-neutral implementation documentation."""
cached = _SESSION_CACHE.get("_root")
if cached:
return cached
candidates = []
# 1. NEXSCOPE_WORKSPACES(implementation,implementation)
acpx = (os.environ.get("NEXSCOPE_WORKSPACES") or "").strip()
if acpx:
acpx = acpx.split(os.pathsep)[0].strip()
if acpx:
candidates.append(os.path.join(acpx, "nexscope"))
# 2. implementation
candidates.append(os.path.join(os.getcwd(), "nexscope"))
# 3. implementation
candidates.append(os.path.join(os.path.expanduser("~"), "nexscope"))
# 4. implementation
import tempfile
candidates.append(os.path.join(tempfile.gettempdir(), "nexscope"))
for root in candidates:
try:
os.makedirs(root, exist_ok=True)
probe = os.path.join(root, ".write_probe")
with open(probe, "w", encoding="utf-8") as f:
f.write("")
os.remove(probe)
except OSError:
continue
root = os.path.abspath(root)
_SESSION_CACHE["_root"] = root
return root
fallback = os.path.abspath(candidates[-1])
_SESSION_CACHE["_root"] = fallback
return fallback
def _format_iso(ts: float) -> str:
return time.strftime("%Y-%m-%dT%H:%M:%S%z", time.localtime(ts))
def _session_id(ts: float) -> str:
"""value env SESSION_ID;value HHMMSS-<6 hex> value(value)。"""
env = os.environ.get("SESSION_ID")
if env:
return env.strip()
if "_auto" not in _SESSION_CACHE:
_SESSION_CACHE["_auto"] = (
time.strftime("%H%M%S", time.localtime(ts)) + "-" + secrets.token_hex(3)
)
return _SESSION_CACHE["_auto"]
def _ensure_session(ts: float) -> tuple[str, str]:
"""value (nexscope_root, session_dir);session_dir value。"""
date_str = time.strftime("%Y-%m-%d", time.localtime(ts))
sid = _session_id(ts)
root = _nexscope_root()
session_dir = os.path.join(root, date_str, sid)
os.makedirs(session_dir, exist_ok=True)
_ensure_meta(root, session_dir, date_str, sid, ts)
return root, session_dir
def _update_meta(session_dir: str, *, skill: str, kind: str, file_rel: str, ts: float) -> None:
"""value _meta.json value。kind ∈ {data, deliverable, media}。"""
meta_path = os.path.join(session_dir, "_meta.json")
try:
with open(meta_path, encoding="utf-8") as f:
meta = json.load(f)
except (OSError, json.JSONDecodeError):
return
if skill and skill not in meta.setdefault("skills_called", []):
meta["skills_called"].append(skill)
bucket = {"data": "data_files", "deliverable": "deliverables", "media": "media_files"}.get(
kind, "data_files"
)
files = meta.setdefault(bucket, [])
if file_rel not in files: # implementation:implementation
files.append(file_rel)
meta["last_used_at"] = _format_iso(ts)
with open(meta_path, "w", encoding="utf-8") as f:
json.dump(meta, f, ensure_ascii=False, indent=2)
def resolve_data_path(slug: str, ts: float, ext: str = "json") -> str:
"""standard skill value <session>/data/<slug>-<ts>.<ext>。"""
_, session_dir = _ensure_session(ts)
sub = os.path.join(session_dir, "data")
os.makedirs(sub, exist_ok=True)
out = os.path.join(sub, f"{slug}-{int(ts * 1_000_000)}.{ext}")
_update_meta(session_dir, skill=slug, kind="data", file_rel=os.path.relpath(out, session_dir), ts=ts)
return out
def _resolve_output_path(ts):
"""value <cwd>/nexscope/<value>/<session>/data/<slug>-<ts>.json,value SESSION_ID value。"""
return resolve_data_path(SLUG, ts)
def main():
argv = sys.argv[1:]
inline = False
use_cache = True
if "--inline" in argv:
inline = True
argv = [a for a in argv if a != "--inline"]
if "--no-cache" in argv:
use_cache = False
argv = [a for a in argv if a != "--no-cache"]
if not argv:
print(
"Usage: sorftime_product_search.py '<JSON parameters>' [--inline]",
file=sys.stderr,
)
sys.exit(1)
try:
params = json.loads(argv[0])
except json.JSONDecodeError as e:
print(f"Invalid parameter format: {e}", file=sys.stderr)
sys.exit(1)
cache_path = _cache_path(params)
result = _load_cache(cache_path) if use_cache else None
if result is None:
result = call_api(params)
if use_cache:
_save_cache(cache_path, result)
serialized = json.dumps(result, ensure_ascii=False, indent=2)
ts = int(time.time())
out_path = _resolve_output_path(ts)
try:
with open(out_path, "w") as f:
f.write(serialized)
print(f"Saved full response: {out_path} ({len(serialized)} bytes)")
if result.get("_cache", {}).get("hit"):
print(f"Cache hit: {cache_path}")
except OSError as e:
print(f"Failed to save to {out_path}: {e}", file=sys.stderr)
if inline or len(serialized.encode("utf-8")) <= SMALL_THRESHOLD:
if result.get("_cache", {}).get("hit"):
print(f"Cache hit: {cache_path}", file=sys.stderr)
print(serialized)
else:
summarize(result)
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |