agentpack-cli 0.1.0__py3-none-any.whl

agentpack/core/models.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+from typing import Literal
+from pydantic import BaseModel
+
+
+class ScanResult(BaseModel):
+    packable: list["FileInfo"]
+    ignored: list["FileInfo"]
+    binary: list["FileInfo"]
+
+    @property
+    def all_files(self) -> list["FileInfo"]:
+        return self.packable + self.ignored + self.binary
+
+
+class FileInfo(BaseModel):
+    path: str
+    abs_path: Path
+    language: str | None = None
+    size_bytes: int
+    estimated_tokens: int
+    hash: str | None = None
+    ignored: bool = False
+    binary: bool = False
+    too_large: bool = False
+    content: str | None = None  # cached at scan time; avoids re-reads in scoring/selection
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class Symbol(BaseModel):
+    name: str
+    kind: Literal["class", "function", "method", "variable"]
+    start_line: int
+    end_line: int
+    signature: str | None = None
+    summary: str | None = None
+    body: str | None = None  # source text captured at extraction time; no re-read needed
+
+
+class FileSummary(BaseModel):
+    path: str
+    hash: str
+    language: str | None = None
+    provider: str = "offline"
+    schema_version: int = 1
+    summary: str
+    imports: list[str] = []
+    symbols: list[Symbol] = []
+
+
+class SelectedFile(BaseModel):
+    path: str
+    language: str | None = None
+    score: float
+    include_mode: Literal["full", "symbols", "summary"]
+    reasons: list[str]
+    content: str | None = None
+    summary: str | None = None
+    symbols: list[Symbol] = []
+    redaction_warnings: list[str] = []
+
+
+class Receipt(BaseModel):
+    path: str
+    action: Literal["included", "excluded", "summarized"]
+    reason: str
+
+
+class ContextPack(BaseModel):
+    task: str
+    agent: str
+    mode: Literal["minimal", "balanced", "deep"]
+    budget: int
+    token_estimate: int
+    raw_repo_tokens: int
+    after_ignore_tokens: int
+    estimated_savings_percent: float
+    changed_files: list[str]
+    selected_files: list[SelectedFile]
+    receipts: list[Receipt]
+    redaction_warnings: list[str] = []
+    stale: bool = False
+
+
+class DependencyNode(BaseModel):
+    path: str
+    imports: list[str] = []
+    imported_by: list[str] = []
+    tests: list[str] = []
+
+
+class DependencyGraph(BaseModel):
+    nodes: dict[str, DependencyNode] = {}
+
+    def get(self, path: str) -> DependencyNode:
+        return self.nodes.get(path, DependencyNode(path=path))
+
+    def __getitem__(self, path: str) -> DependencyNode:
+        return self.nodes[path]
+
+    def __setitem__(self, path: str, node: DependencyNode) -> None:
+        self.nodes[path] = node
+
+    def __contains__(self, path: object) -> bool:
+        return path in self.nodes
+
+    def __iter__(self):  # type: ignore[override]
+        return iter(self.nodes)
+
+    def __len__(self) -> int:
+        return len(self.nodes)
+
+    def items(self):  # type: ignore[override]
+        return self.nodes.items()

