agentpack-cli 0.1.6__tar.gz → 0.1.7__tar.gz

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentpack-cli
-Version: 0.1.6
+Version: 0.1.7
 Summary: Token-aware context packing for AI coding agents — Claude, Cursor, Windsurf, and Codex
 License: MIT
 License-File: LICENSE

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentpack-cli"
-version = "0.1.6"
+version = "0.1.7"
 description = "Token-aware context packing for AI coding agents — Claude, Cursor, Windsurf, and Codex"
 readme = "README.md"
 requires-python = ">=3.10"

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/analysis/ranking.py

@@ -282,6 +282,7 @@ def score_files(
     include_tests: bool = True,
     include_configs: bool = True,
     weights: ScoringWeights | None = None,
+    summaries: dict | None = None,
 ) -> list[tuple[FileInfo, float, list[str]]]:
     from agentpack.core.models import DependencyGraph as _DG
     if not isinstance(dep_graph, _DG):
@@ -312,7 +313,13 @@ def score_files(
             reasons.append("filename keyword match")
 
         node = dep_graph.get(fi.path)
-        sym_names: list[str] = []  # symbols aren't stored on DependencyNode; scoring uses path/content only
+        sym_names: list[str] = []
+        if summaries and fi.path in summaries:
+            raw_syms = summaries[fi.path].get("symbols", [])
+            sym_names = [
+                (s["name"] if isinstance(s, dict) else s.name)
+                for s in raw_syms
+            ]
         if _symbol_matches_keywords(sym_names, keywords):
             score += w.symbol_keyword
             reasons.append("symbol keyword match")

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/application/pack_service.py

@@ -128,6 +128,7 @@ class FileRanker:
         dep_graph: DependencyGraph,
         task: str,
         cfg: Any,
+        summaries: dict | None = None,
     ) -> RankResult:
         keywords = extract_keywords(task)
         keywords = enrich_keywords_from_files(keywords, changes.all_changed, packable)
@@ -147,6 +148,7 @@ class FileRanker:
             include_tests=cfg.context.include_tests,
             include_configs=cfg.context.include_configs,
             weights=cfg.scoring,
+            summaries=summaries,
         )
         return RankResult(keywords=keywords, scored=scored)
 
@@ -163,7 +165,12 @@ class PackPlanner:
 
         t0 = time.perf_counter()
         previous_snap = load_snapshot(root)
-        scan_result = scan(root, ignore_spec, cfg.context.max_file_tokens, previous_snapshot=previous_snap)
+        scan_result = scan(
+            root, ignore_spec, cfg.context.max_file_tokens,
+            previous_snapshot=previous_snap,
+            include_globs=cfg.project.include_globs or None,
+            exclude_globs=cfg.project.exclude_globs or None,
+        )
         phase_times["scan"] = time.perf_counter() - t0
 
         packable = scan_result.packable
@@ -182,7 +189,7 @@ class PackPlanner:
         phase_times["changes"] = time.perf_counter() - t0
 
         t0 = time.perf_counter()
-        rank_result = FileRanker().rank(packable, changes, dep_graph, request.task, cfg)
+        rank_result = FileRanker().rank(packable, changes, dep_graph, request.task, cfg, summaries=summaries)
         phase_times["rank"] = time.perf_counter() - t0
 
         t0 = time.perf_counter()

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/commands/benchmark.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import json
+import random
 import time
 from dataclasses import dataclass, field
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
 
@@ -24,13 +27,21 @@ class BenchmarkCase:
 class CaseResult:
     case: BenchmarkCase
     packed_tokens: int
-    raw_tokens: int
-    saving_pct: float
+    raw_tokens: int           # all files (incl. ignored)
+    after_ignore_tokens: int  # packable files only — honest baseline
+    saving_pct: float         # vs raw
+    saving_pct_honest: float  # vs after_ignore
     selected_paths: list[str]
-    changed_covered: int      # # changed files that were selected
-    changed_total: int        # total changed files detected
+    selected_tokens: dict[str, int]   # path → token count for noise calc
+    changed_covered: int
+    changed_total: int
     total_s: float
     phase_times: dict[str, float]
