agentpack-cli 0.1.0__py3-none-any.whl

agentpack/commands/install.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+
+from agentpack.installers.claude import ClaudeInstaller
+from agentpack.installers.codex import CodexInstaller
+from agentpack.installers.cursor import CursorInstaller
+from agentpack.installers.windsurf import WindsurfInstaller
+from agentpack.integrations.global_install import (
+    install_git_template_hooks,
+    configure_git_template_dir,
+    install_shell_hook,
+    remove_git_template_hooks,
+    remove_shell_hook,
+)
+from agentpack.commands._shared import console, _root
+
+_SUPPORTED_AGENTS = ("claude", "cursor", "windsurf", "codex")
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def install(
+        agent: str = typer.Option("claude", "--agent", help=f"Target agent ({' | '.join(_SUPPORTED_AGENTS)})."),
+        slash_command: bool = typer.Option(True, "--slash-command/--no-slash-command", help="Install /agentpack slash command (Claude only)."),
+        global_install: bool = typer.Option(False, "--global/--local", help="Install globally or locally."),
+    ) -> None:
+        """Configure agentpack for your AI coding agent (Claude, Cursor, Windsurf, or Codex)."""
+        root = _root()
+
+        if agent == "claude":
+            installer = ClaudeInstaller()
+            action = installer.patch_claude_md(root)
+            console.print(f"[green]CLAUDE.md {action}.[/]")
+
+            hook_action = installer.patch_claude_settings(root, global_install)
+            scope = "~/.claude/settings.json" if global_install else ".claude/settings.json"
+            console.print(f"[green]{scope} {hook_action}.[/]")
+
+            if slash_command:
+                _install_slash_command(root, global_install)
+
+        elif agent == "cursor":
+            installer = CursorInstaller()
+            rules_action = installer.patch_cursor_rules(root)
+            console.print(f"[green].cursorrules {rules_action}.[/]")
+            mdc_action = installer.patch_cursor_mdc(root)
+            console.print(f"[green].cursor/rules/agentpack.mdc {mdc_action}.[/]")
+            _print_auto_repack_results(installer.install_auto_repack(root))
+            console.print("  Run [bold]agentpack pack --agent cursor --task \"<task>\"[/] to generate context.")
+
+        elif agent == "windsurf":
+            installer = WindsurfInstaller()
+            rules_action = installer.patch_windsurfrules(root)
+            console.print(f"[green].windsurfrules {rules_action}.[/]")
+            _print_auto_repack_results(installer.install_auto_repack(root))
+            console.print("  Run [bold]agentpack pack --agent windsurf --task \"<task>\"[/] to generate context.")
+
+        elif agent == "codex":
+            installer = CodexInstaller()
+            action = installer.patch_agents_md(root)
+            console.print(f"[green]AGENTS.md {action}.[/]")
+            _print_auto_repack_results(installer.install_auto_repack(root))
+            console.print("  Run [bold]agentpack pack --agent codex --task \"<task>\"[/] to generate context.")
+
+        else:
+            console.print(f"[yellow]Unknown agent: {agent}. Supported: {', '.join(_SUPPORTED_AGENTS)}[/]")
+            raise typer.Exit(1)
+
+    @app.command(name="global-install")
+    def global_install_cmd(
+        agent: str = typer.Option("claude", "--agent", help=f"Target agent ({' | '.join(_SUPPORTED_AGENTS)})."),
+        pipx: bool = typer.Option(True, "--pipx/--no-pipx", help="Install via pipx for global availability."),
+        shell_hook: bool = typer.Option(True, "--shell-hook/--no-shell-hook", help="Add cd hook to shell rc for auto-bootstrap."),
+        git_template: bool = typer.Option(True, "--git-template/--no-git-template", help="Install git template hooks for every new repo."),
+        dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be changed without mutating anything."),
+    ) -> None:
+        """Install agentpack once — works in every repo from that point on.
+
+        Sets up git template hooks (fired on every git init/clone) and a shell
+        cd hook so agentpack auto-bootstraps silently whenever you enter a git
+        repo for the first time. No per-project setup required after this.
+        """
+        import subprocess as sp
+
+        if dry_run:
+            console.print("[bold yellow]Dry run — no files will be changed.[/]\n")
+
+        if pipx and not dry_run:
+            console.print("[bold]Installing agentpack globally via pipx...[/]")
+            result = sp.run(
+                ["pipx", "install", "agentpack-cli", "--force"],
+                capture_output=True, text=True,
+            )
+            if result.returncode == 0:
+                console.print("[green]agentpack installed globally.[/] Available as `agentpack` in any shell.")
+            else:
+                console.print("[yellow]pipx install failed. Trying pip install --user...[/]")
+                result2 = sp.run(
+                    [sys.executable, "-m", "pip", "install", "--user", "agentpack-cli"],
+                    capture_output=True, text=True,
+                )
+                if result2.returncode != 0:
+                    console.print(f"[red]Install failed:[/] {result2.stderr[:200]}")
+                    raise typer.Exit(1)
+                console.print("[green]Installed via pip --user.[/]")
+        elif pipx and dry_run:
+            console.print("[dim]Would run: pipx install agentpack-cli[/]")
+
+        # --- Git template hooks (fire on every future git init / clone) ---
+        if git_template:
+            console.print("\n[bold]Git template hooks:[/]" if dry_run else "\n[bold]Setting up git template hooks...[/]")
+            hook_results = install_git_template_hooks(dry_run=dry_run)
+            for name, action in hook_results.items():
+                if action != "unchanged":
+                    prefix = "[dim]" if dry_run else "[green]"
+                    suffix = "[/]"
+                    console.print(f"{prefix}~/.git-templates/hooks/{name} {action}.{suffix}")
+            git_cfg_action = configure_git_template_dir(dry_run=dry_run)
+            console.print(f"[dim]git config --global init.templateDir {git_cfg_action}.[/]" if dry_run
+                          else f"[green]git config --global init.templateDir {git_cfg_action}.[/]")
+            if not dry_run:
+                console.print("  Every future [bold]git init[/] or [bold]git clone[/] will auto-bootstrap agentpack.")
+
+        # --- Shell cd hook (fires when entering opted-in repos) ---
+        if shell_hook:
+            console.print("\n[bold]Shell cd hook:[/]" if dry_run else "\n[bold]Setting up shell cd hook...[/]")
+            action, rc_path = install_shell_hook(dry_run=dry_run)
+            if rc_path:
+                prefix = "[dim]" if dry_run else "[green]"
+                console.print(f"{prefix}{rc_path} {action}.[/]")
+                if not dry_run:
+                    console.print("  When you [bold]cd[/] into a repo with [dim].agentpack/config.toml[/], agentpack")
+                    console.print("  silently repacks if stale. [dim]Non-configured repos are never touched.[/]")
+                    console.print(f"  [dim]Reload with: source {rc_path}[/]")
+            else:
+                console.print(f"[yellow]Shell hook: {action}[/]")
+
+        root = _root()
+
+        # --- Agent-specific config ---
+        if agent == "claude":
+            if not dry_run:
+                hook_action = ClaudeInstaller().patch_claude_settings(root, global_install=True)
+                console.print(f"\n[green]~/.claude/settings.json {hook_action}.[/]")
+                _install_slash_command(root, global_install=True)
+            else:
+                console.print("\n[dim]Would patch: ~/.claude/settings.json (hooks)[/]")
+                console.print("[dim]Would install: ~/.claude/commands/agentpack.md (slash command)[/]")
+
+        elif agent == "cursor":
+            if not dry_run:
+                inst = CursorInstaller()
+                rules_action = inst.patch_cursor_rules(root)
+                console.print(f"\n[green].cursorrules {rules_action}.[/]")
+                mdc_action = inst.patch_cursor_mdc(root)
+                console.print(f"[green].cursor/rules/agentpack.mdc {mdc_action}.[/]")
+            else:
+                console.print("\n[dim]Would patch: .cursorrules, .cursor/rules/agentpack.mdc[/]")
+
+        elif agent == "windsurf":
+            if not dry_run:
+                rules_action = WindsurfInstaller().patch_windsurfrules(root)
+                console.print(f"\n[green].windsurfrules {rules_action}.[/]")
+            else:
+                console.print("\n[dim]Would patch: .windsurfrules[/]")
+
+        elif agent == "codex":
+            if not dry_run:
+                action = CodexInstaller().patch_agents_md(root)
+                console.print(f"\n[green]AGENTS.md {action}.[/]")
+            else:
+                console.print("\n[dim]Would patch: AGENTS.md[/]")
+
+        else:
+            console.print(f"[yellow]Unknown agent: {agent}. Supported: {', '.join(_SUPPORTED_AGENTS)}[/]")
+            raise typer.Exit(1)
+
+        if dry_run:
+            console.print("\n[bold yellow]Dry run complete. Re-run without --dry-run to apply.[/]")
+        else:
+            console.print("\n[bold green]Global install complete.[/]")
+            console.print("  Git hooks fire on commit/merge/checkout — [bold]only in opted-in repos[/].")
+            if shell_hook:
+                console.print("  Shell hook repacks on cd — [bold]only in repos with .agentpack/config.toml[/].")
+            console.print("  To opt a repo in: [bold]cd repo && agentpack init[/]")
+
+    @app.command(name="global-uninstall")
+    def global_uninstall_cmd(
+        shell_hook: bool = typer.Option(True, "--shell-hook/--no-shell-hook", help="Remove cd hook from shell rc."),
+        git_template: bool = typer.Option(True, "--git-template/--no-git-template", help="Remove git template hooks."),
+    ) -> None:
+        """Remove agentpack global hooks (git templates + shell rc hook).
+
+        Per-project .agentpack/ directories and agent config files are not touched.
+        """
+        if git_template:
+            console.print("[bold]Removing git template hooks...[/]")
+            results = remove_git_template_hooks()
+            if results:
+                for name, action in results.items():
+                    if action != "unchanged":
+                        console.print(f"[green]~/.git-templates/hooks/{name} {action}.[/]")
+            else:
+                console.print("[dim]No git template hooks found.[/]")
+
+        if shell_hook:
+            console.print("\n[bold]Removing shell cd hook...[/]")
+            action, rc_path = remove_shell_hook()
+            if rc_path:
+                console.print(f"[green]{rc_path} {action}.[/]")
+            else:
+                console.print("[dim]No shell hook found (unknown shell).[/]")
+
+        console.print("\n[bold green]Global uninstall complete.[/]")
+        console.print("  Per-project [dim].agentpack/[/] directories are untouched.")
+        console.print("  To remove from a specific repo: delete [dim].agentpack/[/] and remove agent config.")
+
+
+def _print_auto_repack_results(results: dict[str, str]) -> None:
+    for key, action in results.items():
+        if action == "unchanged":
+            continue
+        if key.startswith("git:"):
+            console.print(f"[green].git/hooks/{key[4:]} {action}.[/]")
+        elif key == "vscode:tasks":
+            console.print(f"[green].vscode/tasks.json {action}.[/]")
+
+
+def _install_slash_command(root: Path, global_install: bool) -> None:
+    import importlib.resources
+
+    commands_dir = (
+        Path.home() / ".claude" / "commands" if global_install
+        else root / ".claude" / "commands"
+    )
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    dest = commands_dir / "agentpack.md"
+
+    try:
+        pkg_files = importlib.resources.files("agentpack") / "data" / "agentpack.md"
+        source_text = pkg_files.read_text(encoding="utf-8")
+    except Exception:
+        source_text = (Path(__file__).parent.parent / "data" / "agentpack.md").read_text()
+
+    dest.write_text(source_text)
+    scope = "global" if global_install else "local"
+    console.print(f"[green]Slash command installed ({scope}):[/] {dest}")
+    console.print("  Use [bold]/agentpack[/] in any Claude CLI session.")

