agentpack-cli 0.1.0__py3-none-any.whl

agentpack/commands/session.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.table import Table
+from rich import box
+
+from agentpack.commands._shared import console, _root
+from agentpack.session.state import (
+    CONTEXT_FILE, COMPACT_FILE, TASK_FILE, SESSION_FILE,
+    create_session, load_session, save_session, stop_session, log_activity,
+)
+
+
+def register(app: typer.Typer) -> None:
+    session_app = typer.Typer(help="Manage AgentPack sessions.")
+    app.add_typer(session_app, name="session")
+
+    @session_app.command("start")
+    def start(
+        agent: str = typer.Option("generic", "--agent", help="Target agent (claude|cursor|codex|generic)."),
+        mode: str = typer.Option("balanced", "--mode", help="Pack mode (minimal|balanced|deep)."),
+        task: str = typer.Option("", "--task", help="Initial task description."),
+        budget: int = typer.Option(0, "--budget", help="Token budget (0 = config default)."),
+    ) -> None:
+        """Start a session: create state files and generate initial context."""
+        root = _root()
+        state = create_session(root, agent=agent, mode=mode)
+
+        if task:
+            (root / TASK_FILE).write_text(f"# Current Task\n\n{task}\n", encoding="utf-8")
+
+        console.print()
+        console.print("[bold green]AgentPack session started.[/]")
+        console.print()
+
+        created: list[tuple[str, str]] = [
+            (SESSION_FILE, "session state"),
+            (TASK_FILE, "edit to set your task"),
+        ]
+
+        result = _run_refresh(root, state.agent, state.mode, budget)
+        if result:
+            created += [
+                (CONTEXT_FILE, f"{result['files']} files, {result['tokens']:,} tokens"),
+                (COMPACT_FILE, "compact protocol format"),
+            ]
+            log_activity(root, f"session started — {result['files']} files, {result['tokens']:,} tokens")
+        else:
+            created += [
+                (CONTEXT_FILE, "will generate on first refresh"),
+                (COMPACT_FILE, "will generate on first refresh"),
+            ]
+            log_activity(root, "session started (context generation deferred)")
+
+        console.print("[bold]Created:[/]")
+        for path, note in created:
+            console.print(f"  [green]✓[/] {path}  [dim]{note}[/]")
+
+        console.print()
+        console.print("[bold]Next:[/]")
+        console.print("  - Run [bold]agentpack watch[/] in another terminal to auto-refresh context.")
+        console.print("  - Open Claude / Cursor / Codex and ask your task normally.")
+        console.print("  - To change the task: [bold]agentpack session refresh --task \"new task\"[/]")
+        console.print()
+
+    @session_app.command("stop")
+    def stop() -> None:
+        """Stop the current session."""
+        root = _root()
+        state = load_session(root)
+        if state is None or not state.active:
+            console.print("[yellow]No active session.[/]")
+            raise typer.Exit(1)
+        stop_session(root)
+        log_activity(root, "session stopped")
+        console.print("[dim]Session stopped.[/]")
+
+    @session_app.command("status")
+    def status() -> None:
+        """Show current session status."""
+        root = _root()
+        state = load_session(root)
+        if state is None:
+            console.print("[yellow]No session found. Run: agentpack session start[/]")
+            raise typer.Exit(1)
+
+        tbl = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+        tbl.add_column(style="dim")
+        tbl.add_column(style="bold")
+        tbl.add_row("active", "[green]yes[/]" if state.active else "[red]no[/]")
+        tbl.add_row("agent", state.agent)
+        tbl.add_row("mode", state.mode)
+        tbl.add_row("started", state.started_at or "—")
+        tbl.add_row("last refresh", state.last_refresh_at or "—")
+        tbl.add_row("refresh count", str(state.refresh_count))
+        tbl.add_row("context", str(root / CONTEXT_FILE))
+        console.print(tbl)
+
+        context_path = root / CONTEXT_FILE
+        if context_path.exists():
+            from agentpack.core.token_estimator import estimate_tokens
+            tokens = estimate_tokens(context_path.read_text(encoding="utf-8"))
+            console.print(f"[dim]context size: ~{tokens:,} tokens[/]")
+
+    @session_app.command("refresh")
+    def refresh(
+        task: str = typer.Option("", "--task", help="Override task for this refresh."),
+        budget: int = typer.Option(0, "--budget", help="Token budget override."),
+    ) -> None:
+        """Refresh context pack for the current session."""
+        root = _root()
+        state = load_session(root)
+        if state is None:
+            console.print("[yellow]No session. Run: agentpack session start[/]")
+            raise typer.Exit(1)
+
+        if task:
+            (root / TASK_FILE).write_text(f"# Current Task\n\n{task}\n", encoding="utf-8")
+
+        result = _run_refresh(root, state.agent, state.mode, budget)
+        if result:
+            state.last_refresh_at = _now_iso()
+            state.refresh_count += 1
+            state.last_task_hash = _file_hash(root / TASK_FILE)
+            save_session(root, state)
+            log_activity(root, f"refreshed — {result['files']} files, {result['tokens']:,} tokens")
+            console.print(f"[green]✓[/] refreshed: {result['files']} files, {result['tokens']:,} tokens, {result['saving']:.1f}% saving")
+        else:
+            console.print("[red]Refresh failed.[/]")
+            raise typer.Exit(1)
+
+
+def _run_refresh(
+    root: Path,
+    agent: str,
+    mode: str,
+    budget: int,
+) -> Optional[dict]:
+    """Run PackService and write context + compact files. Returns stats dict or None on error."""
+    try:
+        from agentpack.application.pack_service import PackService, PackRequest
+        from agentpack.core import git
+        from agentpack.renderers.compact import render_compact
+
+        task_path = root / TASK_FILE
+        if task_path.exists():
+            raw = task_path.read_text(encoding="utf-8").strip()
+            lines = [l for l in raw.splitlines() if l.strip() and not l.startswith("#")]
+            task = lines[0].strip() if lines else ""
+        else:
+            task = ""
+
+        if not task:
+            if git.is_git_repo(root):
+                task = git.infer_task_from_git(root)
+            else:
+                task = "Current branch changes and likely related files"
+
+        result = PackService().run(PackRequest(
+            root=root,
+            agent=agent,
+            task=task,
+            mode=mode,
+            budget=budget,
+            since=None,
+            refresh=False,
+            summary_provider="offline",
+        ))
+
+        # Write readable context
+        from agentpack.renderers.markdown import render_generic
+        context_text = render_generic(result.pack)
+        context_path = root / CONTEXT_FILE
+        context_path.parent.mkdir(parents=True, exist_ok=True)
+        context_path.write_text(context_text, encoding="utf-8")
+
+        # Write compact context
+        compact_text = render_compact(result.pack)
+        compact_path = root / COMPACT_FILE
+        compact_path.write_text(compact_text, encoding="utf-8")
+
+        return {
+            "files": len(result.pack.selected_files),
+            "tokens": result.packed_tokens,
+            "saving": result.saving_pct,
+        }
+    except Exception as e:
+        console.print(f"[red]Error during refresh: {e}[/]")
+        return None
+
+
+def _now_iso() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _file_hash(path: Path) -> str:
+    if not path.exists():
+        return ""
+    return hashlib.sha256(path.read_bytes()).hexdigest()[:16]