+    rank_at_k: int | None = None   # min rank to see all expected_files; None if no expected
+    noise_pct: float | None = None  # tokens on non-expected / packed; None if no expected
+    random_precision: float | None = None
+    random_recall: float | None = None
+    random_f1: float | None = None
 
 
 def _load_cases(path: Path) -> list[BenchmarkCase]:
@@ -74,9 +85,64 @@ def _scaffold_cases(root: Path) -> Path:
     return out
 
 
+def _load_history_cases(root: Path, n: int) -> list[BenchmarkCase]:
+    """Sample last N unique tasks from metrics.jsonl."""
+    metrics_path = root / ".agentpack" / "metrics.jsonl"
+    if not metrics_path.exists():
+        return []
+    seen: list[str] = []
+    seen_set: set[str] = set()
+    for line in reversed(metrics_path.read_text().splitlines()):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            rec = json.loads(line)
+            task = rec.get("task", "").strip()
+            mode = rec.get("mode", "balanced")
+            if task and task not in seen_set:
+                seen_set.add(task)
+                seen.append((task, mode))
+                if len(seen) >= n:
+                    break
+        except json.JSONDecodeError:
+            pass
+    return [BenchmarkCase(task=t, mode=m) for t, m in seen]
+
+
+def _random_baseline(
+    packable_paths: list[str],
+    packable_tokens: dict[str, int],
+    expected_files: list[str],
+    budget: int,
+) -> tuple[list[str], float, float, float]:
+    """Random file selection at same budget. Returns (selected, precision, recall, f1)."""
+    shuffled = list(packable_paths)
+    random.shuffle(shuffled)
+    selected: list[str] = []
+    used = 0
+    for p in shuffled:
+        tok = packable_tokens.get(p, 50)
+        if used + tok <= budget:
+            selected.append(p)
+            used += tok
+
+    expected = set(expected_files)
+    sel_set = set(selected)
+    if not expected or not sel_set:
+        return selected, 0.0, 0.0, 0.0
+    tp = len(sel_set & expected)
+    p = tp / len(sel_set)
+    r = tp / len(expected)
+    f1 = 2 * p * r / (p + r) if (p + r) > 0 else 0.0
+    return selected, p, r, f1
+
+
 def _run_case(root: Path, case: BenchmarkCase) -> CaseResult:
     from agentpack.application.pack_service import PackPlanner, PackRequest, _sf_tokens
