crabcode 0.1.0__py3-none-any.whl

crabcode_core/compact/compact.py

@@ -0,0 +1,150 @@
+"""Conversation compaction — summarizes old messages to free context space."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from crabcode_core.api.base import APIAdapter, ModelConfig
+from crabcode_core.types.message import (
+    Message,
+    MessageRole,
+    TextBlock,
+    create_user_message,
+    create_assistant_message,
+)
+
+
+COMPACT_PROMPT = """Summarize the conversation so far concisely. Focus on:
+1. What the user asked for
+2. What actions were taken (files edited, commands run, tools used)
+3. Current state of the task (what's done, what's pending)
+4. Key findings or decisions made
+
+Be concise but preserve all information needed to continue the conversation."""
+
+DEFAULT_COMPACT_THRESHOLD = 100_000
+AUTOCOMPACT_BUFFER_TOKENS = 13_000
+
+
+def estimate_token_count(messages: list[Message]) -> int:
+    """Rough token estimate: ~4 chars per token."""
+    total = 0
+    for msg in messages:
+        if isinstance(msg.content, str):
+            total += len(msg.content)
+        else:
+            for block in msg.content:
+                if isinstance(block, TextBlock):
+                    total += len(block.text)
+                elif hasattr(block, "content"):
+                    total += len(getattr(block, "content", ""))
+    return total // 4
+
+
+def should_auto_compact(
+    messages: list[Message],
+    threshold: int = DEFAULT_COMPACT_THRESHOLD,
+) -> bool:
+    """Check if conversation should be auto-compacted."""
+    if len(messages) < 4:
+        return False
+    estimated_tokens = estimate_token_count(messages)
+    return estimated_tokens > (threshold - AUTOCOMPACT_BUFFER_TOKENS)
+
+
+async def compact_conversation(
+    messages: list[Message],
+    api_adapter: APIAdapter | None = None,
+    custom_summary: str | None = None,
+) -> list[Message] | None:
+    """Compact a conversation by summarizing old messages.
+
+    Returns new message list with summary, or None if compaction failed.
+    """
+    if len(messages) < 4:
+        return None
+
+    if custom_summary:
+        summary = custom_summary
+    elif api_adapter:
+        summary = await _generate_summary(messages, api_adapter)
+    else:
+        summary = _fallback_summary(messages)
+
+    if not summary:
+        return None
+
+    summary_msg = create_user_message(content=f"[Conversation summary: {summary}]")
+    summary_msg.is_compact_summary = True
+
+    recent_count = min(4, len(messages))
+    recent = messages[-recent_count:]
+
+    return [summary_msg, *recent]
+
+
+async def _generate_summary(
+    messages: list[Message],
+    api_adapter: APIAdapter,
+) -> str:
+    """Use the API to generate a conversation summary."""
+    try:
+        conversation_text = ""
+        for msg in messages:
+            role = msg.role.value
+            text = msg.text_content[:2000] if msg.text_content else ""
+            if text:
+                conversation_text += f"{role}: {text}\n\n"
+
+        if len(conversation_text) > 50_000:
+            conversation_text = conversation_text[:50_000] + "\n... (truncated)"
+
+        summary_messages = [
+            create_user_message(
+                content=f"{COMPACT_PROMPT}\n\nConversation:\n{conversation_text}"
+            ),
+        ]
+
+        config = ModelConfig(
+            max_tokens=2048,
+            thinking_enabled=False,
+        )
+
+        summary_parts: list[str] = []
+        async for chunk in api_adapter.stream_message(
+            messages=summary_messages,
+            system=["You are a helpful assistant that summarizes conversations concisely."],
+            tools=[],
+            config=config,
+        ):
+            if chunk.type == "text":
+                summary_parts.append(chunk.text)
+
+        return "".join(summary_parts)
+
+    except Exception:
+        return _fallback_summary(messages)
+
+
+def _fallback_summary(messages: list[Message]) -> str:
+    """Generate a simple summary without API access."""
+    parts: list[str] = []
+
+    user_msgs = [m for m in messages if m.role == MessageRole.USER and m.text_content]
+    if user_msgs:
+        first = user_msgs[0].text_content[:200]
+        parts.append(f"User initially asked: {first}")
+
+    tool_names: set[str] = set()
+    for msg in messages:
+        if not isinstance(msg.content, str):
+            for block in msg.content:
+                if hasattr(block, "name"):
+                    tool_names.add(getattr(block, "name"))
+
+    if tool_names:
+        parts.append(f"Tools used: {', '.join(sorted(tool_names))}")
+
+    parts.append(f"Total messages: {len(messages)}")
+
+    return " | ".join(parts)

crabcode_core/config/__init__.py

@@ -0,0 +1,3 @@
+from crabcode_core.config.manager import ConfigManager
+
+__all__ = ["ConfigManager"]

crabcode_core/config/claudemd.py

@@ -0,0 +1,53 @@
+"""CLAUDE.md discovery — finds and loads CLAUDE.md files from the project hierarchy."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def discover_claude_md(cwd: str) -> list[dict[str, str]]:
+    """Discover all CLAUDE.md files in the project hierarchy.
+
+    Returns list of dicts with 'path' and 'content' keys,
+    ordered from most general (home) to most specific (project root).
+    """
+    results: list[dict[str, str]] = []
+    home = Path.home()
+
+    for config_dir in [".claude", ".crabcode"]:
+        home_md = home / config_dir / "CLAUDE.md"
+        if home_md.exists():
+            try:
+                content = home_md.read_text(errors="replace")
+                results.append({"path": str(home_md), "content": content})
+            except Exception:
+                pass
+
+    search_dir = Path(cwd).resolve()
+    project_files: list[dict[str, str]] = []
+
+    current = search_dir
+    while current != current.parent:
+        for name in ["CLAUDE.md", ".claude/CLAUDE.md", ".crabcode/CLAUDE.md"]:
+            candidate = current / name
+            if candidate.exists():
+                try:
+                    content = candidate.read_text(errors="replace")
+                    project_files.append({"path": str(candidate), "content": content})
+                except Exception:
+                    pass
+        if (current / ".git").exists():
+            break
+        current = current.parent
+
+    results.extend(reversed(project_files))
+    return results
+
+
+def load_claude_md_as_string(cwd: str) -> str | None:
+    """Load all CLAUDE.md files and join them into a single string."""
+    files = discover_claude_md(cwd)
+    if not files:
+        return None
+    return "\n\n---\n\n".join(f["content"] for f in files)

