crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/session/title_gen.py

@@ -0,0 +1,52 @@
+"""Async session title generation using an LLM."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+_TITLE_PROMPT = (
+    "Generate a concise title (5-8 words, no quotes) that captures the main topic "
+    "of the following conversation start. Reply with ONLY the title, nothing else."
+)
+
+
+async def generate_title(
+    first_user_message: str,
+    first_assistant_text: str,
+    api_adapter: Any,
+) -> str | None:
+    """Generate a short title for a conversation using the LLM.
+
+    Returns a title string, or None on failure.
+    """
+    if not first_user_message:
+        return None
+
+    content = f"User: {first_user_message[:500]}"
+    if first_assistant_text:
+        content += f"\n\nAssistant: {first_assistant_text[:500]}"
+
+    try:
+        from crabcode_core.types.message import create_user_message
+
+        messages = [create_user_message(content=content)]
+        response = await api_adapter.chat(
+            messages=messages,
+            system_prompt=_TITLE_PROMPT,
+            tools=[],
+            max_tokens=50,
+        )
+        title = ""
+        for block in response.content:
+            if hasattr(block, "text"):
+                title += block.text
+        title = title.strip().strip('"').strip("'").strip()
+        if title and len(title) <= 200:
+            return title
+    except Exception:
+        logger.debug("Failed to generate session title", exc_info=True)
+    return None

crabcode_core/skills/__init__.py

@@ -0,0 +1,6 @@
+"""Skills package — skill discovery, definitions, and auto-trigger matching."""
+
+from crabcode_core.skills.loader import SkillDefinition, load_skills
+from crabcode_core.skills.matcher import auto_match, resolve_chain
+
+__all__ = ["SkillDefinition", "load_skills", "auto_match", "resolve_chain"]

crabcode_core/skills/context.py

@@ -0,0 +1,23 @@
+"""Deduplicate auto-triggered skill content against the retained conversation."""
+
+import hashlib
+
+from crabcode_core.types.message import create_user_message
+
+
+def auto_skill_messages(skills, messages):
+    retained = {(message.origin, message.content) for message in messages if isinstance(message.content, str)}
+    result = []
+    for skill in skills:
+        content = f"[Auto-triggered skill: {skill.name}] {skill.description or ''}\n{skill.content}"
+        origin = "auto-skill:" + hashlib.sha256(content.encode()).hexdigest()
+        wrapped = ("<system-reminder>\nFollow this skill when relevant to the user's request:\n"
+                   + content + "\n</system-reminder>")
+        if (origin, wrapped) in retained:
+            continue
+        retained.add((origin, wrapped))
+        result.append(create_user_message(
+            content=wrapped,
+            origin=origin,
+        ))
+    return result

crabcode_core/skills/loader.py

@@ -0,0 +1,214 @@
+"""Skill loading — scans .crabcode/skills/ and .claude/skills/ directories.
+
+Search order (later entries override earlier ones with the same name):
+  1. ~/.claude/skills/<name>/SKILL.md     (user global, Claude Code compat)
+  2. $CRABCODE_HOME/skills/<name>/SKILL.md (user global, default ~/.crabcode)
+  3. .claude/skills/<name>/SKILL.md       (project, walking up to home)
+  4. .crabcode/skills/<name>/SKILL.md     (project, walking up to home, highest priority)
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.paths import get_config_home
+
+
+@dataclass
+class SkillDefinition:
+    name: str
+    description: str
+    content: str
+    source_path: str
+    when_to_use: str | None = None
+    paths: list[str] = field(default_factory=list)  # gating: only activate when user paths match
+    # Auto-trigger patterns
+    pathPatterns: list[str] = field(default_factory=list)  # glob: file paths
+    bashPatterns: list[str] = field(default_factory=list)  # regex: bash commands
+    importPatterns: list[str] = field(default_factory=list)  # regex: imports
+    chainTo: list[str] = field(default_factory=list)  # skill names to chain
+
+
+def _parse_frontmatter(text: str) -> tuple[dict[str, Any], str]:
+    """Split YAML frontmatter from Markdown body.
+
+    Returns (frontmatter_dict, body). If no frontmatter block is found,
+    returns ({}, original text).
+
+    Supports scalar values and simple list values (one-per-line or inline
+    comma-separated).  Example::
+
+        name: commit
+        pathPatterns: "src/**/*.py, tests/**/*.py"
+        bashPatterns:
+          - "git commit.*"
+        chainTo: "lint"
+    """
+    match = re.match(r"^---\s*\n(.*?)\n---\s*\n?", text, re.DOTALL)
+    if not match:
+        return {}, text
+
+    raw_yaml = match.group(1)
+    body = text[match.end():]
+
+    data: dict[str, Any] = {}
+    current_key: str | None = None
+    current_list: list[str] | None = None
+
+    for line in raw_yaml.splitlines():
+        # List item under a key: "  - value"
+        list_item = re.match(r'^\s+-\s+"?(.*?)"?\s*$', line)
+        if list_item and current_key is not None:
+            if current_list is None:
+                current_list = []
+            current_list.append(list_item.group(1))
+            continue
+
+        # Key-value pair: "key: value"
+        kv = re.match(r'^([\w][\w_-]*):\s*"?(.*?)"?\s*$', line)
+        if kv:
+            # Flush previous list
+            if current_key is not None and current_list is not None:
+                data[current_key] = current_list
+            current_key = kv.group(1)
+            val = kv.group(2)
+            if val:
+                data[current_key] = val
+                current_list = None
+            else:
+                # Key with no value — might be followed by list items
+                current_list = []
+            continue
+
+    # Flush last list
+    if current_key is not None and current_list is not None:
+        data[current_key] = current_list
+
+    return data, body.lstrip("\n")
+
+
+def _parse_list_field(value: Any) -> list[str]:
+    """Normalize a frontmatter field to a list of strings.
+
+    Accepts: list (already parsed), comma-separated string, single string, None.
+    """
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [item.strip() for item in value if item and item.strip()]
+    if isinstance(value, str):
+        return [p.strip() for p in value.split(",") if p.strip()]
+    return []
+
+
+def _load_skill_from_file(skill_file: Path) -> SkillDefinition | None:
+    """Parse a single SKILL.md file and return a SkillDefinition, or None on error."""
+    try:
+        text = skill_file.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    fm, body = _parse_frontmatter(text)
+    if not body.strip() and not fm:
+        return None
+
+    # Derive name: prefer frontmatter, fall back to parent dir name
+    name = fm.get("name") or skill_file.parent.name
+    description = fm.get("description", "")
+    when_to_use = fm.get("when_to_use") or None
+
+    raw_paths = fm.get("paths", "")
+    paths = _parse_list_field(raw_paths)
+
+    pathPatterns = _parse_list_field(fm.get("pathPatterns", ""))
+    bashPatterns = _parse_list_field(fm.get("bashPatterns", ""))
+    importPatterns = _parse_list_field(fm.get("importPatterns", ""))
+    chainTo = _parse_list_field(fm.get("chainTo", ""))
+
+    return SkillDefinition(
+        name=name,
+        description=description,
+        content=body.strip(),
+        source_path=str(skill_file),
+        when_to_use=when_to_use,
+        paths=paths,
+        pathPatterns=pathPatterns,
+        bashPatterns=bashPatterns,
+        importPatterns=importPatterns,
+        chainTo=chainTo,
+    )
+
+
+def _scan_skills_dir(base: Path) -> dict[str, SkillDefinition]:
+    """Scan a skills directory for <skill-name>/SKILL.md entries."""
+    skills: dict[str, SkillDefinition] = {}
+    if not base.is_dir():
+        return skills
+
+    for entry in sorted(base.iterdir()):
+        if not (entry.is_dir() or entry.is_symlink()):
+            continue
+        skill_file = entry / "SKILL.md"
+        if not skill_file.is_file():
+            continue
+        skill = _load_skill_from_file(skill_file)
+        if skill:
+            skills[skill.name] = skill
+
+    return skills
+
+
+def _dirs_up_to_home(cwd: str, config_dir: str) -> list[Path]:
+    """Return skill dirs from home down to cwd for a given config directory name.
+
+    Walking home → cwd means closer (more specific) directories override
+    farther ones when we merge.
+    """
+    home = Path.home()
+    current = Path(cwd).resolve()
+    dirs: list[Path] = []
+
+    path = current
+    while True:
+        # Skip the home directory itself — it's covered by the global scan
+        if path != home:
+            dirs.append(path / config_dir / "skills")
+        if path == home or path.parent == path:
+            break
+        path = path.parent
+
+    # Reverse so home-adjacent dirs come first (lower priority), cwd last (highest)
+    dirs.reverse()
+    return dirs
+
+
+def load_skills(cwd: str) -> list[SkillDefinition]:
+    """Load all skills visible from *cwd*, merged by priority.
+
+    Skills with the same name loaded later override earlier ones.
+    """
+    merged: dict[str, SkillDefinition] = {}
+    home = Path.home()
+
+    # 1. ~/.claude/skills/ — lowest priority (Claude Code global compat)
+    for name, skill in _scan_skills_dir(home / ".claude" / "skills").items():
+        merged[name] = skill
+
+    # 2. CrabCode global skills — overrides claude global
+    for name, skill in _scan_skills_dir(get_config_home() / "skills").items():
+        merged[name] = skill
+
+    # 3. Project-level .claude/skills/ dirs (home-adjacent → cwd)
+    for skills_dir in _dirs_up_to_home(cwd, ".claude"):
+        for name, skill in _scan_skills_dir(skills_dir).items():
+            merged[name] = skill
+
+    # 4. Project-level .crabcode/skills/ dirs (highest priority)
+    for skills_dir in _dirs_up_to_home(cwd, ".crabcode"):
+        for name, skill in _scan_skills_dir(skills_dir).items():
+            merged[name] = skill
+
+    return list(merged.values())

