agentpack-cli 0.1.0__py3-none-any.whl

agentpack/integrations/vscode_tasks.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+_TASK_LABEL = "AgentPack: Repack context"
+_TASK_LABEL_AUTO = "AgentPack: Repack (auto task)"
+
+
+def _agentpack_tasks(agent: str) -> list[dict]:
+    return [
+        {
+            "label": _TASK_LABEL,
+            "type": "shell",
+            "command": f"agentpack pack --agent {agent} --task auto --mode balanced",
+            "group": "none",
+            "presentation": {"reveal": "always", "panel": "shared"},
+            "problemMatcher": [],
+        },
+        {
+            "label": _TASK_LABEL_AUTO,
+            "type": "shell",
+            "command": f"agentpack pack --agent {agent} --task auto --mode balanced",
+            "runOptions": {"runOn": "folderOpen"},
+            "group": "none",
+            "presentation": {"reveal": "silent", "panel": "shared"},
+            "problemMatcher": [],
+        },
+    ]
+
+
+def install_vscode_tasks(root: Path, agent: str) -> str:
+    """Merge agentpack tasks into .vscode/tasks.json. Returns action taken.
+
+    Idempotent — safe to re-run. Existing tasks with matching labels are
+    updated; other tasks are preserved.
+    """
+    vscode_dir = root / ".vscode"
+    vscode_dir.mkdir(exist_ok=True)
+    tasks_path = vscode_dir / "tasks.json"
+
+    existing: dict = {"version": "2.0.0", "tasks": []}
+    if tasks_path.exists():
+        try:
+            existing = json.loads(tasks_path.read_text())
+        except json.JSONDecodeError:
+            pass
+
+    existing.setdefault("version", "2.0.0")
+    existing.setdefault("tasks", [])
+
+    new_tasks = _agentpack_tasks(agent)
+    new_labels = {t["label"] for t in new_tasks}
+
+    # Remove stale agentpack tasks, keep everything else
+    kept = [t for t in existing["tasks"] if t.get("label") not in new_labels]
+    had_any = len(kept) < len(existing["tasks"])
+
+    existing["tasks"] = kept + new_tasks
+    tasks_path.write_text(json.dumps(existing, indent=2) + "\n")
+
+    return "updated" if had_any else "created"
+
+
+def remove_vscode_tasks(root: Path) -> str:
+    """Remove agentpack tasks from .vscode/tasks.json. Returns action taken."""
+    tasks_path = root / ".vscode" / "tasks.json"
+    if not tasks_path.exists():
+        return "unchanged"
+
+    try:
+        existing = json.loads(tasks_path.read_text())
+    except json.JSONDecodeError:
+        return "unchanged"
+
+    labels = {_TASK_LABEL, _TASK_LABEL_AUTO}
+    before = len(existing.get("tasks", []))
+    existing["tasks"] = [t for t in existing.get("tasks", []) if t.get("label") not in labels]
+    after = len(existing["tasks"])
+
+    if before == after:
+        return "unchanged"
+
+    tasks_path.write_text(json.dumps(existing, indent=2) + "\n")
+    return "cleaned"

agentpack/renderers/__init__.py

@@ -0,0 +1,3 @@
+from agentpack.renderers.compact import render_compact
+
+__all__ = ["render_compact"]