agentpack/commands/monitor.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import json
+
+import typer
+from rich.table import Table
+from rich import box
+
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def monitor(
+        last: int = typer.Option(20, "--last", "-n", help="Show last N pack runs."),
+        clear: bool = typer.Option(False, "--clear", help="Delete metrics log."),
+    ) -> None:
+        """Show pack performance metrics across runs."""
+        root = _root()
+        metrics_path = root / ".agentpack" / "metrics.jsonl"
+
+        if clear:
+            if metrics_path.exists():
+                metrics_path.unlink()
+                console.print("[green]Metrics log cleared.[/]")
+            else:
+                console.print("[dim]No metrics log found.[/]")
+            return
+
+        if not metrics_path.exists():
+            console.print("[yellow]No metrics recorded yet. Run agentpack pack first.[/]")
+            raise typer.Exit(1)
+
+        records = []
+        for line in metrics_path.read_text().splitlines():
+            line = line.strip()
+            if line:
+                try:
+                    records.append(json.loads(line))
+                except json.JSONDecodeError:
+                    pass
+
+        if not records:
+            console.print("[yellow]Metrics log is empty.[/]")
+            raise typer.Exit(1)
+
+        recent = records[-last:]
+
+        # Summary stats
+        savings = [r["saving_pct"] for r in recent]
+        totals = [r["total_s"] for r in recent]
+        avg_saving = sum(savings) / len(savings)
+        avg_total = sum(totals) / len(totals)
+        best_saving = max(savings)
+
+        summary_table = Table(title="Performance Summary", show_header=True, box=box.SIMPLE)
+        summary_table.add_column("Metric", style="cyan")
+        summary_table.add_column("Value", justify="right")
+        summary_table.add_row("Runs recorded", str(len(records)))
+        summary_table.add_row("Shown", str(len(recent)))
+        summary_table.add_row("Avg saving", f"[green]{avg_saving:.1f}%[/]")
+        summary_table.add_row("Best saving", f"[green]{best_saving:.1f}%[/]")
+        summary_table.add_row("Avg pack time", f"{avg_total:.2f}s")
+        console.print(summary_table)
+
+        # Per-run table
+        run_table = Table(title=f"Last {len(recent)} Runs", show_header=True, box=box.SIMPLE)
+        run_table.add_column("When", style="dim", max_width=20)
+        run_table.add_column("Task", max_width=35)
+        run_table.add_column("Mode", width=9)
+        run_table.add_column("Saving", justify="right")
+        run_table.add_column("Packed", justify="right")
+        run_table.add_column("Total", justify="right")
+        run_table.add_column("scan", justify="right", style="dim")
+        run_table.add_column("sum", justify="right", style="dim")
+        run_table.add_column("rank", justify="right", style="dim")
+
+        for r in recent:
+            ts = r.get("ts", "")[:16].replace("T", " ")
+            phases = r.get("phases", {})
+            run_table.add_row(
+                ts,
+                r.get("task", "")[:35],
+                r.get("mode", ""),
+                f"[green]{r['saving_pct']:.1f}%[/]",
+                f"{r['packed_tokens']:,}",
+                f"{r['total_s']:.2f}s",
+                f"{phases.get('scan', 0):.2f}s",
+                f"{phases.get('summarize', 0):.2f}s",
+                f"{phases.get('rank', 0):.2f}s",
+            )
+
+        console.print(run_table)
+
+        # Phase breakdown averaged
+        phase_keys = ["scan", "summarize", "deps", "changes", "rank", "select", "render"]
+        phase_table = Table(title="Avg Phase Times", show_header=True, box=box.SIMPLE)
+        phase_table.add_column("Phase", style="cyan")
+        phase_table.add_column("Avg (s)", justify="right")
+        phase_table.add_column("Max (s)", justify="right")
+        for pk in phase_keys:
+            vals = [r.get("phases", {}).get(pk, 0) for r in recent]
+            if any(v > 0 for v in vals):
+                phase_table.add_row(pk, f"{sum(vals)/len(vals):.3f}", f"{max(vals):.3f}")
+        console.print(phase_table)