agentpack/commands/stats.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from rich.table import Table
+from rich import box
+
+from agentpack.core.config import load_config
+from agentpack.core.ignore import load_spec
+from agentpack.core.scanner import scan
+from agentpack.core.context_pack import load_pack_metadata
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def stats() -> None:
+        """Show token-saving statistics and session info."""
+        root = _root()
+        cfg = load_config(root)
+        ignore_spec = load_spec(root / cfg.project.ignore_file)
+
+        scan_result = scan(root, ignore_spec, cfg.context.max_file_tokens)
+        meta = load_pack_metadata(root)
+
+        raw = sum(f.estimated_tokens for f in scan_result.all_files)
+        after_ignore = sum(f.estimated_tokens for f in scan_result.packable)
+        packed = meta.get("token_estimate", 0) if meta else 0
+        saving = (1 - packed / raw) * 100 if raw > 0 else 0
+
+        ignored_count = len(scan_result.ignored) + len(scan_result.binary)
+        included_count = 0
+        summarized_count = 0
+        top_files: list[tuple[str, str]] = []
+
+        if meta:
+            context_path = root / meta.get("context_path", "")
+            if context_path.exists():
+                content = context_path.read_text()
+                included_count = content.count("Included as: **full**")
+                summarized_count = (
+                    content.count("Included as: **summary**")
+                    + content.count("Included as: **symbols**")
+                )
+
+        full_files = [f for f in scan_result.packable
+                      if f.estimated_tokens <= cfg.context.max_file_tokens]
+        manual_estimate = min(after_ignore, sum(f.estimated_tokens for f in full_files[:20]))
+        vs_manual = (1 - packed / manual_estimate) * 100 if manual_estimate > 0 else 0
+
+        # --- Session info ---
+        from agentpack.session.state import load_session, CONTEXT_FILE
+        session = load_session(root)
+
+        if session:
+            sess_tbl = Table(title="Session", box=box.SIMPLE, show_header=False, padding=(0, 2))
+            sess_tbl.add_column(style="dim")
+            sess_tbl.add_column(style="bold")
+            sess_tbl.add_row("active", "[green]yes[/]" if session.active else "[red]no[/]")
+            sess_tbl.add_row("agent", session.agent)
+            sess_tbl.add_row("mode", session.mode)
+            if session.started_at:
+                sess_tbl.add_row("started", session.started_at[:19].replace("T", " "))
+            if session.last_refresh_at:
+                sess_tbl.add_row("last refresh", session.last_refresh_at[:19].replace("T", " "))
+            sess_tbl.add_row("refreshes", str(session.refresh_count))
+            console.print(sess_tbl)
+            console.print()
+
+        # --- Last context top files ---
+        metrics_path = root / ".agentpack" / "metrics.jsonl"
+        last_selected: list[dict] = []
+        if metrics_path.exists():
+            lines = [l.strip() for l in metrics_path.read_text().splitlines() if l.strip()]
+            if lines:
+                try:
+                    last_record = json.loads(lines[-1])
+                    # metrics don't store per-file data — use context file for top files
+                except Exception:
+                    pass
+
+        context_path_obj = root / CONTEXT_FILE
+        if context_path_obj.exists():
+            top_files = _parse_top_files(context_path_obj)
+
+        # --- Token table ---
+        token_tbl = Table(title="Last Context", box=box.SIMPLE, show_header=False, padding=(0, 2))
+        token_tbl.add_column(style="dim")
+        token_tbl.add_column(justify="right", style="bold")
+        token_tbl.add_row("raw repo tokens", f"{raw:,}")
+        token_tbl.add_row("after ignore", f"{after_ignore:,}")
+        token_tbl.add_row("packed tokens", f"{packed:,}")
+        token_tbl.add_row("vs raw repo", f"[green]{saving:.1f}% smaller[/]")
+        token_tbl.add_row("vs manual (~20 files)", f"[green]{vs_manual:.1f}% smaller[/]")
+        token_tbl.add_row("files ignored", f"{ignored_count:,}")
+        token_tbl.add_row("files full", f"{included_count:,}")
+        token_tbl.add_row("files summarized", f"{summarized_count:,}")
+        console.print(token_tbl)
+
+        if top_files:
+            console.print()
+            top_tbl = Table(title="Top Included", box=box.SIMPLE, show_header=True, padding=(0, 1))
+            top_tbl.add_column("#", width=3, style="dim")
+            top_tbl.add_column("file", style="cyan", max_width=55)
+            top_tbl.add_column("mode", width=8)
+            top_tbl.add_column("why", style="dim", max_width=35)
+            for i, (path, mode, why) in enumerate(top_files[:10], 1):
+                top_tbl.add_row(str(i), path, mode, why)
+            console.print(top_tbl)
+
+        console.print("[dim]'manual' = hand-picking 20 most relevant full files[/]")
+
+
+def _parse_top_files(context_path: Path) -> list[tuple[str, str, str]]:
+    """Parse top selected files from context.md. Returns list of (path, mode, why)."""
+    results: list[tuple[str, str, str]] = []
+    try:
+        content = context_path.read_text(encoding="utf-8")
+        # Parse the Selected Files table: | `path` | mode | score | why |
+        in_table = False
+        for line in content.splitlines():
+            if line.startswith("| File") or line.startswith("|---|"):
+                in_table = True
+                continue
+            if in_table:
+                if not line.startswith("|"):
+                    break
+                parts = [p.strip() for p in line.split("|") if p.strip()]
+                if len(parts) >= 3:
+                    path = parts[0].strip("`")
+                    mode = parts[1]
+                    why = parts[3] if len(parts) > 3 else ""
+                    results.append((path, mode, why))
+    except Exception:
+        pass
+    return results