agentpack/renderers/compact.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from agentpack.core.models import ContextPack, SelectedFile
+
+
+def _format_file_entry(sf: SelectedFile) -> str:
+    """Format a single selected file entry for the compact format."""
+    lines: list[str] = [sf.path]
+    lines.append(f"score: {int(sf.score)}")
+    lines.append(f"include: {sf.include_mode}")
+    if sf.reasons:
+        lines.append(f"why: {', '.join(sf.reasons)}")
+    if sf.symbols:
+        symbol_names = ", ".join(s.name for s in sf.symbols)
+        lines.append(f"symbols: {symbol_names}")
+    return "\n".join(lines)
+
+
+def render_compact(pack: ContextPack) -> str:
+    """Render a ContextPack into a structured compact format."""
+    selected: list[SelectedFile] = []
+    deps: list[SelectedFile] = []
+
+    for sf in pack.selected_files:
+        if sf.include_mode in ("full", "symbols"):
+            selected.append(sf)
+        else:
+            deps.append(sf)
+
+    now = datetime.now(timezone.utc).isoformat()
+    sections: list[str] = []
+
+    sections.append("# AgentPack Context")
+    sections.append("")
+    sections.append(f"task: {pack.task}")
+    sections.append(f"mode: {pack.mode}")
+    sections.append(f"budget: {pack.token_estimate}/{pack.budget}")
+    sections.append(f"generated: {now}")
+    sections.append("")
+
+    sections.append("## selected")
+    sections.append("")
+    if selected:
+        for sf in selected:
+            sections.append(_format_file_entry(sf))
+            sections.append("")
+    else:
+        sections.append("(none)")
+        sections.append("")
+
+    sections.append("## deps")
+    sections.append("")
+    if deps:
+        for sf in deps:
+            lines: list[str] = [sf.path]
+            lines.append(f"score: {int(sf.score)}")
+            lines.append("include: summary")
+            if sf.reasons:
+                lines.append(f"why: {sf.reasons[0]}")
+            sections.append("\n".join(lines))
+            sections.append("")
+    else:
+        sections.append("(none)")
+        sections.append("")
+
+    sections.append("## instructions")
+    sections.append("")
+    sections.append("- Prefer selected files first.")
+    sections.append("- If task changes significantly, update `.agentpack/task.md`.")
+    sections.append("- Run `agentpack session refresh` if context seems stale.")
+    sections.append("")
+
+    return "\n".join(sections)