agentpack/commands/pack.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.columns import Columns
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+
+from agentpack.core import git
+from agentpack.application.pack_service import PackRequest, PackService, PackResult
+from agentpack.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command()
+    def pack(
+        agent: str = typer.Option("claude", "--agent", help="Target agent (claude|cursor|windsurf|codex|generic)."),
+        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)."),
+        print_output: bool = typer.Option(False, "--print", help="Print context to stdout."),
+        refresh: bool = typer.Option(False, "--refresh", help="Rebuild summaries before packing."),
+        summary_provider: str = typer.Option("offline", "--summary-provider", help="Summary provider (offline|claude)."),
+        watch: bool = typer.Option(False, "--watch", help="Watch for file changes and re-pack automatically."),
+        session: bool = typer.Option(False, "--session", help="Keep re-packing on changes for the whole session (alias for --watch)."),
+    ) -> None:
+        """Generate a context pack for an AI coding agent."""
+        if mode not in ("minimal", "balanced", "deep"):
+            console.print(f"[red]Invalid mode: {mode}. Use minimal|balanced|deep.[/]")
+            raise typer.Exit(1)
+
+        resolved_task = _resolve_task(task)
+
+        if watch or session:
+            _pack_watch(agent=agent, task=resolved_task, mode=mode, budget=budget,
+                        since=since, summary_provider=summary_provider)
+            return
+
+        result = PackService().run(PackRequest(
+            root=_root(),
+            agent=agent,
+            task=resolved_task,
+            mode=mode,
+            budget=budget,
+            since=since,
+            refresh=refresh,
+            summary_provider=summary_provider,
+        ))
+        _print_pack_summary(result)
+        if print_output:
+            print(result.out_path.read_text())
+
+
+def _resolve_task(task: str) -> str:
+    if task != "auto":
+        return task
+    inferred = git.infer_task_from_git(_root())
+    console.print(f"[dim]Auto task: {inferred}[/]")
+    return inferred
+
+
+def _print_pack_summary(result: PackResult) -> None:
+    out_path = result.out_path
+    selected = result.pack.selected_files
+    packed_tokens = result.packed_tokens
+    raw_tokens = result.raw_tokens
+    saving_pct = result.saving_pct
+    changed_files = result.changed_files
+    task = result.pack.task
+    since = None  # since is not stored in PackResult; shown via changed_files
+
+    stats = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+    stats.add_column(style="dim")
+    stats.add_column(justify="right", style="bold")
+    stats.add_row("packed tokens", f"{packed_tokens:,}")
+    stats.add_row("raw tokens", f"{raw_tokens:,}")
+    stats.add_row("saving", f"[green]{saving_pct:.1f}%[/]")
+
+    MODE_STYLE = {"full": "green", "symbols": "yellow", "summary": "dim"}
+    files_tbl = Table(box=box.SIMPLE, show_header=True, padding=(0, 1))
+    files_tbl.add_column("file", style="dim", no_wrap=False, max_width=55)
+    files_tbl.add_column("mode", justify="center", width=8)
+    files_tbl.add_column("why", style="dim", max_width=30)
+
+    changed_set = set(changed_files)
+    for sf in selected[:20]:
+        style = MODE_STYLE.get(sf.include_mode, "")
+        changed_marker = " [red]●[/]" if sf.path in changed_set else ""
+        files_tbl.add_row(
+            f"{sf.path}{changed_marker}",
+            f"[{style}]{sf.include_mode}[/]",
+            sf.reasons[0] if sf.reasons else "",
+        )
+    if len(selected) > 20:
+        files_tbl.add_row(f"[dim]... {len(selected) - 20} more[/]", "", "")
+
+    if changed_files:
+        changed_lines = "\n".join(f"  [red]●[/] {f}" for f in changed_files[:10])
+        if len(changed_files) > 10:
+            changed_lines += f"\n  [dim]... {len(changed_files) - 10} more[/]"
+    else:
+        changed_lines = "  [dim]none detected[/]"
+
+    console.print()
+    console.print(Panel(
+        f"[bold cyan]{task}[/]",
+        title="[bold green]✓ Context Pack Ready[/]",
+        subtitle=f"[dim]{out_path}[/]",
+        border_style="green",
+        padding=(0, 1),
+    ))
+    console.print()
+    console.print(Columns([stats, files_tbl], equal=False, expand=False))
+
+    if changed_files:
+        console.print(f"\n[bold]Changed files[/] ({len(changed_files)}):")
+        console.print(changed_lines)
+
+    console.print(f"\n[bold]Next step:[/]")
+    console.print(f"  [bold white]claude < {out_path}[/]")
+    console.print(f"  [dim]or: agentpack pack --task \"{task}\" --print | claude[/]")
+    console.print()
+
+
+def _pack_watch(
+    agent: str,
+    task: str,
+    mode: str,
+    budget: int,
+    since: str | None,
+    summary_provider: str,
+) -> None:
+    try:
+        from watchdog.observers import Observer
+        from watchdog.events import FileSystemEventHandler
+    except ImportError:
+        console.print("[red]watchdog is required for --watch mode.[/]")
+        console.print("Install it: [bold]pip install watchdog[/]")
+        raise typer.Exit(1)
+
+    root = _root()
+    console.print(f"[bold]Watch mode active.[/] Repacking on file changes... (Ctrl+C to stop)")
+    console.print(f"  Task: {task}")
+
+    def _run_pack() -> None:
+        result = PackService().run(PackRequest(
+            root=root, agent=agent, task=task, mode=mode, budget=budget,
+            since=since, refresh=False, summary_provider=summary_provider,
+        ))
+        _print_pack_summary(result)
+
+    _run_pack()
+
+    _last_pack = [time.time()]
+    _DEBOUNCE = 2.0
+
+    class Handler(FileSystemEventHandler):
+        def on_any_event(self, event):  # type: ignore[override]
+            if event.is_directory:
+                return
+            path = str(event.src_path)
+            if ".agentpack" in path:
+                return
+            now = time.time()
+            if now - _last_pack[0] < _DEBOUNCE:
+                return
+            _last_pack[0] = now
+            console.print(f"\n[dim]Change detected: {event.src_path}[/]")
+            try:
+                _run_pack()
+            except Exception as e:
+                console.print(f"[red]Pack error: {e}[/]")
+
+    observer = Observer()
+    observer.schedule(Handler(), str(root), recursive=True)
+    observer.start()
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+        console.print("\n[dim]Watch mode stopped.[/]")
+    observer.join()