agentpack/core/redactor.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import re
+
+# Placeholder patterns — values matching these are NOT redacted
+_PLACEHOLDER_RE = re.compile(
+    r"your[_-]?(?:api[_-]?)?(?:key|token|secret)[_-]?here|"
+    r"<[A-Z_]{3,}(?:KEY|TOKEN|SECRET|PASSWORD)[A-Z_]*>|"
+    r"xxx+|"
+    r"insert[_-]?(?:key|token|secret)[_-]?here|"
+    r"changeme|"
+    r"example[_-]?(?:key|token|secret)|"
+    r"(?:key|token|secret)[_-]?example",
+    re.IGNORECASE,
+)
+
+# (pattern, label, value_group): when value_group is set, only that group is redacted.
+_SECRET_PATTERNS: list[tuple[re.Pattern[str], str, int | None]] = [
+    (re.compile(
+        r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?"
+        r"-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"
+    ), "private-key", None),
+    (re.compile(
+        r"eyJ[A-Za-z0-9\-_]{20,}\.[A-Za-z0-9\-_]{20,}\.[A-Za-z0-9\-_]{20,}"
+    ), "jwt", None),
+    (re.compile(r"AKIA[0-9A-Z]{16}"), "aws-access-key", None),
+    (re.compile(
+        r"(?i)(aws_secret(?:_access_key)?\s*[=:\"'\s]+\s*)([A-Za-z0-9+/]{40})"
+    ), "aws-secret-key", 2),
+    (re.compile(r"gh[pousr]_[A-Za-z0-9]{36,}"), "github-token", None),
+    # Anthropic before OpenAI to avoid partial match on sk- prefix
+    (re.compile(r"sk-ant-[A-Za-z0-9\-]{32,}"), "anthropic-key", None),
+    (re.compile(r"sk-[A-Za-z0-9]{32,}"), "openai-key", None),
+    # Generic: handles key=value, key='value', key="value", key: value
+    (re.compile(
+        r"(?i)(?:api[_-]?key|token|secret|password|passwd|auth[_-]?key)"
+        r"\s*[=:]\s*[\"']?\s*([A-Za-z0-9+/\-_]{40,})"
+    ), "api-key", 1),
+]
+
+
+def _is_placeholder(value: str) -> bool:
+    return bool(_PLACEHOLDER_RE.search(value))
+
+
+def _line_of(text: str, start: int) -> int:
+    """Return 1-indexed line number for character offset *start* in *text*."""
+    return text.count("\n", 0, start) + 1
+
+
+def redact_secrets(text: str, path: str) -> tuple[str, list[str]]:
+    """Scan *text* for secrets and replace each with ``[REDACTED:<type>]``.
+
+    Returns ``(redacted_text, warnings)`` where each warning is a
+    human-readable string like ``"src/config.py: aws-access-key detected (line 12)"``.
+    """
+    warnings: list[str] = []
+    # Collect (start, end, replacement_str) tuples; apply in reverse order.
+    replacements: list[tuple[int, int, str]] = []
+    # Track redacted spans to avoid double-reporting overlapping matches.
+    redacted_spans: list[tuple[int, int]] = []
+
+    def _overlaps(start: int, end: int) -> bool:
+        for rs, re_ in redacted_spans:
+            if start < re_ and end > rs:
+                return True
+        return False
+
+    for pattern, label, value_group in _SECRET_PATTERNS:
+        for m in pattern.finditer(text):
+            if value_group is not None:
+                secret_val = m.group(value_group)
+                secret_start = m.start(value_group)
+                secret_end = m.end(value_group)
+            else:
+                secret_val = m.group(0)
+                secret_start = m.start()
+                secret_end = m.end()
+
+            if _is_placeholder(secret_val):
+                continue
+            if _overlaps(secret_start, secret_end):
+                continue
+
+            line_no = _line_of(text, secret_start)
+            replacements.append((secret_start, secret_end, f"[REDACTED:{label}]"))
+            redacted_spans.append((secret_start, secret_end))
+            warnings.append(f"{path}: {label} detected (line {line_no})")
+
+    if not replacements:
+        return text, warnings
+
+    # Apply replacements in reverse order to preserve earlier offsets
+    replacements.sort(key=lambda r: r[0], reverse=True)
+    chars = list(text)
+    for start, end, repl in replacements:
+        chars[start:end] = list(repl)
+
+    return "".join(chars), warnings

