agentpack-cli 0.1.0__py3-none-any.whl

agentpack/__init__.py

@@ -0,0 +1,3 @@
+"""AgentPack — token-aware context packing for AI coding agents."""
+
+__version__ = "0.1.0"

agentpack/adapters/base.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from agentpack.core.models import ContextPack
+
+
+class BaseAdapter(ABC):
+    @abstractmethod
+    def output_path(self, root: Path) -> Path:
+        ...
+
+    @abstractmethod
+    def render(self, pack: ContextPack) -> str:
+        ...
+
+    def write(self, pack: ContextPack, root: Path) -> Path:
+        out = self.output_path(root)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(self.render(pack))
+        return out

agentpack/adapters/claude.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.adapters.base import BaseAdapter
+from agentpack.core.models import ContextPack
+from agentpack.renderers.markdown import render_claude
+
+# Re-export installer symbols for backward compatibility
+from agentpack.installers.claude import (  # noqa: F401
+    ClaudeInstaller,
+    _AGENTPACK_BLOCK,
+    _BLOCK_RE,
+)
+
+
+class ClaudeAdapter(BaseAdapter):
+    def __init__(self, output: str = ".agentpack/context.claude.md"):
+        self._output = output
+
+    def output_path(self, root: Path) -> Path:
+        return root / self._output
+
+    def render(self, pack: ContextPack) -> str:
+        return render_claude(pack)
+
+    # Delegating install methods — kept for backward compat with any callers using adapter directly
+    def patch_claude_md(self, root: Path) -> str:
+        return ClaudeInstaller().patch_claude_md(root)
+
+    def patch_claude_settings(self, root: Path, global_install: bool = False) -> str:
+        return ClaudeInstaller().patch_claude_settings(root, global_install)

agentpack/adapters/codex.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.adapters.base import BaseAdapter
+from agentpack.core.models import ContextPack
+from agentpack.renderers.markdown import render_generic
+from agentpack.installers.codex import CodexInstaller  # noqa: F401
+
+
+class CodexAdapter(BaseAdapter):
+    def __init__(self, output: str = ".agentpack/context.md"):
+        self._output = output
+
+    def output_path(self, root: Path) -> Path:
+        return root / self._output
+
+    def render(self, pack: ContextPack) -> str:
+        return render_generic(pack)
+
+    # Delegating install methods — kept for backward compat
+    def patch_agents_md(self, root: Path) -> str:
+        return CodexInstaller().patch_agents_md(root)
+
+    def install_auto_repack(self, root: Path) -> dict[str, str]:
+        return CodexInstaller().install_auto_repack(root)

agentpack/adapters/cursor.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.adapters.base import BaseAdapter
+from agentpack.core.models import ContextPack
+from agentpack.renderers.markdown import render_generic
+from agentpack.installers.cursor import CursorInstaller  # noqa: F401
+
+
+class CursorAdapter(BaseAdapter):
+    def __init__(self, output: str = ".agentpack/context.md"):
+        self._output = output
+
+    def output_path(self, root: Path) -> Path:
+        return root / self._output
+
+    def render(self, pack: ContextPack) -> str:
+        return render_generic(pack)
+
+    # Delegating install methods — kept for backward compat
+    def patch_cursor_rules(self, root: Path) -> str:
+        return CursorInstaller().patch_cursor_rules(root)
+
+    def patch_cursor_mdc(self, root: Path) -> str:
+        return CursorInstaller().patch_cursor_mdc(root)
+
+    def install_auto_repack(self, root: Path) -> dict[str, str]:
+        return CursorInstaller().install_auto_repack(root)

agentpack/adapters/generic.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.adapters.base import BaseAdapter
+from agentpack.core.models import ContextPack
+from agentpack.renderers.markdown import render_generic
+
+
+class GenericAdapter(BaseAdapter):
+    def __init__(self, output: str = ".agentpack/context.md"):
+        self._output = output
+
+    def output_path(self, root: Path) -> Path:
+        return root / self._output
+
+    def render(self, pack: ContextPack) -> str:
+        return render_generic(pack)

