nexscope-cli 0.1.0__py3-none-any.whl

nexscope_cli/workflows/compare.py

@@ -0,0 +1,213 @@
+# Copyright 2026 Nexscope
+# SPDX-License-Identifier: Apache-2.0
+"""A single task entry: plan, optional search, details, evidence and report."""
+from datetime import datetime, timezone
+import hashlib
+import json
+
+from ..capabilities.catalog import DOMAINS
+from ..capabilities.plan import plan
+from ..core.datasets import product
+from ..core.evidence import Artifacts, decode, read_bundle, validate_request
+from ..core.errors import Failure
+from ..reports.compare import render_format
+from ..reports.formats import FORMATS
+
+
+def read_candidates(folder):
+    bundle = read_bundle(folder)
+    if set(bundle) != {'plan.json', 'request-1.json', 'candidates.json', 'result.json'}:
+        raise Failure('Resume requires a completed candidates-only output; failed calls are never replayed.')
+    previous = decode(bundle['plan.json'])
+    result = decode(bundle['result.json'])
+    search = validate_request(decode(bundle['request-1.json']))
+    if (not isinstance(previous, dict) or previous.get('schemaVersion') != 'nexscope.comparison-plan.v1'
+            or previous.get('status') != 'PLANNED' or type(previous.get('maxCalls')) is not int
+            or previous.get('marketplace') not in DOMAINS
+            or previous.get('authMode') not in ('browser-account', 'env-api-key')
+            or previous.get('asins') is not None or previous.get('selectedAsins') is not None
+            or previous.get('importedSearch') is not None or not previous.get('keyword')
+            or not isinstance(result, dict) or result.get('schemaVersion') != 'nexscope.comparison-result.v1'
+            or result.get('status') != 'CANDIDATES_READY' or result.get('error') != 'SELECTION_REQUIRED'
+            or result.get('sourceType') not in ('mock', 'remote')):
+        raise Failure('Resume requires a versioned CANDIDATES_READY comparison checkpoint.')
+    rebuilt = workflow_plan(keyword=previous['keyword'], market=previous.get('marketplace'),
+                            max_calls=previous.get('maxCalls'), auth_mode=previous.get('authMode'))
+    execution = previous.get('execution')
+    if (not isinstance(execution, dict) or execution.get('sourceType') != result['sourceType']
+            or execution.get('origin') != search['origin'] or execution.get('requestsSent') != 0
+            or previous.get('maximumRequests') != 1 or search['capability'] != 'amazon-search'
+            or search['status'] != 'SUCCESS' or search['cacheHit'] or search['sequence'] != 1
+            or search['authMode'] != rebuilt['authMode'] or search['params'] != rebuilt['steps'][0]['requests'][0]['body']
+            or not isinstance(previous.get('steps'), list) or len(previous['steps']) != 1
+            or not isinstance(previous['steps'][0], dict)
+            or previous['steps'][0].get('requests') != rebuilt['steps'][0]['requests']
+            or previous['steps'][0].get('capability') != 'amazon-search'
+            or previous['steps'][0].get('contractVersion') != search['contractVersion']
+            or previous['steps'][0].get('source') != search['source']
+            or not isinstance(previous['steps'][0].get('auth'), dict)
+            or previous['steps'][0]['auth'].get('mode') != search['authMode']
+            or previous['steps'][0]['auth'].get('origin') != search['origin']
+            or (result['sourceType'] == 'mock' and search['origin'] != 'https://mock.invalid')):
+        raise Failure('Checkpoint plan and search evidence disagree.')
+    candidates = search['response']['data']['products']
+    budget = result.get('budget')
+    if (decode(bundle['candidates.json']) != candidates or result.get('candidates') != candidates
+            or not isinstance(budget, dict) or type(budget.get('requestsSent')) is not int or budget['requestsSent'] != 1
+            or budget.get('maxCalls') != rebuilt['maxCalls'] or budget.get('cacheHits') != 0
+            or budget.get('stoppedAfterFailure') is not False):
+        raise Failure('Checkpoint candidates or accounting disagree with search evidence.')
+    return previous, result, search, bundle
+
+
+def workflow_plan(*, asins=None, keyword=None, resume=None, selected=None, market=None, max_calls=None, auth_mode=None, api_base=None):
+    if sum(bool(value) for value in (asins, keyword, resume)) != 1:
+        raise Failure('Provide exactly one of asins, keyword or resume.')
+    history = None
+    if resume:
+        previous, result, search, bundle = read_candidates(resume)
+        if ((market is not None and market != previous['marketplace'])
+                or (auth_mode is not None and auth_mode != previous['authMode'])
+                or (api_base is not None and api_base.rstrip('/') != search['origin'])):
+            raise Failure('Resume must keep the original marketplace, authentication mode and origin.')
+        market, auth_mode = previous['marketplace'], previous['authMode']
+        if auth_mode == 'browser-account':
+            api_base = search['origin']
+        max_calls = previous['maxCalls'] if max_calls is None else max_calls
+        if type(max_calls) is not int or max_calls > previous['maxCalls']:
+            raise Failure('Resume cannot increase the original max-calls budget.')
+        if not selected:
+            raise Failure('Resume requires select-asins from the saved candidates.')
+        if not set(selected.split(',')) <= {row['asin'] for row in search['response']['data']['products']}:
+            raise Failure('Selected ASINs must come from the saved search evidence.')
+        history = {'historical': True, 'sourceType': result['sourceType'], 'authMode': search['authMode'],
+                   'origin': search['origin'], 'fetchedAt': search['fetchedAt'], 'cacheHit': False,
+                   'evidenceFile': 'request-1.json', 'planFile': 'search-plan.json',
+                   'planSha256': hashlib.sha256(bundle['plan.json']).hexdigest(), 'requestsSent': 1}
+    market = market if market is not None else 'amazon.com'
+    auth_mode = auth_mode if auth_mode is not None else 'browser-account'
+    max_calls = max_calls if max_calls is not None else 4
+    if market not in DOMAINS:
+        raise Failure('Choose a supported Amazon marketplace.')
+    if selected and not (keyword or resume):
+        raise Failure('select-asins is only valid with keyword search.')
+    if asins or selected:
+        detail = plan('amazon-product-detail', {'asins': asins or selected, 'amazonDomain': market}, auth_mode=auth_mode, max_calls=max_calls, api_base=api_base)
+        if len(detail['requests']) < 2:
+            raise Failure('A comparison requires two or three distinct ASINs.')
+    else:
+        detail = None
+    search = plan('amazon-search', {'keyword': keyword, 'amazonDomain': market}, auth_mode=auth_mode, max_calls=max_calls, api_base=api_base) if keyword else None
+    maximum = (len(detail['requests']) if detail else 0) + (1 if search or history else 0)
+    if maximum > max_calls:
+        raise Failure('Search plus details exceeds max-calls; no requests were sent.')
+    return {'schemaVersion': 'nexscope.comparison-plan.v1', 'status': 'PLANNED',
+            'authMode': auth_mode, 'marketplace': market, 'asins': asins, 'keyword': keyword,
+            'selectedAsins': selected, 'maximumRequests': maximum, 'maxCalls': max_calls,
+            'estimatedCredits': None, 'billingCap': None, 'requestsSent': 1 if history else 0,
+            'newRequests': maximum - (1 if history else 0), 'importedSearch': history,
+            'selectionPolicy': 'explicit-ASINs-only; otherwise return candidates',
+            'steps': [item for item in (search, detail) if item], 'liveExecutionAvailable': False}
+
+
+def compare(executor, folder, *, asins=None, keyword=None, resume=None, selected=None, market=None, mock=False, format='html', allow_paid=False):
+    if not mock and not allow_paid:
+        raise Failure('LIVE_EXECUTION_UNAVAILABLE: remote execution requires explicit --allow-paid authorization.')
+    source_type = 'mock' if mock else 'remote'
+    if format not in (*FORMATS, 'all'):
+        raise Failure('Choose html, csv, markdown or all.')
+    execution_plan = workflow_plan(asins=asins, keyword=keyword, resume=resume, selected=selected, market=market,
+                                   max_calls=executor.max_calls, auth_mode=executor.context.mode,
+                                   api_base=executor.context.base if executor.context.mode == 'browser-account' else None)
+    market = execution_plan['marketplace']
+    if executor.sent or executor.results or executor.imported_results:
+        raise Failure('A comparison requires a fresh executor and its own request budget.')
+    imported = execution_plan['importedSearch']
+    if imported and (imported['sourceType'] != source_type or imported['origin'] != executor.context.base):
+        raise Failure('Resume must keep the original source type and authentication origin.')
+    execution_plan['execution'] = {'sourceType': source_type, 'origin': executor.context.base, 'requestsSent': 0}
+    execution_plan['liveExecutionAvailable'] = allow_paid and not mock
+    execution_plan['reportFormat'] = format
+    for step in execution_plan['steps']:
+        step['auth'].update(origin=executor.context.base, originSource='fictional mock transport' if mock else 'selected authentication context')
+    artifacts = Artifacts(folder, execution_plan)
+    if resume:
+        _, _, historical_search, bundle = read_candidates(resume)
+        artifacts.write_bytes('search-plan.json', bundle['plan.json'])
+        artifacts.write_bytes('search-result.json', bundle['result.json'])
+        for name in ('request-1.json', 'candidates.json'):
+            artifacts.write_bytes(name, bundle[name])
+        executor.imported_results = [historical_search]
+    executor.record = artifacts.record
+    chosen = asins or selected
+    if keyword:
+        search = executor.execute('amazon-search', {'keyword': keyword, 'amazonDomain': market})[0]
+        candidates = search['response']['data']['products'] if search['status'] == 'SUCCESS' else []
+        artifacts.write('candidates.json', candidates)
+        available = {row['asin'] for row in candidates}
+        if search['status'] != 'SUCCESS' or not chosen or not set(chosen.split(',')) <= available:
+            status = 'CANDIDATES_READY' if search['status'] == 'SUCCESS' and not chosen else 'FAILED'
+            result = {'schemaVersion': 'nexscope.comparison-result.v1', 'status': status, 'sourceType': source_type, 'report': None,
+                      'error': 'SELECTION_REQUIRED' if status == 'CANDIDATES_READY' else 'SEARCH_OR_SELECTION_FAILED',
+                      'candidates': candidates, 'output': str(artifacts.root), 'budget': executor.summary()}
+            artifacts.write('result.json', dict(result, output='.'))
+            artifacts.finish()
+            return result
+    details = executor.execute('amazon-product-detail', {'asins': chosen, 'amazonDomain': market})
+    rows = [product(result, market) for result in details if result['status'] == 'SUCCESS']
+    for row in rows:
+        evidence_file = artifacts.root / row['extra']['evidenceFile']
+        row['extra']['evidenceSha256'] = hashlib.sha256(evidence_file.read_bytes()).hexdigest()
+    errors = [{'asin': result['params']['asins'], 'status': result['status'], 'error': result['error']}
+              for result in details if result['status'] != 'SUCCESS']
+    status = ('COMPLETE' if not errors else 'PARTIAL') if len(rows) >= 2 else 'INSUFFICIENT_DATA'
+    digest = hashlib.sha256((artifacts.root / 'plan.json').read_bytes()).hexdigest()
+    dataset = {'schemaVersion': 1, 'sourceType': source_type, 'inputName': 'plan.json', 'inputSha256': digest,
+               'importedAt': datetime.now(timezone.utc).isoformat(), 'products': rows,
+               'collectionStatus': status, 'errors': errors, 'budget': executor.summary()}
+    artifacts.write('dataset.json', dataset)
+    result = {'schemaVersion': 'nexscope.comparison-result.v1', 'status': status, 'sourceType': source_type, 'requested': len(chosen.split(',')),
+              'succeeded': len(rows), 'errors': errors, 'budget': executor.summary(),
+              'output': str(artifacts.root), 'report': None, 'reports': {},
+              'liveRequests': 0 if mock else executor.summary()['requestsSent'],
+              'liveRequestsThisRun': 0 if mock else executor.sent}
+    if len(rows) >= 2:
+        # Report beside its evidence; all links stay relative when sharing folder.
+        for selected_format in FORMATS if format == 'all' else (format,):
+            report = artifacts.root / ('comparison' + FORMATS[selected_format])
+            with report.open('x', encoding='utf-8', newline='') as stream:
+                stream.write(render_format(dataset, '.', selected_format))
+            result['reports'][selected_format] = str(report)
+        result['report'] = next(iter(result['reports'].values()))
+        result['reportFormat'] = format
+    artifacts.write('result.json', dict(result, output='.',
+                    report=next((('comparison' + FORMATS[name]) for name in result['reports']), None),
+                    reports={name: 'comparison' + FORMATS[name] for name in result['reports']}))
+    artifacts.finish()
+    return result
+
+
+def command(args):
+    if args.mock and args.api_base is not None:
+        raise Failure('Mock workflow uses a fictional origin only; omit --api-base.')
+    execution_plan = workflow_plan(asins=args.asins, keyword=args.keyword, resume=args.resume, selected=args.select_asins,
+                                   market=args.market, max_calls=args.max_calls, auth_mode=args.auth_mode, api_base=args.api_base)
+    args.market, args.max_calls, args.auth_mode = execution_plan['marketplace'], execution_plan['maxCalls'], execution_plan['authMode']
+    imported = execution_plan['importedSearch']
+    if imported and imported['sourceType'] != ('mock' if args.mock else 'remote'):
+        raise Failure('Resume must keep the original source type; choose the same mock or remote execution mode.')
+    if args.dry_run:
+        execution_plan['reportFormat'] = args.format
+        return execution_plan
+    if not args.mock and not args.allow_paid:
+        raise Failure('LIVE_EXECUTION_UNAVAILABLE: --execute requires --mock or explicit --allow-paid.')
+    if args.mock and args.allow_paid:
+        raise Failure('Choose mock execution or paid execution, not both.')
+    if not args.out:
+        raise Failure('Choose a new output directory with --out.')
+    if imported and args.auth_mode == 'browser-account':
+        args.api_base = imported['origin']
+    from ..core.remote import engine_for
+    engine = engine_for(args)
+    return compare(engine, args.out, asins=args.asins, keyword=args.keyword, resume=args.resume,
+                   selected=args.select_asins, market=args.market, mock=bool(args.mock), format=args.format, allow_paid=args.allow_paid)

