erk 0.4.5__py3-none-any.whl

erk/core/output_filter.py

@@ -0,0 +1,338 @@
+"""Output filtering for Claude CLI stream-json format.
+
+This module provides functions to parse and filter Claude CLI output in stream-json
+format, extracting relevant text content and tool summaries while suppressing
+verbose/noisy tool invocations.
+"""
+
+import json
+from pathlib import Path
+
+
+def extract_text_content(message: dict) -> str | None:
+    """Extract Claude's text response from assistant message.
+
+    Args:
+        message: Assistant message dict from stream-json
+
+    Returns:
+        Extracted text content, or None if no text found
+
+    Example:
+        >>> msg = {"type": "assistant_message", "content": [{"type": "text", "text": "Hello"}]}
+        >>> extract_text_content(msg)
+        'Hello'
+    """
+    content = message.get("content", [])
+    if not isinstance(content, list):
+        return None
+
+    text_parts: list[str] = []
+    for item in content:
+        if isinstance(item, dict) and item.get("type") == "text":
+            text = item.get("text")
+            if isinstance(text, str) and text.strip():
+                text_parts.append(text.strip())
+
+    if not text_parts:
+        return None
+
+    return "\n".join(text_parts)
+
+
+def summarize_tool_use(tool_use: dict, worktree_path: Path) -> str | None:
+    """Create brief summary for important tools, None for suppressible tools.
+
+    Args:
+        tool_use: Tool use dict from stream-json content
+        worktree_path: Path to worktree for relativizing file paths
+
+    Returns:
+        Brief summary string for important tools, None for suppressible tools
+
+    Example:
+        >>> tool = {"name": "Edit", "input": {"file_path": "/repo/src/file.py"}}
+        >>> summarize_tool_use(tool, Path("/repo"))
+        'Editing src/file.py...'
+    """
+    tool_name = tool_use.get("name")
+    if not isinstance(tool_name, str):
+        return None
+
+    params = tool_use.get("input", {})
+    if not isinstance(params, dict):
+        params = {}
+
+    # Suppress common/noisy tools
+    if tool_name in ["Read", "Glob", "Grep"]:
+        return None
+
+    # Bash commands
+    if tool_name == "Bash":
+        command = params.get("command", "")
+        if not isinstance(command, str):
+            return None
+
+        # Check for pytest
+        if "pytest" in command:
+            return "Running tests..."
+
+        # Check for CI commands
+        if "fast-ci" in command or "all-ci" in command:
+            return "Running CI checks..."
+
+        # Generic bash command
+        return f"Running: {command[:50]}..."
+
+    # Slash commands
+    if tool_name == "SlashCommand":
+        cmd = params.get("command", "")
+        if not isinstance(cmd, str):
+            return None
+
+        if "/gt:pr-submit" in cmd or "/erk:git-pr-push" in cmd:
+            return "Creating pull request..."
+
+        if "/fast-ci" in cmd or "/all-ci" in cmd:
+            return "Running CI checks..."
+
+        return f"Running {cmd}..."
+
+    # File operations
+    if tool_name == "Edit":
+        filepath = params.get("file_path", "")
+        if isinstance(filepath, str):
+            relative = make_relative_to_worktree(filepath, worktree_path)
+            return f"Editing {relative}..."
+
+    if tool_name == "Write":
+        filepath = params.get("file_path", "")
+        if isinstance(filepath, str):
+            relative = make_relative_to_worktree(filepath, worktree_path)
+            return f"Writing {relative}..."
+
+    # Default: show tool name for unknown tools
+    return f"Using {tool_name}..."
+
+
+def make_relative_to_worktree(filepath: str, worktree_path: Path) -> str:
+    """Convert absolute path to worktree-relative path.
+
+    Args:
+        filepath: Absolute or relative file path
+        worktree_path: Path to worktree root
+
+    Returns:
+        Path relative to worktree if possible, otherwise original filepath
+
+    Example:
+        >>> make_relative_to_worktree("/repo/src/file.py", Path("/repo"))
+        'src/file.py'
+    """
+    path = Path(filepath)
+
+    # Check if path is absolute and relative to worktree
+    if path.is_absolute():
+        if path.exists() and path.is_relative_to(worktree_path):
+            return str(path.relative_to(worktree_path))
+
+    return filepath
+
+
+def extract_pr_url(tool_result_content: str) -> str | None:
+    """Extract PR URL from exec command JSON output.
+
+    Args:
+        tool_result_content: Content string from tool_result
+
+    Returns:
+        PR URL if found in JSON, None otherwise
+
+    Example:
+        >>> content = '{"success": true, "pr_url": "https://github.com/user/repo/pull/123"}'
+        >>> extract_pr_url(content)
+        'https://github.com/user/repo/pull/123'
+    """
+    if not isinstance(tool_result_content, str):
+        return None
+
+    # Parse JSON safely - JSON parsing requires exception handling
+    data: dict | None = None
+    if tool_result_content.strip():
+        try:
+            parsed = json.loads(tool_result_content)
+            if isinstance(parsed, dict):
+                data = parsed
+        except json.JSONDecodeError:
+            return None
+
+    if data is None:
+        return None
+
+    pr_url = data.get("pr_url")
+    if isinstance(pr_url, str):
+        return pr_url
+
+    return None
+
+
+def extract_pr_metadata(tool_result_content: str) -> dict[str, str | int | None]:
+    """Extract PR metadata from exec command JSON output.
+
+    Args:
+        tool_result_content: Content string from tool_result
+
+    Returns:
+        Dict with pr_url, pr_number, pr_title, and issue_number (all may be None)
+
+    Example:
+        >>> content = '{"success": true, "pr_url": "https://...", "pr_number": 123, '
+        >>> content += '"pr_title": "Fix bug", "issue_number": 456}'
+        >>> extract_pr_metadata(content)
+        {'pr_url': 'https://...', 'pr_number': 123, 'pr_title': 'Fix bug', 'issue_number': 456}
+    """
+    if not isinstance(tool_result_content, str):
+        return {"pr_url": None, "pr_number": None, "pr_title": None, "issue_number": None}
+
+    # Parse JSON safely - JSON parsing requires exception handling
+    data: dict | None = None
+    if tool_result_content.strip():
+        try:
+            parsed = json.loads(tool_result_content)
+            if isinstance(parsed, dict):
+                data = parsed
+        except json.JSONDecodeError:
+            return {"pr_url": None, "pr_number": None, "pr_title": None, "issue_number": None}
+
+    if data is None:
+        return {"pr_url": None, "pr_number": None, "pr_title": None, "issue_number": None}
+
+    pr_url = data.get("pr_url")
+    pr_number = data.get("pr_number")
+    pr_title = data.get("pr_title")
+    issue_number = data.get("issue_number")
+
+    return {
+        "pr_url": pr_url if isinstance(pr_url, str) else None,
+        "pr_number": pr_number if isinstance(pr_number, int) else None,
+        "pr_title": pr_title if isinstance(pr_title, str) else None,
+        "issue_number": issue_number if isinstance(issue_number, int) else None,
+    }
+
+
+def extract_pr_metadata_from_text(text: str) -> dict[str, str | int | None]:
+    """Extract PR metadata from agent text output using pattern matching.
+
+    This is simpler and more robust than parsing nested JSON from tool results.
+    The agent's text output contains PR info in human-readable format like:
+    - "PR #1311" or "**PR #1311**"
+    - "https://github.com/.../pull/1311" or "https://app.graphite.com/.../1311"
+    - "issue #1308" or "Linked to issue #1308"
+
+    Args:
+        text: Agent text output containing PR information
+
+    Returns:
+        Dict with pr_url, pr_number, and issue_number (pr_title always None)
+
+    Example:
+        >>> text = "**PR #123** created\\n- **Link**: https://github.com/o/r/pull/123"
+        >>> extract_pr_metadata_from_text(text)
+        {'pr_url': 'https://github.com/o/r/pull/123', 'pr_number': 123, ...}
+    """
+    import re
+
+    result: dict[str, str | int | None] = {
+        "pr_url": None,
+        "pr_number": None,
+        "pr_title": None,
+        "issue_number": None,
+    }
+
+    if not isinstance(text, str):
+        return result
+
+    # Extract PR number and title from various patterns:
+    # - "PR #123: Title" or "PR #123 - Title"
+    # - "#123 - Title" or '#123 - "Title"'
+    # - "**PR Updated**: #123 - Title"
+    pr_with_title_match = re.search(
+        r"#(\d+)\s*[-:]\s*[\"']?(.+?)[\"']?(?:\n|$)", text, re.IGNORECASE
+    )
+    if pr_with_title_match:
+        result["pr_number"] = int(pr_with_title_match.group(1))
+        result["pr_title"] = pr_with_title_match.group(2).strip().strip("\"'")
+    else:
+        # Fallback: just extract PR number without title
+        pr_num_match = re.search(r"#(\d+)", text)
+        if pr_num_match:
+            result["pr_number"] = int(pr_num_match.group(1))
+
+    # Extract GitHub PR URL
+    github_url_match = re.search(r"https://github\.com/[^/]+/[^/]+/pull/(\d+)", text)
+    if github_url_match:
+        result["pr_url"] = github_url_match.group(0)
+        # Also extract pr_number from URL if not found earlier
+        if result["pr_number"] is None:
+            result["pr_number"] = int(github_url_match.group(1))
+
+    # Extract Graphite URL as fallback
+    if result["pr_url"] is None:
+        graphite_url_match = re.search(
+            r"https://app\.graphite\.com/github/pr/[^/]+/[^/]+/(\d+)", text
+        )
+        if graphite_url_match:
+            result["pr_url"] = graphite_url_match.group(0)
+            if result["pr_number"] is None:
+                result["pr_number"] = int(graphite_url_match.group(1))
+
+    # Extract issue number from patterns like "issue #123" or "Linked to issue #123"
+    # or "#1308 (will auto-close"
+    issue_match = re.search(r"issue\s*#(\d+)", text, re.IGNORECASE)
+    if issue_match:
+        result["issue_number"] = int(issue_match.group(1))
+    else:
+        # Try "Closes #123" pattern
+        closes_match = re.search(r"Closes\s*#(\d+)", text, re.IGNORECASE)
+        if closes_match:
+            result["issue_number"] = int(closes_match.group(1))
+
+    return result
+
+
+def determine_spinner_status(tool_use: dict | None, command: str, worktree_path: Path) -> str:
+    """Map current activity to spinner status message.
+
+    Args:
+        tool_use: Current tool use dict, or None if no tool running
+        command: The slash command being executed
+        worktree_path: Path to worktree for relativizing paths
+
+    Returns:
+        Status message for spinner
+
+    Example:
+        >>> determine_spinner_status(None, "/erk:plan-implement", Path("/repo"))
+        'Running /erk:plan-implement...'
+    """
+    if tool_use is None:
+        return f"Running {command}..."
+
+    # First try to get a detailed summary
+    summary = summarize_tool_use(tool_use, worktree_path)
+    if summary:
+        return summary
+
+    # For suppressed tools (Read, Glob, Grep), provide a generic but distinct message
+    tool_name = tool_use.get("name")
+    if isinstance(tool_name, str):
+        if tool_name == "Read":
+            return "Reading files..."
+        if tool_name == "Glob":
+            return "Searching for files..."
+        if tool_name == "Grep":
+            return "Searching code..."
+        # Fallback for unknown tools
+        return f"Using {tool_name}..."
+
+    return f"Running {command}..."

