crabcode 0.1.0__py3-none-any.whl

crabcode_core/permissions/manager.py

@@ -0,0 +1,106 @@
+"""Permission management — controls tool execution authorization."""
+
+from __future__ import annotations
+
+import fnmatch
+from enum import Enum
+from typing import Any
+
+from crabcode_core.types.config import PermissionRule, PermissionsSettings
+from crabcode_core.types.tool import PermissionBehavior, PermissionResult, Tool
+
+
+class PermissionMode(str, Enum):
+    DEFAULT = "default"
+    ACCEPT_EDITS = "acceptEdits"
+    BYPASS = "bypassPermissions"
+    PLAN = "plan"
+    DONT_ASK = "dontAsk"
+
+
+class PermissionManager:
+    """Manages tool permissions based on settings and mode."""
+
+    def __init__(
+        self,
+        settings: PermissionsSettings | None = None,
+        mode: PermissionMode = PermissionMode.DEFAULT,
+    ):
+        self.settings = settings or PermissionsSettings()
+        if self.settings.run_everything:
+            self.mode = PermissionMode.BYPASS
+        else:
+            self.mode = mode
+
+    def check(
+        self,
+        tool: Tool,
+        tool_input: dict[str, Any],
+    ) -> PermissionResult:
+        """Check if a tool can be used with the given input."""
+        if self.mode == PermissionMode.BYPASS:
+            return PermissionResult(behavior=PermissionBehavior.ALLOW)
+
+        if self.mode == PermissionMode.PLAN:
+            if not tool.is_read_only:
+                return PermissionResult(
+                    behavior=PermissionBehavior.DENY,
+                    reason="Plan mode: write operations are not allowed",
+                )
+
+        for rule in self.settings.deny:
+            if self._matches_rule(rule, tool, tool_input):
+                return PermissionResult(
+                    behavior=PermissionBehavior.DENY,
+                    reason=f"Denied by rule: {rule.tool}",
+                )
+
+        for rule in self.settings.allow:
+            if self._matches_rule(rule, tool, tool_input):
+                return PermissionResult(behavior=PermissionBehavior.ALLOW)
+
+        for rule in self.settings.ask:
+            if self._matches_rule(rule, tool, tool_input):
+                return PermissionResult(
+                    behavior=PermissionBehavior.ASK,
+                    reason=f"Requires confirmation: {rule.tool}",
+                )
+
+        if tool.is_read_only:
+            return PermissionResult(behavior=PermissionBehavior.ALLOW)
+
+        if self.mode == PermissionMode.ACCEPT_EDITS:
+            return PermissionResult(behavior=PermissionBehavior.ALLOW)
+
+        if self.mode == PermissionMode.DONT_ASK:
+            return PermissionResult(
+                behavior=PermissionBehavior.DENY,
+                reason="dontAsk mode: denied by default",
+            )
+
+        return PermissionResult(behavior=PermissionBehavior.ASK)
+
+    def add_allow_rule(self, tool_name: str) -> None:
+        """Add a runtime allow rule (for 'always allow' during a session)."""
+        self.settings.allow.append(PermissionRule(tool=tool_name))
+
+    def _matches_rule(
+        self,
+        rule: PermissionRule,
+        tool: Tool,
+        tool_input: dict[str, Any],
+    ) -> bool:
+        if rule.tool != tool.name and rule.tool != "*":
+            return False
+
+        if rule.path:
+            file_path = tool_input.get("file_path", "") or tool_input.get("path", "")
+            if file_path and not fnmatch.fnmatch(file_path, rule.path):
+                return False
+
+        if rule.command:
+            command = tool_input.get("command", "")
+            if command and not fnmatch.fnmatch(command, rule.command):
+                return False
+
+        return True

crabcode_core/prompts/context.py

@@ -0,0 +1,209 @@
+"""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
+
+
+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,
+        )
+        stdout, _ = await proc.communicate()
+        return stdout.decode().strip()
+    except Exception:
+        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:
+        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, cwd=cwd, timeout=5,
+        )
+        is_git = result.stdout.strip() == "true"
+    except Exception:
+        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, cwd=cwd, timeout=5,
+            ).stdout.strip()
+            parts.append(f"Current branch: {branch}")
+
+            status = subprocess.run(
+                ["git", "--no-optional-locks", "status", "--short"],
+                capture_output=True, text=True, cwd=cwd, timeout=5,
+            ).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, cwd=cwd, timeout=5,
+            ).stdout.strip()
+            parts.append(f"Recent commits:\n{log}")
+
+            context["gitStatus"] = "\n\n".join(parts)
+        except Exception:
+            pass
+
+    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(errors="replace"))
+        except Exception:
+            pass
+
+    crabcode_md = home / ".crabcode" / "CLAUDE.md"
+    if crabcode_md.exists():
+        try:
+            contents.append(crabcode_md.read_text(errors="replace"))
+        except Exception:
+            pass
+
+    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(errors="replace"))
+                except Exception:
+                    pass
+        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 persistent memories and format them for context injection."""
+    try:
+        from crabcode_core.tools.memory import load_all_memories
+    except ImportError:
+        return None
+
+    memories = load_all_memories(cwd)
+    if not memories:
+        return None
+
+    lines = []
+    for m in memories:
+        scope = m.pop("_scope", "?")
+        lines.append(f"- [{scope}] {m['title']}: {m['content']}")
+
+    return (
+        "The following memories were saved from previous conversations. "
+        "They may or may not be relevant to the current task.\n\n"
+        + "\n".join(lines)
+    )

crabcode_core/prompts/profile.py

@@ -0,0 +1,66 @@
+"""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
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+from crabcode_core.prompts.templates import DEFAULT_AGENT_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
+
+    # 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