-    from agentpack.core.token_estimator import estimate_tokens
+    from agentpack.core.config import load_config
+
+    cfg = load_config(root)
 
     request = PackRequest(
         root=root,
@@ -95,29 +161,63 @@ def _run_case(root: Path, case: BenchmarkCase) -> CaseResult:
 
     packed_tokens = sum(_sf_tokens(sf) for sf in plan.selected)
     raw_tokens = sum(f.estimated_tokens for f in plan.scan_result.all_files)
+    after_ignore_tokens = sum(f.estimated_tokens for f in plan.scan_result.packable)
     saving_pct = (1 - packed_tokens / raw_tokens) * 100 if raw_tokens > 0 else 0.0
+    saving_pct_honest = (1 - packed_tokens / after_ignore_tokens) * 100 if after_ignore_tokens > 0 else 0.0
 
     selected_paths = [sf.path for sf in plan.selected]
     selected_set = set(selected_paths)
+    selected_tokens = {sf.path: _sf_tokens(sf) for sf in plan.selected}
 
     changed_covered = len(plan.all_changed & selected_set)
     changed_total = len(plan.all_changed)
 
+    # Rank@K: min rank in scored list to cover all expected files
+    rank_at_k: int | None = None
+    noise_pct: float | None = None
+    rand_p = rand_r = rand_f1 = None
+
+    if case.expected_files:
+        expected_set = set(case.expected_files)
+        scored_paths = [fi.path for fi, _score, _reasons in plan.scored]
+        found: set[str] = set()
+        for k, path in enumerate(scored_paths, 1):
+            if path in expected_set:
+                found.add(path)
+            if found >= expected_set:
+                rank_at_k = k
+                break
+
+        expected_tokens = sum(selected_tokens.get(p, 0) for p in selected_set & expected_set)
+        noise_pct = (1 - expected_tokens / packed_tokens) * 100 if packed_tokens > 0 else 0.0
+
+        packable_paths = [f.path for f in plan.scan_result.packable]
+        packable_token_map = {f.path: f.estimated_tokens for f in plan.scan_result.packable}
+        budget = cfg.context.default_budget
+        _, rand_p, rand_r, rand_f1 = _random_baseline(packable_paths, packable_token_map, case.expected_files, budget)
+
     return CaseResult(
         case=case,
         packed_tokens=packed_tokens,
         raw_tokens=raw_tokens,
+        after_ignore_tokens=after_ignore_tokens,
         saving_pct=saving_pct,
+        saving_pct_honest=saving_pct_honest,
         selected_paths=selected_paths,
+        selected_tokens=selected_tokens,
         changed_covered=changed_covered,
         changed_total=changed_total,
         total_s=total_s,
         phase_times=plan.phase_times,
+        rank_at_k=rank_at_k,
+        noise_pct=noise_pct,
+        random_precision=rand_p,
+        random_recall=rand_r,
+        random_f1=rand_f1,
     )
 
 
 def _precision_recall(result: CaseResult) -> tuple[float, float, float]:
-    """Returns (precision, recall, f1). Requires expected_files on the case."""
     expected = set(result.case.expected_files)
     if not expected:
         return 0.0, 0.0, 0.0
@@ -129,6 +229,37 @@ def _precision_recall(result: CaseResult) -> tuple[float, float, float]:
     return p, r, f1
 
 
+def _persist_result(root: Path, result: CaseResult) -> None:
+    out = root / ".agentpack" / "benchmark_results.jsonl"
+    p, r, f1 = _precision_recall(result) if result.case.expected_files else (None, None, None)
+    record = {
+        "ts": datetime.now(timezone.utc).isoformat(),
+        "task": result.case.task,
+        "mode": result.case.mode,
+        "packed_tokens": result.packed_tokens,
+        "raw_tokens": result.raw_tokens,
+        "after_ignore_tokens": result.after_ignore_tokens,
+        "saving_pct": round(result.saving_pct, 1),
+        "saving_pct_honest": round(result.saving_pct_honest, 1),
+        "files_selected": len(result.selected_paths),
+        "changed_covered": result.changed_covered,
+        "changed_total": result.changed_total,
+        "total_s": round(result.total_s, 3),
+        "phases": {k: round(v, 3) for k, v in result.phase_times.items()},
+        "precision": round(p, 3) if p is not None else None,
+        "recall": round(r, 3) if r is not None else None,
+        "f1": round(f1, 3) if f1 is not None else None,
+        "rank_at_k": result.rank_at_k,
+        "noise_pct": round(result.noise_pct, 1) if result.noise_pct is not None else None,
+        "random_f1": round(result.random_f1, 3) if result.random_f1 is not None else None,
+    }
+    try:
+        with out.open("a") as fh:
+            fh.write(json.dumps(record) + "\n")
+    except Exception:
+        pass
+
+
 def _print_case_detail(result: CaseResult) -> None:
     has_gt = bool(result.case.expected_files)
     p, r, f1 = _precision_recall(result) if has_gt else (0.0, 0.0, 0.0)
@@ -139,8 +270,10 @@ def _print_case_detail(result: CaseResult) -> None:
     tbl.add_column(style="dim")
     tbl.add_column(justify="right", style="bold")
     tbl.add_row("packed tokens", f"{result.packed_tokens:,}")
-    tbl.add_row("raw tokens", f"{result.raw_tokens:,}")
-    tbl.add_row("saving", f"[green]{result.saving_pct:.1f}%[/]")
+    tbl.add_row("raw tokens (all files)", f"{result.raw_tokens:,}")
+    tbl.add_row("after ignore tokens", f"{result.after_ignore_tokens:,}")
+    tbl.add_row("saving vs raw", f"[green]{result.saving_pct:.1f}%[/]")
+    tbl.add_row("saving vs after-ignore", f"[cyan]{result.saving_pct_honest:.1f}%[/]")
     tbl.add_row("files selected", str(len(result.selected_paths)))
     if result.changed_total > 0:
         cov_pct = result.changed_covered / result.changed_total * 100
@@ -162,6 +295,19 @@ def _print_case_detail(result: CaseResult) -> None:
             f"recall [bold]{r:.1%}[/]  "
             f"F1 [bold]{f1:.1%}[/]"
         )
