agentpack-cli 0.1.0__py3-none-any.whl

agentpack/commands/claude_cmd.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import hashlib
+import shutil
+import subprocess
+from datetime import datetime, timezone
+
+import typer
+
+from agentpack.commands._shared import console, _root
+from agentpack.commands.session import _run_refresh, _now_iso
+from agentpack.session.state import CONTEXT_FILE, TASK_FILE, load_session, log_activity, save_session
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("claude")
+    def claude_cmd() -> None:
+        """Launch Claude CLI with the current AgentPack context."""
+        root = _root()
+        state = load_session(root)
+
+        if state is None or not state.active:
+            console.print("[yellow]No active session.[/]")
+            console.print("Start one with: [bold]agentpack session start[/]")
+            raise typer.Exit(1)
+
+        console.print("Session active. Refreshing context...")
+        result = _run_refresh(root, state.agent, state.mode, budget=0)
+        if result:
+            console.print(
+                f"[green]✓[/] refreshed: {result['files']} files, "
+                f"{result['tokens'] / 1000:.1f}k tokens"
+            )
+            state.last_refresh_at = _now_iso()
+            state.refresh_count += 1
+            task_path = root / TASK_FILE
+            if task_path.exists():
+                state.last_task_hash = hashlib.sha256(task_path.read_bytes()).hexdigest()[:16]
+            save_session(root, state)
+            log_activity(root, f"claude cmd — {result['files']} files, {result['tokens']:,} tokens")
+        else:
+            console.print("[red]Refresh failed — proceeding with existing context if available.[/]")
+
+        context_path = root / CONTEXT_FILE
+        console.print(f"\nContext ready: [bold]{context_path}[/]\n")
+
+        claude_bin = shutil.which("claude")
+        if claude_bin:
+            console.print("Launching Claude CLI...")
+            console.print("[dim](Claude reads .agentpack/context.md via CLAUDE.md or /agentpack)[/]\n")
+            subprocess.run(["claude"])
+        else:
+            console.print("[yellow]Claude CLI not found.[/]")
+            console.print("Install: https://claude.ai/download")
+            console.print(f"\nOnce installed, run [bold]claude[/] and use: [bold]{context_path}[/]")

agentpack/commands/diff.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import typer
+from rich.table import Table
+
+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, load_snapshot
+from agentpack.core.diff import diff_snapshots
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def diff() -> None:
+        """Show changes since last snapshot."""
+        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)
+        current = build_snapshot(scan_result.packable)
+        previous = load_snapshot(root)
+        result = diff_snapshots(previous, current)
+
+        table = Table(title="Snapshot Diff", show_header=True)
+        table.add_column("Category", style="cyan")
+        table.add_column("Count", justify="right")
+        table.add_row("Added files", str(len(result.added)))
+        table.add_row("Modified files", str(len(result.modified)))
+        table.add_row("Deleted files", str(len(result.deleted)))
+        table.add_row("Unchanged files", str(len(result.unchanged)))
+        console.print(table)
+
+        for label, items, style in [
+            ("Added", result.added, "green"),
+            ("Modified", result.modified, "yellow"),
+            ("Deleted", result.deleted, "red"),
+        ]:
+            if items:
+                console.print(f"\n[{style}]{label}:[/]")
+                for f in items[:30]:
+                    console.print(f"  {f}")
+                if len(items) > 30:
+                    console.print(f"  ... and {len(items) - 30} more")