agentpack/renderers/markdown.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from agentpack.core.models import ContextPack, SelectedFile, Symbol
+
+
+def _lang_fence(lang: str | None) -> str:
+    return lang or ""
+
+
+def _symbols_block(symbols: list[Symbol], lang: str | None) -> str:
+    if not symbols:
+        return ""
+    lines = ["```" + _lang_fence(lang)]
+    for s in symbols:
+        if s.signature:
+            lines.append(s.signature)
+            if s.summary:
+                lines.append(f"    # {s.summary}")
+    lines.append("```")
+    return "\n".join(lines)
+
+
+def _file_section(sf: SelectedFile) -> str:
+    # Content is already redacted at materialization time (context_pack.select_files)
+    parts = [f"### {sf.path}", ""]
+    parts.append(f"Included as: **{sf.include_mode}**")
+    parts.append("")
+    if sf.reasons:
+        parts.append("Reasons:")
+        for r in sf.reasons:
+            parts.append(f"- {r}")
+        parts.append("")
+
+    if sf.include_mode in ("full", "symbols") and sf.content:
+        parts.append("```" + _lang_fence(sf.language))
+        parts.append(sf.content)
+        parts.append("```")
+        if sf.redaction_warnings:
+            types = ", ".join(
+                w.split(": ", 1)[1] if ": " in w else w for w in sf.redaction_warnings
+            )
+            parts.append(f"> ⚠ Secrets redacted: {types}")
+
+    elif sf.include_mode == "symbols":
+        if sf.summary:
+            parts.append("Summary:")
+            parts.append(sf.summary)
+            parts.append("")
+        if sf.symbols:
+            parts.append("Relevant symbols:")
+            parts.append("")
+            parts.append(_symbols_block(sf.symbols, sf.language))
+
+    elif sf.include_mode == "summary":
+        if sf.summary:
+            parts.append("Summary:")
+            parts.append(sf.summary)
+
+    return "\n".join(parts)
+
+
+def render_claude(pack: ContextPack) -> str:
+    sections: list[str] = []
+
+    sections.append("# AgentPack Context for Claude")
+    sections.append("")
+
+    if pack.stale:
+        sections.append("> **Warning:** This context pack may be stale. Run `agentpack pack` to regenerate.")
+        sections.append("")
+
+    sections.append("## Task")
+    sections.append("")
+    sections.append(pack.task)
+    sections.append("")
+
+    sections.append("## Instructions for Claude")
+    sections.append("")
+    sections.append(
+        "This is a task-focused context pack. Act on it immediately:\n\n"
+        "1. **Orient** — identify the changed files and key symbols relevant to the task.\n"
+        "2. **Diagnose or plan** — find the root cause (bug fix) or outline the approach (feature).\n"
+        "3. **Work** — edit files, write code, fix the issue. Do not wait for more instructions.\n\n"
+        "Priority order: changed files → keyword-matched files → dependencies → summaries.\n"
+        "Files marked `full` contain complete source. Files marked `symbols` contain relevant "
+        "function/class bodies. Files marked `summary` are unchanged context.\n"
+        "If the pack looks stale (changed files list is empty but you expect changes), "
+        "ask the user to run `agentpack pack --task \"<task>\"` to refresh."
+    )
+    sections.append("")
+
+    sections.append("## Token Stats")
+    sections.append("")
+    sections.append(f"Raw repo tokens: {pack.raw_repo_tokens:,}")
+    sections.append(f"After ignore: {pack.after_ignore_tokens:,}")
+    sections.append(f"Packed tokens: {pack.token_estimate:,}")
+    sections.append(f"Estimated saving: {pack.estimated_savings_percent:.1f}%")
+    sections.append("")
+
+    if pack.redaction_warnings:
+        sections.append("## Security")
+        sections.append("")
+        sections.append("> The following secrets were redacted before packing:")
+        sections.append("")
+        for w in pack.redaction_warnings:
+            sections.append(f"- {w}")
+        sections.append("")
+
+    sections.append("## Changed Files")
+    sections.append("")
+    if pack.changed_files:
+        for f in pack.changed_files:
+            sections.append(f"- {f}")
+    else:
+        sections.append("_No changed files detected._")
+    sections.append("")
+
+    sections.append("## Selected Files")
+    sections.append("")
+    sections.append("| File | Mode | Score | Why |")
+    sections.append("|---|---|---:|---|")
+    for sf in pack.selected_files:
+        why = sf.reasons[0] if sf.reasons else ""
+        sections.append(f"| `{sf.path}` | {sf.include_mode} | {sf.score:.0f} | {why} |")
+    sections.append("")
+
+    if pack.receipts:
+        sections.append("## Context Receipts")
+        sections.append("")
+        for r in pack.receipts:
+            sections.append(f"- `{r.path}` {r.action} because {r.reason}")
+        sections.append("")
+
+    sections.append("## File Context")
+    sections.append("")
+    for sf in pack.selected_files:
+        sections.append(_file_section(sf))
+        sections.append("")
+
+    return "\n".join(sections)
+
+
+def render_generic(pack: ContextPack) -> str:
+    return render_claude(pack).replace("# AgentPack Context for Claude", "# AgentPack Context")

agentpack/renderers/receipts.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from agentpack.core.models import Receipt
+
+
+def format_receipts(receipts: list[Receipt]) -> str:
+    lines = []
+    for r in receipts:
+        lines.append(f"- `{r.path}` {r.action}: {r.reason}")
+    return "\n".join(lines)

agentpack/session/__init__.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from agentpack.session.state import (
+    SessionState,
+    load_session,
+    save_session,
+    create_session,
+    stop_session,
+    log_activity,
+    AGENTPACK_DIR,
+    SESSION_FILE,
+    TASK_FILE,
+    CONTEXT_FILE,
+    COMPACT_FILE,
+    ACTIVITY_LOG,
+    TASK_FILE_TEMPLATE,
+)
+
+__all__ = [
+    "SessionState",
+    "load_session",
+    "save_session",
+    "create_session",
+    "stop_session",
+    "log_activity",
+    "AGENTPACK_DIR",
+    "SESSION_FILE",
+    "TASK_FILE",
+    "CONTEXT_FILE",
+    "COMPACT_FILE",
+    "ACTIVITY_LOG",
+    "TASK_FILE_TEMPLATE",
+]