agentpack/commands/status.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import typer
+
+from agentpack.core.config import load_config
+from agentpack.core.ignore import load_spec
+from agentpack.core.scanner import scan
+from agentpack.core.snapshot import build_snapshot
+from agentpack.core.context_pack import load_pack_metadata
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def status() -> None:
+        """Check if the latest context pack is stale."""
+        root = _root()
+        cfg = load_config(root)
+        ignore_spec = load_spec(root / cfg.project.ignore_file)
+
+        meta = load_pack_metadata(root)
+        if not meta:
+            console.print("[yellow]No context pack found. Run agentpack pack to generate one.[/]")
+            raise typer.Exit(1)
+
+        scan_result = scan(root, ignore_spec, cfg.context.max_file_tokens)
+        current = build_snapshot(scan_result.packable)
+
+        if current["root_hash"] == meta.get("snapshot_root_hash"):
+            console.print("[green]Context pack is up to date.[/]")
+            console.print(f"  Task: {meta.get('task')}")
+            console.print(f"  Generated: {meta.get('generated_at')}")
+        else:
+            console.print("[yellow]Context pack is STALE.[/] Files changed since last pack.")
+            console.print(f"  Last generated: {meta.get('generated_at')}")
+            console.print("  Run [bold]agentpack pack[/] to refresh.")
+            raise typer.Exit(1)