agentpack/commands/scan.py

@@ -0,0 +1,51 @@
+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.commands._shared import console, _root
+
+
+def register(app: typer.Typer) -> None:
+    @app.command(name="scan")
+    def scan_cmd() -> None:
+        """Scan the repository and report file statistics."""
+        root = _root()
+        cfg = load_config(root)
+        ignore_spec = load_spec(root / cfg.project.ignore_file)
+
+        console.print("[bold]Scanning repository...[/]")
+        scan_result = scan(root, ignore_spec, cfg.context.max_file_tokens)
+
+        total = len(scan_result.all_files)
+        ignored = len(scan_result.ignored) + len(scan_result.binary)
+        scanned = len(scan_result.packable)
+        raw_tokens = sum(f.estimated_tokens for f in scan_result.all_files)
+        after_ignore = sum(f.estimated_tokens for f in scan_result.packable)
+
+        largest = sorted(
+            scan_result.packable,
+            key=lambda x: x.estimated_tokens,
+            reverse=True,
+        )[:10]
+
+        table = Table(title="Repository Scan", show_header=True)
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", justify="right")
+        table.add_row("Files discovered", str(total))
+        table.add_row("Files ignored / binary", str(ignored))
+        table.add_row("Files scanned", str(scanned))
+        table.add_row("Raw estimated tokens", f"{raw_tokens:,}")
+        table.add_row("Tokens after ignore", f"{after_ignore:,}")
+        console.print(table)
+
+        if largest:
+            lt = Table(title="Largest Files", show_header=True)
+            lt.add_column("File", style="dim")
+            lt.add_column("Tokens", justify="right")
+            for f in largest:
+                lt.add_row(f.path, f"{f.estimated_tokens:,}")
+            console.print(lt)