agentsnap 0.1.0__tar.gz

agentsnap-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+.claude/
+
+.pytest_cache/
+
+__agent_snapshots__/
+
+.env
+
+docs/

agentsnap-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

agentsnap-0.1.0/.superpowers/sdd/.gitignore

@@ -0,0 +1 @@
+*

agentsnap-0.1.0/.superpowers/sdd/progress.md

@@ -0,0 +1,10 @@
+# SDD Progress Ledger
+# Plan: docs/superpowers/plans/2026-06-27-setup-wizard.md
+# Branch base: b76ce6c3517bf78d441e76c4a40d09fda812ce53
+
+## Tasks
+- [x] Task 1: config.py write_config() + tomlkit dep (commit b76ce6c..b920f99, review clean)
+- [x] Task 2: setup_wizard.py — WizardResult, run_wizard, apply_result (commit b920f99..0af0c0f, review clean)
+  Minor findings: mid-file imports in test (inherited from brief); mock patches openai.OpenAI globally (works but subtle)
+- [x] Task 3: CLI commands — agentsnap init and agentsnap check (commits 0af0c0f..6128d5a, review clean; Important findings fixed: SystemExit consistency, config.get defaults, unused imports)
+- [x] Task 4: README and USAGE update (commit 8e0cac5, review pending)

agentsnap-0.1.0/.superpowers/sdd/review-0835bb9..4ab6190.diff