agentpack/commands/doctor.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+
+from agentpack.integrations.global_install import (
+    _GIT_TEMPLATE_DIR,
+    _AGENTPACK_MARKER,
+    _SHELL_MARKER_START,
+    _HOOK_SCRIPTS,
+    _detect_rc_file,
+)
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def doctor() -> None:
+        """Diagnose agentpack installation state — global hooks, per-repo config, agent setup."""
+        ok = True
+
+        # --- CLI binary ---
+        console.print("[bold]CLI[/]")
+        binary = shutil.which("agentpack")
+        if binary:
+            try:
+                result = subprocess.run(["agentpack", "--version"], capture_output=True, text=True)
+                ver = result.stdout.strip() or result.stderr.strip()
+                console.print(f"  [green]✓[/] agentpack found at {binary} ({ver})")
+            except Exception:
+                console.print(f"  [green]✓[/] agentpack found at {binary}")
+        else:
+            console.print("  [red]✗[/] agentpack not on PATH — run: pipx install agentpack-cli")
+            ok = False
+
+        # --- Git template hooks ---
+        console.print("\n[bold]Git template hooks (~/.git-templates/hooks/)[/]")
+        hooks_dir = _GIT_TEMPLATE_DIR / "hooks"
+        if not hooks_dir.exists():
+            console.print("  [yellow]![/] ~/.git-templates/hooks/ does not exist — run: agentpack global-install")
+            ok = False
+        else:
+            for name in _HOOK_SCRIPTS:
+                hook_path = hooks_dir / name
+                if hook_path.exists() and _AGENTPACK_MARKER in hook_path.read_text():
+                    console.print(f"  [green]✓[/] {name}")
+                else:
+                    console.print(f"  [red]✗[/] {name} missing — run: agentpack global-install --no-shell-hook --no-pipx")
+                    ok = False
+
+        # --- git config init.templateDir ---
+        console.print("\n[bold]git config init.templateDir[/]")
+        try:
+            result = subprocess.run(
+                ["git", "config", "--global", "init.templateDir"],
+                capture_output=True, text=True,
+            )
+            configured_dir = result.stdout.strip()
+            if configured_dir == str(_GIT_TEMPLATE_DIR):
+                console.print(f"  [green]✓[/] init.templateDir = {configured_dir}")
+            elif configured_dir:
+                console.print(f"  [yellow]![/] init.templateDir = {configured_dir} (not agentpack's dir)")
+            else:
+                console.print("  [red]✗[/] init.templateDir not set — run: agentpack global-install --no-shell-hook --no-pipx")
+                ok = False
+        except Exception:
+            console.print("  [yellow]![/] Could not check git config")
+
+        # --- Shell hook ---
+        console.print("\n[bold]Shell cd hook[/]")
+        rc_file = _detect_rc_file()
+        if rc_file is None:
+            console.print(f"  [yellow]![/] Unknown shell ({os.environ.get('SHELL', 'unset')}) — cannot check")
+        elif not rc_file.exists():
+            console.print(f"  [red]✗[/] {rc_file} does not exist — run: agentpack global-install --no-git-template --no-pipx")
+            ok = False
+        elif _SHELL_MARKER_START in rc_file.read_text():
+            console.print(f"  [green]✓[/] Hook present in {rc_file}")
+        else:
+            console.print(f"  [red]✗[/] Hook missing from {rc_file} — run: agentpack global-install --no-git-template --no-pipx")
+            ok = False
+
+        # --- Per-repo state ---
+        console.print("\n[bold]Per-repo state[/]")
+        try:
+            root = _root()
+        except Exception:
+            console.print("  [dim]Not in a git repository[/]")
+            _print_summary(ok)
+            return
+
+        config_path = root / ".agentpack" / "config.toml"
+        context_path = root / ".agentpack" / "context.claude.md"
+        if not config_path.exists():
+            console.print(f"  [yellow]![/] Not initialized in {root} — run: agentpack init")
+        else:
+            console.print(f"  [green]✓[/] .agentpack/config.toml present")
+            if context_path.exists():
+                import time
+                age = time.time() - context_path.stat().st_mtime
+                age_str = f"{int(age // 3600)}h {int((age % 3600) // 60)}m" if age > 3600 else f"{int(age // 60)}m"
+                console.print(f"  [green]✓[/] context pack present (age: {age_str})")
+            else:
+                console.print("  [yellow]![/] No context pack yet — run: agentpack pack --task \"<task>\"")
+
+        # --- Agent-specific config ---
+        console.print("\n[bold]Agent config[/]")
+        _check_agent_file(root, "CLAUDE.md", "claude")
+        _check_agent_file(root, ".cursorrules", "cursor")
+        _check_agent_file(root, ".windsurfrules", "windsurf")
+        _check_agent_file(root, "AGENTS.md", "codex")
+
+        claude_settings = root / ".claude" / "settings.json"
+        global_claude_settings = Path.home() / ".claude" / "settings.json"
+        import json as _json
+        _local_has_hooks = False
+        _global_has_hooks = False
+        if claude_settings.exists():
+            try:
+                data = _json.loads(claude_settings.read_text())
+                hooks = data.get("hooks", {})
+                if "UserPromptSubmit" in hooks or "SessionStart" in hooks:
+                    console.print(f"  [green]✓[/] Claude hooks present (local): {claude_settings}")
+                    _local_has_hooks = True
+                else:
+                    console.print(f"  [yellow]![/] Claude hooks missing (local) — run: agentpack install --agent claude")
+                    ok = False
+            except Exception:
+                console.print(f"  [yellow]![/] Could not parse {claude_settings}")
+        else:
+            console.print("  [dim]-[/] .claude/settings.json not present (run: agentpack install --agent claude)")
+        if global_claude_settings.exists():
+            try:
+                data = _json.loads(global_claude_settings.read_text())
+                hooks = data.get("hooks", {})
+                if "UserPromptSubmit" in hooks or "SessionStart" in hooks:
+                    console.print(f"  [green]✓[/] Claude hooks present (global): {global_claude_settings}")
+                    _global_has_hooks = True
+                else:
+                    console.print(f"  [yellow]![/] Claude hooks missing (global) — run: agentpack install --agent claude --global")
+            except Exception:
+                console.print(f"  [yellow]![/] Could not parse {global_claude_settings}")
+        else:
+            console.print("  [dim]-[/] ~/.claude/settings.json has no agentpack hooks — run: agentpack install --agent claude --global")
+        if _local_has_hooks and not _global_has_hooks:
+            console.print("  [yellow]![/] Hooks local-only — context won't auto-inject in other repos. Run: agentpack install --agent claude --global")
+
+        # --- Slash command ---
+        console.print("\n[bold]Slash command (/agentpack)[/]")
+        local_cmd = root / ".claude" / "commands" / "agentpack.md"
+        global_cmd = Path.home() / ".claude" / "commands" / "agentpack.md"
+        if local_cmd.exists():
+            console.print(f"  [green]✓[/] Slash command installed (local): {local_cmd}")
+        else:
+            console.print("  [dim]-[/] Slash command not installed locally — run: agentpack install --agent claude")
+        if global_cmd.exists():
+            console.print(f"  [green]✓[/] Slash command installed (global): {global_cmd}")
+        else:
+            console.print("  [dim]-[/] Slash command not installed globally — run: agentpack install --agent claude --global")
+
+        _print_summary(ok)
+
+
+def _check_agent_file(root: Path, filename: str, agent: str) -> None:
+    path = root / filename
+    if path.exists():
+        content = path.read_text()
+        if "agentpack" in content.lower():
+            console.print(f"  [green]✓[/] {filename} (agentpack configured)")
+        else:
+            console.print(f"  [dim]-[/] {filename} exists but agentpack not configured — run: agentpack install --agent {agent}")
+    else:
+        console.print(f"  [dim]-[/] {filename} not present (optional)")
+
+
+def _print_summary(ok: bool) -> None:
+    console.print("")
+    if ok:
+        console.print("[bold green]All checks passed.[/]")
+    else:
+        console.print("[bold yellow]Some checks failed. Run the suggested commands above to fix.[/]")

