unvibecode 0.3.0__py3-none-any.whl

shipreadyv2/SOURCE_MANIFEST.json

@@ -0,0 +1,27 @@
+{
+  "schema_version": "shipreadyv2.exact_source_manifest.v2",
+  "package_version": "0.3.0",
+  "engine_baseline_version": "0.2.1",
+  "engine_changes_from_baseline": [],
+  "hash_mode": "LF-normalized SHA-256 for text; raw SHA-256 for binary",
+  "customer_runner_source": "shipreadyv2_customer_mvp_runner_v9.py",
+  "engine_source": "shipreadyv2_fresh_source.zip plus universal_insight_rules.yaml",
+  "source_files": {
+    "customer_runner.py": "6a0593de05be1a460c0375a431331fb115d6426c507a185a087c801a78055c1d",
+    "engine_sources/00a_shipreadyv2_fast_lane_v11_api_context_bundle.py": "1eac10db5403bb470929da4b52eaafb88dbce6b5919492016754e227680e7c3e",
+    "engine_sources/01_shipreadyv2_merged_graph_pipeline_5chunks.py": "697f7dda0a65a582939bae75b16d601342fd547adeda1a209778f60903a494a2",
+    "engine_sources/02_shipreadyv2_prepare_pass1_inputs.py": "cb5bb27a6d923341e55b2b121e128bcce66edf04937cc3b18e31d5f3989fe891",
+    "engine_sources/03_shipreadyv2_pass1_full_runner.py": "40e5a0afd70e55110c1784f5e29332a910fad3b03fe3030492633277ff93caba",
+    "engine_sources/04_shipreadyv2_business_path_compiler.py": "7ed142e07cb37b1f90084837b7cb45f63f2718826f121b834c5e1a5a57ffab94",
+    "engine_sources/05_shipreadyv2_critical_business_insight_selector_v4.py": "e770c8cd21a06a7a02d8e8f9e8c6f7bedb1a5b7be96fdb6ba646e740f006a011",
+    "engine_sources/06_shipreadyv2_step4_v2_with_v4_inputs.py": "6dbc77b72e0066f9fcfb7e5d92026bb6b54b77a8eed687a94971c4d9ab6160c2",
+    "engine_sources/agent_knowledge_graph.db": "db362f684eb4d9e43827400f4e11f1dfd7cbfffa5fd481c105cd9d3f14d9f8b2",
+    "engine_sources/archetype_taxonomy.yaml": "55e98bdace2af1a1dbe6a73315e651383f9f2ca265a3ad5ca262dbd8acbf1f5f",
+    "engine_sources/archetype_taxonomy_pass1_compact.yaml": "93452175b35bd74bc9043766324c8442607e920a70548115c32a0b09a33673e3",
+    "engine_sources/build_pass1_compact_taxonomy.py": "5d8692214509c80dddeb2e2eee0d6f80f172d8150b9640db27dbeb07dec69769",
+    "engine_sources/generate_combinedjson.py": "1c2ffbb4ec9d40b9b4304abc2848943a69424d3087125993733a1b57064f5267",
+    "engine_sources/normalized_business_path.schema.json": "5d408b2cce353ab6ef4b37a0686330ff5610c6d7aaf4bc37fdf9b0aa1fc665cd",
+    "engine_sources/shipready_business_insight_implementation_plan_v2.md": "210cc34f9a28c7e4acc4ba39a164f8d78ce5c97b99fb9f9beff308db2bda7eac",
+    "engine_sources/universal_insight_rules.yaml": "4aa10f8c581100190c24365fa4188862c49738403db36c6c298ba15c54067ab7"
+  }
+}

shipreadyv2/__init__.py

@@ -0,0 +1,3 @@
+"""ShipReadyV2 customer package."""
+
+__version__ = "0.3.0"

shipreadyv2/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

shipreadyv2/cli.py