agentpack/adapters/windsurf.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.adapters.base import BaseAdapter
+from agentpack.core.models import ContextPack
+from agentpack.renderers.markdown import render_generic
+from agentpack.installers.windsurf import WindsurfInstaller  # noqa: F401
+
+
+class WindsurfAdapter(BaseAdapter):
+    def __init__(self, output: str = ".agentpack/context.md"):
+        self._output = output
+
+    def output_path(self, root: Path) -> Path:
+        return root / self._output
+
+    def render(self, pack: ContextPack) -> str:
+        return render_generic(pack)
+
+    # Delegating install methods — kept for backward compat
+    def patch_windsurfrules(self, root: Path) -> str:
+        return WindsurfInstaller().patch_windsurfrules(root)
+
+    def install_auto_repack(self, root: Path) -> dict[str, str]:
+        return WindsurfInstaller().install_auto_repack(root)

agentpack/analysis/dependency_graph.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agentpack.core.models import DependencyGraph, DependencyNode, FileInfo
+from agentpack.analysis.python_imports import extract_imports as py_imports
+from agentpack.analysis.python_imports import resolve_relative_import as py_resolve
+from agentpack.analysis.js_ts_imports import extract_imports as js_imports
+from agentpack.analysis.js_ts_imports import resolve_relative_import as js_resolve
+from agentpack.analysis.go_imports import extract_imports as go_imports
+from agentpack.analysis.rust_imports import extract_imports as rust_imports
+from agentpack.analysis.java_imports import extract_imports as java_imports
+
+
+def build(
+    files: list[FileInfo],
+    root: Path,
+    summaries: dict | None = None,
+) -> DependencyGraph:
+    """Build an import/imported-by graph over packable files.
+
+    Args:
+        files: Packable (non-ignored, non-binary) FileInfo objects.
+        root: Repository root for resolving relative imports.
+        summaries: Optional pre-built summary cache; cached imports avoid re-parsing.
+
+    Returns:
+        DependencyGraph with typed DependencyNode entries. Caller fills tests
+        via find_related_tests after construction.
+    """
+    graph = DependencyGraph(
+        nodes={fi.path: DependencyNode(path=fi.path) for fi in files}
+    )
+    path_set = {fi.path for fi in files}
+
+    for fi in files:
+        if summaries and fi.path in summaries:
+            cached_imports = summaries[fi.path].get("imports", [])
+            if cached_imports:
+                graph.nodes[fi.path].imports = cached_imports
+                for dep in cached_imports:
+                    if dep in graph:
+                        graph.nodes[dep].imported_by.append(fi.path)
+                continue
+
+        raw_imports: list[str] = []
+        lang = fi.language
+        cached = fi.content
+
+        if lang == "python":
+            raw_imports = py_imports(fi.abs_path, cached)
+        elif lang in ("javascript", "typescript"):
+            raw_imports = js_imports(fi.abs_path, cached)
+        elif lang == "go":
+            raw_imports = go_imports(fi.abs_path, cached)
+        elif lang == "rust":
+            raw_imports = rust_imports(fi.abs_path, cached)
+        elif lang in ("java", "kotlin"):
+            raw_imports = java_imports(fi.abs_path, cached)
+
+        resolved: list[str] = []
+        for imp in raw_imports:
+            if imp.startswith("."):
+                if lang == "python":
+                    r = py_resolve(fi.path, imp, root)
+                elif lang in ("javascript", "typescript"):
+                    r = js_resolve(fi.path, imp, root)
+                else:
+                    r = None
+                if r and r in path_set:
+                    resolved.append(r)
+            else:
+                resolved.append(imp)
+
+        graph.nodes[fi.path].imports = resolved
+        for dep in resolved:
+            if dep in graph:
+                graph.nodes[dep].imported_by.append(fi.path)
+
+    return graph

