nexscope-ai/nexscope-ecommerce-skills / ecommerce-amazon-category-lookup
ecommerce.amazon-category-lookup
VerifiedBrowse Amazon category nodes by parent identifier or search category metadata by name. Use this skill when the user asks for this exact ecommerce workflow, analysis, data lookup, or deliverable.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 5.9 KB |
| manifest.json | config | 618 B |
| references/api.json | config | 1.1 KB |
| references/api.md | markdown | 3.6 KB |
| references/credentials.md | markdown | 984 B |
| references/testing.md | markdown | 1.0 KB |
| references/workflow.md | markdown | 1.2 KB |
| scripts/amazon_category_lookup.py | script | 11.2 KB |
scripts/amazon_category_lookup.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 amazon_category_lookup.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_LOOKUP = "/api/v1/tools/research/amazon/nodes/lookup"
API_PATH_LIKE = "/api/v1/tools/research/amazon/nodes/lookup/like"
SLUG = "nexscope-amazon-category-lookup"
SMALL_THRESHOLD = 8000
CACHE_TTL_SEC = 24 * 60 * 60
_SESSION_CACHE: dict[str, str] = {}
def get_api_base() -> str:
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(mode: str) -> str:
if mode == "like":
return get_api_base() + API_PATH_LIKE
return get_api_base() + API_PATH_LOOKUP
def get_api_key() -> str:
key = os.environ.get("NEXSCOPE_API_KEY") or os.environ.get("NEXSCOPE_API_KEY")
if not key:
print(
"API Key not configured. Please complete authorization first:\n"
"1. Visit to obtain your Key\n"
"2. Set the environment variable: export NEXSCOPE_API_KEY=your-key-here",
file=sys.stderr,
)
sys.exit(1)
return key
def call_api(mode: str, params: dict) -> dict:
api_url = get_api_url(mode)
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(mode: str, params: dict) -> str:
raw = json.dumps({"mode": mode, **params}, ensure_ascii=False, sort_keys=True)
return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
def _cache_path(mode: str, params: dict) -> str:
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(mode, params)}.json")
def _load_cache(path: str):
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: str, payload) -> None:
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):
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) -> None:
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",
"size", "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:
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:
cached = _SESSION_CACHE.get("_root")
if cached:
return cached
candidates = []
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"))
candidates.append(os.path.join(os.getcwd(), "nexscope"))
candidates.append(os.path.join(os.path.expanduser("~"), "nexscope"))
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 _ensure_session(ts: float) -> tuple:
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:
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:
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:
_, 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: float) -> str:
return resolve_data_path(SLUG, ts)
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:
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 main():
argv = sys.argv[1:]
inline = False
use_cache = True
mode = "lookup"
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 "--mode" in argv:
idx = argv.index("--mode")
if idx + 1 < len(argv):
mode = argv[idx + 1]
argv = argv[:idx] + argv[idx + 2:]
else:
print("--mode requires a value: lookup or like", file=sys.stderr)
sys.exit(1)
if mode not in ("lookup", "like"):
print(f"Invalid --mode '{mode}'. Must be 'lookup' or 'like'.", file=sys.stderr)
sys.exit(1)
if not argv:
print(
"Usage: amazon_category_lookup.py --mode lookup|like '<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)
if not isinstance(params, dict):
sys.exit("Parameters must be a JSON object")
if mode == "like" and not params.get("nodeLabel"):
sys.exit("Missing required parameter for like mode: nodeLabel")
cache_path = _cache_path(mode, params)
result = _load_cache(cache_path) if use_cache else None
if result is None:
result = call_api(mode, params)
if use_cache:
_save_cache(cache_path, result)
serialized = json.dumps(result, ensure_ascii=False, indent=2)
ts = time.time()
out_path = _resolve_output_path(ts)
try:
with open(out_path, "w", encoding="utf-8") 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 |