erk/core/plan_store/__init__.py

@@ -0,0 +1,6 @@
+"""Provider-agnostic abstraction for plan storage.
+
+This package previously re-exported from erk_shared.plan_store.
+All imports have been migrated to erk_shared.plan_store directly.
+This module remains as an empty namespace marker.
+"""

erk/core/planner/__init__.py

@@ -0,0 +1 @@
+"""Planner box management for remote planning with Claude Code."""

erk/core/planner/registry_abc.py

@@ -0,0 +1,8 @@
+"""Planner registry ABC re-export.
+
+ABC is defined in erk_shared.core. This module re-exports for backward compatibility.
+"""
+
+# Re-export from erk_shared.core
+from erk_shared.core.planner_registry import PlannerRegistry as PlannerRegistry
+from erk_shared.core.planner_registry import RegisteredPlanner as RegisteredPlanner

erk/core/planner/registry_fake.py

@@ -0,0 +1,129 @@
+"""Fake implementation of PlannerRegistry for testing.
+
+Stores planner data in memory without touching filesystem.
+"""
+
+from dataclasses import replace
+from datetime import datetime
+
+from erk.core.planner.registry_abc import PlannerRegistry
+from erk.core.planner.types import RegisteredPlanner
+
+
+class FakePlannerRegistry(PlannerRegistry):
+    """In-memory implementation for testing.
+
+    Provides mutation tracking via read-only properties for assertions.
+    """
+
+    def __init__(
+        self,
+        planners: list[RegisteredPlanner] | None = None,
+        default_planner: str | None = None,
+    ) -> None:
+        """Initialize the fake registry.
+
+        Args:
+            planners: Initial list of planners
+            default_planner: Name of the default planner (must exist in planners)
+        """
+        self._planners: dict[str, RegisteredPlanner] = {}
+        self._default_planner: str | None = default_planner
+
+        # Track mutations for assertions
+        self._registered: list[RegisteredPlanner] = []
+        self._unregistered: list[str] = []
+        self._marked_configured: list[str] = []
+        self._updated_last_connected: list[tuple[str, datetime]] = []
+        self._set_defaults: list[str] = []
+
+        if planners:
+            for planner in planners:
+                self._planners[planner.name] = planner
+
+    def list_planners(self) -> list[RegisteredPlanner]:
+        """List all registered planners."""
+        return list(self._planners.values())
+
+    def get(self, name: str) -> RegisteredPlanner | None:
+        """Get a planner by name."""
+        return self._planners.get(name)
+
+    def get_default(self) -> RegisteredPlanner | None:
+        """Get the default planner."""
+        if self._default_planner is None:
+            return None
+        return self._planners.get(self._default_planner)
+
+    def get_default_name(self) -> str | None:
+        """Get the name of the default planner."""
+        return self._default_planner
+
+    def set_default(self, name: str) -> None:
+        """Set the default planner."""
+        if name not in self._planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        self._default_planner = name
+        self._set_defaults.append(name)
+
+    def register(self, planner: RegisteredPlanner) -> None:
+        """Register a new planner."""
+        if planner.name in self._planners:
+            raise ValueError(f"Planner '{planner.name}' already exists")
+        self._planners[planner.name] = planner
+        self._registered.append(planner)
+
+    def unregister(self, name: str) -> None:
+        """Remove a planner from the registry."""
+        if name not in self._planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        del self._planners[name]
+
+        # Clear default if we're removing the default planner
+        if self._default_planner == name:
+            self._default_planner = None
+
+        self._unregistered.append(name)
+
+    def mark_configured(self, name: str) -> None:
+        """Mark a planner as configured."""
+        if name not in self._planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        old_planner = self._planners[name]
+        self._planners[name] = replace(old_planner, configured=True)
+        self._marked_configured.append(name)
+
+    def update_last_connected(self, name: str, timestamp: datetime) -> None:
+        """Update the last connected timestamp for a planner."""
+        if name not in self._planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        old_planner = self._planners[name]
+        self._planners[name] = replace(old_planner, last_connected_at=timestamp)
+        self._updated_last_connected.append((name, timestamp))
+
+    # Read-only mutation tracking properties for test assertions
+
+    @property
+    def registered_planners(self) -> list[RegisteredPlanner]:
+        """Planners registered during test (for assertions)."""
+        return list(self._registered)
+
+    @property
+    def unregistered_names(self) -> list[str]:
+        """Names of planners unregistered during test (for assertions)."""
+        return list(self._unregistered)
+
+    @property
+    def marked_configured_names(self) -> list[str]:
+        """Names of planners marked as configured during test (for assertions)."""
+        return list(self._marked_configured)
+
+    @property
+    def updated_connections(self) -> list[tuple[str, datetime]]:
+        """(name, timestamp) pairs for last_connected updates (for assertions)."""
+        return list(self._updated_last_connected)
+
+    @property
+    def set_default_history(self) -> list[str]:
+        """History of set_default calls (for assertions)."""
+        return list(self._set_defaults)