+        if result.rank_at_k is not None:
+            console.print(f"  rank@K (all expected covered at rank) [bold]{result.rank_at_k}[/]")
+        else:
+            console.print("  rank@K  [dim]expected files not all found in scored list[/]")
+        if result.noise_pct is not None:
+            console.print(f"  noise (tokens on non-expected files) [bold]{result.noise_pct:.1f}%[/]")
+        if result.random_f1 is not None:
+            lift = f1 - result.random_f1
+            color = "green" if lift >= 0 else "red"
+            console.print(
+                f"  random baseline F1 [dim]{result.random_f1:.1%}[/]  "
+                f"ranker lift [{color}]{lift:+.1%}[/{color}]"
+            )
         expected_set = set(result.case.expected_files)
         selected_set = set(result.selected_paths)
         hits = expected_set & selected_set
@@ -181,13 +327,17 @@ def _print_summary_table(results: list[CaseResult]) -> None:
     tbl.add_column("task", max_width=40)
     tbl.add_column("mode", width=9)
     tbl.add_column("tokens", justify="right")
-    tbl.add_column("saving", justify="right")
+    tbl.add_column("vs raw", justify="right")
+    tbl.add_column("vs ignore", justify="right")
     tbl.add_column("files", justify="right")
     tbl.add_column("time", justify="right")
     if has_gt:
         tbl.add_column("P", justify="right")
         tbl.add_column("R", justify="right")
         tbl.add_column("F1", justify="right")
+        tbl.add_column("rand F1", justify="right")
+        tbl.add_column("rank@K", justify="right")
+        tbl.add_column("noise%", justify="right")
 
     for r in results:
         p, rec, f1 = _precision_recall(r) if r.case.expected_files else (0.0, 0.0, 0.0)
@@ -196,6 +346,7 @@ def _print_summary_table(results: list[CaseResult]) -> None:
             r.case.mode,
             f"{r.packed_tokens:,}",
             f"{r.saving_pct:.1f}%",
+            f"{r.saving_pct_honest:.1f}%",
             str(len(r.selected_paths)),
             f"{r.total_s:.2f}s",
         ]
@@ -204,6 +355,9 @@ def _print_summary_table(results: list[CaseResult]) -> None:
                 f"{p:.1%}" if r.case.expected_files else "—",
                 f"{rec:.1%}" if r.case.expected_files else "—",
                 f"{f1:.1%}" if r.case.expected_files else "—",
+                f"{r.random_f1:.1%}" if r.random_f1 is not None else "—",
+                str(r.rank_at_k) if r.rank_at_k is not None else "—",
+                f"{r.noise_pct:.0f}%" if r.noise_pct is not None else "—",
             ]
         tbl.add_row(*row)
 
@@ -212,13 +366,13 @@ def _print_summary_table(results: list[CaseResult]) -> None:
 
 
 def _print_compare_table(task: str, results: list[CaseResult]) -> None:
-    """Side-by-side mode comparison for a single task."""
     console.print(f"\n[bold]Mode comparison:[/] [cyan]{task}[/]\n")
 
     tbl = Table(box=box.SIMPLE, show_header=True, padding=(0, 2))
     tbl.add_column("mode", width=10)
     tbl.add_column("tokens", justify="right")
-    tbl.add_column("saving", justify="right")
+    tbl.add_column("vs raw", justify="right")
+    tbl.add_column("vs ignore", justify="right")
     tbl.add_column("files", justify="right")
     tbl.add_column("time", justify="right")
 
@@ -227,6 +381,7 @@ def _print_compare_table(task: str, results: list[CaseResult]) -> None:
             r.case.mode,
             f"{r.packed_tokens:,}",
             f"{r.saving_pct:.1f}%",