agentpack/core/scanner.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+import pathspec
+
+from agentpack.core.ignore import load_spec, is_ignored
+from agentpack.core.models import FileInfo, ScanResult
+from agentpack.core.token_estimator import estimate_tokens
+
+BINARY_EXTENSIONS = {
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".svg",
+    ".pdf", ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar",
+    ".exe", ".dll", ".so", ".dylib", ".bin",
+    ".mp3", ".mp4", ".wav", ".avi", ".mov",
+    ".ttf", ".woff", ".woff2", ".eot",
+    ".pyc", ".pyo", ".class",
+    ".db", ".sqlite", ".sqlite3",
+}
+
+LANGUAGE_MAP: dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".rb": "ruby",
+    ".php": "php",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".html": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".md": "markdown",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".sql": "sql",
+    ".tf": "terraform",
+    ".xml": "xml",
+}
+
+ALWAYS_SKIP = {".git", ".agentpack"}
+
+
+def file_hash(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _is_binary(path: Path) -> bool:
+    if path.suffix.lower() in BINARY_EXTENSIONS:
+        return True
+    try:
+        chunk = path.read_bytes()[:1024]
+        return b"\x00" in chunk
+    except OSError:
+        return True
+
+
+def scan(
+    root: Path,
+    ignore_spec: pathspec.PathSpec,
+    max_file_tokens: int = 4000,
+) -> ScanResult:
+    packable: list[FileInfo] = []
+    ignored: list[FileInfo] = []
+    binary: list[FileInfo] = []
+
+    for abs_path in root.rglob("*"):
+        if not abs_path.is_file():
+            continue
+
+        rel = abs_path.relative_to(root)
+        parts = rel.parts
+
+        if any(p in ALWAYS_SKIP for p in parts):
+            continue
+
+        rel_str = str(rel)
+
+        if is_ignored(ignore_spec, 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_binary(abs_path):
+            size = abs_path.stat().st_size
+            lang = LANGUAGE_MAP.get(abs_path.suffix.lower())
+            binary.append(
+                FileInfo(
+                    path=rel_str,
+                    abs_path=abs_path,
+                    language=lang,
+                    size_bytes=size,
+                    estimated_tokens=0,
+                    binary=True,
+                )
+            )
+            continue
+
+        size = abs_path.stat().st_size
+        lang = LANGUAGE_MAP.get(abs_path.suffix.lower())
+
+        try:
+            text = abs_path.read_text(errors="replace")
+        except OSError:
+            continue
+
+        tokens = estimate_tokens(text)
+        too_large = tokens > max_file_tokens
+
+        packable.append(
+            FileInfo(
+                path=rel_str,
+                abs_path=abs_path,
+                language=lang,
+                size_bytes=size,
+                estimated_tokens=tokens,
+                hash=file_hash(abs_path),
+                too_large=too_large,
+                content=text,
+            )
+        )
+
+    return ScanResult(packable=packable, ignored=ignored, binary=binary)

agentpack/core/snapshot.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from agentpack.core.merkle import root_hash
+from agentpack.core.models import FileInfo
+
+
+SNAPSHOT_VERSION = 1
+
+
+def _snapshots_dir(root: Path) -> Path:
+    return root / ".agentpack" / "snapshots"
+
+
+def _latest_path(root: Path) -> Path:
+    return _snapshots_dir(root) / "latest.json"
+
+
+def build_snapshot(files: list[FileInfo]) -> dict[str, Any]:
+    """Build a snapshot from packable FileInfo objects. Skips ignored and binary entries defensively."""
+    file_data: dict[str, Any] = {}
+    hashes: dict[str, str] = {}
+    for f in files:
+        if f.ignored or f.binary:
+            continue
+        file_data[f.path] = {
+            "hash": f.hash,
+            "size_bytes": f.size_bytes,
+            "estimated_tokens": f.estimated_tokens,
+            "language": f.language,
+        }
+        if f.hash:
+            hashes[f.path] = f.hash
+
+    return {
+        "version": SNAPSHOT_VERSION,
+        "root_hash": root_hash(hashes),
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "files": file_data,
+    }
+
+
+def save_snapshot(snapshot: dict[str, Any], root: Path) -> None:
+    snapshots_dir = _snapshots_dir(root)
+    snapshots_dir.mkdir(parents=True, exist_ok=True)
+    _latest_path(root).write_text(json.dumps(snapshot, indent=2))
+
+
+def load_snapshot(root: Path) -> dict[str, Any] | None:
+    path = _latest_path(root)
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None

agentpack/core/token_estimator.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+_encoder = None
+
+
+def _get_encoder():
+    global _encoder
+    if _encoder is None:
+        try:
+            import tiktoken
+            _encoder = tiktoken.get_encoding("cl100k_base")
+        except ImportError:
+            _encoder = False
+    return _encoder
+
+
+def estimate_tokens(text: str) -> int:
+    enc = _get_encoder()
+    if enc:
+        return max(1, len(enc.encode(text, disallowed_special=())))
+    return max(1, len(text) // 4)
+
+
+def estimate_tokens_bytes(size_bytes: int) -> int:
+    # byte-level fallback when text is unavailable
+    return max(1, size_bytes // 4)

agentpack/core/vscode_tasks.py

@@ -0,0 +1,5 @@
+"""Backward-compat shim — moved to agentpack.integrations.vscode_tasks."""
+from agentpack.integrations.vscode_tasks import (  # noqa: F401
+    install_vscode_tasks,
+    remove_vscode_tasks,
+)

agentpack/data/agentpack.md

@@ -0,0 +1,160 @@
+---
+description: Pack repo context and immediately start working on the task. Supports session mode (start once, work normally) and manual pack mode. Reads context and begins helping — no manual piping needed.
+---
+
+# AgentPack
+
+Pack repo context and immediately start working on the task.
+
+## Usage
+
+```
+/agentpack --task "fix Redis SSE cancellation issue"
+/agentpack --task "add rate limiting to auth endpoints" --mode deep
+/agentpack --task auto      # infer task from branch + changed files + git log
+/agentpack init             # interactive: prompts for default mode
+/agentpack status
+/agentpack stats
+/agentpack diff
+/agentpack summarize
+/agentpack install
+/agentpack session start
+/agentpack session status
+/agentpack session refresh --task "new task"
+/agentpack session stop
+/agentpack watch
+/agentpack claude
+/agentpack explain --task auto
+/agentpack explain --file src/auth/session.py
+/agentpack explain --omitted
+```
+
+## Session Mode (recommended)
+
+If a session is already running (`.agentpack/session.json` exists and `"active": true`):
+
+1. Read `.agentpack/context.md` — context is already fresh.
+2. If the user gives a new coding task, write a one-line summary to `.agentpack/task.md`.
+3. Re-read `.agentpack/context.md` after watch mode refreshes it (a few seconds).
+4. Proceed with the task using the context you just read.
+
+To start a session:
+
+```bash
+agentpack session start                     # creates session + generates initial context
+agentpack session start --agent claude      # specify agent
+agentpack session start --task "fix bug"    # set initial task
+
+agentpack watch                             # in another terminal — auto-refreshes on changes
+```
+
+To check session state:
+
+```bash
+agentpack session status    # shows active, agent, mode, last refresh, refresh count
+agentpack stats             # shows session panel + token stats + top files
+```
+
+To force a refresh:
+
+```bash
+agentpack session refresh
+agentpack session refresh --task "new task description"
+```
+
+To stop:
+
+```bash
+agentpack session stop
+```
+
+Then use normal prompts — context stays current while `watch` is running.
+
+## Manual Pack Mode (no session)
+
+```bash
+agentpack pack --agent claude --task "<task>" --mode balanced
+```
+
+Then read `.agentpack/context.claude.md` in full.
+
+## Process
+
+### Step 1: Check agentpack is installed
+
+```bash
+agentpack --help 2>/dev/null || pip install agentpack-cli
+```
+
+### Step 2: Initialize if not already done
+
+```bash
+test -f .agentpack/config.toml || agentpack init --yes
+```
+
+### Step 3: Determine workflow
+
+**Session active** (`.agentpack/session.json` exists, `"active": true`):
+- Read `.agentpack/context.md`
+- Update `.agentpack/task.md` if task changed
+- Proceed immediately
+
+**No session**:
+- Run `agentpack session start` or `agentpack pack --task auto`
+- Read the context file
+- Proceed
+
+### Step 4: Immediately start working
+
+Using the context you just read:
+
+1. **Orient** — state which files are changed and what the key code areas are (2-3 sentences)
+2. **Diagnose or plan** — root cause for bugs, approach for features. Reference specific file:line
+3. **Start working** — edit code, fix the issue, implement the feature
+
+Do not say "context pack ready" and stop. Do not tell the user to run more commands.
+
+## Stale pack handling
+
+If `agentpack status` exits non-zero or context seems unrelated to the task:
+- Run `agentpack session refresh` (if session active)
+- Or run `agentpack pack --task auto` (manual mode)
+- Re-read the context, then proceed
+
+Do not ask the user — just refresh and proceed.
+
+## Debugging selection
+
+```bash
+agentpack explain --task auto                          # show ranked file list
+agentpack explain --file src/auth/session.py           # per-file score breakdown
+agentpack explain --omitted                            # see what was excluded and why
+```
+
+## Subcommand routing
+
+| User types | Action |
+|---|---|
+| `/agentpack --task "..."` | check session or pack + read + work |
+| `/agentpack` | check session or pack with `--task auto` + read + work |
+| `/agentpack session start` | `agentpack session start` |
+| `/agentpack session status` | `agentpack session status` |
+| `/agentpack session refresh` | `agentpack session refresh` |
+| `/agentpack session stop` | `agentpack session stop` |
+| `/agentpack watch` | `agentpack watch` (foreground, Ctrl+C to stop) |
+| `/agentpack claude` | `agentpack claude` (refresh + launch claude) |
+| `/agentpack init` | `agentpack init` only |
+| `/agentpack status` | check staleness |
+| `/agentpack stats` | session info + token savings |
+| `/agentpack diff` | changed files |
+| `/agentpack summarize` | rebuild offline summary cache |
+| `/agentpack install` | `agentpack install --agent claude` |
+| `/agentpack explain` | show ranked file selection |
+
+## Notes
+
+- All commands are local — no API calls
+- `--task auto` infers from branch name → changed file paths → recent commit
+- Changed files are highest priority in context
+- Session context files: `.agentpack/context.md` (readable), `.agentpack/context.compact.md` (compact)
+- Never overwrite `.agentignore` or `config.toml` without `--force`