erk/core/planner/registry_real.py

@@ -0,0 +1,195 @@
+"""Real implementation of PlannerRegistry using TOML file storage.
+
+Stores planner configuration in ~/.erk/planners.toml.
+"""
+
+import tomllib
+from datetime import datetime
+from pathlib import Path
+
+import tomlkit
+
+from erk.core.planner.registry_abc import PlannerRegistry
+from erk.core.planner.types import RegisteredPlanner
+
+SCHEMA_VERSION = 1
+
+
+class RealPlannerRegistry(PlannerRegistry):
+    """Production implementation that reads/writes ~/.erk/planners.toml."""
+
+    def __init__(self, config_path: Path) -> None:
+        """Initialize the registry.
+
+        Args:
+            config_path: Path to the planners.toml config file.
+                        Typically obtained from erk_installation.get_planners_config_path().
+        """
+        self._config_path = config_path
+
+    def _load_data(self) -> dict:
+        """Load data from TOML file.
+
+        Returns:
+            Parsed TOML data, or empty structure if file doesn't exist
+        """
+        if not self._config_path.exists():
+            return {"schema_version": SCHEMA_VERSION, "planners": {}}
+
+        content = self._config_path.read_text(encoding="utf-8")
+        return tomllib.loads(content)
+
+    def _save_data(self, data: dict) -> None:
+        """Save data to TOML file.
+
+        Args:
+            data: Data structure to save
+        """
+        # Ensure parent directory exists
+        self._config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Use tomlkit to preserve formatting
+        doc = tomlkit.document()
+        doc["schema_version"] = data.get("schema_version", SCHEMA_VERSION)
+
+        if "default_planner" in data and data["default_planner"] is not None:
+            doc["default_planner"] = data["default_planner"]
+
+        # Add planners table
+        planners_table = tomlkit.table()
+        for name, planner_data in data.get("planners", {}).items():
+            planner_table = tomlkit.table()
+            planner_table["gh_name"] = planner_data["gh_name"]
+            planner_table["repository"] = planner_data["repository"]
+            planner_table["configured"] = planner_data["configured"]
+            planner_table["registered_at"] = planner_data["registered_at"]
+            if planner_data.get("last_connected_at") is not None:
+                planner_table["last_connected_at"] = planner_data["last_connected_at"]
+            planners_table[name] = planner_table
+
+        doc["planners"] = planners_table
+
+        self._config_path.write_text(tomlkit.dumps(doc), encoding="utf-8")
+
+    def _planner_from_dict(self, name: str, data: dict) -> RegisteredPlanner:
+        """Convert a dict to a RegisteredPlanner.
+
+        Args:
+            name: Planner name
+            data: Dict with planner data
+
+        Returns:
+            RegisteredPlanner instance
+        """
+        return RegisteredPlanner(
+            name=name,
+            gh_name=data["gh_name"],
+            repository=data["repository"],
+            configured=data["configured"],
+            registered_at=datetime.fromisoformat(data["registered_at"]),
+            last_connected_at=(
+                datetime.fromisoformat(data["last_connected_at"])
+                if data.get("last_connected_at")
+                else None
+            ),
+        )
+
+    def _planner_to_dict(self, planner: RegisteredPlanner) -> dict:
+        """Convert a RegisteredPlanner to a dict.
+
+        Args:
+            planner: RegisteredPlanner instance
+
+        Returns:
+            Dict representation
+        """
+        result = {
+            "gh_name": planner.gh_name,
+            "repository": planner.repository,
+            "configured": planner.configured,
+            "registered_at": planner.registered_at.isoformat(),
+        }
+        if planner.last_connected_at is not None:
+            result["last_connected_at"] = planner.last_connected_at.isoformat()
+        return result
+
+    def list_planners(self) -> list[RegisteredPlanner]:
+        """List all registered planners."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        return [self._planner_from_dict(name, pdata) for name, pdata in planners.items()]
+
+    def get(self, name: str) -> RegisteredPlanner | None:
+        """Get a planner by name."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        if name not in planners:
+            return None
+        return self._planner_from_dict(name, planners[name])
+
+    def get_default(self) -> RegisteredPlanner | None:
+        """Get the default planner."""
+        data = self._load_data()
+        default_name = data.get("default_planner")
+        if default_name is None:
+            return None
+        return self.get(default_name)
+
+    def get_default_name(self) -> str | None:
+        """Get the name of the default planner."""
+        data = self._load_data()
+        return data.get("default_planner")
+
+    def set_default(self, name: str) -> None:
+        """Set the default planner."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        if name not in planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        data["default_planner"] = name
+        self._save_data(data)
+
+    def register(self, planner: RegisteredPlanner) -> None:
+        """Register a new planner."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        if planner.name in planners:
+            raise ValueError(f"Planner '{planner.name}' already exists")
+        planners[planner.name] = self._planner_to_dict(planner)
+        data["planners"] = planners
+        self._save_data(data)
+
+    def unregister(self, name: str) -> None:
+        """Remove a planner from the registry."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        if name not in planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        del planners[name]
+        data["planners"] = planners
+
+        # Clear default if we're removing the default planner
+        if data.get("default_planner") == name:
+            data["default_planner"] = None
+
+        self._save_data(data)
+
+    def mark_configured(self, name: str) -> None:
+        """Mark a planner as configured."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        if name not in planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        planners[name]["configured"] = True
+        data["planners"] = planners
+        self._save_data(data)
+
+    def update_last_connected(self, name: str, timestamp: datetime) -> None:
+        """Update the last connected timestamp for a planner."""
+        data = self._load_data()
+        planners = data.get("planners", {})
+        if name not in planners:
+            raise ValueError(f"No planner named '{name}' exists")
+        planners[name]["last_connected_at"] = timestamp.isoformat()
+        data["planners"] = planners
+        self._save_data(data)

erk/core/planner/types.py

@@ -0,0 +1,7 @@
+"""Planner types re-export.
+
+Types are defined in erk_shared.core. This module re-exports for backward compatibility.
+"""
+
+# Re-export from erk_shared.core
+from erk_shared.core.planner_registry import RegisteredPlanner as RegisteredPlanner