+            f"{r.saving_pct_honest:.1f}%",
             str(len(r.selected_paths)),
             f"{r.total_s:.2f}s",
         )
@@ -241,6 +396,7 @@ def register(app: typer.Typer) -> None:
         cases: str = typer.Option("", "--cases", help="Path to TOML cases file (default: .agentpack/benchmark.toml)."),
         compare: bool = typer.Option(False, "--compare", is_flag=True, help="Compare minimal/balanced/deep for each task."),
         init: bool = typer.Option(False, "--init", is_flag=True, help="Scaffold a benchmark.toml and exit."),
+        from_history: int = typer.Option(0, "--from-history", help="Sample last N unique tasks from metrics.jsonl history."),
     ) -> None:
         """Benchmark file selection quality and token efficiency across tasks."""
         root = _root()
@@ -252,7 +408,12 @@ def register(app: typer.Typer) -> None:
             return
 
         # Build case list
-        if task:
+        if from_history > 0:
+            bench_cases = _load_history_cases(root, from_history)
+            if not bench_cases:
+                console.print("[yellow]No task history found in metrics.jsonl. Run agentpack pack first.[/]")
+                raise typer.Exit(1)
+        elif task:
             resolved = _resolve_task(task) if task == "auto" else task
             bench_cases = [BenchmarkCase(task=resolved, mode=mode)]
         else:
@@ -282,6 +443,7 @@ def register(app: typer.Typer) -> None:
             with console.status(f"[dim]{label}[/]"):
                 try:
                     r = _run_case(root, c)
+                    _persist_result(root, r)
                     results.append(r)
                 except Exception as e:
                     console.print(f"[red]Error on case '{c.task}': {e}[/]")

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/commands/explain.py

@@ -204,11 +204,12 @@ def register(app: typer.Typer) -> None:
         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 ""
+            reason_str = ", ".join(reasons) if reasons else ""
+            mode_color = "green" if sf.include_mode == "full" else "yellow" if sf.include_mode == "symbols" else "dim"
             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"[[{mode_color}]{sf.include_mode}[/]]  "
                 f"[dim]{reason_str}[/]"
             )
 

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/commands/init.py

@@ -5,7 +5,7 @@ from typing import Optional
 
 import typer
 
-from agentpack.core.config import DEFAULT_CONFIG, save_config
+from agentpack.core.config import DEFAULT_CONFIG, CONFIG_TEMPLATE, save_config
 from agentpack.core.ignore import DEFAULT_AGENTIGNORE
 from agentpack.commands._shared import console, _root
 
@@ -63,7 +63,17 @@ def register(app: typer.Typer) -> None:
             if budget > 0:
                 cfg.context.default_budget = budget
 
-            save_config(cfg, root)
+            config_toml = CONFIG_TEMPLATE.replace(
+                'default_mode = "balanced"',
+                f'default_mode = "{cfg.context.default_mode}"',
+            )
+            if budget > 0:
+                config_toml = config_toml.replace(
+                    "default_budget = 25000",
+                    f"default_budget = {cfg.context.default_budget}",
+                )
+            config_path_file.parent.mkdir(parents=True, exist_ok=True)
+            config_path_file.write_text(config_toml)
             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)")

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/commands/pack.py

@@ -11,6 +11,7 @@ from rich.table import Table
 from rich import box
 
 from agentpack.core import git
+from agentpack.core.ignore import SENSITIVE_PATTERNS
 from agentpack.application.pack_service import PackRequest, PackService, PackResult
 from agentpack.commands._shared import console, _root
 
@@ -101,7 +102,7 @@ def _print_pack_summary(result: PackResult) -> None:
         files_tbl.add_row(
             f"{sf.path}{changed_marker}",
             f"[{style}]{sf.include_mode}[/]",
-            sf.reasons[0] if sf.reasons else "",
+            ", ".join(sf.reasons) if sf.reasons else "",
         )
     if len(selected) > 20:
         files_tbl.add_row(f"[dim]... {len(selected) - 20} more[/]", "", "")