crabcode_core/config/manager.py

@@ -0,0 +1,152 @@
+"""Configuration manager — 5-layer settings merge with Pydantic validation."""
+
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.types.config import CrabCodeSettings
+
+
+SETTING_SOURCES = [
+    "userSettings",
+    "projectSettings",
+    "localSettings",
+    "flagSettings",
+    "policySettings",
+]
+
+
+def _merge_settings(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
+    """Deep merge two settings dicts. Arrays are concatenated and deduped."""
+    result = deepcopy(base)
+    for key, value in override.items():
+        if key in result:
+            if isinstance(result[key], list) and isinstance(value, list):
+                seen: set[str] = set()
+                merged: list[Any] = []
+                for item in result[key] + value:
+                    item_key = json.dumps(item, sort_keys=True) if isinstance(item, dict) else str(item)
+                    if item_key not in seen:
+                        seen.add(item_key)
+                        merged.append(item)
+                result[key] = merged
+            elif isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = _merge_settings(result[key], value)
+            else:
+                result[key] = deepcopy(value)
+        else:
+            result[key] = deepcopy(value)
+    return result
+
+
+class ConfigManager:
+    """Manages CrabCode settings from multiple sources.
+
+    Merge order (later overrides earlier):
+        userSettings -> projectSettings -> localSettings -> flagSettings -> policySettings
+    """
+
+    def __init__(
+        self,
+        cwd: str = ".",
+        flag_settings_path: str | None = None,
+    ):
+        self._cwd = cwd
+        self._flag_settings_path = flag_settings_path
+        self._cache: CrabCodeSettings | None = None
+
+    @property
+    def settings_file_paths(self) -> dict[str, str | None]:
+        home = Path.home() / ".crabcode"
+        project = Path(self._cwd).resolve()
+        return {
+            "userSettings": str(home / "settings.json"),
+            "projectSettings": str(project / ".crabcode" / "settings.json"),
+            "localSettings": str(project / ".crabcode" / "settings.local.json"),
+            "flagSettings": self._flag_settings_path,
+            "policySettings": str(home / "managed-settings.json"),
+        }
+
+    def load(self) -> CrabCodeSettings:
+        """Load and merge all settings layers."""
+        merged: dict[str, Any] = {}
+
+        for source in SETTING_SOURCES:
+            path_str = self.settings_file_paths.get(source)
+            if not path_str:
+                continue
+
+            path = Path(path_str)
+            if not path.exists():
+                continue
+
+            try:
+                raw = json.loads(path.read_text(errors="replace"))
+                if isinstance(raw, dict):
+                    merged = _merge_settings(merged, raw)
+            except (json.JSONDecodeError, OSError):
+                continue
+
+        try:
+            self._cache = CrabCodeSettings.model_validate(merged)
+        except Exception:
+            self._cache = CrabCodeSettings()
+
+        return self._cache
+
+    def get(self) -> CrabCodeSettings:
+        """Get cached settings or load from disk."""
+        if self._cache is None:
+            return self.load()
+        return self._cache
+
+    def reset_cache(self) -> None:
+        """Clear the cached settings."""
+        self._cache = None
+
+    def get_settings_for_source(self, source: str) -> dict[str, Any] | None:
+        """Get raw settings from a single source."""
+        path_str = self.settings_file_paths.get(source)
+        if not path_str:
+            return None
+
+        path = Path(path_str)
+        if not path.exists():
+            return None
+
+        try:
+            raw = json.loads(path.read_text(errors="replace"))
+            return raw if isinstance(raw, dict) else None
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    def update_settings(
+        self,
+        source: str,
+        settings: dict[str, Any],
+    ) -> None:
+        """Update settings for a given source."""
+        if source in ("policySettings", "flagSettings"):
+            return
+
+        path_str = self.settings_file_paths.get(source)
+        if not path_str:
+            return
+
+        path = Path(path_str)
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+        existing: dict[str, Any] = {}
+        if path.exists():
+            try:
+                existing = json.loads(path.read_text(errors="replace"))
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        merged = _merge_settings(existing, settings)
+        path.write_text(json.dumps(merged, indent=2, ensure_ascii=False) + "\n")
+
+        self.reset_cache()