agentpack/session/state.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+import json
+
+AGENTPACK_DIR = ".agentpack"
+SESSION_FILE = ".agentpack/session.json"
+TASK_FILE = ".agentpack/task.md"
+CONTEXT_FILE = ".agentpack/context.md"
+COMPACT_FILE = ".agentpack/context.compact.md"
+ACTIVITY_LOG = ".agentpack/activity.log"
+
+TASK_FILE_TEMPLATE = """\
+# Current Task
+
+Write or update the current coding task here.
+
+AgentPack will refresh context based on this task.
+"""
+
+
+@dataclass
+class SessionState:
+    active: bool
+    started_at: Optional[str]
+    agent: str = "generic"
+    mode: str = "balanced"
+    context_file: str = CONTEXT_FILE
+    compact_context_file: str = COMPACT_FILE
+    task_file: str = TASK_FILE
+    last_refresh_at: Optional[str] = None
+    last_task_hash: str = ""
+    last_git_hash: str = ""
+    refresh_count: int = 0
+
+
+def load_session(root: Path) -> Optional[SessionState]:
+    """Load session state from .agentpack/session.json. Returns None if missing."""
+    session_path = root / SESSION_FILE
+    try:
+        data = json.loads(session_path.read_text(encoding="utf-8"))
+        return SessionState(
+            active=data.get("active", False),
+            started_at=data.get("started_at"),
+            agent=data.get("agent", "generic"),
+            mode=data.get("mode", "balanced"),
+            context_file=data.get("context_file", CONTEXT_FILE),
+            compact_context_file=data.get("compact_context_file", COMPACT_FILE),
+            task_file=data.get("task_file", TASK_FILE),
+            last_refresh_at=data.get("last_refresh_at"),
+            last_task_hash=data.get("last_task_hash", ""),
+            last_git_hash=data.get("last_git_hash", ""),
+            refresh_count=data.get("refresh_count", 0),
+        )
+    except FileNotFoundError:
+        return None
+
+
+def save_session(root: Path, state: SessionState) -> None:
+    """Write session state to .agentpack/session.json."""
+    session_path = root / SESSION_FILE
+    session_path.parent.mkdir(parents=True, exist_ok=True)
+    session_path.write_text(
+        json.dumps(asdict(state), indent=2, default=str),
+        encoding="utf-8",
+    )
+
+
+def create_session(root: Path, agent: str, mode: str) -> SessionState:
+    """Create a new active session, write session.json, create task.md if missing."""
+    (root / AGENTPACK_DIR).mkdir(parents=True, exist_ok=True)
+
+    task_path = root / TASK_FILE
+    if not task_path.exists():
+        task_path.write_text(TASK_FILE_TEMPLATE, encoding="utf-8")
+
+    state = SessionState(
+        active=True,
+        started_at=datetime.now(timezone.utc).isoformat(),
+        agent=agent,
+        mode=mode,
+    )
+    save_session(root, state)
+    return state
+
+
+def stop_session(root: Path) -> None:
+    """Mark the active session as inactive and update session.json."""
+    state = load_session(root)
+    if state is None:
+        return
+    state.active = False
+    save_session(root, state)
+
+
+def log_activity(root: Path, message: str) -> None:
+    """Append a timestamped line to .agentpack/activity.log."""
+    log_path = root / ACTIVITY_LOG
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now(timezone.utc).isoformat()
+    with log_path.open("a", encoding="utf-8") as fh:
+        fh.write(f"[{timestamp}] {message}\n")