crabcode_core/skills/matcher.py

@@ -0,0 +1,203 @@
+"""Skill auto-trigger matcher.
+
+Matches user context (file paths, bash commands, import lines) against
+skill patterns and returns a list of skills to auto-invoke, in order.
+
+Pattern types:
+  - paths: glob patterns used as a gating filter — when declared, the skill
+    only activates if at least one user-mentioned file path matches; if no
+    other positive pattern (pathPatterns/bashPatterns/importPatterns) is
+    declared, paths alone also acts as the positive trigger
+  - pathPatterns: glob patterns matched against file paths the user is
+    working with (from conversation context, git status, etc.)
+  - bashPatterns: regex patterns matched against bash commands the user
+    has run or wants to run
+  - importPatterns: regex patterns matched against import/require lines
+    found in the project or mentioned by the user
+
+Chain routing:
+  - chainTo: after a skill executes, automatically queue the listed
+    skill(s) as follow-ups
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import re
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from crabcode_core.skills.loader import SkillDefinition
+
+
+def _fnmatch_any(fpath: str, patterns: list[str]) -> bool:
+    """Return True if *fpath* matches any glob in *patterns* (case-insensitive)."""
+    for pattern in patterns:
+        if fnmatch.fnmatch(fpath, pattern) or fnmatch.fnmatch(fpath.lower(), pattern.lower()):
+            return True
+    return False
+
+
+def match_path_patterns(
+    skills: list[SkillDefinition], file_paths: list[str],
+) -> list[SkillDefinition]:
+    """Return skills whose pathPatterns or paths match any of the given file paths.
+
+    ``pathPatterns`` is a positive match — the skill triggers when a user-mentioned
+    file path matches.  ``paths`` is a gating filter — when declared, the skill
+    only triggers if at least one user-mentioned file path falls under one of the
+    declared paths.  If a skill declares ``paths`` but no ``pathPatterns``, the
+    paths gate itself serves as the positive trigger (gate passed ⇒ match).
+    """
+    matched: list[SkillDefinition] = []
+    for skill in skills:
+        # If `paths` is declared, at least one user file must match it
+        paths_gate_passed = not skill.paths or any(
+            _fnmatch_any(fp, skill.paths) for fp in file_paths
+        )
+        if not paths_gate_passed:
+            continue
+        # pathPatterns positive match
+        if skill.pathPatterns:
+            if any(_fnmatch_any(fp, skill.pathPatterns) for fp in file_paths):
+                matched.append(skill)
+        elif skill.paths:
+            # paths alone acts as positive trigger when no pathPatterns declared
+            matched.append(skill)
+    return matched
+
+
+def match_bash_patterns(
+    skills: list[SkillDefinition], bash_commands: list[str],
+    file_paths: list[str] | None = None,
+) -> list[SkillDefinition]:
+    """Return skills whose bashPatterns match any of the given bash commands.
+
+    If a skill declares ``paths``, at least one user-mentioned file path must
+    match (same gating logic as ``match_path_patterns``).
+    """
+    matched: list[SkillDefinition] = []
+    for skill in skills:
+        if skill.paths and not any(_fnmatch_any(fp, skill.paths) for fp in (file_paths or [])):
+            continue
+        if not skill.bashPatterns:
+            continue
+        for pattern in skill.bashPatterns:
+            try:
+                regex = re.compile(pattern)
+            except re.error:
+                continue
+            for cmd in bash_commands:
+                if regex.search(cmd):
+                    matched.append(skill)
+                    break
+            else:
+                continue
+            break
+    return matched
+
+
+def match_import_patterns(
+    skills: list[SkillDefinition], import_lines: list[str],
+    file_paths: list[str] | None = None,
+) -> list[SkillDefinition]:
+    """Return skills whose importPatterns match any of the given import lines.
+
+    If a skill declares ``paths``, at least one user-mentioned file path must
+    match (same gating logic as ``match_path_patterns``).
+    """
+    matched: list[SkillDefinition] = []
+    for skill in skills:
+        if skill.paths and not any(_fnmatch_any(fp, skill.paths) for fp in (file_paths or [])):
+            continue
+        if not skill.importPatterns:
+            continue
+        for pattern in skill.importPatterns:
+            try:
+                regex = re.compile(pattern)
+            except re.error:
+                continue
+            for line in import_lines:
+                if regex.search(line):
+                    matched.append(skill)
+                    break
+            else:
+                continue
+            break
+    return matched
+
+
+def resolve_chain(
+    skill: SkillDefinition,
+    skill_map: dict[str, SkillDefinition],
+    visited: set[str] | None = None,
+) -> list[SkillDefinition]:
+    """Resolve the chainTo routing for a skill, returning the full chain.
+
+    Detects circular references and skips unknown skill names.
+    The source skill's name is added to visited to prevent cycles.
+    """
+    if visited is None:
+        visited = set()
+    visited.add(skill.name)
+
+    chain: list[SkillDefinition] = []
+    if not skill.chainTo:
+        return chain
+
+    for target_name in skill.chainTo:
+        if target_name in visited:
+            continue  # break circular chain
+        target = skill_map.get(target_name)
+        if not target:
+            continue
+        visited.add(target_name)
+        chain.append(target)
+        # Recursively resolve nested chains
+        chain.extend(resolve_chain(target, skill_map, visited))
+
+    return chain
+
+
+def auto_match(
+    skills: list[SkillDefinition],
+    file_paths: list[str] | None = None,
+    bash_commands: list[str] | None = None,
+    import_lines: list[str] | None = None,
+) -> list[SkillDefinition]:
+    """Match skills against context, returning ordered results with chains.
+
+    Deduplicates and preserves insertion order. Chain-following skills
+    are appended after their trigger skill.
+    """
+    file_paths = file_paths or []
+    bash_commands = bash_commands or []
+    import_lines = import_lines or []
+
+    if not skills:
+        return []
+
+    skill_map = {s.name: s for s in skills}
+    seen: set[str] = set()
+    result: list[SkillDefinition] = []
+
+    # Collect direct matches
+    direct_matches: list[SkillDefinition] = []
+    direct_matches.extend(match_path_patterns(skills, file_paths))
+    direct_matches.extend(match_bash_patterns(skills, bash_commands, file_paths=file_paths))
+    direct_matches.extend(match_import_patterns(skills, import_lines, file_paths=file_paths))
+
+    # Add matched skills + their chains, deduplicating
+    for skill in direct_matches:
+        if skill.name in seen:
+            continue
+        seen.add(skill.name)
+        result.append(skill)
+
+        # Resolve chainTo
+        for chained in resolve_chain(skill, skill_map):
+            if chained.name not in seen:
+                seen.add(chained.name)
+                result.append(chained)
+
+    return result

crabcode_core/snapshot/__init__.py

@@ -0,0 +1,21 @@
+from crabcode_core.snapshot.snapshot import (
+    FileDiff,
+    Patch,
+    SnapshotManager,
+)
+from crabcode_core.snapshot.tracker import (
+    get_session_snapshots,
+    pre_bash_snapshot,
+    restore_snapshot,
+    track_snapshot_for_file,
+)
+
+__all__ = [
+    "FileDiff",
+    "Patch",
+    "SnapshotManager",
+    "get_session_snapshots",
+    "pre_bash_snapshot",
+    "restore_snapshot",
+    "track_snapshot_for_file",
+]