@@ -128,6 +129,25 @@ def _print_pack_summary(result: PackResult) -> None:
         console.print(f"\n[bold]Changed files[/] ({len(changed_files)}):")
         console.print(changed_lines)
 
+    redaction_warnings = result.pack.redaction_warnings
+    if redaction_warnings:
+        console.print(f"\n[bold yellow]⚠ Secrets redacted ({len(redaction_warnings)}):[/]")
+        for w in redaction_warnings[:10]:
+            console.print(f"  [yellow]{w}[/]")
+        if len(redaction_warnings) > 10:
+            console.print(f"  [dim]... {len(redaction_warnings) - 10} more[/]")
+
+    sensitive_excluded = [
+        fi.path for fi in result.scan_result.ignored
+        if SENSITIVE_PATTERNS.match_file(fi.path)
+    ]
+    if sensitive_excluded:
+        console.print(f"\n[bold green]✓ Sensitive files excluded ({len(sensitive_excluded)}):[/]")
+        for p in sensitive_excluded[:10]:
+            console.print(f"  [dim]{p}[/]")
+        if len(sensitive_excluded) > 10:
+            console.print(f"  [dim]... {len(sensitive_excluded) - 10} more[/]")
+
     console.print(f"\n[bold]Next step:[/]")
     console.print(f"  [bold white]claude < {out_path}[/]")
     console.print()

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/commands/session.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import hashlib
+import os
 from pathlib import Path
 from typing import Optional
 
@@ -174,17 +175,16 @@ def _run_refresh(
             summary_provider="offline",
         ))
 
-        # Write readable context
+        # Write context files atomically — avoids partial reads if interrupted mid-write
         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")
+        _atomic_write(context_path, context_text)
 
-        # Write compact context
         compact_text = render_compact(result.pack)
         compact_path = root / COMPACT_FILE