agentpack/analysis/go_imports.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_SINGLE = re.compile(r'^import\s+"([^"]+)"', re.MULTILINE)
+_BLOCK_START = re.compile(r"^import\s+\(", re.MULTILINE)
+_BLOCK_ENTRY = re.compile(r'^\s+(?:\w+\s+)?"([^"]+)"')
+
+
+def extract_imports(path: Path, text: str | None = None) -> list[str]:
+    if text is None:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            return []
+
+    imports: list[str] = []
+    imports.extend(m.group(1) for m in _SINGLE.finditer(text))
+
+    for block_m in _BLOCK_START.finditer(text):
+        rest = text[block_m.end():]
+        end = rest.find(")")
+        if end == -1:
+            continue
+        block = rest[:end]
+        for line in block.splitlines():
+            m = _BLOCK_ENTRY.match(line)
+            if m:
+                imports.append(m.group(1))
+
+    return imports

agentpack/analysis/java_imports.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_IMPORT = re.compile(r"^import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;", re.MULTILINE)
+_KOTLIN_IMPORT = re.compile(r"^import\s+([\w.]+(?:\.\*)?)", re.MULTILINE)
+
+
+def extract_imports(path: Path, text: str | None = None) -> list[str]:
+    if text is None:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            return []
+
+    suffix = path.suffix.lower()
+    pattern = _KOTLIN_IMPORT if suffix == ".kt" else _IMPORT
+    return [m.group(1) for m in pattern.finditer(text)]

agentpack/analysis/js_ts_imports.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+_IMPORT_PATTERNS = [
+    re.compile(r'import\s+.*?\s+from\s+["\']([^"\']+)["\']'),
+    re.compile(r'import\s+["\']([^"\']+)["\']'),
+    re.compile(r'require\s*\(\s*["\']([^"\']+)["\']\s*\)'),
+    re.compile(r'export\s+.*?\s+from\s+["\']([^"\']+)["\']'),
+]
+
+_RELATIVE_EXTS = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs")
+
+
+def extract_imports(path: Path, text: str | None = None) -> list[str]:
+    if text is None:
+        try:
+            text = path.read_text(errors="replace")
+        except OSError:
+            return []
+
+    imports: list[str] = []
+    for pattern in _IMPORT_PATTERNS:
+        for m in pattern.finditer(text):
+            imports.append(m.group(1))
+    return imports
+
+
+def resolve_relative_import(importer: str, import_str: str, root: Path) -> str | None:
+    if not import_str.startswith("."):
+        return None
+
+    base = (root / importer).parent
+    candidate = (base / import_str).resolve()
+
+    for ext in _RELATIVE_EXTS:
+        p = candidate.with_suffix(ext)
+        if p.exists():
+            try:
+                return str(p.relative_to(root))
+            except ValueError:
+                pass
+
+    for ext in _RELATIVE_EXTS:
+        p = candidate / f"index{ext}"
+        if p.exists():
+            try:
+                return str(p.relative_to(root))
+            except ValueError:
+                pass
+
+    return None

agentpack/analysis/python_imports.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+
+def extract_imports(path: Path, text: str | None = None) -> list[str]:
+    try:
+        source = text if text is not None else path.read_text(errors="replace")
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+
+    imports: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            level = node.level or 0
+            prefix = "." * level
+            imports.append(f"{prefix}{module}" if module else prefix)
+    return imports
+
+
+def resolve_relative_import(importer: str, import_str: str, root: Path) -> str | None:
+    """Resolve a relative Python import to a file path relative to root."""
+    if not import_str.startswith("."):
+        return None
+
+    dots = len(import_str) - len(import_str.lstrip("."))
+    module = import_str[dots:].replace(".", "/")
+
+    base = Path(importer).parent
+    for _ in range(dots - 1):
+        base = base.parent
+
+    candidate = base / module
+    for suffix in (".py", "/__init__.py"):
+        full = root / (str(candidate) + suffix)
+        if full.exists():
+            return str((candidate).with_suffix(".py") if suffix == ".py" else candidate / "__init__.py")
+
+    return None