agentpack/commands/summarize.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from agentpack.core.config import load_config
+from agentpack.core.ignore import load_spec
+from agentpack.core.scanner import scan
+from agentpack.summaries.base import get_or_build_summary
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def summarize(
+        provider: str = typer.Option("offline", "--provider", help="Summary provider (offline|claude)."),
+        refresh: bool = typer.Option(False, "--refresh", help="Force rebuild all summaries."),
+        model: Optional[str] = typer.Option(None, "--model", help="LLM model override (for claude provider)."),
+    ) -> None:
+        """Build or refresh summary cache. Default: offline (no API calls)."""
+        root = _root()
+        cfg = load_config(root)
+        ignore_spec = load_spec(root / cfg.project.ignore_file)
+
+        if provider not in ("offline", "claude"):
+            console.print("[red]Supported providers: offline, claude[/]")
+            raise typer.Exit(1)
+
+        if provider == "claude":
+            console.print("[bold]Building LLM summaries via Claude (requires ANTHROPIC_API_KEY)...[/]")
+        else:
+            console.print("[bold]Building offline summaries...[/]")
+
+        scan_result = scan(root, ignore_spec, cfg.context.max_file_tokens)
+        active = scan_result.packable
+
+        built = 0
+        errors = 0
+        for fi in active:
+            try:
+                if provider == "claude" and model:
+                    # pass model through via a thin wrapper
+                    from agentpack.summaries import llm as llm_mod
+                    from agentpack.core import cache as summary_cache
+                    if fi.hash:
+                        cached = summary_cache.load_summary(root, fi.path, fi.hash, provider)
+                        if cached and not refresh:
+                            built += 1
+                            continue
+                        summary = llm_mod.summarize(fi.path, fi.abs_path, fi.language, fi.hash or "", provider=provider, model=model)
+                        summary_cache.save_summary(root, summary)
+                else:
+                    get_or_build_summary(fi, root, provider)
+                built += 1
+            except Exception as e:
+                console.print(f"[yellow]Warning:[/] {fi.path}: {e}")
+                errors += 1
+
+        console.print(f"[green]Done.[/] Built/refreshed {built} summaries.", end="")
+        if errors:
+            console.print(f" [yellow]{errors} errors.[/]")
+        else:
+            console.print()