agentpack/commands/explain.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import typer
+
+from agentpack.application.pack_service import PackPlanner, PackRequest
+from agentpack.core.context_pack import select_files
+from agentpack.commands._shared import console, _root
+from agentpack.commands.pack import _resolve_task
+from agentpack.core.config import load_config, ScoringWeights
+
+
+def _resolve_signal_weight(reason: str, weights: ScoringWeights) -> float:
+    """Map a reason string to its numeric weight value."""
+    reason_lower = reason.lower()
+    if reason_lower == "modified":
+        return weights.modified
+    if reason_lower == "staged":
+        return weights.staged
+    if reason_lower == "filename keyword match":
+        return weights.filename_keyword
+    if reason_lower == "symbol keyword match":
+        return weights.symbol_keyword
+    m = re.match(r"content keyword match \((\d+)\)", reason_lower)
+    if m:
+        n = int(m.group(1))
+        return min(n * weights.content_keyword_per_hit, weights.content_keyword_max)
+    if reason_lower == "direct dependency of changed file":
+        return weights.direct_dep
+    if reason_lower == "reverse dependency":
+        return weights.reverse_dep
+    if reason_lower == "has related tests":
+        return weights.related_test
+    if reason_lower == "config file":
+        return weights.config_file
+    if reason_lower == "recently modified":
+        return weights.recently_modified
+    if reason_lower in ("large/unrelated file", "large unrelated file"):
+        return weights.large_unrelated_penalty
+    return 0.0
+
+
+def _print_file_detail(
+    file_path: str,
+    plan: object,
+    weights: ScoringWeights,
+    near_cutoff_paths: set[str],
+) -> None:
+    """Print per-file score breakdown."""
+    score_map: dict[str, tuple[float, list[str]]] = {
+        fi.path: (score, reasons) for fi, score, reasons in plan.scored  # type: ignore[attr-defined]
+    }
+
+    if file_path not in score_map:
+        console.print(f"[red]File not found in scoring data: {file_path}[/]")
+        raise typer.Exit(1)
+
+    score_val, reasons = score_map[file_path]
+
+    # Find in selected
+    selected_file = None
+    for sf in plan.selected:  # type: ignore[attr-defined]
+        if sf.path == file_path:
+            selected_file = sf
+            break
+
+    is_selected = selected_file is not None
+    would_appear = file_path in near_cutoff_paths
+
+    # Token count from selected file, fall back to FileInfo scan estimate
+    token_count = 0
+    if selected_file is not None:
+        from agentpack.application.pack_service import _sf_tokens
+        token_count = _sf_tokens(selected_file)
+    else:
+        for fi in plan.scan_result.packable:  # type: ignore[attr-defined]
+            if fi.path == file_path:
+                token_count = fi.estimated_tokens
+                break
+
+    include_mode = selected_file.include_mode if selected_file else "—"
+
+    # Symbols from plan.summaries
+    summary_data = plan.summaries.get(file_path, {})  # type: ignore[attr-defined]
+    raw_symbols = summary_data.get("symbols", []) if isinstance(summary_data, dict) else []
+    symbol_names = [s["name"] if isinstance(s, dict) else s.name for s in raw_symbols]
+
+    console.print()
+    console.print(f"[bold]{file_path}[/]")
+    console.print(f"  selected:  {'[green]yes[/]' if is_selected else '[yellow]no[/]'}")
+    if not is_selected:
+        console.print(f"  would appear with larger budget:  {'[cyan]yes[/]' if would_appear else 'no'}")
+    console.print(f"  score:     [bold]{score_val:.0f}[/]")
+    console.print(f"  include:   {include_mode}")
+    console.print(f"  tokens:    {token_count:,}")
+    console.print()
+    console.print("  [bold]signals:[/]")
+    if reasons:
+        for reason in reasons:
+            weight = _resolve_signal_weight(reason, weights)
+            sign = "+" if weight >= 0 else ""
+            color = "green" if weight > 0 else "red" if weight < 0 else "dim"
+            console.print(f"    [{color}]{sign}{weight:.0f}[/]  {reason}")
+    else:
+        console.print("    [dim](none)[/]")
+    if symbol_names:
+        console.print()
+        console.print(f"  [bold]symbols:[/] {', '.join(symbol_names)}")
+    console.print()
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def explain(
+        task: str = typer.Option("auto", "--task", help="Task description, or 'auto' to infer from git."),
+        mode: str = typer.Option("balanced", "--mode", help="Budget mode (minimal|balanced|deep)."),
+        budget: int = typer.Option(0, "--budget", help="Token budget (0 = use config default)."),
+        since: Optional[str] = typer.Option(None, "--since", help="Git ref to compare against (e.g. HEAD~1, main)."),
+        summary_provider: str = typer.Option("offline", "--summary-provider", help="Summary provider (offline|claude)."),
+        file: Optional[str] = typer.Option(None, "--file", help="Show detailed score breakdown for a specific file."),
+        omitted: bool = typer.Option(False, "--omitted", is_flag=True, help="Show top-10 excluded files and why."),
+    ) -> None:
+        """Explain which files would be selected and why, without writing a context file."""
+        if mode not in ("minimal", "balanced", "deep"):
+            console.print(f"[red]Invalid mode: {mode}. Use minimal|balanced|deep.[/]")
+            raise typer.Exit(1)
+
+        root = _root()
+        resolved_task = _resolve_task(task)
+
+        request = PackRequest(
+            root=root,
+            agent="generic",
+            task=resolved_task,
+            mode=mode,
+            budget=budget,
+            since=since,
+            refresh=False,
+            summary_provider=summary_provider,
+        )
+
+        with console.status("[bold]Planning..."):
+            plan = PackPlanner().plan(request)
+
+        selected = plan.selected
+        receipts = plan.receipts
+        score_map: dict[str, tuple[float, list[str]]] = {
+            fi.path: (score, reasons) for fi, score, reasons in plan.scored
+        }
+
+        selected_paths = {sf.path for sf in selected}
+        excluded_receipts = [
+            r for r in receipts
+            if r.action == "excluded" and r.reason not in ("ignored or binary",)
+            and r.path in score_map
+        ]
+        excluded_receipts.sort(key=lambda r: -score_map[r.path][0])
+
+        cfg = load_config(root)
+        deep_budget = plan.budget * 2
+        _, deep_receipts = select_files(
+            files=plan.scan_result.packable,
+            scored=plan.scored,
+            changed_paths=plan.all_changed,
+            summaries=plan.summaries,
+            mode=mode,  # type: ignore[arg-type]
+            budget=deep_budget,
+            max_file_tokens=cfg.context.max_file_tokens,
+            keywords=plan.keywords,
+        )
+        deep_selected_paths = {
+            r.path for r in deep_receipts if r.action in ("included", "summarized")
+        }
+        near_cutoff_paths = deep_selected_paths - selected_paths
+
+        # --file: per-file detail view
+        if file is not None:
+            console.print(f"\n[bold]Task:[/] [cyan]{resolved_task}[/]  [dim]mode={mode}  budget={plan.budget:,}[/]")
+            _print_file_detail(file, plan, cfg.scoring, near_cutoff_paths)
+            return
+
+        # --omitted: dedicated excluded file view
+        if omitted:
+            console.print(f"\n[bold]Task:[/] [cyan]{resolved_task}[/]  [dim]mode={mode}  budget={plan.budget:,}[/]\n")
+            console.print("[bold]Top excluded files (by score):[/]")
+            if not excluded_receipts:
+                console.print("  [dim](none)[/]")
+            else:
+                for r in excluded_receipts[:10]:
+                    score_val, reasons = score_map.get(r.path, (0, []))
+                    reason_str = reasons[0] if reasons else ""
+                    console.print(
+                        f"  [dim]-[/] {r.path:<50} "
+                        f"[dim]score={score_val:.0f}   {r.reason}[/]"
+                        + (f"  [dim]({reason_str})[/]" if reason_str and reason_str != r.reason else "")
+                    )
+            console.print()
+            return
+
+        console.print(f"\n[bold]Task:[/] [cyan]{resolved_task}[/]  [dim]mode={mode}  budget={plan.budget:,}[/]\n")
+
+        console.print("[bold]Top selected files (ranked):[/]")
+        for i, sf in enumerate(selected, 1):
+            score_val, reasons = score_map.get(sf.path, (sf.score, sf.reasons))
+            reason_str = reasons[0] if reasons else ""
+            console.print(
+                f"  [bold]{i}.[/] {sf.path:<50} "
+                f"[dim]score={score_val:.0f}[/]  "
+                f"[[{'green' if sf.include_mode == 'full' else 'yellow' if sf.include_mode == 'symbols' else 'dim'}]{sf.include_mode}[/]]  "
+                f"[dim]{reason_str}[/]"
+            )
+
+        if near_cutoff_paths:
+            console.print(f"\n[bold]Files near budget cutoff[/] [dim](would appear with larger budget):[/]")
+            near_sorted = sorted(
+                near_cutoff_paths,
+                key=lambda p: -score_map.get(p, (0, []))[0],
+            )
+            for i, path in enumerate(near_sorted[:5], len(selected) + 1):
+                score_val, reasons = score_map.get(path, (0, []))
+                reason_str = reasons[0] if reasons else ""
+                console.print(
+                    f"  [dim]{i}.[/] {path:<50} "
+                    f"[dim]score={score_val:.0f}   {reason_str}[/]"
+                )
+
+        if excluded_receipts:
+            console.print(f"\n[bold]Excluded[/] [dim](top 5 by score):[/]")
+            for r in excluded_receipts[:5]:
+                score_val, _ = score_map.get(r.path, (0, []))
+                console.print(
+                    f"  [dim]-[/] {r.path:<50} "
+                    f"[dim]score={score_val:.0f}   {r.reason}[/]"
+                )
+
+        console.print()

