agentpack-cli 0.1.0__py3-none-any.whl

agentpack/core/cache.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from agentpack.core.models import FileSummary
+
+
+def _cache_key(path: str, file_hash: str, provider: str, schema_version: int) -> str:
+    import hashlib
+    raw = f"{path}|{file_hash}|{provider}|{schema_version}"
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+def _cache_dir(root: Path) -> Path:
+    return root / ".agentpack" / "cache"
+
+
+def load_summary(
+    root: Path, path: str, file_hash: str, provider: str = "offline", schema_version: int = 1
+) -> FileSummary | None:
+    key = _cache_key(path, file_hash, provider, schema_version)
+    cache_file = _cache_dir(root) / f"{key}.json"
+    if not cache_file.exists():
+        return None
+    try:
+        return FileSummary.model_validate_json(cache_file.read_text())
+    except Exception:
+        try:
+            cache_file.unlink(missing_ok=True)
+        except OSError:
+            pass
+        return None
+
+
+def save_summary(root: Path, summary: FileSummary) -> None:
+    key = _cache_key(summary.path, summary.hash, summary.provider, summary.schema_version)
+    cache_dir = _cache_dir(root)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    cache_file = cache_dir / f"{key}.json"
+    cache_file.write_text(summary.model_dump_json(indent=2))

agentpack/core/config.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import tomllib
+import tomli_w
+from pydantic import BaseModel, Field
+
+
+class ProjectConfig(BaseModel):
+    root: str = "."
+    ignore_file: str = ".agentignore"
+
+
+class ContextConfig(BaseModel):
+    default_budget: int = 25000
+    default_mode: str = "balanced"
+    max_file_tokens: int = 4000
+    include_tests: bool = True
+    include_configs: bool = True
+    include_receipts: bool = True
+
+
+class SummaryConfig(BaseModel):
+    provider: str = "offline"
+    schema_version: int = 1
+
+
+class AgentConfig(BaseModel):
+    output: str
+    patch_claude_md: bool = False
+
+
+class AgentsConfig(BaseModel):
+    claude: AgentConfig = Field(
+        default_factory=lambda: AgentConfig(
+            output=".agentpack/context.claude.md",
+            patch_claude_md=True,
+        )
+    )
+    generic: AgentConfig = Field(
+        default_factory=lambda: AgentConfig(output=".agentpack/context.md")
+    )
+
+
+class ScoringWeights(BaseModel):
+    """Configurable scoring weights. All values are additive points."""
+    modified: float = 100
+    staged: float = 90
+    filename_keyword: float = 80
+    symbol_keyword: float = 70
+    content_keyword_per_hit: float = 10
+    content_keyword_max: float = 60
+    direct_dep: float = 50
+    reverse_dep: float = 40
+    related_test: float = 35
+    config_file: float = 25
+    recently_modified: float = 20
+    large_unrelated_penalty: float = -50
+    ignored_penalty: float = -100
+
+
+class Config(BaseModel):
+    project: ProjectConfig = Field(default_factory=ProjectConfig)
+    context: ContextConfig = Field(default_factory=ContextConfig)
+    summary: SummaryConfig = Field(default_factory=SummaryConfig)
+    agents: AgentsConfig = Field(default_factory=AgentsConfig)
+    scoring: ScoringWeights = Field(default_factory=ScoringWeights)
+
+
+DEFAULT_CONFIG = Config()
+
+
+def config_path(root: Path) -> Path:
+    return root / ".agentpack" / "config.toml"
+
+
+def load_config(root: Path) -> Config:
+    path = config_path(root)
+    if not path.exists():
+        return DEFAULT_CONFIG
+    try:
+        with path.open("rb") as f:
+            data: dict[str, Any] = tomllib.load(f)
+        return Config.model_validate(data)
+    except Exception:
+        import warnings
+        warnings.warn(
+            f"Failed to parse {path} — using defaults. Fix or delete the file.",
+            stacklevel=2,
+        )
+        return DEFAULT_CONFIG
+
+
+def save_config(cfg: Config, root: Path) -> None:
+    path = config_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = cfg.model_dump()
+    with path.open("wb") as f:
+        tomli_w.dump(data, f)