@@ -0,0 +1,192 @@
+# Review package: 0835bb9..HEAD
+
+## Commits
+4ab6190 feat: agentsnap update shows diff and prompts for confirmation
+
+## Files changed
+ agentsnap/cli.py                     | 49 +++++++++++++++++++++++--
+ tests/integration/test_cli_update.py | 70 ++++++++++++++++++++++++++++++++++++
+ 2 files changed, 116 insertions(+), 3 deletions(-)
+
+## Diff
+diff --git a/agentsnap/cli.py b/agentsnap/cli.py
+index a645b5f..3a9011d 100644
+--- a/agentsnap/cli.py
++++ b/agentsnap/cli.py
+@@ -1,21 +1,20 @@
+ from __future__ import annotations
+ 
+ import json
+ import shutil
+ import sys
+ from pathlib import Path
+ 
+ import click
+ 
+ from agentsnap.core.snapshot import list_snapshots, last_run_path, snapshot_path
+-from agentsnap.exceptions import SnapshotNotFoundError
+ 
+ DEFAULT_SNAPSHOT_DIR = "__agent_snapshots__"
+ 
+ 
+ @click.group()
+ def cli() -> None:
+     """agentsnap — deterministic snapshot testing for AI agents."""
+ 
+ 
+ @cli.command("record")
+@@ -49,32 +48,76 @@ def run_cmd(test_file: str, snapshot_dir: str) -> None:
+ def diff_cmd(snapshot_file: str) -> None:
+     """Pretty-print snapshot contents."""
+     path = Path(snapshot_file)
+     if not path.exists():
+         click.echo(f"Snapshot not found: {snapshot_file}", err=True)
+         raise SystemExit(1)
+     data = json.loads(path.read_text(encoding="utf-8"))
+     click.echo(json.dumps(data, indent=2, sort_keys=True))
+ 
+ 
++def _print_update_diff(old: dict, new: dict) -> None:
++    """Print a human-readable diff between golden and last-run snapshots."""
++    click.echo("\nChanges to approve:")
++
++    old_output = old.get("output", "")
++    new_output = new.get("output", "")
++    if old_output != new_output:
++        click.echo(f"  output:\n    old: {old_output!r}\n    new: {new_output!r}")
++    else:
++        click.echo(f"  output: unchanged ({old_output!r})")
++
++    old_tools = [s["name"] for s in old.get("trace", []) if s.get("type") == "tool_call"]
++    new_tools = [s["name"] for s in new.get("trace", []) if s.get("type") == "tool_call"]
++    if old_tools != new_tools:
++        click.echo(f"  tool sequence:\n    old: {old_tools}\n    new: {new_tools}")
++    else:
++        click.echo(f"  tool sequence: unchanged {old_tools}")
++
++    old_steps = len(old.get("trace", []))
++    new_steps = len(new.get("trace", []))
++    if old_steps != new_steps:
++        click.echo(f"  trace steps: {old_steps} → {new_steps}")
++
++    old_model = old.get("model", "unknown")
++    new_model = new.get("model", "unknown")
++    if old_model != new_model:
++        click.echo(f"  model: {old_model!r} → {new_model!r}")
++
++
+ @cli.command("update")
+ @click.argument("test_name")
+ @click.option("--snapshot-dir", default=DEFAULT_SNAPSHOT_DIR, show_default=True)
+-def update_cmd(test_name: str, snapshot_dir: str) -> None:
+-    """Copy the last run trace over the snapshot (approve a regression)."""
++@click.option("--yes", "-y", is_flag=True, default=False, help="Skip confirmation prompt.")
++def update_cmd(test_name: str, snapshot_dir: str, yes: bool) -> None:
++    """Show what changed and promote the last run to the golden snapshot."""
+     src = last_run_path(test_name, snapshot_dir)
+     dst = snapshot_path(test_name, snapshot_dir)
++
+     if not src.exists():
+         click.echo(
+             f"No last run found for '{test_name}'. Run 'agentsnap run' first.", err=True
+         )
+         raise SystemExit(1)
++
++    if dst.exists():
++        old = json.loads(dst.read_text(encoding="utf-8"))
++        new = json.loads(src.read_text(encoding="utf-8"))
++        _print_update_diff(old, new)
++    else:
++        click.echo("No existing snapshot — will create a new golden.")
++
++    if not yes:
++        if not click.confirm("\nApprove and update snapshot?"):
++            click.echo("Aborted.")
++            raise SystemExit(1)
++
+     shutil.copy2(src, dst)
+     click.echo(f"Updated snapshot: {dst}")
+ 
+ 
+ @cli.command("list")
+ @click.option("--snapshot-dir", default=DEFAULT_SNAPSHOT_DIR, show_default=True)
+ def list_cmd(snapshot_dir: str) -> None:
+     """List all snapshots in the snapshot directory."""
+     snapshots = list_snapshots(snapshot_dir)
+     if not snapshots:
+diff --git a/tests/integration/test_cli_update.py b/tests/integration/test_cli_update.py
+new file mode 100644
+index 0000000..a6efe57
+--- /dev/null
++++ b/tests/integration/test_cli_update.py
+@@ -0,0 +1,70 @@
++from __future__ import annotations
++
++import json
++from pathlib import Path
++
++import pytest
++from click.testing import CliRunner
++
++from agentsnap.cli import cli
++from agentsnap.core.snapshot import last_run_path, snapshot_path
++
++
++def _write_snap(path: Path, output: str, tools: list[str]) -> None:
++    path.parent.mkdir(parents=True, exist_ok=True)
++    trace = [{"type": "tool_call", "name": t, "args": {}, "result": "r", "step": i}
++             for i, t in enumerate(tools)]
++    data = {"output": output, "trace": trace, "model": "test", "version": "1.0",
++            "recorded_at": "2026-01-01T00:00:00+00:00", "input": None}
++    path.write_text(json.dumps(data), encoding="utf-8")
++
++
++def test_update_shows_diff_and_confirms(tmp_path):
++    runner = CliRunner()
++    snap_dir = str(tmp_path / "snaps")
++    name = "my_test"
++
++    _write_snap(snapshot_path(name, snap_dir), output="old output", tools=["search"])
++    _write_snap(last_run_path(name, snap_dir), output="new output", tools=["fetch"])
++
++    result = runner.invoke(cli, ["update", name, f"--snapshot-dir={snap_dir}", "--yes"])
++
++    assert result.exit_code == 0, result.output
++    assert "old output" in result.output
++    assert "new output" in result.output
++    assert "fetch" in result.output
++
++
++def test_update_aborts_without_yes(tmp_path):
++    runner = CliRunner()
++    snap_dir = str(tmp_path / "snaps")
++    name = "abort_test"
++
++    _write_snap(snapshot_path(name, snap_dir), output="old", tools=[])
++    _write_snap(last_run_path(name, snap_dir), output="new", tools=[])
++
++    # Simulate user typing 'n'
++    result = runner.invoke(cli, ["update", name, f"--snapshot-dir={snap_dir}"], input="n\n")
++
++    assert result.exit_code != 0
++    # Golden should be unchanged
++    data = json.loads(snapshot_path(name, snap_dir).read_text())
++    assert data["output"] == "old"
++
++
++def test_update_no_last_run_exits_nonzero(tmp_path):
++    runner = CliRunner()
++    result = runner.invoke(cli, ["update", "missing", f"--snapshot-dir={tmp_path}"])
++    assert result.exit_code != 0
++
++
++def test_update_no_existing_golden_creates_new(tmp_path):
++    runner = CliRunner()
++    snap_dir = str(tmp_path / "snaps")
++    name = "new_golden"
++
++    _write_snap(last_run_path(name, snap_dir), output="first output", tools=["lookup"])
++
++    result = runner.invoke(cli, ["update", name, f"--snapshot-dir={snap_dir}", "--yes"])
++    assert result.exit_code == 0
++    assert snapshot_path(name, snap_dir).exists()