nexscope_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: nexscope-cli
+Version: 0.1.0
+Summary: Offline product comparison reports and bounded Nexscope ecommerce data workflows
+Author: Nexscope
+License-Expression: Apache-2.0
+Project-URL: Repository, https://github.com/nexscope-ai/nexscope-cli
+Project-URL: Issues, https://github.com/nexscope-ai/nexscope-cli/issues
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+License-File: ASSET-NOTICES.md
+License-File: THIRD-PARTY-NOTICES.md
+License-File: third-party-notices/backports-tarfile/LICENSE
+License-File: third-party-notices/certifi/LICENSE
+License-File: third-party-notices/cffi/LICENSE
+License-File: third-party-notices/charset-normalizer/LICENSE
+License-File: third-party-notices/cryptography/LICENSE
+License-File: third-party-notices/cryptography/LICENSE.APACHE
+License-File: third-party-notices/cryptography/LICENSE.BSD
+License-File: third-party-notices/idna/LICENSE.md
+License-File: third-party-notices/importlib-metadata/LICENSE
+License-File: third-party-notices/jaraco-classes/LICENSE
+License-File: third-party-notices/jaraco-context/LICENSE
+License-File: third-party-notices/jaraco-functools/LICENSE
+License-File: third-party-notices/jeepney/LICENSE
+License-File: third-party-notices/keyring/LICENSE
+License-File: third-party-notices/more-itertools/LICENSE
+License-File: third-party-notices/pycparser/LICENSE
+License-File: third-party-notices/pywin32-ctypes/LICENSE.txt
+License-File: third-party-notices/requests/LICENSE
+License-File: third-party-notices/requests/NOTICE
+License-File: third-party-notices/secretstorage/LICENSE
+License-File: third-party-notices/urllib3/LICENSE.txt
+License-File: third-party-notices/zipp/LICENSE
+Requires-Dist: keyring<26,>=25
+Requires-Dist: requests<3,>=2.32
+Dynamic: license-file
+
+# Nexscope CLI
+
+Create product comparison reports from your own CSV or JSON, entirely offline.
+No account, API key, keyring, LLM or upload is needed. HTML, CSV and Markdown
+reports include the exact input, validated rows and evidence hashes.
+
+This is the independent CLI repository. Its first version is **0.1.0**.
+Verified behavior and remaining acceptance limits are recorded in ACCEPTANCE.md.
+The published Codex plugin and independent Skills are separate distributions.
+
+## Install and try your own data
+
+Python 3.11 or newer is required. Build the wheel from this repository, or obtain
+the exact reviewed wheel and its SHA-256 from a release of this repository.
+Do not install an unverified package just because it has the same name.
+
+From source on macOS or Linux:
+
+```sh
+git clone https://github.com/nexscope-ai/nexscope-cli.git
+cd nexscope-cli
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip wheel --no-deps --wheel-dir dist .
+python -m pip install --no-index --no-deps dist/nexscope_cli-0.1.0-py3-none-any.whl
+```
+
+On Windows PowerShell, create the environment with `py -3 -m venv .venv` and use
+`.venv\Scripts\python.exe` for the Python commands; activation is optional.
+There is no need to change PowerShell's execution policy.
+
+If you already have the reviewed wheel, install it with:
+
+```sh
+python -m pip install --no-index --no-deps /absolute/path/nexscope_cli-0.1.0-py3-none-any.whl
+nexscope doctor --offline
+nexscope report template --format csv --out products.csv
+nexscope report describe --schema
+nexscope report demo --format json --out sample.json
+nexscope report compare --input sample.json --format html --out comparison.html
+nexscope report compare --input sample.json --format csv --out comparison.csv
+nexscope report compare --input sample.json --format markdown --out comparison.md
+```
+
+Use fresh output names. Reports never overwrite files or silently fall back to
+another directory. Keep each report with its sibling `.evidence` directory.
+The samples are fictional. `nexscope demo product-comparison --out demo-output`
+also exercises the complete three-product workflow without credentials or network.
+
+`product_id` and `title` are required. A price requires an explicit currency;
+a rating requires its explicit positive scale. Missing values stay unknown.
+Identifiers must be strings and unique within a marketplace. Additional input
+columns are retained as metadata. There is no inferred sales, profit, currency
+conversion or ranking across different markets, currencies or rating scales.
+Remote currency symbols such as `$` are ambiguous. The CLI keeps the product and
+records `unresolvedCurrency`/`unresolvedPrice` alongside its raw evidence, while
+leaving comparable currency and price unknown. It never infers USD from a symbol
+or marketplace. Known fictional search candidates retain their fields in mock
+details. Report dry-runs validate parent directories and existing outputs before
+export. Successful live keyword search and continuation remain unaccepted; see
+ACCEPTANCE.md for the exact results.
+
+Raw UTF-8 CSV/JSON inputs are limited to 10 MiB and 10,000 products. Local imports
+have no three-product limit. CSV errors use logical record numbers including the
+header; JSON errors use one-based array positions. Invalid rows are explained,
+never silently dropped. Versioned datasets allow 32 MiB because normalization
+adds metadata; evidence bundles allow 64 MiB. See `report describe` for fields.
+
+## Product comparison workflows
+
+Remote planning is free of network and credential access:
+
+```sh
+nexscope workflow compare --asins B000000001,B000000002,B000000003 --dry-run
+nexscope workflow compare --keyword lamp --dry-run
+```
+
+The bounded workflow accepts two or three distinct ASINs, or one search page
+followed by explicit selection of two or three candidates. Use `--mock complete`
+for fictional execution. `--mock partial` demonstrates partial completion.
+
+```sh
+nexscope workflow compare --keyword lamp --execute --mock complete --max-calls 4 --out candidates
+nexscope workflow compare --resume candidates --select-asins B000000001,B000000002 --dry-run --mock complete
+nexscope workflow compare --resume candidates --select-asins B000000001,B000000002 --execute --mock complete --format all --out finished
+nexscope report compare --input finished/dataset.json --format markdown --out another.md
+```
+
+`--resume` imports the original search evidence, sends only the selected detail
+requests and carries forward the original budget. One search plus two details
+is three total requests. The original marketplace, source type, auth mode and
+origin must agree; a resumed budget cannot increase. Omitted marketplace, auth
+mode and max-calls inherit the checkpoint. `--keyword --select-asins` retains its
+existing meaning of a new search plus details; use `--resume` after selection
+to avoid paying for another search.
+
+Only completed `CANDIDATES_READY` outputs with a valid manifest may be resumed.
+Failed/incomplete outputs are never automatically replayed. A deliberate new
+command using the same candidates starts another branch of work; there is no
+server-side spending lock. `max-calls` is a request limit, not a monetary cap.
+Ambiguous failures consume a call. No automatic retries, pagination or ASIN
+expansion occur. Exit code 1 marks failures, partial or insufficient results;
+inspect saved results and evidence before deciding what to do next.
+
+Historical search imports are explicit user-selected evidence, not cache hits,
+fresh live queries, proof of account identity or server-signed records. They are
+never inserted into a credential context's cache. New requests use only the
+currently selected credentials. Each finished directory contains the original
+search plan/response, current plan, all details and hashes, with relative links.
+
+`report compare` can read this version's `dataset.json` without refreshing data.
+It checks the complete bundle, input digest, request contracts, product mappings,
+selection and accounting, preserving `sourceType`, retrieval times, errors and
+the original `inputName/inputSha256`. `report-input.json` separately identifies
+the exact input selected for re-export. These hashes detect inconsistent edits
+or corruption; they do not authenticate an author who can rewrite the whole
+bundle. Do not treat third-party bundles as verified live market data.
+Older preview datasets without manifests must be regenerated; this version does
+not silently relabel them as user imports.
+
+## Connect
+
+Online browser/plugin use needs the existing hash-pinned dependency profile:
+Set `APPROVED_API_ORIGIN` to the approved service origin. For paid data, set
+`ASIN_1` and `ASIN_2` to verified real identifiers and explicitly approve the
+request budget. The fictional identifiers used by mock examples are not live
+test inputs; empty responses can still incur charges.
+
+```sh
+python -m pip install --require-hashes -r /absolute/checkout/cli/nexscope_cli/dependencies.lock
+nexscope --api-base "$APPROVED_API_ORIGIN" auth login --source-client python-cli --source-channel github
+# Complete the returned connection URL in your browser, then:
+nexscope --api-base "$APPROVED_API_ORIGIN" auth poll
+nexscope --api-base "$APPROVED_API_ORIGIN" account
+nexscope --api-base "$APPROVED_API_ORIGIN" workflow compare --asins "$ASIN_1,$ASIN_2" --max-calls 2 --execute --allow-paid --out live-comparison
+```
+
+Browser credentials use the OS credential store. Supported backends are Windows
+Credential Manager, macOS Keychain, Secret Service and KWallet. The CLI does not
+read an environment key in `browser-account` mode or fall back when login fails.
+`--api-base` is a global option before the command when a different approved
+browser API origin is needed. Authenticated redirects are refused.
+
+Independent Skills and explicit `--auth-mode env-api-key` use only
+`NEXSCOPE_API_KEY` and `NEXSCOPE_PROXY_BASE`, privately configured in your shell.
+They require no browser login or keyring. Do not put keys into command history,
+documents or Git. Omit `--api-base` in this mode. Credential failure never
+switches modes. Cache entries are valid-success-only, memory-only, expire after
+300 seconds and are isolated by immutable auth context, origin, capability,
+parameters, marketplace and contract. Separate processes never share a cache.
+
+`get-skills`, browser-account `run ... -- <old script arguments>` and `export`
+remain available. The bundled standalone scripts require exactly this wheel
+version and preserve their JSON argument, `--inline`, `--no-cache`, original
+environment configuration and legacy response/exit semantics. They forward a
+legacy batch/page once without the bounded workflow's three-ASIN/one-page limits.
+Legacy JSON business errors can still exit zero: inspect the response code/error.
+Do not replace published Skills with these adapters before installation and live
+compatibility acceptance. No dependencies are auto-installed at query time.
+
+Only Amazon search/detail are adapted. Credits are unknown (`null`); response
+`cost` is not treated as a credit charge. Real account, balance and billing
+acceptance remain separate gates. Reports contain no telemetry or automatic
+upload. Review product data before sharing a report or its evidence.
+
+## Development and verification
+
+```sh
+python -m pip install --no-deps .
+python -m unittest discover -s tests -v
+python scripts/check_resources.py
+python -m pip wheel --no-deps --wheel-dir dist .
+python scripts/verify_wheel.py dist/nexscope_cli-0.1.0-py3-none-any.whl
+```
+
+The standard-library test suite runs with no service credentials. The wheel
+verification creates a fresh environment outside the checkout, clears source
+path injection, installs the actual wheel without dependencies, blocks network
+and keyring for offline checks, then runs the installed test suite and CLI cases.
+It also tests old adapters against a fictional loopback server. Loopback fixtures
+do not constitute live Nexscope acceptance. CI runs the same checks on Windows,
+macOS and Linux with Python 3.11 and 3.12; a configured matrix is not a passing run.
+
+Use a separate environment for upgrades and rollback. Install the prior exact
+verified wheel, and restore any paired Skill directory to its matching version.
+The verification script accepts `--previous-wheel /path/to/prior.whl` to exercise
+upgrade/rollback while checking that user reports and test credential sentinels
+survive. No public package, tag, release or plugin upload is made by these scripts.
+
+On a machine with a real supported OS credential store, add `--with-os-keyring`
+alongside `--with-dependencies` to test an isolated fictional credential. The
+verifier checks write/read, upgrade/rollback and uninstall persistence, then
+deletes only its own uniquely named entry. It does not log in to a service or
+modify an existing account credential. A missing desktop credential store is
+reported as a prerequisite failure; it never falls back to plaintext storage.
+
+For an Ubuntu host without `ensurepip`, use `--pip-wheel /path/to/reviewed/pip.whl`
+to bootstrap pip inside the fresh venv from an explicit trusted wheel, such as
+Python's bundled ensurepip wheel. This does not install into the system Python.
+Windows and Ubuntu WSL2 installation acceptance has been run locally; WSL2 does
+not certify macOS or a Linux desktop credential store.
+
+When intentionally changing a bundled adapter, run
+`python scripts/check_resources.py --update` and review the catalog diff. This
+updates current-file hashes only; historical source snapshot hashes are retained.
+Keep CLI behavior here and have consumers pin its version; do not maintain a
+second CLI copy in the published plugin.
+
+See [ACCEPTANCE.md](ACCEPTANCE.md) for verified scope and outstanding release gates,
+and [the macOS handoff](docs/HANDOFF-MACOS.md) for the remaining acceptance work.
+Report reproducible problems, without keys or private reports, in
+[GitHub Issues](https://github.com/nexscope-ai/nexscope-cli/issues). Nexscope is the
+maintainer; named pilot/release ownership still needs assignment before release.
+
+Apache-2.0. Initial source: plugin commit
+`814f28016af6b3ff57ef12093a6bb133c4fb20b9`. Original Skill provenance remains in
+the catalog. See `NOTICE`, `ASSET-NOTICES.md` and `THIRD-PARTY-NOTICES.md`.

nexscope_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,74 @@
+nexscope_cli/__init__.py,sha256=MA6r0Ji2BlUrNJZytOG-Qrf1Ks8M7GIRKUQQwvPQqB4,134
+nexscope_cli/api-contract.json,sha256=DqG4ePGE4rHAF1n8F57dgws6kRC1MdkmQT5oGyAOOEw,1366
+nexscope_cli/catalog.json,sha256=szJeqEps5D1vNIZ5W0pzRBXw78HHwfl_vYiwGao-zxk,3782
+nexscope_cli/dependencies.lock,sha256=Vig5T24dYtoSD89m-AraThIQn0W2gOXWHp0faUlsk_s,23092
+nexscope_cli/dependency-lock.json,sha256=8fvy3PWAjaG9RCa1muu6n2g0_MHKS3Wfe7PELaZp7Gk,22633
+nexscope_cli/doctor.py,sha256=fk3U3KcDjhKuiy88OegBpcM8jJq40ly_1CrKa5NahCM,7885
+nexscope_cli/main.py,sha256=ek6hx-JG8eNOCs-Hec0vaNENaweFrmsysBvOjux5vRc,18549
+nexscope_cli/runner.py,sha256=K3XczQQtUFE_t7JaNrzsnMnQD44S6ktrvdVmL-eYKgg,1712
+nexscope_cli/capabilities/__init__.py,sha256=yC8NklpF_pD51UvpgZXe9V6FAdQ_l7kEdjljgwMlGfQ,147
+nexscope_cli/capabilities/catalog.py,sha256=ColpJeAEFTlmkH5OowOZNSKa83tYPWvl2W95NM3zaS0,4181
+nexscope_cli/capabilities/mock.py,sha256=9GRWHL-dxw3TF5V6GqV4V1RHuBtqTVX60zaP2T1gitE,2486
+nexscope_cli/capabilities/plan.py,sha256=uXPx7Q7KSa-ERYA_mZ2wVS1biRM2SbZn3r4EaV2SxNg,7104
+nexscope_cli/compat/__init__.py,sha256=pZzFzapYd9ZWJYP05f-36a5xrI7YHl1jc0Cyfwy7tHI,156
+nexscope_cli/compat/legacy.py,sha256=WFAiutykjH4MmnzQIb_R2XWkPMOVr4UyZ0WyJaBkYow,6988
+nexscope_cli/core/__init__.py,sha256=G10sB-SuPgPDM-eKwACSR8rRUlRBui-YtDJDtTZ3kHo,114
+nexscope_cli/core/auth.py,sha256=0_wqGcj0CVS5iEnHYV6goJ78W2c9IM1rfx65mUR7alc,3633
+nexscope_cli/core/datasets.py,sha256=4DpQAmkBfOIsWFM2n-CzvK59myi9KTAhIBFiGb2g8P4,18254
+nexscope_cli/core/errors.py,sha256=9x6q2djbY5vD9wyly6Xlj0f0GeCpBCoSp6Q6ZuaNH5E,196
+nexscope_cli/core/evidence.py,sha256=0ZXqJK4btTfrZGLKWydZPKnoenojCYb3FJGUzDtoaxs,5899
+nexscope_cli/core/execution.py,sha256=8gkrxrBTYz3-vV-TIMunnzny_EuMIXZws-B3dbqMZEc,8674
+nexscope_cli/core/remote.py,sha256=_cgdF42GtEQOa1MsLkZxLAY4l37eufUnIUIAjNyjCxo,915
+nexscope_cli/core/transport.py,sha256=EB676UQiQZXu0ar4dnfgDkWVkpwDuosvfQPLqty_geE,2420
+nexscope_cli/reports/__init__.py,sha256=yPZe1M_GvAljCuk7nhnS8c0n1wt53ZJkKNYkBpH-my4,139
+nexscope_cli/reports/compare.py,sha256=vg6KI6bUybgS5ZafLU0X8GCDrCRyIACWwbUl49w5gOw,7195
+nexscope_cli/reports/formats.py,sha256=OQxn7qYOg6T7o0UNF09IfqmDCi7e2N2IYi9_JuTPnBk,5108
+nexscope_cli/resources/__init__.py,sha256=LCYY0xAIWGldghAQQVbtBNTn6OAeHDkyKIR_gHCGk2c,136
+nexscope_cli/resources/fields.json,sha256=VcGNy3fzeGDdKNiDd30qYI8yX_jJNRwc2ykCaytA4Sc,2243
+nexscope_cli/resources/mock-products.json,sha256=0A7bvwm4galLD-giB3m1UtbP9UMb-ugNEXxuCoWBEaU,658
+nexscope_cli/resources/products-sample.csv,sha256=CSNfqSboxonl55xf6qDPOMgABfkyCo5R8k651v_7J_8,511
+nexscope_cli/resources/products-sample.json,sha256=Z2Pp83wA7gFS4lWZGygz2Gyvr4ckDMcOhTnoCVsHH5c,858
+nexscope_cli/resources/products-template.csv,sha256=gBnfKUox-H_2TtRk6sa6lBtZUVvcIWBl8x95o956PDc,100
+nexscope_cli/resources/products.schema.json,sha256=ST7pYiqAX6Nl7B-IPxIO5aXuA6lWkjK-0_FfSwehZU0,4011
+nexscope_cli/resources/report.html,sha256=xrl8ydpn11P3xWd1dUAkUm8OIieGAcEmNVLIF6MZcsk,1710
+nexscope_cli/skills/amazon-product-detail/SKILL.md,sha256=kRmC04bf0sY5NvbjB_Dfxp4Uif8k00IxDL1GABRtF_8,12167
+nexscope_cli/skills/amazon-product-detail/requirements.txt,sha256=8skrREsVeyayEmb00-9vXjJJdxNGmZp9jt0GS9IVw-k,20
+nexscope_cli/skills/amazon-product-detail/references/api.md,sha256=KtU314YeZQoewZV5HnqkiGFBMuEwVHPFOvDHpj9NDVk,10929
+nexscope_cli/skills/amazon-product-detail/scripts/amazon_product_detail.py,sha256=z36uqUhlpufJ3HJ_5eT4AArJGmfIpOTtvmGKyEst5uk,1028
+nexscope_cli/skills/amazon-search/SKILL.md,sha256=kEErz2BwoGmVk7AoUmQh05Z1jx8HBlyJfgNUEXX-cQw,11985
+nexscope_cli/skills/amazon-search/requirements.txt,sha256=8skrREsVeyayEmb00-9vXjJJdxNGmZp9jt0GS9IVw-k,20
+nexscope_cli/skills/amazon-search/references/api.md,sha256=rC9nZN2vvUqw4Zy188_jeDjr12h5xgStYsQKTc1ud-o,8074
+nexscope_cli/skills/amazon-search/scripts/amazon_search.py,sha256=Vp738AVF37pSu11_EjnAjOiqnsMAOuNh3qPD1YW8PC0,1020
+nexscope_cli/workflows/__init__.py,sha256=YeGkzL96b4uUwhBzBHTcN54zdlOQH-YKam00xtCFL1c,136
+nexscope_cli/workflows/compare.py,sha256=Tg2NFZVqBiBufIqZ-hivfND32PA0t5f0CXDL82MkIzs,14835
+nexscope_cli-0.1.0.dist-info/licenses/ASSET-NOTICES.md,sha256=tL-BhhfpHa8I6eIXYaPG4QS2SjJtsjHuptTWl0aBY0Y,449
+nexscope_cli-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+nexscope_cli-0.1.0.dist-info/licenses/NOTICE,sha256=yBCNot83LMzDRtVSqDU0AoTHf8JummN91R3yAmo8lZ4,1053
+nexscope_cli-0.1.0.dist-info/licenses/THIRD-PARTY-NOTICES.md,sha256=xQyGc1Qotvlhsv3guhu_Pcu25OemcQLJ7czVBUqVYGY,2496
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/backports-tarfile/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/certifi/LICENSE,sha256=6TcW2mucDVpKHfYP5pWzcPBpVgPSH2-D8FPkLPwQyvc,989
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/cffi/LICENSE,sha256=W6JN3FcGf5JJrdZEw6_EGl1tw34jQz73Wdld83Cwr2M,1123
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/charset-normalizer/LICENSE,sha256=bQ1Bv-FwrGx9wkjJpj4lTQ-0WmDVCoJX0K-SxuJJuIc,1071
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/cryptography/LICENSE,sha256=Pgx8CRqUi4JTO6mP18u0BDLW8amsv4X1ki0vmak65rs,197
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/cryptography/LICENSE.APACHE,sha256=qsc7MUj20dcRHbyjIJn2jSbGRMaBOuHk8F9leaomY_4,11360
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/cryptography/LICENSE.BSD,sha256=YCxMdILeZHndLpeTzaJ15eY9dz2s0eymiSMqtwCPtPs,1532
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/idna/LICENSE.md,sha256=GppPDj1HmickDd1ZqRN6ZqtKD539yMphiMwL_YUYfwQ,1541
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/importlib-metadata/LICENSE,sha256=4ve7BVfno4FJnxW6p8HXdtg9ZhZZkXnXHTEJuOOfeyU,10278
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/jaraco-classes/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/jaraco-context/LICENSE,sha256=l1WhhRlmbl8PTK49qtPXASvK5IpgCzEjfXXp_hNOZoM,1076
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/jaraco-functools/LICENSE,sha256=l1WhhRlmbl8PTK49qtPXASvK5IpgCzEjfXXp_hNOZoM,1076
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/jeepney/LICENSE,sha256=GyKwSbUmfW38I6Z79KhNjsBLn9-xpR02DkK0NCyLQVQ,1081
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/keyring/LICENSE,sha256=WlfLTbheKi3YjCkGKJCK3VfjRRRJ4KmnH9-zh3b9dZ0,1076
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/more-itertools/LICENSE,sha256=CfHIyelBrz5YTVlkHqm4fYPAyw_QB-te85Gn4mQ8GkY,1053
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/pycparser/LICENSE,sha256=DIRjmTaep23de1xE_m0WSXQV_PAV9cu1CMJL-YuBxbE,1543
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/pywin32-ctypes/LICENSE.txt,sha256=36g7PicJrfzbg42a1VgjymdKu3gOYFY9ndlUTMv3hek,1644
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/requests/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/requests/NOTICE,sha256=9REJct7a0rTp0xRRja87fXLW4C5Jms2AIYHeb3RXHcw,38
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/secretstorage/LICENSE,sha256=5wA1dZK7k3BMsEDOSmZjqFKScWpAQbaiZ_WY8hZYRm8,1504
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/urllib3/LICENSE.txt,sha256=Ew46ZNX91dCWp1JpRjSn2d8oRGnehuVzIQAmgEHj1oY,1093
+nexscope_cli-0.1.0.dist-info/licenses/third-party-notices/zipp/LICENSE,sha256=l1WhhRlmbl8PTK49qtPXASvK5IpgCzEjfXXp_hNOZoM,1076
+nexscope_cli-0.1.0.dist-info/METADATA,sha256=L-4MVoenH7TzK4Q7Son7iGay7-LRjfgkTC8ltmfP7Ig,14309
+nexscope_cli-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+nexscope_cli-0.1.0.dist-info/entry_points.txt,sha256=izkHi1XuzJJ-NnMB-21B4fT7aP7Q6W-qS8dhYW4FUDU,52
+nexscope_cli-0.1.0.dist-info/top_level.txt,sha256=nayB2rke499IWWFGp9mH-63cKyCrz5VG_bAOslgOsUE,13
+nexscope_cli-0.1.0.dist-info/RECORD,,

nexscope_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nexscope_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nexscope = nexscope_cli.main:main

nexscope_cli-0.1.0.dist-info/licenses/ASSET-NOTICES.md

@@ -0,0 +1,9 @@
+# Bundled asset attribution
+
+Copyright 2026 Nexscope.
+
+This independent CLI contains report templates and fictional product samples.
+Templates use system fonts, with no external font, JavaScript or image assets.
+The original plugin icon and plugin entrypoint are not part of this distribution.
+Apache-2.0 Section 6 governs trademark use; the copyright license does not grant
+trademark rights or imply Nexscope endorsement of modified distributions.