agentpack/core/context_pack.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Literal
+
+from agentpack.core.config import Config
+from agentpack.core.models import (
+    ContextPack,
+    FileInfo,
+    Receipt,
+    SelectedFile,
+    Symbol,
+)
+from agentpack.core.redactor import redact_secrets
+from agentpack.core.token_estimator import estimate_tokens
+
+
+Mode = Literal["minimal", "balanced", "deep"]
+
+_MODE_WEIGHTS: dict[str, dict[str, bool]] = {
+    "minimal": {
+        "include_unchanged_deps": False,
+        "include_rev_deps": False,
+        "include_tests": False,
+        "include_docs": False,
+        "extra_full": False,
+    },
+    "balanced": {
+        "include_unchanged_deps": True,
+        "include_rev_deps": True,
+        "include_tests": True,
+        "include_docs": False,
+        "extra_full": False,
+    },
+    "deep": {
+        "include_unchanged_deps": True,
+        "include_rev_deps": True,
+        "include_tests": True,
+        "include_docs": True,
+        "extra_full": True,
+    },
+}
+
+
+def _metadata_path(root: Path) -> Path:
+    return root / ".agentpack" / "pack_metadata.json"
+
+
+def save_pack_metadata(
+    root: Path,
+    context_path: str,
+    snapshot_root_hash: str,
+    task: str,
+    agent: str,
+    mode: str,
+    budget: int,
+    token_estimate: int = 0,
+) -> None:
+    meta = {
+        "context_path": context_path,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "snapshot_root_hash": snapshot_root_hash,
+        "task": task,
+        "agent": agent,
+        "mode": mode,
+        "budget": budget,
+        "token_estimate": token_estimate,
+    }
+    _metadata_path(root).write_text(json.dumps(meta, indent=2))
+
+
+def load_pack_metadata(root: Path) -> dict[str, Any] | None:
+    path = _metadata_path(root)
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _extract_relevant_symbol_bodies(
+    fi: FileInfo,
+    syms: list[Symbol],
+    keywords: set[str],
+    budget_remaining: int,
+) -> tuple[str | None, int]:
+    """Assemble symbol bodies from Symbol.body (captured at extraction time — no file re-read)."""
+    from agentpack.analysis.symbols import filter_symbols_by_keywords
+
+    relevant = filter_symbols_by_keywords(syms, keywords) if keywords else syms[:5]
+    if not relevant:
+        return None, 0
+
+    parts: list[str] = []
+    tokens_used = 0
+    for sym in relevant:
+        body = sym.body
+        if body:
+            tok = estimate_tokens(body)
+            if tokens_used + tok <= budget_remaining:
+                parts.append(body)
+                tokens_used += tok
+            elif sym.signature:
+                sig_tok = estimate_tokens(sym.signature)
+                if tokens_used + sig_tok <= budget_remaining:
+                    parts.append(sym.signature)
+                    tokens_used += sig_tok
+        elif sym.signature:
+            sig_tok = estimate_tokens(sym.signature)
+            if tokens_used + sig_tok <= budget_remaining:
+                parts.append(sym.signature)
+                tokens_used += sig_tok
+
+    return "\n\n".join(parts) if parts else None, tokens_used
+
+
+def select_files(
+    files: list[FileInfo],
+    scored: list[tuple[FileInfo, float, list[str]]],
+    changed_paths: set[str],
+    summaries: dict[str, Any],
+    mode: Mode,
+    budget: int,
+    max_file_tokens: int,
+    keywords: set[str] | None = None,
+) -> tuple[list[SelectedFile], list[Receipt]]:
+    opts = _MODE_WEIGHTS[mode]
+    selected: list[SelectedFile] = []
+    receipts: list[Receipt] = []
+    tokens_used = 0
+    kw = keywords or set()
+
+    for fi, score, reasons in sorted(scored, key=lambda x: -x[1]):
+        if fi.ignored or fi.binary:
+            receipts.append(Receipt(path=fi.path, action="excluded", reason="ignored or binary"))
+            continue
+
+        if score <= 0:
+            receipts.append(Receipt(path=fi.path, action="excluded", reason="score too low"))
+            continue
+
+        is_changed = fi.path in changed_paths
+        summary_data = summaries.get(fi.path)
+
+        # Determine inclusion mode
+        if is_changed and fi.estimated_tokens <= max_file_tokens:
+            mode_str: Literal["full", "symbols", "summary"] = "full"
+            content = fi.content if fi.content is not None else (
+                fi.abs_path.read_text(errors="replace") if fi.abs_path.exists() else None
+            )
+            tok = fi.estimated_tokens
+        elif is_changed or (opts["extra_full"] and fi.estimated_tokens <= max_file_tokens):
+            mode_str = "symbols"
+            content = None
+            tok = min(fi.estimated_tokens, max_file_tokens // 2)
+        elif summary_data:
+            mode_str = "summary"
+            content = None
+            tok = estimate_tokens(summary_data.get("summary", ""))
+        else:
+            mode_str = "summary"
+            content = None
+            tok = min(fi.estimated_tokens, 200)
+
+        if tokens_used + tok > budget:
+            receipts.append(Receipt(path=fi.path, action="excluded", reason="budget exhausted"))
+            continue
+
+        tokens_used += tok
+
+        # Build symbol list
+        syms: list[Symbol] = []
+        if summary_data and mode_str in ("symbols", "summary"):
+            raw_syms = summary_data.get("symbols", [])
+            for s in raw_syms:
+                try:
+                    syms.append(Symbol(**s) if isinstance(s, dict) else s)
+                except Exception as exc:
+                    import warnings
+                    warnings.warn(f"skipping malformed symbol in {fi.path}: {exc}", stacklevel=2)
+
+        # Symbol body extraction for "symbols" mode
+        sym_body_content: str | None = None
+        if mode_str == "symbols" and syms and fi.abs_path.exists():
+            budget_remaining = budget - tokens_used
+            sym_body_content, extra_tok = _extract_relevant_symbol_bodies(
+                fi, syms, kw, min(budget_remaining, max_file_tokens // 2)
+            )
+            if extra_tok > 0 and tokens_used + extra_tok <= budget:
+                tokens_used += extra_tok
+
+        # Redact secrets at materialization — before content reaches any renderer or adapter
+        materialized = content if mode_str == "full" else sym_body_content
+        redaction_warnings: list[str] = []
+        if materialized:
+            materialized, redaction_warnings = redact_secrets(materialized, fi.path)
+
+        selected.append(
+            SelectedFile(
+                path=fi.path,
+                language=fi.language,
+                score=score,
+                include_mode=mode_str,
+                reasons=reasons,
+                content=materialized,
+                summary=summary_data.get("summary") if summary_data else None,
+                symbols=syms,
+                redaction_warnings=redaction_warnings,
+            )
+        )
+
+        action: Literal["included", "excluded", "summarized"] = (
+            "included" if mode_str == "full" else "summarized"
+        )
+        receipts.append(
+            Receipt(path=fi.path, action=action, reason=", ".join(reasons[:2]))
+        )
+
+    return selected, receipts

agentpack/core/diff.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class SnapshotDiff:
+    added: list[str]
+    modified: list[str]
+    deleted: list[str]
+    unchanged: list[str]
+
+
+def diff_snapshots(
+    old: dict[str, Any] | None,
+    new: dict[str, Any],
+) -> SnapshotDiff:
+    new_files: dict[str, str] = {
+        p: info["hash"] for p, info in new.get("files", {}).items() if info.get("hash")
+    }
+
+    if old is None:
+        return SnapshotDiff(
+            added=sorted(new_files),
+            modified=[],
+            deleted=[],
+            unchanged=[],
+        )
+
+    old_files: dict[str, str] = {
+        p: info["hash"] for p, info in old.get("files", {}).items() if info.get("hash")
+    }
+
+    added = sorted(p for p in new_files if p not in old_files)
+    deleted = sorted(p for p in old_files if p not in new_files)
+    modified = sorted(p for p in new_files if p in old_files and new_files[p] != old_files[p])
+    unchanged = sorted(p for p in new_files if p in old_files and new_files[p] == old_files[p])
+
+    return SnapshotDiff(added=added, modified=modified, deleted=deleted, unchanged=unchanged)

agentpack/core/git.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def _run(args: list[str], cwd: Path) -> str | None:
+    try:
+        result = subprocess.run(
+            args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            return result.stdout
+        return None
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+
+
+def is_git_repo(root: Path) -> bool:
+    out = _run(["git", "rev-parse", "--is-inside-work-tree"], root)
+    return out is not None and out.strip() == "true"
+
+
+def changed_files(root: Path) -> set[str]:
+    """Unstaged + staged modified/added files."""
+    result: set[str] = set()
+    for args in [
+        ["git", "diff", "--name-only"],
+        ["git", "diff", "--cached", "--name-only"],
+    ]:
+        out = _run(args, root)
+        if out:
+            for line in out.splitlines():
+                line = line.strip()
+                if line:
+                    result.add(line)
+    return result
+
+
+def untracked_files(root: Path) -> set[str]:
+    out = _run(["git", "status", "--short"], root)
+    result: set[str] = set()
+    if not out:
+        return result
+    for line in out.splitlines():
+        if line.startswith("??"):
+            result.add(line[3:].strip())
+    return result
+
+
+def recently_modified_files(root: Path, n: int = 20) -> list[str]:
+    out = _run(
+        ["git", "log", "--diff-filter=M", "--name-only", "--format=", f"-{n}"],
+        root,
+    )
+    if not out:
+        return []
+    return [line.strip() for line in out.splitlines() if line.strip()]
+
+
+def changed_files_since(root: Path, ref: str) -> set[str]:
+    """Files changed between ref and HEAD (e.g. ref='HEAD~1', ref='main')."""
+    result: set[str] = set()
+    out = _run(["git", "diff", "--name-only", ref, "HEAD"], root)
+    if out:
+        for line in out.splitlines():
+            line = line.strip()
+            if line:
+                result.add(line)
+    return result
+
+
+def infer_task_from_git(root: Path) -> str:
+    """Infer a task description from branch name, changed files, and recent commits.
+
+    Priority: branch name (explicit intent) → changed file paths (current work) → recent commit.
+    """
+    branch: str | None = None
+    branch_out = _run(["git", "rev-parse", "--abbrev-ref", "HEAD"], root)
+    if branch_out:
+        b = branch_out.strip()
+        if b and b not in ("HEAD", "main", "master", "develop"):
+            slug = b.split("/", 1)[-1]
+            branch = slug.replace("-", " ").replace("_", " ")
+
+    # Changed files are the strongest signal for *current* work
+    changed = changed_files(root)
+    file_topic = _topic_from_paths(changed) if changed else None
+
+    # Fallback: most recent non-merge commit
+    commit: str | None = None
+    log_out = _run(["git", "log", "--oneline", "-5"], root)
+    if log_out:
+        for line in log_out.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            msg = line.split(" ", 1)[1] if " " in line else line
+            if not msg.lower().startswith("merge "):
+                commit = msg
+                break
+
+    if branch and file_topic:
+        return f"{branch}: {file_topic}"
+    if branch:
+        return branch
+    if file_topic:
+        return file_topic
+    if commit:
+        return commit
+    return "general development"
+
+
+def _topic_from_paths(paths: set[str]) -> str | None:
+    """Extract a short topic string from a set of file paths."""
+    _SKIP = {"__init__", "index", "main", "mod", "lib", "utils", "helpers", "types", "constants"}
+    words: list[str] = []
+    for path in sorted(paths):
+        parts = Path(path).parts
+        # Skip test dirs and generated dirs
+        stem = Path(path).stem
+        if stem in _SKIP:
+            continue
+        # Take the most specific meaningful directory + stem
+        for part in reversed(parts[:-1]):
+            if part not in ("src", "lib", "pkg", "app", "tests", "test", "__pycache__"):
+                words.append(part.replace("_", " ").replace("-", " "))
+                break
+        words.append(stem.replace("_", " ").replace("-", " "))
+    if not words:
+        return None
+    # Deduplicate preserving order, keep up to 5 words
+    seen: set[str] = set()
+    unique: list[str] = []
+    for w in words:
+        if w not in seen:
+            seen.add(w)
+            unique.append(w)
+        if len(unique) == 5:
+            break
+    return ", ".join(unique)

agentpack/core/git_hooks.py

@@ -0,0 +1,8 @@
+"""Backward-compat shim — moved to agentpack.integrations.git_hooks."""
+from agentpack.integrations.git_hooks import (  # noqa: F401
+    install_git_hooks,
+    remove_git_hooks,
+    _HOOK_EVENTS,
+    _AGENTPACK_MARKER,
+    _hook_script,
+)

agentpack/core/global_install.py

@@ -0,0 +1,14 @@
+"""Backward-compat shim — moved to agentpack.integrations.global_install."""
+from agentpack.integrations.global_install import (  # noqa: F401
+    install_git_template_hooks,
+    configure_git_template_dir,
+    remove_git_template_hooks,
+    install_shell_hook,
+    remove_shell_hook,
+    _GIT_TEMPLATE_DIR,
+    _AGENTPACK_MARKER,
+    _SHELL_MARKER_START,
+    _SHELL_MARKER_END,
+    _HOOK_SCRIPTS,
+    _detect_rc_file,
+)

agentpack/core/ignore.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pathspec
+
+
+DEFAULT_AGENTIGNORE = """\
+# dependencies
+node_modules/
+.venv/
+venv/
+__pycache__/
+
+# builds
+dist/
+build/
+.next/
+coverage/
+
+# caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# generated/noisy
+generated/
+*.generated.*
+*.min.js
+*.map
+*.lock
+*.log
+
+# secrets
+.env
+.env.*
+*.pem
+*.key
+
+# lock files
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+Pipfile.lock
+poetry.lock
+Cargo.lock
+composer.lock
+Gemfile.lock
+
+# large data
+*.csv
+*.jsonl
+*.parquet
+"""
+
+
+def load_spec(ignore_path: Path) -> pathspec.PathSpec:
+    if ignore_path.exists():
+        lines = ignore_path.read_text().splitlines()
+    else:
+        lines = DEFAULT_AGENTIGNORE.splitlines()
+    return pathspec.PathSpec.from_lines("gitignore", lines)
+
+
+def is_ignored(spec: pathspec.PathSpec, path: str) -> bool:
+    return spec.match_file(path)

agentpack/core/merkle.py

@@ -0,0 +1,8 @@
+import hashlib
+
+
+def root_hash(file_hashes: dict[str, str]) -> str:
+    h = hashlib.sha256()
+    for path in sorted(file_hashes):
+        h.update(f"{path}:{file_hashes[path]}".encode())
+    return h.hexdigest()