agentsnap-0.1.0/.superpowers/sdd/review-0af0c0f..92532e8.diff

@@ -0,0 +1,310 @@
+# Review package: 0af0c0f3bd2c6900446a8b78ff9a46c4a6d99934..HEAD
+
+## Commits
+92532e8 feat: add agentsnap init and agentsnap check CLI commands
+
+## Files changed
+ agentsnap/cli.py                   |  86 ++++++++++++++++++
+ tests/integration/test_cli_init.py | 182 +++++++++++++++++++++++++++++++++++++
+ 2 files changed, 268 insertions(+)
+
+## Diff
+diff --git a/agentsnap/cli.py b/agentsnap/cli.py
+index 3a9011d..ce499f8 100644
+--- a/agentsnap/cli.py
++++ b/agentsnap/cli.py
+@@ -108,20 +108,106 @@ def update_cmd(test_name: str, snapshot_dir: str, yes: bool) -> None:
+ 
+     if not yes:
+         if not click.confirm("\nApprove and update snapshot?"):
+             click.echo("Aborted.")
+             raise SystemExit(1)
+ 
+     shutil.copy2(src, dst)
+     click.echo(f"Updated snapshot: {dst}")
+ 
+ 
++@cli.command("init")
++def init_cmd() -> None:
++    """Interactive setup wizard — choose LLM judge or offline embeddings."""
++    from agentsnap.setup_wizard import (
++        _download_model,
++        apply_result,
++        run_wizard,
++        test_judge_connection,
++    )
++
++    result = run_wizard()
++    project_dir = Path.cwd()
++    apply_result(result, project_dir)
++
++    if result.backend == "offline":
++        if result.pre_download_model:
++            click.echo("\nDownloading all-MiniLM-L6-v2...")
++            _download_model()
++            click.echo("  Model cached.")
++        else:
++            click.echo(
++                "\nModel will download automatically on first test run (~22 MB)."
++            )
++        click.echo("\nOffline embeddings configured.")
++    else:
++        click.echo("\nTesting connection...")
++        try:
++            latency = test_judge_connection(
++                base_url=result.judge_base_url,
++                model=result.judge_model,
++                api_key=result.api_key,
++            )
++            click.echo(f"  Connection ok ({latency:.1f}s)")
++        except RuntimeError as exc:
++            click.echo(f"  Warning: {exc}", err=True)
++            click.echo(
++                "  Setup saved anyway — fix the key and re-run `agentsnap check`."
++            )
++
++        if result.save_key_to_env:
++            click.echo(f"  API key written to .env ({result.api_key_env_var})")
++        click.echo("\nLLM judge configured.")
++
++    click.echo("Configuration written to pyproject.toml.")
++    click.echo("\nRun `pytest` to verify everything works.")
++
++
++@cli.command("check")
++def check_cmd() -> None:
++    """Verify current agentsnap setup and backend connectivity."""
++    import sys
++
++    from agentsnap import config
++    from agentsnap.setup_wizard import check_offline_model, test_judge_connection
++
++    cfg = config.load(Path.cwd())
++    api_key = cfg.get("judge_api_key")
++
++    if api_key:
++        click.echo("Backend : LLM judge")
++        click.echo(f"Provider: {cfg['judge_base_url']}")
++        click.echo(f"Model   : {cfg['judge_model']}")
++        click.echo("API key : found")
++        try:
++            latency = test_judge_connection(
++                base_url=cfg["judge_base_url"],
++                model=cfg["judge_model"],
++                api_key=api_key,
++            )
++            click.echo(f"Status  : ok ({latency:.2f}s)")
++        except RuntimeError as exc:
++            click.echo(f"Status  : error — {exc}", err=True)
++            sys.exit(1)
++    else:
++        cached = check_offline_model()
++        click.echo("Backend : offline embeddings (all-MiniLM-L6-v2)")
++        if cached:
++            click.echo(f"Model   : cached at {cached}")
++            click.echo("Status  : ok")
++        else:
++            click.echo(
++                "Model   : not cached — will download (~22 MB) on first test run"
++            )
++            click.echo("Status  : ok (will download on first run)")
++
++
+ @cli.command("list")
+ @click.option("--snapshot-dir", default=DEFAULT_SNAPSHOT_DIR, show_default=True)
+ def list_cmd(snapshot_dir: str) -> None:
+     """List all snapshots in the snapshot directory."""
+     snapshots = list_snapshots(snapshot_dir)
+     if not snapshots:
+         click.echo(f"No snapshots found in '{snapshot_dir}'.")
+         return
+     click.echo(f"Snapshots in '{snapshot_dir}':")
+     for p in snapshots:
+diff --git a/tests/integration/test_cli_init.py b/tests/integration/test_cli_init.py
+new file mode 100644
+index 0000000..2728edd
+--- /dev/null
++++ b/tests/integration/test_cli_init.py
+@@ -0,0 +1,182 @@
++from __future__ import annotations
++
++import unittest.mock as mock
++from pathlib import Path
++
++import pytest
++from click.testing import CliRunner
++
++from agentsnap.cli import cli
++
++
++# ── agentsnap init — offline path ─────────────────────────────────────────────
++
++def test_init_offline_no_predownload(tmp_path):
++    """User picks [2] offline, declines pre-download."""
++    runner = CliRunner()
++    with runner.isolated_filesystem(temp_dir=tmp_path):
++        result = runner.invoke(
++            cli,
++            ["init"],
++            input="2\nn\n",   # [2] offline, [n] no pre-download
++            catch_exceptions=False,
++        )
++    assert result.exit_code == 0, result.output
++    assert "offline" in result.output.lower() or "embedding" in result.output.lower()
++
++
++def test_init_offline_with_predownload(tmp_path):
++    """User picks [2] offline and accepts pre-download; download is mocked."""
++    runner = CliRunner()
++    with mock.patch("agentsnap.setup_wizard._download_model") as mock_dl:
++        with runner.isolated_filesystem(temp_dir=tmp_path):
++            result = runner.invoke(
++                cli,
++                ["init"],
++                input="2\ny\n",
++                catch_exceptions=False,
++            )
++    assert result.exit_code == 0, result.output
++    mock_dl.assert_called_once()
++
++
++def test_init_writes_pyproject_toml(tmp_path):
++    """init must create/update pyproject.toml in the working directory."""
++    runner = CliRunner()
++    with runner.isolated_filesystem(temp_dir=tmp_path):
++        runner.invoke(cli, ["init"], input="2\nn\n", catch_exceptions=False)
++        assert Path("pyproject.toml").exists()
++
++
++def test_init_menu_shows_coming_soon(tmp_path):
++    """The wizard output must mention coming soon for local LLM option."""
++    runner = CliRunner()
++    with runner.isolated_filesystem(temp_dir=tmp_path):
++        result = runner.invoke(
++            cli,
++            ["init"],
++            input="2\nn\n",
++            catch_exceptions=False,
++        )
++    assert "coming soon" in result.output.lower()
++
++
++# ── agentsnap init — judge path ───────────────────────────────────────────────
++
++def test_init_judge_openrouter(tmp_path):
++    """User picks [1] judge with OpenRouter; connectivity test is mocked."""
++    runner = CliRunner()
++    with mock.patch("agentsnap.setup_wizard.test_judge_connection", return_value=0.5):
++        with runner.isolated_filesystem(temp_dir=tmp_path):
++            result = runner.invoke(
++                cli,
++                ["init"],
++                # [1] judge, [1] openrouter, accept default model, api key, [y] save to .env
++                input="1\n1\n\nsk-or-test\ny\n",
++                catch_exceptions=False,
++            )
++    assert result.exit_code == 0, result.output
++    assert "judge" in result.output.lower() or "connection" in result.output.lower()
++
++
++def test_init_judge_saves_key_to_env_not_pyproject(tmp_path):
++    """API key must be written to .env, never to pyproject.toml."""
++    runner = CliRunner()
++    with mock.patch("agentsnap.setup_wizard.test_judge_connection", return_value=0.3):
++        with runner.isolated_filesystem(temp_dir=tmp_path):
++            runner.invoke(
++                cli,
++                ["init"],
++                input="1\n1\n\nsk-or-testkey\ny\n",
++                catch_exceptions=False,
++            )
++            assert Path(".env").exists()
++            assert "sk-or-testkey" in Path(".env").read_text()
++            assert "sk-or-testkey" not in Path("pyproject.toml").read_text()
++
++
++def test_init_judge_connection_failure_shows_warning(tmp_path):
++    """If connectivity test fails, init still completes and shows a warning."""
++    runner = CliRunner()
++    with mock.patch(
++        "agentsnap.setup_wizard.test_judge_connection",
++        side_effect=RuntimeError("auth failed"),
++    ):
++        with runner.isolated_filesystem(temp_dir=tmp_path):
++            result = runner.invoke(
++                cli,
++                ["init"],
++                input="1\n1\n\nsk-bad\ny\n",
++                catch_exceptions=False,
++            )
++    assert result.exit_code == 0, result.output
++    assert "warning" in result.output.lower() or "failed" in result.output.lower()
++
++
++# ── agentsnap check ───────────────────────────────────────────────────────────
++
++def test_check_offline_cached(tmp_path, monkeypatch):
++    """check exits 0 and reports model cached when offline model is present."""
++    monkeypatch.setattr(
++        "agentsnap.setup_wizard.check_offline_model",
++        lambda: "/fake/cache/models--sentence-transformers--all-MiniLM-L6-v2",
++    )
++    monkeypatch.delenv("AGENTSNAP_JUDGE_API_KEY", raising=False)
++    monkeypatch.delenv("OPENROUTER_API_KEY", raising=False)
++
++    runner = CliRunner()
++    with runner.isolated_filesystem(temp_dir=tmp_path):
++        result = runner.invoke(cli, ["check"], catch_exceptions=False)
++    assert result.exit_code == 0, result.output
++    assert "offline" in result.output.lower() or "embedding" in result.output.lower()
++
++
++def test_check_offline_not_cached(tmp_path, monkeypatch):
++    """check exits 0 but notes model will download on first test run."""
++    monkeypatch.setattr(
++        "agentsnap.setup_wizard.check_offline_model",
++        lambda: None,
++    )
++    monkeypatch.delenv("AGENTSNAP_JUDGE_API_KEY", raising=False)
++    monkeypatch.delenv("OPENROUTER_API_KEY", raising=False)
++
++    runner = CliRunner()
++    with runner.isolated_filesystem(temp_dir=tmp_path):
++        result = runner.invoke(cli, ["check"], catch_exceptions=False)
++    assert result.exit_code == 0
++    assert (
++        "download" in result.output.lower()
++        or "not cached" in result.output.lower()
++        or "first" in result.output.lower()
++    )
++
++
++def test_check_judge_connected(tmp_path, monkeypatch):
++    """check exits 0 and reports latency when judge connectivity passes."""
++    monkeypatch.setenv("OPENROUTER_API_KEY", "sk-or-test")
++
++    with mock.patch("agentsnap.setup_wizard.test_judge_connection", return_value=0.4):
++        runner = CliRunner()
++        with runner.isolated_filesystem(temp_dir=tmp_path):
++            result = runner.invoke(cli, ["check"], catch_exceptions=False)
++    assert result.exit_code == 0, result.output
++    assert (
++        "ok" in result.output.lower()
++        or "connected" in result.output.lower()
++        or "0." in result.output
++    )
++
++
++def test_check_judge_unreachable(tmp_path, monkeypatch):
++    """check exits 1 when judge API call fails."""
++    monkeypatch.setenv("OPENROUTER_API_KEY", "sk-or-bad")
++
++    with mock.patch(
++        "agentsnap.setup_wizard.test_judge_connection",
++        side_effect=RuntimeError("auth error"),
++    ):
++        runner = CliRunner()
++        with runner.isolated_filesystem(temp_dir=tmp_path):
++            result = runner.invoke(cli, ["check"])
++    assert result.exit_code == 1
++    assert "error" in result.output.lower() or "failed" in result.output.lower()