swisper-prism-cli 0.1.0__tar.gz

swisper_prism_cli-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+.pytest_cache/
+*.egg-info/
+dist/
+build/

swisper_prism_cli-0.1.0/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 — 2026-04-27
+
+First public release on PyPI.
+
+- Code-intelligence CLI for AI coding agents.
+- Subcommands: `search`, `find-refs`, `def`, `body`, `outline`, `module-map`, `deps`, `prepare-edit`, `edit-anchors`, `check`, `ping`, `list-repos`, `find`.
+- `--auto-overlay` flag (default ON for editing-relevant subcommands) for unpushed-file freshness via overlay γ (FEAT_013).
+- Auth via `PRISM_TOKEN` env or piggyback on `~/.claude.json:mcpServers.prism-hosted`.
+- Base URL via `PRISM_BASE_URL` env or default `https://prism-gateway.swisper.app`.

swisper_prism_cli-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: swisper-prism-cli
+Version: 0.1.0
+Summary: Prism — code-intelligence CLI for AI coding agents
+Project-URL: Homepage, https://github.com/Fintama/swisper_prism
+Project-URL: Repository, https://github.com/Fintama/swisper_prism
+Project-URL: Documentation, https://github.com/Fintama/swisper_prism/tree/main/apps/prism-cli
+Author: Fintama Prism Team
+License: Proprietary - Fintama Internal Use Only
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# swisper-prism-cli
+
+`prism` — code-intelligence CLI for AI coding agents. Search, navigate, and reason about your codebase from the shell, with overlay-γ awareness for unpushed local edits.
+
+## Install
+
+```bash
+pip install --user swisper-prism-cli
+```
+
+Or with [pipx](https://pipx.pypa.io/) (recommended on systems where `pip --user` is restricted):
+
+```bash
+pipx install swisper-prism-cli
+```
+
+Requires Python ≥ 3.11.
+
+## Auth
+
+Generate a developer token at <https://prism-console-swisper.web.app/settings>, then either:
+
+```bash
+export PRISM_TOKEN="prism_<your-token>"
+```
+
+…or rely on `~/.claude.json:mcpServers.prism-hosted.headers.Authorization` if you already have the Prism MCP server configured (the CLI piggybacks on that config).
+
+## Verify
+
+```bash
+prism ping
+```
+
+Expected: `{"status": "ok", ...}` plus a freshness timestamp.
+
+## Common commands
+
+```bash
+prism search "rate limit retry"
+prism find-refs "User.save" --pretty
+prism def "MyClass.handler"
+prism prepare-edit "MyClass.handler"
+prism module-map
+prism --help
+```
+
+The `--auto-overlay` flag (default ON for editing-relevant subcommands) handles freshness for unpushed local edits — your dirty-file content flows into the query without a reindex.
+
+## Surfaces
+
+| Tool | When |
+|---|---|
+| `prism` CLI (this package) | Coding agents — anything with shell access (Cursor, Claude Code, Windsurf, Codex, Devin, Antigravity) |
+| MCP server (`prism-hosted` in `~/.claude.json`) | Non-editing agents (chatbots like Claude Desktop) |
+
+Both surfaces talk to the same gateway and use the same token.
+
+## Contributing (developers)
+
+```bash
+git clone https://github.com/Fintama/swisper_prism
+cd swisper_prism/apps/prism-cli
+uv pip install -e .
+uv run python -m pytest tests/ -v
+```
+
+See [`CHANGELOG.md`](./CHANGELOG.md) for release history.

swisper_prism_cli-0.1.0/README.md

@@ -0,0 +1,68 @@
+# swisper-prism-cli
+
+`prism` — code-intelligence CLI for AI coding agents. Search, navigate, and reason about your codebase from the shell, with overlay-γ awareness for unpushed local edits.
+
+## Install
+
+```bash
+pip install --user swisper-prism-cli
+```
+
+Or with [pipx](https://pipx.pypa.io/) (recommended on systems where `pip --user` is restricted):
+
+```bash
+pipx install swisper-prism-cli
+```
+
+Requires Python ≥ 3.11.
+
+## Auth
+
+Generate a developer token at <https://prism-console-swisper.web.app/settings>, then either:
+
+```bash
+export PRISM_TOKEN="prism_<your-token>"
+```
+
+…or rely on `~/.claude.json:mcpServers.prism-hosted.headers.Authorization` if you already have the Prism MCP server configured (the CLI piggybacks on that config).
+
+## Verify
+
+```bash
+prism ping
+```
+
+Expected: `{"status": "ok", ...}` plus a freshness timestamp.
+
+## Common commands
+
+```bash
+prism search "rate limit retry"
+prism find-refs "User.save" --pretty
+prism def "MyClass.handler"
+prism prepare-edit "MyClass.handler"
+prism module-map
+prism --help
+```
+
+The `--auto-overlay` flag (default ON for editing-relevant subcommands) handles freshness for unpushed local edits — your dirty-file content flows into the query without a reindex.
+
+## Surfaces
+
+| Tool | When |
+|---|---|
+| `prism` CLI (this package) | Coding agents — anything with shell access (Cursor, Claude Code, Windsurf, Codex, Devin, Antigravity) |
+| MCP server (`prism-hosted` in `~/.claude.json`) | Non-editing agents (chatbots like Claude Desktop) |
+
+Both surfaces talk to the same gateway and use the same token.
+
+## Contributing (developers)
+
+```bash
+git clone https://github.com/Fintama/swisper_prism
+cd swisper_prism/apps/prism-cli
+uv pip install -e .
+uv run python -m pytest tests/ -v
+```
+
+See [`CHANGELOG.md`](./CHANGELOG.md) for release history.

swisper_prism_cli-0.1.0/prism_cli/__main__.py

@@ -0,0 +1,3 @@
+from prism_cli.cli import main
+
+main()

swisper_prism_cli-0.1.0/prism_cli/api_client.py

@@ -0,0 +1,47 @@
+"""Thin HTTP client for the prism gateway /api/v1 surface."""
+from __future__ import annotations
+
+import json as _json
+from typing import Any
+
+import httpx
+
+from .auth import resolve_base_url, resolve_token
+
+
+class PrismAPIError(RuntimeError):
+    pass
+
+
+class PrismClient:
+    def __init__(
+        self, base_url: str | None = None, token: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        self.base_url = (base_url or resolve_base_url()).rstrip("/")
+        self.token = token or resolve_token()
+        self._http = httpx.Client(timeout=timeout)
+
+    def call(self, subcommand: str, payload: dict[str, Any]) -> dict[str, Any]:
+        url = f"{self.base_url}/api/v1/{subcommand}"
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+        }
+        try:
+            resp = self._http.post(url, json=payload, headers=headers)
+        except httpx.HTTPError as e:
+            raise PrismAPIError(f"network: {e}") from e
+        if resp.status_code == 413:
+            raise PrismAPIError(f"overlay rejected (413): {resp.text}")
+        if resp.status_code >= 500:
+            raise PrismAPIError(f"server error {resp.status_code}: {resp.text}")
+        if resp.status_code >= 400:
+            raise PrismAPIError(f"client error {resp.status_code}: {resp.text}")
+        try:
+            return resp.json()
+        except _json.JSONDecodeError as e:
+            raise PrismAPIError(f"non-JSON response: {resp.text[:200]}") from e
+
+    def close(self) -> None:
+        self._http.close()

swisper_prism_cli-0.1.0/prism_cli/auth.py

@@ -0,0 +1,57 @@
+"""Resolve the Prism dev token from env var or ~/.claude.json."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+class AuthError(RuntimeError):
+    """Raised when no Prism token is available."""
+
+
+def resolve_token() -> str:
+    env_token = os.environ.get("PRISM_TOKEN")
+    if env_token:
+        return env_token
+
+    claude_json = Path.home() / ".claude.json"
+    if claude_json.exists():
+        try:
+            data = json.loads(claude_json.read_text())
+        except json.JSONDecodeError:
+            data = {}
+        servers = data.get("mcpServers", {})
+        prism = servers.get("prism-hosted") or servers.get("prism")
+        if prism:
+            auth = (prism.get("headers") or {}).get("Authorization", "")
+            if auth.startswith("Bearer "):
+                return auth.removeprefix("Bearer ")
+
+    raise AuthError(
+        "No Prism token found. Set PRISM_TOKEN env var or configure "
+        "prism-hosted in ~/.claude.json."
+    )
+
+
+def resolve_base_url() -> str:
+    env_url = os.environ.get("PRISM_BASE_URL")
+    if env_url:
+        return env_url
+    claude_json = Path.home() / ".claude.json"
+    if claude_json.exists():
+        try:
+            data = json.loads(claude_json.read_text())
+        except json.JSONDecodeError:
+            data = {}
+        servers = data.get("mcpServers", {})
+        prism = servers.get("prism-hosted") or servers.get("prism")
+        if prism and "url" in prism:
+            # Strip trailing /mcp or /sse to get gateway root
+            url: str = prism["url"]
+            for suffix in ("/mcp", "/sse", "/"):
+                if url.endswith(suffix):
+                    url = url[: -len(suffix)]
+                    break
+            return url
+    return "https://prism-gateway.swisper.app"  # default

swisper_prism_cli-0.1.0/prism_cli/auto_overlay.py

@@ -0,0 +1,93 @@
+"""Automate the §6.6 recipe: collect git state, build overlay payload."""
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+_MAX_OVERLAY_BYTES = 1024 * 1024  # 1 MB
+
+
+def collect_git_state() -> dict:
+    """Run git commands; return local_state-shaped dict.
+
+    Empty dict on failure (caller should not pass overlay in that case).
+    """
+    try:
+        head = subprocess.check_output(
+            ["git", "rev-parse", "HEAD"], text=True, stderr=subprocess.DEVNULL,
+        ).strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return {}
+    try:
+        branch = subprocess.check_output(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            text=True, stderr=subprocess.DEVNULL,
+        ).strip()
+    except subprocess.CalledProcessError:
+        branch = ""
+
+    dirty_paths: list[str] = []
+    try:
+        porcelain = subprocess.check_output(
+            ["git", "status", "--porcelain", "-uall"],
+            text=True, stderr=subprocess.DEVNULL,
+        )
+    except subprocess.CalledProcessError:
+        return {}
+    for line in porcelain.splitlines():
+        if not line.strip():
+            continue
+        # Two-char status code + space + path. Untracked is "??".
+        path = line[3:].strip()
+        if path:
+            dirty_paths.append(path)
+
+    unpushed: list[str] = []
+    try:
+        log = subprocess.check_output(
+            ["git", "log", "@{upstream}..HEAD", "--format=%H"],
+            text=True, stderr=subprocess.DEVNULL,
+        )
+        unpushed = [s.strip() for s in log.splitlines() if s.strip()]
+    except subprocess.CalledProcessError:
+        pass  # no upstream; not unusual on local-only branches
+
+    return {
+        "head_sha": head,
+        "branch": branch,
+        "dirty_paths": dirty_paths,
+        "unpushed_commits": unpushed,
+    }
+
+
+def build_overlay(
+    state: dict, root: Path | None = None, max_bytes: int = _MAX_OVERLAY_BYTES
+) -> dict:
+    """Build {local_state, working_tree_overlay} from a state dict.
+
+    Reads dirty_paths from disk; truncates if total exceeds max_bytes.
+    """
+    if not state:
+        return {}
+    base = Path(root) if root else Path.cwd()
+    files: dict[str, str] = {}
+    total = 0
+    for path in state.get("dirty_paths", []):
+        full = base / path
+        if not full.is_file():
+            continue
+        try:
+            content = full.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        size = len(content.encode("utf-8"))
+        if total + size > max_bytes:
+            break  # cap; remaining files dropped (caller decides if to retry)
+        files[path] = content
+        total += size
+
+    return {
+        "local_state": state,
+        "working_tree_overlay": files,
+    }

swisper_prism_cli-0.1.0/prism_cli/cli.py

@@ -0,0 +1,265 @@
+"""prism CLI entrypoint."""
+from __future__ import annotations
+
+import json as _json
+import sys
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+from typing import Any
+
+import click
+
+from .api_client import PrismClient, PrismAPIError
+from .auto_overlay import build_overlay, collect_git_state
+from .auth import AuthError
+
+
+def _resolve_version() -> str:
+    try:
+        return _pkg_version("swisper-prism-cli")
+    except PackageNotFoundError:
+        return "0.0.0+local"
+
+
+# Subcommands that benefit from --auto-overlay by default.
+_OVERLAY_DEFAULT_ON = {
+    "search", "grep", "find-refs", "refs", "def", "outline",
+    "module-map", "map", "body", "prepare-edit", "edit-anchors",
+}
+
+
+def _format(result: dict[str, Any], pretty: bool) -> str:
+    if pretty:
+        return _json.dumps(result, indent=2)
+    return _json.dumps(result)
+
+
+def _maybe_attach_overlay(payload: dict[str, Any], auto_overlay: bool) -> dict[str, Any]:
+    if not auto_overlay:
+        return payload
+    state = collect_git_state()
+    if not state:
+        return payload
+    overlay = build_overlay(state)
+    return {**payload, **overlay}
+
+
+def _retry_with_recommended(
+    client: PrismClient, subcommand: str, payload: dict[str, Any], result: dict[str, Any],
+) -> dict[str, Any]:
+    """If response asks for overlay on additional files, retry once.
+
+    overlay_recommended_for is stamped at the top level of the response
+    dict (not nested under 'freshness').
+    """
+    rec = result.get("overlay_recommended_for") or []
+    if not rec:
+        return result
+    state = collect_git_state()
+    overlay = build_overlay({**state, "dirty_paths": rec})
+    new_payload = {**payload, **overlay}
+    return client.call(subcommand, new_payload)
+
+
+def _run(
+    subcommand: str, payload: dict[str, Any], *, auto_overlay: bool, pretty: bool
+) -> int:
+    try:
+        client = PrismClient()
+    except AuthError as e:
+        click.echo(f"auth: {e}", err=True)
+        return 1
+    payload = _maybe_attach_overlay(payload, auto_overlay)
+    try:
+        result = client.call(subcommand, payload)
+        if auto_overlay:
+            result = _retry_with_recommended(client, subcommand, payload, result)
+    except PrismAPIError as e:
+        click.echo(str(e), err=True)
+        return 2
+    finally:
+        try:
+            client.close()
+        except Exception:
+            pass
+    click.echo(_format(result, pretty))
+    return 0
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.version_option(_resolve_version(), prog_name="prism")
+@click.option("--pretty", is_flag=True, help="Indent JSON output.")
+@click.pass_context
+def cli(ctx: click.Context, pretty: bool) -> None:
+    """prism — code-intelligence CLI for AI coding agents."""
+    ctx.ensure_object(dict)
+    ctx.obj["pretty"] = pretty
+
+
+def _add_overlay_flag(default_on: bool) -> Any:
+    return click.option(
+        "--auto-overlay/--no-overlay",
+        default=default_on,
+        help="Run git status + read dirty files into overlay payload.",
+    )
+
+
+@cli.command()
+@click.argument("query")
+@click.option("--limit", type=int, default=20)
+@click.option("--repo")
+@_add_overlay_flag(True)
+@click.pass_context
+def search(ctx: click.Context, query: str, limit: int, repo: str | None, auto_overlay: bool) -> None:
+    payload: dict[str, Any] = {"query": query, "limit": limit}
+    if repo:
+        payload["repo"] = repo
+    sys.exit(_run("search", payload, auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="grep")
+@click.argument("query")
+@click.option("--limit", type=int, default=20)
+@click.option("--repo")
+@_add_overlay_flag(True)
+@click.pass_context
+def grep(ctx: click.Context, query: str, limit: int, repo: str | None, auto_overlay: bool) -> None:
+    """Alias for search."""
+    payload: dict[str, Any] = {"query": query, "limit": limit}
+    if repo:
+        payload["repo"] = repo
+    sys.exit(_run("search", payload, auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="find-refs")
+@click.argument("symbol")
+@click.option(
+    "--kind",
+    type=click.Choice(["all", "callers", "imports", "definitions"]),
+    default="all",
+)
+@click.option("--repo")
+@_add_overlay_flag(True)
+@click.pass_context
+def find_refs(ctx: click.Context, symbol: str, kind: str, repo: str | None, auto_overlay: bool) -> None:
+    payload: dict[str, Any] = {"symbol": symbol, "reference_type": kind}
+    if repo:
+        payload["repo"] = repo
+    sys.exit(_run("find-refs", payload, auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="refs")
+@click.argument("symbol")
+@_add_overlay_flag(True)
+@click.pass_context
+def refs(ctx: click.Context, symbol: str, auto_overlay: bool) -> None:
+    """Alias for find-refs."""
+    sys.exit(_run("find-refs", {"symbol": symbol},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="def")
+@click.argument("symbol")
+@_add_overlay_flag(True)
+@click.pass_context
+def definition(ctx: click.Context, symbol: str, auto_overlay: bool) -> None:
+    sys.exit(_run("def", {"symbol": symbol},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command()
+@click.argument("path")
+@_add_overlay_flag(True)
+@click.pass_context
+def outline(ctx: click.Context, path: str, auto_overlay: bool) -> None:
+    sys.exit(_run("outline", {"file_path": path},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="module-map")
+@click.argument("path", required=False, default=".")
+@_add_overlay_flag(True)
+@click.pass_context
+def module_map(ctx: click.Context, path: str, auto_overlay: bool) -> None:
+    sys.exit(_run("module-map", {"path": path},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="map")
+@click.argument("path", required=False, default=".")
+@_add_overlay_flag(True)
+@click.pass_context
+def map_alias(ctx: click.Context, path: str, auto_overlay: bool) -> None:
+    """Alias for module-map."""
+    sys.exit(_run("module-map", {"path": path},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command()
+@click.argument("symbol")
+@_add_overlay_flag(True)
+@click.pass_context
+def body(ctx: click.Context, symbol: str, auto_overlay: bool) -> None:
+    sys.exit(_run("body", {"symbol": symbol},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command()
+@click.argument("path")
+@click.pass_context
+def deps(ctx: click.Context, path: str) -> None:
+    sys.exit(_run("deps", {"path": path},
+                  auto_overlay=False, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="prepare-edit")
+@click.argument("symbol")
+@_add_overlay_flag(True)
+@click.pass_context
+def prepare_edit(ctx: click.Context, symbol: str, auto_overlay: bool) -> None:
+    sys.exit(_run("prepare-edit", {"symbol": symbol},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="edit-anchors")
+@click.argument("symbol")
+@_add_overlay_flag(True)
+@click.pass_context
+def edit_anchors(ctx: click.Context, symbol: str, auto_overlay: bool) -> None:
+    sys.exit(_run("edit-anchors", {"symbol": symbol},
+                  auto_overlay=auto_overlay, pretty=ctx.obj["pretty"]))
+
+
+@cli.command()
+@click.argument("intent")
+@click.pass_context
+def check(ctx: click.Context, intent: str) -> None:
+    sys.exit(_run("check", {"intent": intent},
+                  auto_overlay=False, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="find")
+@click.argument("pattern")
+@click.pass_context
+def find_files(ctx: click.Context, pattern: str) -> None:
+    sys.exit(_run("find", {"pattern": pattern},
+                  auto_overlay=False, pretty=ctx.obj["pretty"]))
+
+
+@cli.command()
+@click.pass_context
+def ping(ctx: click.Context) -> None:
+    sys.exit(_run("ping", {}, auto_overlay=False, pretty=ctx.obj["pretty"]))
+
+
+@cli.command(name="list-repos")
+@click.pass_context
+def list_repos(ctx: click.Context) -> None:
+    sys.exit(_run("list-repos", {}, auto_overlay=False, pretty=ctx.obj["pretty"]))
+
+
+def main() -> None:
+    cli(obj={})
+
+
+if __name__ == "__main__":
+    main()

swisper_prism_cli-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "swisper-prism-cli"
+version = "0.1.0"
+description = "Prism — code-intelligence CLI for AI coding agents"
+authors = [{name = "Fintama Prism Team"}]
+license = {text = "Proprietary - Fintama Internal Use Only"}
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "click>=8.1",
+    "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://github.com/Fintama/swisper_prism"
+Repository = "https://github.com/Fintama/swisper_prism"
+Documentation = "https://github.com/Fintama/swisper_prism/tree/main/apps/prism-cli"
+
+[project.scripts]
+prism = "prism_cli.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["prism_cli"]
+
+[tool.pytest.ini_options]
+markers = [
+    "unit: fast unit tests (no I/O)",
+    "integration: integration tests",
+    "e2e: end-to-end tests",
+    "ci_critical: golden-path tests that must complete in <2s each",
+]

swisper_prism_cli-0.1.0/tests/test_auth.py

@@ -0,0 +1,75 @@
+"""Tests for the prism CLI auth resolution."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+
+
+@pytest.mark.unit
+def test_token_from_env_var(monkeypatch):
+    monkeypatch.setenv("PRISM_TOKEN", "from-env")
+    from prism_cli.auth import resolve_token
+    assert resolve_token() == "from-env"
+
+
+@pytest.mark.unit
+def test_token_from_claude_json(monkeypatch, tmp_path):
+    monkeypatch.delenv("PRISM_TOKEN", raising=False)
+    home = tmp_path
+    (home / ".claude.json").write_text(json.dumps({
+        "mcpServers": {
+            "prism-hosted": {
+                "type": "streamable-http",
+                "url": "https://gw.example/mcp",
+                "headers": {"Authorization": "Bearer from-claude"},
+            }
+        }
+    }))
+    monkeypatch.setattr(Path, "home", lambda: home)
+    from prism_cli.auth import resolve_token
+    assert resolve_token() == "from-claude"
+
+
+@pytest.mark.unit
+def test_token_missing_raises(monkeypatch, tmp_path):
+    monkeypatch.delenv("PRISM_TOKEN", raising=False)
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    from prism_cli.auth import resolve_token, AuthError
+    with pytest.raises(AuthError):
+        resolve_token()
+
+
+@pytest.mark.unit
+def test_base_url_from_env(monkeypatch):
+    monkeypatch.setenv("PRISM_BASE_URL", "http://custom:8080")
+    from prism_cli.auth import resolve_base_url
+    assert resolve_base_url() == "http://custom:8080"
+
+
+@pytest.mark.unit
+def test_base_url_strips_mcp_suffix(monkeypatch, tmp_path):
+    monkeypatch.delenv("PRISM_BASE_URL", raising=False)
+    home = tmp_path
+    (home / ".claude.json").write_text(json.dumps({
+        "mcpServers": {
+            "prism-hosted": {
+                "type": "streamable-http",
+                "url": "https://gw.example/mcp",
+                "headers": {"Authorization": "Bearer tok"},
+            }
+        }
+    }))
+    monkeypatch.setattr(Path, "home", lambda: home)
+    from prism_cli.auth import resolve_base_url
+    assert resolve_base_url() == "https://gw.example"
+
+
+@pytest.mark.unit
+def test_base_url_default(monkeypatch, tmp_path):
+    monkeypatch.delenv("PRISM_BASE_URL", raising=False)
+    monkeypatch.setattr(Path, "home", lambda: tmp_path)
+    from prism_cli.auth import resolve_base_url
+    assert resolve_base_url() == "https://prism-gateway.swisper.app"

swisper_prism_cli-0.1.0/tests/test_auto_overlay.py

@@ -0,0 +1,79 @@
+"""Tests for git-state collection and overlay assembly."""
+from __future__ import annotations
+
+import subprocess
+from unittest.mock import patch
+
+import pytest
+
+
+@pytest.mark.unit
+def test_collect_git_state_returns_head_and_dirty(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    # Build a minimal repo
+    subprocess.run(["git", "init", "-q", "."], check=True)
+    subprocess.run(["git", "config", "user.email", "t@t"], check=True)
+    subprocess.run(["git", "config", "user.name", "t"], check=True)
+    (tmp_path / "x.py").write_text("a")
+    subprocess.run(["git", "add", "x.py"], check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "init"], check=True)
+    (tmp_path / "x.py").write_text("changed")  # dirty
+
+    from prism_cli.auto_overlay import collect_git_state
+    state = collect_git_state()
+    assert len(state["head_sha"]) >= 7
+    assert "x.py" in state["dirty_paths"]
+
+
+@pytest.mark.unit
+def test_build_overlay_reads_dirty_files_within_cap(tmp_path):
+    (tmp_path / "x.py").write_text("hello")
+    state = {
+        "head_sha": "abc", "branch": "main",
+        "dirty_paths": ["x.py"], "unpushed_commits": [],
+    }
+    from prism_cli.auto_overlay import build_overlay
+    payload = build_overlay(state, root=tmp_path, max_bytes=1024 * 1024)
+    assert payload["working_tree_overlay"]["x.py"] == "hello"
+
+
+@pytest.mark.unit
+def test_collect_git_state_returns_empty_outside_repo(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    from prism_cli.auto_overlay import collect_git_state
+    # tmp_path is not a git repo — git rev-parse HEAD should fail
+    state = collect_git_state()
+    assert state == {}
+
+
+@pytest.mark.unit
+def test_build_overlay_empty_state_returns_empty():
+    from prism_cli.auto_overlay import build_overlay
+    assert build_overlay({}) == {}
+
+
+@pytest.mark.unit
+def test_build_overlay_respects_byte_cap(tmp_path):
+    """Files that would exceed the cap are not included."""
+    (tmp_path / "big.py").write_text("x" * 100)
+    (tmp_path / "small.py").write_text("y" * 10)
+    state = {
+        "head_sha": "abc", "branch": "main",
+        "dirty_paths": ["big.py", "small.py"],
+        "unpushed_commits": [],
+    }
+    from prism_cli.auto_overlay import build_overlay
+    # cap at 50 bytes — big.py (100 bytes) must be dropped
+    payload = build_overlay(state, root=tmp_path, max_bytes=50)
+    assert "big.py" not in payload["working_tree_overlay"]
+
+
+@pytest.mark.unit
+def test_build_overlay_skips_missing_files(tmp_path):
+    state = {
+        "head_sha": "abc", "branch": "main",
+        "dirty_paths": ["nonexistent.py"], "unpushed_commits": [],
+    }
+    from prism_cli.auto_overlay import build_overlay
+    payload = build_overlay(state, root=tmp_path)
+    assert payload["working_tree_overlay"] == {}

swisper_prism_cli-0.1.0/tests/test_cli.py

@@ -0,0 +1,184 @@
+"""End-to-end CLI invocation tests using a fake API client."""
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+
+@pytest.mark.unit
+def test_cli_help():
+    from prism_cli.cli import cli
+    runner = CliRunner()
+    result = runner.invoke(cli, ["--help"])
+    assert result.exit_code == 0
+    assert "search" in result.output
+    assert "find-refs" in result.output
+    assert "grep" in result.output  # alias visible
+
+
+@pytest.mark.unit
+def test_cli_ping_invokes_client():
+    from prism_cli import cli as cli_mod
+    runner = CliRunner()
+
+    class FakeClient:
+        def __init__(self): pass
+        def call(self, sub, payload):
+            return {"ok": True, "subcommand": sub, "payload": payload}
+        def close(self): pass
+
+    with patch.object(cli_mod, "PrismClient", FakeClient):
+        result = runner.invoke(cli_mod.cli, ["ping"])
+    assert result.exit_code == 0
+    body = json.loads(result.output)
+    assert body["subcommand"] == "ping"
+
+
+@pytest.mark.unit
+def test_grep_routes_to_search_subcommand():
+    from prism_cli import cli as cli_mod
+    runner = CliRunner()
+
+    class FakeClient:
+        def __init__(self): self.last = None
+        def call(self, sub, payload):
+            self.last = (sub, payload)
+            return {"ok": True}
+        def close(self): pass
+
+    fake = FakeClient()
+    with patch.object(cli_mod, "PrismClient", lambda: fake):
+        result = runner.invoke(cli_mod.cli, ["grep", "needle", "--no-overlay"])
+    assert result.exit_code == 0
+    sub, payload = fake.last
+    assert sub == "search"
+    assert payload["query"] == "needle"
+
+
+@pytest.mark.unit
+def test_map_alias_routes_to_module_map():
+    from prism_cli import cli as cli_mod
+    runner = CliRunner()
+
+    class FakeClient:
+        def __init__(self): self.last = None
+        def call(self, sub, payload):
+            self.last = (sub, payload)
+            return {"ok": True}
+        def close(self): pass
+
+    fake = FakeClient()
+    with patch.object(cli_mod, "PrismClient", lambda: fake):
+        result = runner.invoke(cli_mod.cli, ["map", ".", "--no-overlay"])
+    assert result.exit_code == 0
+    sub, payload = fake.last
+    assert sub == "module-map"
+
+
+@pytest.mark.unit
+def test_refs_alias_routes_to_find_refs():
+    from prism_cli import cli as cli_mod
+    runner = CliRunner()
+
+    class FakeClient:
+        def __init__(self): self.last = None
+        def call(self, sub, payload):
+            self.last = (sub, payload)
+            return {"ok": True}
+        def close(self): pass
+
+    fake = FakeClient()
+    with patch.object(cli_mod, "PrismClient", lambda: fake):
+        result = runner.invoke(cli_mod.cli, ["refs", "MyClass", "--no-overlay"])
+    assert result.exit_code == 0
+    sub, payload = fake.last
+    assert sub == "find-refs"
+    assert payload["symbol"] == "MyClass"
+
+
+@pytest.mark.unit
+def test_auth_error_exits_1(monkeypatch):
+    from prism_cli import cli as cli_mod
+    from prism_cli.auth import AuthError
+    runner = CliRunner()
+
+    def raise_auth(*args, **kwargs):
+        raise AuthError("no token")
+
+    with patch.object(cli_mod, "PrismClient", raise_auth):
+        result = runner.invoke(cli_mod.cli, ["ping"])
+    assert result.exit_code == 1
+    assert "auth" in result.output
+
+
+@pytest.mark.unit
+def test_api_error_exits_2():
+    from prism_cli import cli as cli_mod
+    from prism_cli.api_client import PrismAPIError
+    runner = CliRunner()
+
+    class FailClient:
+        def __init__(self): pass
+        def call(self, sub, payload):
+            raise PrismAPIError("server exploded")
+        def close(self): pass
+
+    with patch.object(cli_mod, "PrismClient", FailClient):
+        result = runner.invoke(cli_mod.cli, ["ping"])
+    assert result.exit_code == 2
+
+
+@pytest.mark.unit
+def test_pretty_flag_indents_output():
+    from prism_cli import cli as cli_mod
+    runner = CliRunner()
+
+    class FakeClient:
+        def __init__(self): pass
+        def call(self, sub, payload):
+            return {"key": "value"}
+        def close(self): pass
+
+    with patch.object(cli_mod, "PrismClient", FakeClient):
+        result = runner.invoke(cli_mod.cli, ["--pretty", "ping"])
+    assert result.exit_code == 0
+    # Pretty output has indentation
+    assert "\n" in result.output
+    body = json.loads(result.output)
+    assert body["key"] == "value"
+
+
+@pytest.mark.unit
+def test_retry_on_overlay_recommended_for():
+    """CLI retries once when response contains overlay_recommended_for."""
+    from prism_cli import cli as cli_mod
+    runner = CliRunner()
+
+    call_log = []
+
+    class FakeClient:
+        def __init__(self): pass
+        def call(self, sub, payload):
+            call_log.append((sub, payload.copy()))
+            if len(call_log) == 1:
+                return {"results": [], "overlay_recommended_for": ["src/foo.py"]}
+            return {"results": ["retried"], "overlay_recommended_for": []}
+        def close(self): pass
+
+    # Mock collect_git_state + build_overlay so they return something usable
+    with patch.object(cli_mod, "PrismClient", FakeClient), \
+         patch.object(cli_mod, "collect_git_state", return_value={
+             "head_sha": "abc", "branch": "main",
+             "dirty_paths": [], "unpushed_commits": [],
+         }), \
+         patch.object(cli_mod, "build_overlay", return_value={
+             "local_state": {"head_sha": "abc"},
+             "working_tree_overlay": {},
+         }):
+        result = runner.invoke(cli_mod.cli, ["search", "something", "--auto-overlay"])
+    assert result.exit_code == 0
+    # Should have called the client twice (initial + retry)
+    assert len(call_log) == 2

swisper_prism_cli-0.1.0/tests/test_packaging_smoke.py

@@ -0,0 +1,56 @@
+"""Packaging smoke test — gates the PyPI publish pipeline.
+
+Asserts pyproject.toml metadata is publish-ready and `prism --version`
+round-trips with the version declared in pyproject.toml.
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+import pytest
+
+
+_PYPROJECT = Path(__file__).resolve().parent.parent / "pyproject.toml"
+
+
+def _read_pyproject() -> dict:
+    return tomllib.loads(_PYPROJECT.read_text())
+
+
+@pytest.mark.unit
+def test_distribution_name_is_swisper_prism_cli() -> None:
+    """PyPI distribution name must be `swisper-prism-cli` (mirrors swisper-studio-sdk)."""
+    project = _read_pyproject()["project"]
+    assert project["name"] == "swisper-prism-cli", (
+        f"Expected name 'swisper-prism-cli' (PyPI), got {project['name']!r}"
+    )
+
+
+@pytest.mark.unit
+def test_pyproject_has_publish_required_fields() -> None:
+    """A publishable PyPI package needs name, version, description, authors,
+    license, readme, and a Homepage URL. Missing any of these makes
+    `twine check` warn or fail."""
+    project = _read_pyproject()["project"]
+    for field in ("name", "version", "description", "authors", "license", "readme"):
+        assert field in project, f"Missing required publish field: {field!r}"
+    urls = project.get("urls", {})
+    assert urls.get("Homepage"), "Missing [project.urls] Homepage"
+
+
+@pytest.mark.unit
+def test_prism_version_matches_pyproject() -> None:
+    """`prism --version` must print the version declared in pyproject.toml.
+    Catches mismatches between the package metadata and the bundled binary."""
+    declared = _read_pyproject()["project"]["version"]
+    result = subprocess.run(
+        [sys.executable, "-m", "prism_cli.cli", "--version"],
+        capture_output=True, text=True, check=True,
+    )
+    assert declared in result.stdout, (
+        f"`prism --version` output {result.stdout.strip()!r} does not contain "
+        f"declared pyproject version {declared!r}"
+    )

swisper_prism_cli-0.1.0/uv.lock

@@ -0,0 +1,116 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.4.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/cc/762dfb036166873f0059f3b7de4565e1b5bc3d6f28a414c13da27e442f99/idna-3.13.tar.gz", hash = "sha256:585ea8fe5d69b9181ec1afba340451fba6ba764af97026f92a91d4eef164a242", size = 194210, upload-time = "2026-04-22T16:42:42.314Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/13/ad7d7ca3808a898b4612b6fe93cde56b53f3034dcde235acb1f0e1df24c6/idna-3.13-py3-none-any.whl", hash = "sha256:892ea0cde124a99ce773decba204c5552b69c3c67ffd5f232eb7696135bc8bb3", size = 68629, upload-time = "2026-04-22T16:42:40.909Z" },
+]
+
+[[package]]
+name = "swisper-prism-cli"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "click" },
+    { name = "httpx" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "click", specifier = ">=8.1" },
+    { name = "httpx", specifier = ">=0.27" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]