agentpack/commands/init.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+import typer
+
+from agentpack.core.config import DEFAULT_CONFIG, save_config
+from agentpack.core.ignore import DEFAULT_AGENTIGNORE
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def init(
+        force: bool = typer.Option(False, "--force", help="Overwrite existing files."),
+        mode: Optional[str] = typer.Option(None, "--mode", help="Default pack mode (minimal|balanced|deep)."),
+        budget: int = typer.Option(0, "--budget", help="Default token budget (0 = keep default 25000)."),
+        yes: bool = typer.Option(False, "--yes", "-y", help="Skip interactive prompts, use defaults."),
+        silent: bool = typer.Option(False, "--silent", help="Suppress all output (for use in hooks/scripts)."),
+        share_cache: bool = typer.Option(False, "--share-cache", help="Commit summary cache to git (recommended for teams)."),
+    ) -> None:
+        """Initialize AgentPack in the current directory."""
+        if silent:
+            yes = True
+            console.quiet = True
+        root = _root()
+        agentpack_dir = root / ".agentpack"
+        agentpack_dir.mkdir(exist_ok=True)
+        (agentpack_dir / "snapshots").mkdir(exist_ok=True)
+        (agentpack_dir / "cache").mkdir(exist_ok=True)
+
+        gitignore = agentpack_dir / ".gitignore"
+        if not gitignore.exists() or force:
+            # With --share-cache, cache/ is committed so teammates skip the summarize step
+            cache_line = "" if share_cache else ".agentpack/cache/\n"
+            gitignore.write_text(
+                f"{cache_line}.agentpack/snapshots/\n.agentpack/context.*\n.agentpack/metrics.jsonl\n"
+            )
+            console.print("[green]Created[/] .agentpack/.gitignore")
+            if share_cache:
+                console.print("  [dim]cache/ not gitignored — commit it so teammates skip agentpack summarize[/]")
+        else:
+            console.print("[dim]Skipped[/] .agentpack/.gitignore (exists)")
+
+        config_path_file = agentpack_dir / "config.toml"
+        if not config_path_file.exists() or force:
+            cfg = DEFAULT_CONFIG.model_copy(deep=True)
+
+            # Interactive mode selection
+            if not yes and mode is None and sys.stdin.isatty():
+                console.print("\n[bold]Choose default pack mode:[/]")
+                console.print("  [cyan]1[/] minimal  — changed files + configs only (fastest, fewest tokens)")
+                console.print("  [cyan]2[/] balanced — + deps, tests, summaries [bold](recommended)[/]")
+                console.print("  [cyan]3[/] deep     — + docs, more full files (most context)")
+                choice = typer.prompt("Mode", default="2")
+                mode_map = {"1": "minimal", "2": "balanced", "3": "deep",
+                            "minimal": "minimal", "balanced": "balanced", "deep": "deep"}
+                cfg.context.default_mode = mode_map.get(choice.strip(), "balanced")
+            elif mode in ("minimal", "balanced", "deep"):
+                cfg.context.default_mode = mode
+
+            if budget > 0:
+                cfg.context.default_budget = budget
+
+            save_config(cfg, root)
+            console.print(f"[green]Created[/] .agentpack/config.toml  [dim](mode: {cfg.context.default_mode}, budget: {cfg.context.default_budget:,})[/]")
+        else:
+            console.print("[dim]Skipped[/] .agentpack/config.toml (exists)")
+
+        ignore_path = root / ".agentignore"
+        if not ignore_path.exists() or force:
+            ignore_path.write_text(DEFAULT_AGENTIGNORE)
+            console.print("[green]Created[/] .agentignore")
+        else:
+            console.print("[dim]Skipped[/] .agentignore (exists)")
+
+        console.print("\n[bold green]AgentPack initialized.[/]")
+        console.print("Run [bold]agentpack scan[/] to explore your repo.")