agentpack/summaries/base.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.core.models import FileInfo, FileSummary
+from agentpack.core import cache as summary_cache
+from agentpack.summaries import offline
+
+
+_LLM_PROVIDERS = {"claude", "openai"}
+
+
+def get_or_build_summary(fi: FileInfo, root: Path, provider: str = "offline") -> FileSummary:
+    if fi.hash is None:
+        return offline.summarize(fi.path, fi.abs_path, fi.language, "")
+
+    cached = summary_cache.load_summary(root, fi.path, fi.hash, provider)
+    if cached:
+        return cached
+
+    if provider in _LLM_PROVIDERS:
+        from agentpack.summaries import llm as llm_mod
+        summary = llm_mod.summarize(fi.path, fi.abs_path, fi.language, fi.hash, provider=provider)
+    else:
+        summary = offline.summarize(fi.path, fi.abs_path, fi.language, fi.hash)
+
+    summary_cache.save_summary(root, summary)
+    return summary
+
+
+def build_all_summaries(
+    files: list[FileInfo],
+    root: Path,
+    provider: str = "offline",
+) -> dict[str, FileSummary]:
+    """Build summaries for packable files. Skips ignored and binary entries defensively."""
+    result: dict[str, FileSummary] = {}
+    for fi in files:
+        if fi.ignored or fi.binary:
+            continue
+        result[fi.path] = get_or_build_summary(fi, root, provider)
+    return result

agentpack/summaries/llm.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.core.models import FileSummary
+from agentpack.analysis.symbols import extract_symbols
+
+
+_SYSTEM_PROMPT = """\
+You are a code summarizer. Given source code, produce a concise summary (3-5 sentences) covering:
+- What this file does and its likely responsibility
+- Key classes, functions, or exports it provides
+- Important dependencies or side effects
+
+Be factual and terse. No filler phrases."""
+
+_MAX_INPUT_CHARS = 12000
+
+
+def summarize_with_claude(
+    path: str,
+    abs_path: Path,
+    language: str | None,
+    file_hash: str,
+    model: str = "claude-haiku-4-5-20251001",
+) -> FileSummary:
+    try:
+        import anthropic
+    except ImportError:
+        raise ImportError("Install agentpack[llm] to use LLM summaries: pip install 'agentpack[llm]'")
+
+    try:
+        content = abs_path.read_text(errors="replace")[:_MAX_INPUT_CHARS]
+    except OSError:
+        content = ""
+
+    import os
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        raise EnvironmentError(
+            "ANTHROPIC_API_KEY is not set. "
+            "Set it or use --summary-provider offline (the default)."
+        )
+
+    try:
+        client = anthropic.Anthropic()
+        message = client.messages.create(
+            model=model,
+            max_tokens=300,
+            system=_SYSTEM_PROMPT,
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"File: {path}\nLanguage: {language or 'unknown'}\n\n```\n{content}\n```",
+                }
+            ],
+        )
+    except anthropic.AuthenticationError as exc:
+        raise EnvironmentError(
+            f"Anthropic authentication failed — check ANTHROPIC_API_KEY. ({exc})"
+        ) from exc
+    except anthropic.RateLimitError as exc:
+        raise RuntimeError(
+            f"Anthropic rate limit hit while summarising {path}. "
+            "Wait and retry, or use --summary-provider offline."
+        ) from exc
+    except anthropic.APIStatusError as exc:
+        raise RuntimeError(
+            f"Anthropic API error while summarising {path}: {exc}"
+        ) from exc
+
+    summary_text = message.content[0].text if message.content else ""
+
+    symbols = extract_symbols(abs_path, language)
+
+    return FileSummary(
+        path=path,
+        hash=file_hash,
+        language=language,
+        provider="claude",
+        schema_version=1,
+        summary=summary_text,
+        imports=[],
+        symbols=symbols,
+    )
+
+
+def summarize(
+    path: str,
+    abs_path: Path,
+    language: str | None,
+    file_hash: str,
+    provider: str = "claude",
+    model: str | None = None,
+) -> FileSummary:
+    if provider == "claude":
+        return summarize_with_claude(
+            path, abs_path, language, file_hash,
+            model=model or "claude-haiku-4-5-20251001",
+        )
+    raise ValueError(f"Unknown LLM provider: {provider}")