-        compact_path.write_text(compact_text, encoding="utf-8")
+        _atomic_write(compact_path, compact_text)
 
         return {
             "files": len(result.pack.selected_files),
@@ -196,6 +196,26 @@ def _run_refresh(
         return None
 
 
+def _atomic_write(path: Path, text: str) -> None:
+    """Write to a temp file in the same dir, then rename — atomic on POSIX."""
+    import tempfile
+    dir_ = path.parent
+    try:
+        fd, tmp = tempfile.mkstemp(dir=dir_, prefix=".tmp_")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+                fh.write(text)
+            os.replace(tmp, path)
+        except Exception:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+    except OSError:
+        path.write_text(text, encoding="utf-8")
+
+
 def _now_iso() -> str:
     from datetime import datetime, timezone
     return datetime.now(timezone.utc).isoformat()

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/commands/watch.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import time
 from datetime import datetime
 from pathlib import Path
@@ -10,8 +11,15 @@ 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_DIRS = {
+    ".git", "node_modules", ".venv", "venv", "dist", "build", ".next",
+    "__pycache__", ".yarn", ".mypy_cache", ".ruff_cache", ".pytest_cache",
+    ".tox", ".eggs", "*.egg-info",
+}
 _IGNORE_NAMES = {"context.md", "context.compact.md"}
+_IGNORE_PREFIXES = (".agentpack/context",)
+
+_MAX_POLL_FILES = 50_000
 
 
 def register(app: typer.Typer) -> None:
@@ -58,12 +66,19 @@ def _should_ignore(path: str) -> bool:
         if part in _IGNORE_DIRS:
             return True
     name = Path(path).name
-    return name in _IGNORE_NAMES
+    if name in _IGNORE_NAMES:
+        return True
+    norm = path.replace("\\", "/")
+    return any(norm.startswith(p) for p in _IGNORE_PREFIXES)
 
 
 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)
+    try:
+        result = do_refresh(root, agent, mode, budget)
+    except Exception as e:
+        console.print(f"[dim][{_ts()}][/] [red]refresh error: {e}[/]")
+        return
     if result:
         ts = _ts()
         console.print(
@@ -102,21 +117,37 @@ def _watch_with_watchdog(
         def on_any_event(self, event):  # type: ignore[override]
             if event.is_directory:
                 return
-            path = str(event.src_path)
+            try:
+                path = str(Path(event.src_path).relative_to(root))
+            except ValueError:
+                return
             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:
+        observer.schedule(Handler(), str(root), recursive=True)
+        observer.start()
+    except Exception as e:
+        console.print(f"[red]Failed to start file watcher: {e}[/]")
+        console.print("[dim]Falling back to polling.[/]")
+        _watch_polling(root, agent, mode, budget, debounce, state)
+        return
 
     try:
         while True:
             time.sleep(0.5)
+            if not observer.is_alive():
+                console.print(f"[dim][{_ts()}][/] [yellow]watcher thread died — restarting...[/]")
+                try:
+                    observer.stop()
+                except Exception:
+                    pass
+                _watch_polling(root, agent, mode, budget, debounce, state)
+                return
             current_state = load_session(root)
             if current_state is not None and not current_state.active:
                 console.print("\n[dim]Session stopped — watch exiting.[/]")
@@ -127,14 +158,45 @@ def _watch_with_watchdog(
                 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}[/]")
+                    _run_refresh(root, agent, mode, budget)
     except KeyboardInterrupt:
         observer.stop()
         console.print("\n[dim]Watch stopped.[/]")
-    observer.join()
+    finally:
+        observer.join(timeout=3)
+
+
+def _collect_mtimes(root: Path) -> dict[str, float]:
+    """Walk repo files without following symlinks; cap at _MAX_POLL_FILES."""
+    mtimes: dict[str, float] = {}
+    try:
+        for entry in _walk_no_symlinks(root):
+            rel = str(Path(entry).relative_to(root))
+            if _should_ignore(rel):
+                continue
+            try:
+                mtimes[rel] = os.stat(entry).st_mtime
+            except OSError:
+                pass
+            if len(mtimes) >= _MAX_POLL_FILES:
+                break
+    except OSError:
+        pass
+    return mtimes
+
+
+def _walk_no_symlinks(root: Path):
+    """os.walk without following symlinks — avoids infinite loops in symlink forests."""
+    for dirpath, dirnames, filenames in os.walk(root, followlinks=False, onerror=lambda e: None):
+        # Prune ignored dirs in-place so os.walk won't descend into them
+        dirnames[:] = [
+            d for d in dirnames
+            if d not in _IGNORE_DIRS and not os.path.islink(os.path.join(dirpath, d))
+        ]
+        for fname in filenames:
+            fpath = os.path.join(dirpath, fname)
+            if not os.path.islink(fpath):
+                yield fpath
 
 
 def _watch_polling(
@@ -148,21 +210,7 @@ def _watch_polling(
     """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()
+    prev = _collect_mtimes(root)
     _run_refresh(root, agent, mode, budget)
     _last_refresh = time.monotonic()
 
@@ -173,7 +221,7 @@ def _watch_polling(
             if current_state is not None and not current_state.active:
                 console.print("\n[dim]Session stopped — watch exiting.[/]")
                 break
-            curr = _collect_mtimes()
+            curr = _collect_mtimes(root)
             changed = {p for p, m in curr.items() if prev.get(p) != m}
             changed |= set(prev) - set(curr)
             if changed:
@@ -184,10 +232,7 @@ def _watch_polling(
                 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}[/]")
+                    _run_refresh(root, agent, mode, budget)
             else:
                 prev = curr
     except KeyboardInterrupt:

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/core/config.py

@@ -14,6 +14,8 @@ from pydantic import BaseModel, Field
 class ProjectConfig(BaseModel):
     root: str = "."
     ignore_file: str = ".agentignore"
+    include_globs: list[str] = Field(default_factory=list)
+    exclude_globs: list[str] = Field(default_factory=list)
 
 
 class ContextConfig(BaseModel):
@@ -74,6 +76,41 @@ class Config(BaseModel):
 
 DEFAULT_CONFIG = Config()
 
+CONFIG_TEMPLATE = """\
+[project]
+# Restrict packing to these glob patterns (empty = all files).
+# Example: include_globs = ["app/**", "packages/core/**"]
+include_globs = []
+# Always exclude these patterns on top of .agentignore.
+# Example: exclude_globs = ["migrations/**", "generated/**", "snapshots/**"]
+exclude_globs = []
+
+[context]
+default_budget = 25000   # token budget per pack
+default_mode = "balanced"  # minimal | balanced | deep
+max_file_tokens = 4000   # files larger than this are summarised, not inlined
+include_tests = true
+include_configs = true
+include_receipts = true
+
+[scoring]
+# Scoring weights — higher wins budget allocation.
+# Tune these to make agentpack favour your team's file layout.
+modified              = 100
+staged                = 90
+filename_keyword      = 80
+symbol_keyword        = 70
+content_keyword_per_hit = 10
+content_keyword_max   = 60
+direct_dep            = 50
+reverse_dep           = 40
+related_test          = 35
+config_file           = 25
+recently_modified     = 20
+large_unrelated_penalty = -50
+ignored_penalty       = -100
+"""
+
 
 def config_path(root: Path) -> Path:
     return root / ".agentpack" / "config.toml"

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/core/ignore.py

@@ -36,6 +36,18 @@ generated/
 .env.*
 *.pem
 *.key
+id_rsa
+id_dsa
+id_ecdsa
+id_ed25519
+*.p12
+*.pfx
+*.jks
+.npmrc
+.pypirc
+.netrc
+*.tfvars
+terraform.tfvars
 
 # lock files
 package-lock.json
@@ -57,6 +69,15 @@ Gemfile.lock
 """
 
 
+SENSITIVE_PATTERNS = pathspec.PathSpec.from_lines("gitignore", [
+    ".env", ".env.*", "*.pem", "*.key",
+    "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519",
+    "*.p12", "*.pfx", "*.jks",
+    ".npmrc", ".pypirc", ".netrc",
+    "*.tfvars", "terraform.tfvars",
+])
+
+
 def load_spec(ignore_path: Path) -> pathspec.PathSpec:
     if ignore_path.exists():
         lines = ignore_path.read_text().splitlines()

{agentpack_cli-0.1.6 → agentpack_cli-0.1.7}/src/agentpack/core/scanner.py

@@ -75,17 +75,29 @@ def _is_binary(path: Path) -> bool:
         return True
 
 
+def _build_glob_specs(
+    include_globs: list[str],
+    exclude_globs: list[str],
+) -> tuple[pathspec.PathSpec | None, pathspec.PathSpec | None]:
+    inc = pathspec.PathSpec.from_lines("gitignore", include_globs) if include_globs else None
+    exc = pathspec.PathSpec.from_lines("gitignore", exclude_globs) if exclude_globs else None
+    return inc, exc
+
+
 def scan(
     root: Path,
     ignore_spec: pathspec.PathSpec,
     max_file_tokens: int = 4000,
     previous_snapshot: dict | None = None,
+    include_globs: list[str] | None = None,
+    exclude_globs: list[str] | None = None,
 ) -> ScanResult:
     packable: list[FileInfo] = []
     ignored: list[FileInfo] = []
     binary: list[FileInfo] = []
 
     prev_files: dict[str, dict] = (previous_snapshot or {}).get("files", {})
+    inc_spec, exc_spec = _build_glob_specs(include_globs or [], exclude_globs or [])
 
     for abs_path in root.rglob("*"):
         if not abs_path.is_file():
@@ -99,6 +111,20 @@ def scan(
 
         rel_str = str(rel)
 
+        if inc_spec is not None and not inc_spec.match_file(rel_str):
+            ignored.append(FileInfo(
+                path=rel_str, abs_path=abs_path,
+                size_bytes=abs_path.stat().st_size, estimated_tokens=0, ignored=True,
+            ))
+            continue
+
+        if exc_spec is not None and exc_spec.match_file(rel_str):
+            ignored.append(FileInfo(
+                path=rel_str, abs_path=abs_path,
+                size_bytes=abs_path.stat().st_size, estimated_tokens=0, ignored=True,
+            ))
+            continue
+
         if is_ignored(ignore_spec, rel_str):
             ignored.append(
                 FileInfo(