crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/plan/types.py

@@ -0,0 +1,169 @@
+"""Data structures for structured execution plans."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class PlanStep:
+    """A single step in an execution plan."""
+
+    id: str
+    title: str
+    description: str
+    files: list[str] = field(default_factory=list)
+    depends_on: list[str] = field(default_factory=list)
+    subagent_type: str = "generalPurpose"
+    status: str = "pending"  # pending | running | completed | failed | cancelled
+    agent_id: str | None = None
+    result: str = ""
+    error: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "files": list(self.files),
+            "depends_on": list(self.depends_on),
+            "subagent_type": self.subagent_type,
+            "status": self.status,
+            "agent_id": self.agent_id,
+            "result": self.result,
+            "error": self.error,
+        }
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> PlanStep:
+        return PlanStep(
+            id=data["id"],
+            title=data.get("title", ""),
+            description=data.get("description", ""),
+            files=data.get("files", []),
+            depends_on=data.get("depends_on", []),
+            subagent_type=data.get("subagent_type", "generalPurpose"),
+            status=data.get("status", "pending"),
+            agent_id=data.get("agent_id"),
+            result=data.get("result", ""),
+            error=data.get("error", ""),
+        )
+
+
+@dataclass
+class ExecutionPlan:
+    """A structured execution plan with steps and dependency DAG."""
+
+    title: str
+    steps: list[PlanStep] = field(default_factory=list)
+    summary: str = ""
+    status: str = "pending"  # pending | running | completed | failed
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "title": self.title,
+            "summary": self.summary,
+            "status": self.status,
+            "steps": [s.to_dict() for s in self.steps],
+        }
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> ExecutionPlan:
+        steps = [PlanStep.from_dict(s) for s in data.get("steps", [])]
+        return ExecutionPlan(
+            title=data.get("title", ""),
+            summary=data.get("summary", ""),
+            status=data.get("status", "pending"),
+            steps=steps,
+        )
+
+    def validate_dag(self) -> list[str]:
+        """Validate the DAG has no cycles and all dependencies exist.
+
+        Returns a list of error messages (empty if valid).
+        """
+        step_ids = {s.id for s in self.steps}
+        errors: list[str] = []
+
+        for step in self.steps:
+            for dep in step.depends_on:
+                if dep not in step_ids:
+                    errors.append(
+                        f"Step '{step.id}' depends on unknown step '{dep}'"
+                    )
+
+        # Cycle detection via topological sort (Kahn's algorithm)
+        in_degree: dict[str, int] = {s.id: 0 for s in self.steps}
+        adjacency: dict[str, list[str]] = {s.id: [] for s in self.steps}
+        for step in self.steps:
+            for dep in step.depends_on:
+                if dep in step_ids:
+                    adjacency[dep].append(step.id)
+                    in_degree[step.id] += 1
+
+        queue = [sid for sid, deg in in_degree.items() if deg == 0]
+        visited = 0
+        while queue:
+            node = queue.pop(0)
+            visited += 1
+            for neighbor in adjacency[node]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        if visited != len(self.steps):
+            errors.append("Dependency graph contains a cycle")
+
+        return errors
+
+    def get_ready_steps(self) -> list[PlanStep]:
+        """Return steps whose dependencies are all completed."""
+        completed = {s.id for s in self.steps if s.status == "completed"}
+        return [
+            s
+            for s in self.steps
+            if s.status == "pending"
+            and all(dep in completed for dep in s.depends_on)
+        ]
+
+    def prepare_for_execution(self) -> tuple[int, int]:
+        """Reset stale step statuses before DAG run.
+
+        Returns ``(total_steps, reset_count)``. Steps already tied to a sub-agent
+        (``agent_id`` set) are left unchanged for resume scenarios.
+        """
+        reset = 0
+        for step in self.steps:
+            if not step.agent_id and step.status != "pending":
+                step.status = "pending"
+                step.error = ""
+                step.result = ""
+                reset += 1
+        return len(self.steps), reset
+
+    def render(self) -> str:
+        """Render a human-readable view of the plan."""
+        status_icons = {
+            "pending": "○",
+            "running": "◉",
+            "completed": "●",
+            "failed": "✗",
+            "cancelled": "⊘",
+        }
+        lines = [f"Plan: {self.title}"]
+        if self.summary:
+            lines.append(f"  {self.summary}")
+        lines.append("")
+        for step in self.steps:
+            icon = status_icons.get(step.status, "?")
+            deps = ""
+            if step.depends_on:
+                deps = f" (after: {', '.join(step.depends_on)})"
+            lines.append(f"  {icon} [{step.id}] {step.title}{deps}")
+            if step.files:
+                lines.append(f"      files: {', '.join(step.files)}")
+        done = sum(1 for s in self.steps if s.status == "completed")
+        total = len(self.steps)
+        lines.append(f"\n  Progress: {done}/{total} steps executed")
+        return "\n".join(lines)

crabcode_core/prompts/blocks.py

@@ -0,0 +1,10 @@
+"""System sections with cache metadata that never becomes model-visible text."""
+
+
+class SystemPrompt(list[str]):
+    def __init__(self, sections=(), *, static_count: int = 0):
+        super().__init__(sections)
+        self.static_count = min(max(static_count, 0), len(self))
+
+    def with_dynamic(self, *sections: str) -> "SystemPrompt":
+        return SystemPrompt([*self, *(s for s in sections if s)], static_count=self.static_count)

crabcode_core/prompts/context.py

@@ -0,0 +1,229 @@
+"""Context assembly — ported from src/context.ts.
+
+Provides getSystemContext (git status etc.) and getUserContext (CLAUDE.md, date).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.paths import get_config_home
+from crabcode_core.subprocess_utils import decode_subprocess_output, subprocess_group_options
+
+logger = get_logger(__name__)
+
+
+async def _run_git(*args: str, cwd: str = ".") -> str:
+    """Run a git command and return stdout, or empty string on failure."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git", *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd,
+            **subprocess_group_options(),
+        )
+        stdout, _ = await proc.communicate()
+        return decode_subprocess_output(stdout).strip()
+    except Exception:
+        logger.debug("Git command failed: git %s", " ".join(args), exc_info=True)
+        return ""
+
+
+async def _is_git_repo(cwd: str = ".") -> bool:
+    result = await _run_git("rev-parse", "--is-inside-work-tree", cwd=cwd)
+    return result == "true"
+
+
+async def get_git_status(cwd: str = ".") -> str | None:
+    """Build the git status context block."""
+    is_git = await _is_git_repo(cwd)
+    if not is_git:
+        return None
+
+    try:
+        branch, main_branch, status, log, user_name = await asyncio.gather(
+            _run_git("branch", "--show-current", cwd=cwd),
+            _run_git("rev-parse", "--abbrev-ref", "origin/HEAD", cwd=cwd),
+            _run_git("--no-optional-locks", "status", "--short", cwd=cwd),
+            _run_git("--no-optional-locks", "log", "--oneline", "-n", "5", cwd=cwd),
+            _run_git("config", "user.name", cwd=cwd),
+        )
+
+        main_branch = main_branch.replace("origin/", "") if main_branch else "main"
+
+        max_chars = 2000
+        if len(status) > max_chars:
+            status = (
+                status[:max_chars]
+                + '\n... (truncated because it exceeds 2k characters. '
+                'If you need more information, run "git status" using BashTool)'
+            )
+
+        parts = [
+            "This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.",
+            f"Current branch: {branch}",
+            f"Main branch (you will usually use this for PRs): {main_branch}",
+        ]
+        if user_name:
+            parts.append(f"Git user: {user_name}")
+        parts.append(f"Status:\n{status or '(clean)'}")
+        parts.append(f"Recent commits:\n{log}")
+
+        return "\n\n".join(parts)
+    except Exception:
+        logger.debug("Failed to build async git status context for %s", cwd, exc_info=True)
+        return None
+
+
+def get_system_context(cwd: str = ".") -> dict[str, str]:
+    """Build system context (appended to system prompt).
+
+    Synchronous wrapper — runs git commands in event loop if available.
+    For the initial version, we do a simplified synchronous git check.
+    """
+    context: dict[str, str] = {}
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True, text=True, encoding="utf-8", errors="replace", cwd=cwd, timeout=5,
+            **subprocess_group_options(),
+        )
+        is_git = result.stdout.strip() == "true"
+    except Exception:
+        logger.debug("Failed to detect git repository for %s", cwd, exc_info=True)
+        is_git = False
+
+    if is_git:
+        try:
+            parts = []
+            parts.append(
+                "This is the git status at the start of the conversation. "
+                "Note that this status is a snapshot in time, and will not "
+                "update during the conversation."
+            )
+
+            branch = subprocess.run(
+                ["git", "branch", "--show-current"],
+                capture_output=True, text=True, encoding="utf-8", errors="replace", cwd=cwd, timeout=5,
+                **subprocess_group_options(),
+            ).stdout.strip()
+            parts.append(f"Current branch: {branch}")
+
+            status = subprocess.run(
+                ["git", "--no-optional-locks", "status", "--short"],
+                capture_output=True, text=True, encoding="utf-8", errors="replace", cwd=cwd, timeout=5,
+                **subprocess_group_options(),
+            ).stdout.strip()
+            parts.append(f"Status:\n{status or '(clean)'}")
+
+            log = subprocess.run(
+                ["git", "--no-optional-locks", "log", "--oneline", "-n", "5"],
+                capture_output=True, text=True, encoding="utf-8", errors="replace", cwd=cwd, timeout=5,
+                **subprocess_group_options(),
+            ).stdout.strip()
+            parts.append(f"Recent commits:\n{log}")
+
+            context["gitStatus"] = "\n\n".join(parts)
+        except Exception:
+            logger.debug("Failed to build git status system context for %s", cwd, exc_info=True)
+
+    return context
+
+
+def get_user_context(cwd: str = ".") -> dict[str, str]:
+    """Build user context (prepended as first user message).
+
+    Contains CLAUDE.md content, persistent memories, and current date.
+    """
+    context: dict[str, str] = {}
+
+    context["currentDate"] = f"Today's date is {date.today().isoformat()}."
+
+    claude_md = _load_claude_md(cwd)
+    if claude_md:
+        context["claudeMd"] = claude_md
+
+    memories_text = _load_memories_context(cwd)
+    if memories_text:
+        context["memories"] = memories_text
+
+    return context
+
+
+def _load_claude_md(cwd: str) -> str | None:
+    """Discover and load CLAUDE.md files from project hierarchy."""
+    contents: list[str] = []
+
+    search_dir = Path(cwd).resolve()
+    home = Path.home()
+
+    home_claude_md = home / ".claude" / "CLAUDE.md"
+    if home_claude_md.exists():
+        try:
+            contents.append(home_claude_md.read_text(encoding="utf-8", errors="replace"))
+        except Exception:
+            logger.warning("Failed to read %s", home_claude_md, exc_info=True)
+
+    crabcode_md = get_config_home() / "CLAUDE.md"
+    if crabcode_md.exists():
+        try:
+            contents.append(crabcode_md.read_text(encoding="utf-8", errors="replace"))
+        except Exception:
+            logger.warning("Failed to read %s", crabcode_md, exc_info=True)
+
+    current = search_dir
+    project_files: list[str] = []
+    while current != current.parent:
+        for name in ["CLAUDE.md", ".claude/CLAUDE.md"]:
+            candidate = current / name
+            if candidate.exists():
+                try:
+                    project_files.append(
+                        candidate.read_text(encoding="utf-8", errors="replace")
+                    )
+                except Exception:
+                    logger.warning("Failed to read %s", candidate, exc_info=True)
+        if (current / ".git").exists():
+            break
+        current = current.parent
+
+    contents.extend(reversed(project_files))
+
+    if not contents:
+        return None
+    return "\n\n---\n\n".join(contents)
+
+
+def _load_memories_context(cwd: str) -> str | None:
+    """Load a compact memory directory for context injection."""
+    try:
+        from crabcode_core.tools.memory import (
+            format_memory_directory,
+            load_all_memories,
+        )
+    except ImportError:
+        return None
+
+    memories = load_all_memories(cwd)
+    if not memories:
+        return None
+
+    directory = format_memory_directory(memories)
+    if not directory:
+        return None
+
+    return (
+        "The following compact directory lists memories saved from previous "
+        "conversations. Titles are summaries, not the full memory content. "
+        "They may or may not be relevant to the current task. Use the Memory "
+        "tool's search and read actions when details are needed.\n\n"
+        + directory
+    )

crabcode_core/prompts/library.py

@@ -0,0 +1,92 @@
+"""Named prompt templates and prompts appended to user input.
+
+A template section that is missing or blank keeps the built-in default.
+Selecting no template leaves the legacy ``prompt_profile`` in effect, and
+otherwise uses the built-in prompt.
+"""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+from crabcode_core.prompts.profile import PromptProfile
+from crabcode_core.types.config import (
+    CrabCodeSettings,
+    PromptTemplateConfig,
+    UserAppendPromptConfig,
+)
+
+PROMPT_SECTIONS: tuple[tuple[str, str], ...] = (
+    ("prefix", "身份前缀"),
+    ("intro", "介绍"),
+    ("system", "系统规则"),
+    ("doing_tasks", "任务执行"),
+    ("actions", "授权与安全"),
+    ("git_safety", "Git 安全"),
+    ("using_tools", "工具使用"),
+    ("tone_and_style", "语气与风格"),
+    ("output_efficiency", "输出效率"),
+    ("session_guidance", "会话指引"),
+    ("agent_prompt", "子代理提示词"),
+    ("compact_prompt", "上下文压缩提示词"),
+    ("extra", "额外段落"),
+)
+
+PROMPT_SECTION_KEYS = frozenset(key for key, _label in PROMPT_SECTIONS)
+_PROFILE_KEYS = PROMPT_SECTION_KEYS - {"extra"}
+
+_T = TypeVar("_T", PromptTemplateConfig, UserAppendPromptConfig)
+
+
+def last_by_id(items: list[_T]) -> list[_T]:
+    """Keep one item per id. A later settings layer overrides an earlier one."""
+    order: list[str] = []
+    by_id: dict[str, _T] = {}
+    for item in items:
+        if item.id not in by_id:
+            order.append(item.id)
+        by_id[item.id] = item
+    return [by_id[item_id] for item_id in order]
+
+
+def profile_from_sections(sections: dict[str, str]) -> PromptProfile:
+    """Build a profile. Blank text is omitted so that section stays default."""
+    kwargs: dict[str, object] = {}
+    extra: list[str] = []
+    for key, raw in sections.items():
+        if not isinstance(raw, str):
+            continue
+        text = raw.strip()
+        if not text or key not in PROMPT_SECTION_KEYS:
+            continue
+        if key == "extra":
+            extra.append(text)
+        elif key in _PROFILE_KEYS:
+            kwargs[key] = text
+    if extra:
+        kwargs["extra_sections"] = extra
+    return PromptProfile(**kwargs)
+
+
+def resolve_prompt_profile(settings: CrabCodeSettings) -> PromptProfile | None:
+    """Return the active template, otherwise a legacy prompt_profile."""
+    active = settings.active_prompt_template
+    if active:
+        match = next(
+            (item for item in last_by_id(settings.prompt_templates) if item.id == active),
+            None,
+        )
+        if match is not None:
+            return profile_from_sections(match.sections)
+    if settings.prompt_profile:
+        return PromptProfile(**settings.prompt_profile)
+    return None
+
+
+def enabled_user_append_texts(settings: CrabCodeSettings) -> list[str]:
+    """Return checked prompts in list order, after later layers override ids."""
+    texts: list[str] = []
+    for item in last_by_id(settings.user_append_prompts):
+        if item.enabled and item.text.strip():
+            texts.append(item.text.strip())
+    return texts

crabcode_core/prompts/profile.py

@@ -0,0 +1,79 @@
+"""Prompt profile — configurable prompt templates for different agent personas.
+
+Each section field controls one part of the system prompt:
+  - None   → use the built-in default for that section
+  - ""     → disable (skip) the section entirely
+  - "..."  → override with custom text
+
+The compaction prompt is separate from the system prompt; blank text uses its
+built-in default rather than disabling checkpoint instructions.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+from crabcode_core.prompts.templates import DEFAULT_AGENT_PROMPT, DEFAULT_COMPACT_PROMPT, DEFAULT_PREFIX
+
+
+class PromptProfile(BaseModel):
+    """Configurable prompt profile that separates identity/behavior from engine logic."""
+
+    # Agent identity line — used to build the default intro section.
+    prefix: str = DEFAULT_PREFIX
+
+    # ── Behavioral sections (domain-specific, the main things to swap) ──
+
+    intro: str | None = None
+    system: str | None = None
+    doing_tasks: str | None = None
+    actions: str | None = None
+    git_safety: str | None = None
+    using_tools: str | None = None
+    tone_and_style: str | None = None
+    output_efficiency: str | None = None
+    session_guidance: str | None = None
+
+    # Sub-agent system prompt.
+    agent_prompt: str | None = None
+
+    # Checkpoint instructions for manual and automatic context compaction.
+    compact_prompt: str | None = None
+
+    # Extra sections appended after all built-in sections
+    # (before the dynamic env / language / mcp blocks).
+    extra_sections: list[str] = Field(default_factory=list)
+
+    model_config = {"extra": "allow"}
+
+
+def default_profile() -> PromptProfile:
+    """The default coding-assistant profile (all built-in defaults)."""
+    return PromptProfile()
+
+
+def minimal_profile() -> PromptProfile:
+    """A minimal profile with coding-specific sections stripped out.
+
+    Useful as a starting point for non-coding agents.
+    """
+    return PromptProfile(
+        prefix="You are a helpful AI assistant.",
+        doing_tasks="",
+        actions="",
+        git_safety="",
+    )
+
+
+def resolve_agent_prompt(profile: PromptProfile | None) -> str:
+    """Return the sub-agent system prompt, respecting profile overrides."""
+    if profile and profile.agent_prompt is not None:
+        return profile.agent_prompt
+    return DEFAULT_AGENT_PROMPT
+
+
+def resolve_compact_prompt(profile: PromptProfile | None) -> str:
+    """Return checkpoint instructions, falling back for missing or blank text."""
+    if profile and profile.compact_prompt and profile.compact_prompt.strip():
+        return profile.compact_prompt.strip()
+    return DEFAULT_COMPACT_PROMPT