agentpack/commands/watch.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import time
+from datetime import datetime
+from pathlib import Path
+
+import typer
+
+from agentpack.commands._shared import console, _root
+from agentpack.session.state import TASK_FILE, load_session, save_session, log_activity
+
+
+_IGNORE_DIRS = {".git", "node_modules", ".venv", "venv", "dist", "build", ".next", "__pycache__"}
+_IGNORE_NAMES = {"context.md", "context.compact.md"}
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def watch(
+        agent: str = typer.Option("", "--agent", help="Agent override (uses session agent if not set)."),
+        mode: str = typer.Option("", "--mode", help="Mode override (uses session mode if not set)."),
+        budget: int = typer.Option(0, "--budget", help="Token budget override."),
+        debounce: float = typer.Option(2.0, "--debounce", help="Seconds to wait after last change before refresh."),
+    ) -> None:
+        """Watch for file changes and refresh context automatically."""
+        root = _root()
+        state = load_session(root)
+
+        effective_agent = agent or (state.agent if state else "generic")
+        effective_mode = mode or (state.mode if state else "balanced")
+
+        if state is None:
+            console.print("[yellow]No session found — watching in stateless mode.[/]")
+            console.print("[dim]Run 'agentpack session start' for full session support.[/]")
+
+        console.print()
+        console.print("[bold]AgentPack watch active.[/]")
+        console.print("Press Ctrl+C to stop.")
+        console.print(f"[dim]agent={effective_agent} mode={effective_mode}[/]")
+        console.print()
+
+        # Try watchdog first, fall back to polling
+        try:
+            from watchdog.observers import Observer
+            _watch_with_watchdog(root, effective_agent, effective_mode, budget, debounce, state)
+        except ImportError:
+            console.print("[dim]watchdog not installed — using polling (install watchdog for better performance)[/]")
+            _watch_polling(root, effective_agent, effective_mode, budget, debounce, state)
+
+
+def _ts() -> str:
+    return datetime.now().strftime("%H:%M:%S")
+
+
+def _should_ignore(path: str) -> bool:
+    parts = Path(path).parts
+    for part in parts:
+        if part in _IGNORE_DIRS:
+            return True
+    name = Path(path).name
+    return name in _IGNORE_NAMES
+
+
+def _run_refresh(root: Path, agent: str, mode: str, budget: int) -> None:
+    from agentpack.commands.session import _run_refresh as do_refresh, _file_hash, _now_iso
+    result = do_refresh(root, agent, mode, budget)
+    if result:
+        ts = _ts()
+        console.print(
+            f"[dim][{ts}][/] [green]refreshed:[/] {result['files']} files, "
+            f"{result['tokens']:,} tokens, mode={mode}"
+        )
+        state = load_session(root)
+        if state:
+            state.last_refresh_at = _now_iso()
+            state.refresh_count += 1
+            state.last_task_hash = _file_hash(root / TASK_FILE)
+            save_session(root, state)
+            log_activity(root, f"watch refresh — {result['files']} files, {result['tokens']:,} tokens")
+    else:
+        console.print(f"[dim][{_ts()}][/] [red]refresh failed[/]")
+
+
+def _watch_with_watchdog(
+    root: Path,
+    agent: str,
+    mode: str,
+    budget: int,
+    debounce: float,
+    state,
+) -> None:
+    from watchdog.observers import Observer
+    from watchdog.events import FileSystemEventHandler
+
+    _last_refresh = [time.monotonic() - debounce - 1]
+    _pending = [False]
+
+    # Run initial refresh
+    _run_refresh(root, agent, mode, budget)
+
+    class Handler(FileSystemEventHandler):
+        def on_any_event(self, event):  # type: ignore[override]
+            if event.is_directory:
+                return
+            path = str(event.src_path)
+            if _should_ignore(path):
+                return
+            # Task file change → show message
+            if path.endswith(TASK_FILE):
+                console.print(f"[dim][{_ts()}][/] task changed")
+            _pending[0] = True
+
+    observer = Observer()
+    observer.schedule(Handler(), str(root), recursive=True)
+    observer.start()
+
+    try:
+        while True:
+            time.sleep(0.5)
+            if _pending[0]:
+                now = time.monotonic()
+                if now - _last_refresh[0] >= debounce:
+                    _pending[0] = False
+                    _last_refresh[0] = now
+                    try:
+                        _run_refresh(root, agent, mode, budget)
+                    except Exception as e:
+                        console.print(f"[red]refresh error: {e}[/]")
+    except KeyboardInterrupt:
+        observer.stop()
+        console.print("\n[dim]Watch stopped.[/]")
+    observer.join()
+
+
+def _watch_polling(
+    root: Path,
+    agent: str,
+    mode: str,
+    budget: int,
+    debounce: float,
+    state,
+) -> None:
+    """Polling fallback: walk repo files and compare mtimes."""
+    _POLL_INTERVAL = 1.5
+
+    def _collect_mtimes() -> dict[str, float]:
+        mtimes: dict[str, float] = {}
+        for p in root.rglob("*"):
+            if not p.is_file():
+                continue
+            rel = str(p.relative_to(root))
+            if _should_ignore(rel):
+                continue
+            try:
+                mtimes[rel] = p.stat().st_mtime
+            except OSError:
+                pass
+        return mtimes
+
+    prev = _collect_mtimes()
+    _run_refresh(root, agent, mode, budget)
+    _last_refresh = time.monotonic()
+
+    try:
+        while True:
+            time.sleep(_POLL_INTERVAL)
+            curr = _collect_mtimes()
+            changed = {p for p, m in curr.items() if prev.get(p) != m}
+            changed |= set(prev) - set(curr)
+            if changed:
+                task_changed = any(p.endswith(TASK_FILE) for p in changed)
+                if task_changed:
+                    console.print(f"[dim][{_ts()}][/] task changed")
+                now = time.monotonic()
+                if now - _last_refresh >= debounce:
+                    _last_refresh = now
+                    prev = curr
+                    try:
+                        _run_refresh(root, agent, mode, budget)
+                    except Exception as e:
+                        console.print(f"[red]refresh error: {e}[/]")
+            else:
+                prev = curr
+    except KeyboardInterrupt:
+        console.print("\n[dim]Watch stopped.[/]")