@@ -0,0 +1,204 @@
+"""Customer-facing command adapter for the preserved ShipReadyV2 workflow."""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import getpass
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Iterator, Optional, Sequence
+
+from . import __version__
+from . import customer_runner
+from . import credentials
+
+
+def bundled_engine_root() -> Path:
+    """Return the installed directory containing the preserved engine files."""
+    return Path(__file__).resolve().parent / "engine_sources"
+
+
+def default_runs_root() -> Path:
+    """Keep customer runs outside the installed Python package."""
+    return Path.cwd() / "shipready_results"
+
+
+@contextlib.contextmanager
+def prepared_runtime_engine(access_key: str) -> Iterator[Path]:
+    """Provide the preserved scripts with a private hosted-service environment.
+
+    Steps 03 and 06 require an engine-root .env file before they read the
+    SDK credential. The value supplied here is a ShipReady customer credential,
+    and OPENAI_BASE_URL directs the unmodified OpenAI SDK calls to ShipReady's
+    hosted gateway. The customer never supplies an OpenAI API key.
+
+    Installed package directories may be read-only, so the adapter copies the
+    preserved engine into a private temporary directory for the duration of the
+    review. The directory and its temporary .env file are removed afterward.
+    """
+    access_key = credentials.normalize_access_key(access_key)
+    if "\r" in access_key or "\n" in access_key:
+        raise customer_runner.CustomerRunError(
+            "The ShipReady access key contains an invalid line break"
+        )
+
+    hosted_environment = {
+        "OPENAI_API_KEY": access_key,
+        "OPENAI_BASE_URL": credentials.api_base_url(),
+    }
+    previous_environment = {
+        name: os.environ.get(name)
+        for name in hosted_environment
+    }
+
+    with tempfile.TemporaryDirectory(prefix="shipreadyv2-engine-") as temporary:
+        runtime_root = Path(temporary) / "engine"
+        shutil.copytree(
+            bundled_engine_root(),
+            runtime_root,
+            ignore=shutil.ignore_patterns("__pycache__", "*.pyc"),
+        )
+        (runtime_root / ".env").write_text(
+            (
+                f"OPENAI_API_KEY={access_key}\n"
+                f"OPENAI_BASE_URL={credentials.api_base_url()}\n"
+            ),
+            encoding="utf-8",
+        )
+        try:
+            os.environ.update(hosted_environment)
+            yield runtime_root
+        finally:
+            for name, previous_value in previous_environment.items():
+                if previous_value is None:
+                    os.environ.pop(name, None)
+                else:
+                    os.environ[name] = previous_value
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="shipready",
+        description=(
+            "Prepare a Connected Code Map for LLMs and, when repository size "
+            "permits, a Business Workflow & Risk Review."
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    subparsers.add_parser(
+        "activate",
+        help="Securely activate ShipReady on this computer",
+    )
+    subparsers.add_parser(
+        "deactivate",
+        help="Remove the stored ShipReady access key",
+    )
+
+    review = subparsers.add_parser("review", help="Review a source repository")
+    review.add_argument("--repository", required=True)
+    review.add_argument(
+        "--runs-root",
+        default=str(default_runs_root()),
+        help=(
+            "Folder for repository-review runs "
+            "(default: ./shipready_results)"
+        ),
+    )
+    review.add_argument(
+        "--large-repo-token-limit",
+        type=int,
+        default=customer_runner.DEFAULT_LARGE_REPOSITORY_TOKEN_LIMIT,
+        help=(
+            "Prepare only the Connected Code Map above this approximate token "
+            "count (default: 2000000)"
+        ),
+    )
+    review.add_argument(
+        "--no-open-browser",
+        action="store_true",
+        help="Create customer HTML reports without opening browser tabs",
+    )
+    return parser
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "activate":
+        try:
+            access_key = credentials.normalize_access_key(
+                getpass.getpass("Paste your ShipReady access key: ")
+            )
+            verification = credentials.verify_access_key(access_key)
+            if not verification.valid:
+                print(f"[STOPPED] {verification.message}")
+                return 2
+            credentials.store_access_key(access_key)
+        except (credentials.CredentialError, KeyboardInterrupt, EOFError) as exc:
+            message = str(exc) or "Activation was cancelled."
+            print(f"[STOPPED] {message}")
+            return 2
+        print("ShipReady access is ready on this computer.")
+        return 0
+
+    if args.command == "deactivate":
+        try:
+            removed = credentials.delete_access_key()
+        except credentials.CredentialError as exc:
+            print(f"[STOPPED] {exc}")
+            return 2
+        if removed:
+            print("ShipReady access was removed from this computer.")
+        else:
+            print("ShipReady was not activated on this computer.")
+        return 0
+
+    if args.command != "review":
+        parser.error("A supported command is required")
+    if args.large_repo_token_limit <= 0:
+        parser.error("--large-repo-token-limit must be greater than zero")
+
+    try:
+        access_key = credentials.load_access_key()
+        if not access_key:
+            raise credentials.CredentialError(
+                "ShipReady is not activated. Run: shipready activate"
+            )
+    except credentials.CredentialError as exc:
+        print(f"[STOPPED] {exc}")
+        return 2
+
+    try:
+        with prepared_runtime_engine(access_key) as engine_root:
+            runner_args = [
+                "start",
+                "--repository",
+                str(Path(args.repository).expanduser()),
+                "--engine-root",
+                str(engine_root),
+                "--runs-root",
+                str(Path(args.runs_root).expanduser()),
+                "--large-repo-token-limit",
+                str(args.large_repo_token_limit),
+            ]
+            if args.no_open_browser:
+                runner_args.append("--no-open-browser")
+
+            return customer_runner.main(runner_args)
+    except customer_runner.CustomerRunError as exc:
+        print(f"[STOPPED] {exc}")
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

shipreadyv2/credentials.py

@@ -0,0 +1,178 @@
+"""ShipReady hosted-service credential storage and verification."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from typing import Optional
+
+
+DEFAULT_API_BASE_URL = "https://shipready-api.alphashots.ai/v1"
+KEYRING_SERVICE = "ShipReady"
+KEYRING_USERNAME = "customer-access-key"
+
+
+class CredentialError(RuntimeError):
+    """Raised when a ShipReady access credential cannot be used safely."""
+
+
+@dataclass(frozen=True)
+class VerificationResult:
+    valid: bool
+    message: str
+
+
+def api_base_url() -> str:
+    """Return the fixed production URL, with a test-only environment override."""
+
+    value = (
+        os.getenv("SHIPREADY_API_BASE_URL")
+        or DEFAULT_API_BASE_URL
+    ).strip().rstrip("/")
+    if not value.startswith("https://"):
+        raise CredentialError("The ShipReady service URL must use HTTPS.")
+    return value
+
+
+def normalize_access_key(value: str) -> str:
+    """Validate a customer key without exposing it in an error."""
+
+    key = value.strip().strip("\"'").strip()
+    if not key:
+        raise CredentialError("A ShipReady access key is required.")
+    if "\r" in key or "\n" in key or any(character.isspace() for character in key):
+        raise CredentialError("The ShipReady access key contains invalid whitespace.")
+    try:
+        key.encode("ascii")
+    except UnicodeEncodeError as exc:
+        raise CredentialError(
+            "The ShipReady access key contains an invalid character."
+        ) from exc
+    if len(key) < 24:
+        raise CredentialError("The ShipReady access key is not valid.")
+    return key
+
+
+def _keyring_module():
+    try:
+        import keyring  # type: ignore
+    except ImportError as exc:
+        raise CredentialError(
+            "Secure credential storage is unavailable. Reinstall ShipReady."
+        ) from exc
+    return keyring
+
+
+def store_access_key(value: str) -> None:
+    """Store the key in the operating system credential manager."""
+
+    key = normalize_access_key(value)
+    try:
+        _keyring_module().set_password(KEYRING_SERVICE, KEYRING_USERNAME, key)
+    except Exception as exc:
+        raise CredentialError(
+            "The operating system credential manager could not store the "
+            "ShipReady access key."
+        ) from exc
+
+
+def delete_access_key() -> bool:
+    """Delete the stored key, returning False when no stored key exists."""
+
+    keyring = _keyring_module()
+    try:
+        existing = keyring.get_password(KEYRING_SERVICE, KEYRING_USERNAME)
+        if not existing:
+            return False
+        keyring.delete_password(KEYRING_SERVICE, KEYRING_USERNAME)
+    except Exception as exc:
+        raise CredentialError(
+            "The operating system credential manager could not remove the "
+            "ShipReady access key."
+        ) from exc
+    return True
+
+
+def load_access_key() -> Optional[str]:
+    """Prefer an automation environment variable, then secure local storage."""
+
+    environment_key = (os.getenv("SHIPREADY_ACCESS_KEY") or "").strip()
+    if environment_key:
+        return normalize_access_key(environment_key)
+
+    try:
+        stored = _keyring_module().get_password(
+            KEYRING_SERVICE,
+            KEYRING_USERNAME,
+        )
+    except CredentialError:
+        raise
+    except Exception as exc:
+        raise CredentialError(
+            "The operating system credential manager could not read the "
+            "ShipReady access key."
+        ) from exc
+    if not stored:
+        return None
+    return normalize_access_key(stored)
+
+
+def verify_access_key(value: str, timeout_seconds: float = 20.0) -> VerificationResult:
+    """Verify authentication without sending repository code or invoking a model.
+
+    The gateway authenticates before validating the request body. Therefore an
+    empty JSON request returns 400 for a valid key and 401/403 for an invalid key.
+    """
+
+    key = normalize_access_key(value)
+    request = urllib.request.Request(
+        f"{api_base_url()}/responses",
+        data=b"{}",
+        headers={
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+            "User-Agent": "ShipReady-Activation/0.3",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(request, timeout=timeout_seconds) as response:
+            status = int(response.status)
+    except urllib.error.HTTPError as exc:
+        status = int(exc.code)
+        try:
+            payload = json.loads(exc.read().decode("utf-8", errors="replace"))
+        except Exception:
+            payload = {}
+        if status in {401, 403}:
+            message = (
+                payload.get("error", {}).get("message")
+                if isinstance(payload, dict)
+                else None
+            )
+            return VerificationResult(
+                False,
+                str(message or "The ShipReady access key was rejected."),
+            )
+        if status == 400:
+            return VerificationResult(True, "ShipReady access verified.")
+        return VerificationResult(
+            False,
+            f"The ShipReady service returned HTTP {status}.",
+        )
+    except (urllib.error.URLError, TimeoutError) as exc:
+        raise CredentialError(
+            "The ShipReady service could not be reached. Check the internet "
+            "connection and try again."
+        ) from exc
+
+    if 200 <= status < 300:
+        return VerificationResult(True, "ShipReady access verified.")
+    return VerificationResult(
+        False,
+        f"The ShipReady service returned HTTP {status}.",
+    )