Skip to content

nexscope-ai/nexscope-ecommerce-skills / ecommerce-amazon-product-research-api

ecommerce.amazon-product-research-api

Verified

Route 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.

FileKindSize
SKILL.mdskill md8.3 KB
manifest.jsonconfig3.5 KB
references/aba-intelligent-query.mdmarkdown1.6 KB
references/amazon-alexa-search.mdmarkdown1.5 KB
references/amazon-opportunity-report-by-keyword.mdmarkdown1.6 KB
references/amazon-opportunity-search-by-metrics.mdmarkdown1.5 KB
references/amazon-product-detail.mdmarkdown1.5 KB
references/amazon-reviews-list.mdmarkdown1.6 KB
references/amazon-search-by-image.mdmarkdown2.7 KB
references/amazon-search.mdmarkdown1.6 KB
references/api.jsonconfig16.4 KB
references/api.mdmarkdown14.3 KB
references/credentials.mdmarkdown1.2 KB
references/jiimore-get-niche-info-by-keyword.mdmarkdown1.6 KB
references/jiimore-get-niche-info.mdmarkdown1.5 KB
references/jiimore-get-niche-review-from-keyword.mdmarkdown1.6 KB
references/jiimore-page-asins-by-asin.mdmarkdown1.6 KB
references/jiimore-product-discovery.mdmarkdown1.5 KB
references/junglescout-keyword-by-asin.mdmarkdown1.6 KB
references/junglescout-keyword-by-keyword.mdmarkdown1.6 KB
references/junglescout-keyword-history.mdmarkdown1.6 KB
references/junglescout-keyword-share-of-voice.mdmarkdown1.6 KB
references/junglescout-product-database.mdmarkdown1.6 KB
references/junglescout-sales-estimates.mdmarkdown1.7 KB
references/keepa-product-request.mdmarkdown1.6 KB
references/keepa-product-search.mdmarkdown1.6 KB
references/keepa-product-series.mdmarkdown1.6 KB
references/onboarding.mdmarkdown1.4 KB
references/sellersprite-competitor-lookup.mdmarkdown1.6 KB
references/sellersprite-market-research.mdmarkdown1.6 KB
references/sellersprite-market-statistics.mdmarkdown1.5 KB
references/sellersprite-product-search.mdmarkdown1.6 KB
references/sellersprite-traffic-keyword.mdmarkdown1.5 KB
references/sif-asin-keywords.mdmarkdown1.5 KB
references/sif-asin-summary.mdmarkdown1.5 KB
references/sif-keyword-overview.mdmarkdown1.5 KB
references/sif-keyword-summary.mdmarkdown1.5 KB
references/sorftime-amazon-product-detail.mdmarkdown1.6 KB
references/sorftime-amazon-product-query.mdmarkdown1.6 KB
references/testing.mdmarkdown1.6 KB
references/workflow.mdmarkdown1.3 KB
scripts/aba_query.pyscript10.9 KB
scripts/amazon_alexa_search.pyscript10.9 KB
scripts/amazon_opportunity_report.pyscript11.0 KB
scripts/amazon_opportunity_screener.pyscript11.0 KB
scripts/amazon_product_detail.pyscript10.9 KB
scripts/amazon_reviews.pyscript10.9 KB
scripts/amazon_search.pyscript10.9 KB
scripts/amazon_search_by_image.pyscript10.9 KB
scripts/jiimore_get_niche_info.pyscript10.9 KB
scripts/jiimore_get_niche_info_by_keyword.pyscript11.0 KB
scripts/jiimore_get_niche_review.pyscript11.0 KB
scripts/jiimore_page_asins_by_asin.pyscript10.9 KB
scripts/jiimore_product_discovery.pyscript10.9 KB
scripts/junglescout_keyword_by_asin.pyscript11.0 KB
scripts/junglescout_keyword_by_keyword.pyscript11.0 KB
scripts/junglescout_keyword_history.pyscript11.0 KB
scripts/junglescout_keyword_sov.pyscript11.0 KB
scripts/junglescout_product_database.pyscript11.0 KB
scripts/junglescout_sales_estimates.pyscript11.0 KB
scripts/keepa_product_detail.pyscript10.9 KB
scripts/keepa_product_history.pyscript10.9 KB
scripts/keepa_product_search.pyscript10.9 KB
scripts/onboarding.pyscript22.3 KB
scripts/sellersprite_competitor_lookup.pyscript11.0 KB
scripts/sellersprite_market_research.pyscript11.0 KB
scripts/sellersprite_market_statistics.pyscript11.0 KB
scripts/sellersprite_product_search.pyscript11.0 KB
scripts/sellersprite_traffic_keyword.pyscript11.0 KB
scripts/sif_asin_keywords.pyscript10.9 KB
scripts/sif_asin_summary.pyscript10.9 KB
scripts/sif_keyword_overview.pyscript10.9 KB
scripts/sif_keyword_traffic.pyscript10.9 KB
scripts/sorftime_product_detail.pyscript11.0 KB
scripts/sorftime_product_search.pyscript10.9 KB
scripts/upload_image.pyscript6.7 KB

scripts/sellersprite_traffic_keyword.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 sellersprite_traffic_keyword.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/sellersprite/traffic/keyword"
SLUG = "nexscope-sellersprite-traffic-keyword"

# 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: sellersprite_traffic_keyword.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()
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: 472kUpdated Claude CodeCodexVerifiedInstall
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: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
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 availableStars: 322kUpdated Claude CodeCodexVerifiedInstall