agentpack/core/bootstrap.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def is_initialized(root: Path) -> bool:
+    return (root / ".agentpack" / "config.toml").exists()
+
+
+def bootstrap_if_needed(root: Path, agent: str = "claude", silent: bool = True) -> bool:
+    """Run init + pack if not already configured. Returns True if bootstrapped.
+
+    Safe to call from git hooks or shell hooks — catches all exceptions so it
+    never breaks the calling tool.
+    """
+    if is_initialized(root):
+        return False
+
+    # Don't bootstrap non-git directories or directories that look like home/system dirs
+    if not (root / ".git").exists():
+        return False
+
+    # Skip very large directories (>5000 files) — likely not a real project root
+    try:
+        file_count = sum(1 for _ in root.rglob("*") if _.is_file())
+        if file_count > 5000:
+            return False
+    except OSError:
+        return False
+
+    try:
+        kwargs: dict = {"capture_output": silent, "text": True}
+        subprocess.run(
+            [sys.executable, "-m", "agentpack", "init", "--yes"],
+            cwd=str(root), **kwargs
+        )
+        subprocess.run(
+            [sys.executable, "-m", "agentpack", "pack",
+             "--agent", agent, "--task", "auto", "--mode", "balanced"],
+            cwd=str(root), **kwargs
+        )
+        return True
+    except Exception:
+        return False