crabcode 0.1.0__py3-none-any.whl

crabcode_core/tools/lint.py

@@ -0,0 +1,368 @@
+"""LintTool — read linter errors and diagnostics for specified files."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+_LINTER_CONFIGS: list[dict[str, Any]] = [
+    # ── Python ──
+    {
+        "name": "ruff",
+        "extensions": {".py", ".pyi"},
+        "cmd": ["ruff", "check", "--output-format=concise"],
+        "detect_files": {"ruff.toml", ".ruff.toml"},
+        "detect_sections": {"ruff"},
+    },
+    {
+        "name": "pylint",
+        "extensions": {".py"},
+        "cmd": ["pylint", "--output-format=text", "--score=no"],
+        "detect_files": {".pylintrc", "pylintrc"},
+        "detect_sections": {"pylint"},
+    },
+    {
+        "name": "mypy",
+        "extensions": {".py", ".pyi"},
+        "cmd": ["mypy", "--no-error-summary", "--no-pretty", "--show-column-numbers"],
+        "detect_files": {"mypy.ini", ".mypy.ini"},
+        "detect_sections": {"mypy"},
+    },
+    # ── JavaScript / TypeScript ──
+    {
+        "name": "eslint",
+        "extensions": {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"},
+        "cmd": ["eslint", "--format=unix", "--no-color"],
+        "detect_files": {
+            ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json",
+            ".eslintrc.yml", ".eslintrc.yaml", "eslint.config.js",
+            "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts",
+        },
+        "detect_sections": set(),
+    },
+    # ── Go ──
+    {
+        "name": "golangci-lint",
+        "extensions": {".go"},
+        "cmd": ["golangci-lint", "run", "--out-format=line-number"],
+        "detect_files": {".golangci.yml", ".golangci.yaml", ".golangci.toml"},
+        "detect_sections": set(),
+    },
+    # ── Rust ──
+    {
+        "name": "clippy",
+        "extensions": {".rs"},
+        "cmd": ["cargo", "clippy", "--quiet", "--message-format=short"],
+        "detect_files": {"Cargo.toml"},
+        "detect_sections": set(),
+        "project_level": True,
+        "use_stderr": True,
+    },
+    # ── C / C++ ──
+    {
+        "name": "clang-tidy",
+        "extensions": {".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx"},
+        "cmd": ["clang-tidy"],
+        "detect_files": {".clang-tidy", "compile_commands.json"},
+        "detect_sections": set(),
+        "suffix_args": ["--"],
+    },
+    {
+        "name": "cppcheck",
+        "extensions": {".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx"},
+        "cmd": ["cppcheck", "--enable=warning,style,performance", "--template=gcc", "--quiet"],
+        "detect_files": set(),
+        "detect_sections": set(),
+    },
+    # ── Java ──
+    {
+        "name": "checkstyle",
+        "extensions": {".java"},
+        "cmd": ["checkstyle"],
+        "detect_files": {"checkstyle.xml", ".checkstyle", "checkstyle-config.xml"},
+        "detect_sections": set(),
+    },
+    {
+        "name": "pmd",
+        "extensions": {".java"},
+        "cmd": ["pmd", "check", "-f", "text", "--no-progress", "-R",
+                "rulesets/java/quickstart.xml"],
+        "detect_files": {"ruleset.xml", "pmd-ruleset.xml"},
+        "detect_sections": set(),
+        "target_flag": "-d",
+    },
+]
+
+
+def _has_pyproject_section(cwd: str, section_names: set[str]) -> bool:
+    """Check if pyproject.toml has a [tool.<name>] section."""
+    if not section_names:
+        return False
+    pyproject = Path(cwd) / "pyproject.toml"
+    if not pyproject.exists():
+        return False
+    try:
+        text = pyproject.read_text(errors="replace")
+        return any(f"[tool.{s}]" in text for s in section_names)
+    except Exception:
+        return False
+
+
+def _has_config_file(cwd: str, filenames: set[str]) -> bool:
+    """Check if any of the given config files exist in cwd."""
+    for name in filenames:
+        if (Path(cwd) / name).exists():
+            return True
+    return False
+
+
+def _detect_linters(
+    paths: list[Path], cwd: str
+) -> list[dict[str, Any]]:
+    """Pick applicable linters based on file extensions and project config.
+
+    When no paths are given, scans for project config files to decide which
+    linters apply instead of guessing by extension.
+    """
+    extensions = {p.suffix for p in paths if p.suffix}
+    no_paths = not paths
+
+    matched: list[dict[str, Any]] = []
+    seen_names: set[str] = set()
+    for cfg in _LINTER_CONFIGS:
+        if cfg["name"] in seen_names:
+            continue
+        if not shutil.which(cfg["cmd"][0]):
+            continue
+
+        has_config = (
+            _has_config_file(cwd, cfg["detect_files"])
+            or _has_pyproject_section(cwd, cfg["detect_sections"])
+        )
+
+        if no_paths:
+            if not has_config:
+                continue
+        else:
+            if not extensions & cfg["extensions"]:
+                continue
+
+        matched.append({**cfg, "has_config": has_config})
+        seen_names.add(cfg["name"])
+
+    if not matched:
+        return []
+
+    configured = [m for m in matched if m["has_config"]]
+    if configured:
+        return configured
+    return matched[:1]
+
+
+async def _run_linter(
+    cfg: dict[str, Any],
+    targets: list[str],
+    cwd: str,
+    timeout: int = 60,
+) -> tuple[str, str, int]:
+    """Run a linter command and return (output, stderr, exit_code).
+
+    Respects per-linter config flags:
+      project_level  – don't append file targets
+      use_stderr     – read diagnostics from stderr instead of stdout
+      suffix_args    – extra args appended after targets (e.g. ["--"] for clang-tidy)
+      target_flag    – flag before each target (e.g. "-d" for pmd)
+    """
+    cmd = cfg["cmd"]
+    is_project_level = cfg.get("project_level", False)
+    target_flag = cfg.get("target_flag")
+    suffix_args = cfg.get("suffix_args", [])
+
+    full_cmd = list(cmd)
+    if not is_project_level:
+        if target_flag:
+            full_cmd.extend([target_flag, ",".join(targets)])
+        else:
+            full_cmd.extend(targets)
+        full_cmd.extend(suffix_args)
+
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *full_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd,
+        )
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(
+            proc.communicate(), timeout=timeout
+        )
+        stdout = stdout_bytes.decode("utf-8", errors="replace")
+        stderr = stderr_bytes.decode("utf-8", errors="replace")
+
+        if cfg.get("use_stderr"):
+            return stderr, stdout, proc.returncode or 0
+        return stdout, stderr, proc.returncode or 0
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return "", f"Linter timed out after {timeout}s", -1
+    except FileNotFoundError:
+        return "", f"Linter command not found: {cmd[0]}", -1
+
+
+class LintTool(Tool):
+    name = "Lint"
+    description = "Read linter errors and diagnostics for specified files."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": (
+                    "File or directory paths to check. "
+                    "If omitted, checks the current working directory."
+                ),
+            },
+            "linter": {
+                "type": "string",
+                "description": (
+                    "Force a specific linter (e.g., 'ruff', 'eslint', 'mypy'). "
+                    "If omitted, auto-detects based on file types and project config."
+                ),
+            },
+        },
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Read linter errors and diagnostics for specified files or directories. "
+            "Auto-detects the appropriate linter based on file types and project "
+            "configuration.\n\n"
+            "Supported linters:\n"
+            "- Python: ruff, pylint, mypy\n"
+            "- JavaScript/TypeScript: eslint\n"
+            "- Go: golangci-lint\n"
+            "- Rust: clippy (via cargo)\n"
+            "- C/C++: clang-tidy, cppcheck\n"
+            "- Java: checkstyle, pmd\n\n"
+            "Use this tool after making edits to verify you haven't introduced "
+            "errors. You can provide specific file paths or omit them to check "
+            "the whole project.\n\n"
+            "Guidelines:\n"
+            "- Only use on files you've edited or are about to edit.\n"
+            "- Results may include pre-existing errors — focus on errors in "
+            "code you changed.\n"
+            "- If no linter is installed or configured, the tool will report "
+            "that clearly.\n"
+            "- For Rust projects, clippy runs at the project level (ignores "
+            "individual file paths)."
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        raw_paths = tool_input.get("paths") or []
+        forced_linter = tool_input.get("linter")
+
+        cwd = context.cwd
+
+        resolved: list[Path] = []
+        for p in raw_paths:
+            path = Path(p)
+            if not path.is_absolute():
+                path = Path(cwd) / path
+            resolved.append(path)
+
+        missing = [str(p) for p in resolved if not p.exists()]
+        if missing:
+            return ToolResult(
+                result_for_model=f"Error: paths not found: {', '.join(missing)}",
+                is_error=True,
+            )
+
+        if forced_linter:
+            cfg = next(
+                (c for c in _LINTER_CONFIGS if c["name"] == forced_linter), None
+            )
+            if cfg is None:
+                known = ", ".join(c["name"] for c in _LINTER_CONFIGS)
+                return ToolResult(
+                    result_for_model=(
+                        f"Unknown linter '{forced_linter}'. "
+                        f"Supported: {known}"
+                    ),
+                    is_error=True,
+                )
+            if not shutil.which(cfg["cmd"][0]):
+                return ToolResult(
+                    result_for_model=(
+                        f"Linter '{forced_linter}' is not installed. "
+                        f"Install it and try again."
+                    ),
+                    is_error=True,
+                )
+            linters = [cfg]
+        else:
+            linters = _detect_linters(resolved, cwd)
+            if not linters:
+                return ToolResult(
+                    result_for_model=(
+                        "No suitable linter found. Either no linter is installed "
+                        "for the given file types, or no matching files were provided.\n"
+                        "Supported: ruff, pylint, mypy, eslint, golangci-lint, clippy, "
+                        "clang-tidy, cppcheck, checkstyle, pmd."
+                    ),
+                )
+
+        targets = [str(p) for p in resolved] if resolved else ["."]
+
+        all_output: list[str] = []
+        total_issues = 0
+
+        for linter_cfg in linters:
+            linter_name = linter_cfg["name"]
+            stdout, stderr, exit_code = await _run_linter(
+                linter_cfg, targets, cwd
+            )
+
+            if exit_code == -1:
+                all_output.append(f"[{linter_name}] Error: {stderr}")
+                continue
+
+            output = stdout.strip()
+            if not output and exit_code == 0:
+                all_output.append(f"[{linter_name}] No issues found.")
+                continue
+
+            lines = output.split("\n") if output else []
+            issue_count = len([
+                l for l in lines
+                if l.strip() and not l.startswith((" ", "\t"))
+            ])
+            total_issues += issue_count
+
+            max_chars = 50_000
+            if len(output) > max_chars:
+                output = output[:max_chars] + "\n... (truncated)"
+
+            header = f"[{linter_name}] {issue_count} issue(s):"
+            all_output.append(f"{header}\n{output}")
+
+            if stderr.strip() and exit_code != 0:
+                err_preview = stderr.strip()[:2000]
+                all_output.append(f"[{linter_name}] stderr:\n{err_preview}")
+
+        result_text = "\n\n".join(all_output)
+        return ToolResult(
+            data={"total_issues": total_issues},
+            result_for_model=result_text,
+        )

crabcode_core/tools/memory.py

@@ -0,0 +1,236 @@
+"""MemoryTool — persistent memory across conversations."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+GLOBAL_MEMORY_DIR = Path.home() / ".crabcode"
+PROJECT_MEMORY_DIR_NAME = ".crabcode"
+MEMORY_FILENAME = "memories.json"
+
+
+def _memory_path(scope: str, cwd: str) -> Path:
+    if scope == "global":
+        return GLOBAL_MEMORY_DIR / MEMORY_FILENAME
+    return Path(cwd) / PROJECT_MEMORY_DIR_NAME / MEMORY_FILENAME
+
+
+def _load_memories(path: Path) -> list[dict[str, Any]]:
+    if not path.exists():
+        return []
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(data, list):
+            return data
+    except (json.JSONDecodeError, OSError):
+        pass
+    return []
+
+
+def _save_memories(path: Path, memories: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps(memories, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+
+def load_all_memories(cwd: str) -> list[dict[str, Any]]:
+    """Load memories from both global and project scopes for context injection."""
+    results: list[dict[str, Any]] = []
+
+    global_path = _memory_path("global", cwd)
+    for m in _load_memories(global_path):
+        m["_scope"] = "global"
+        results.append(m)
+
+    project_path = _memory_path("project", cwd)
+    if project_path != global_path:
+        for m in _load_memories(project_path):
+            m["_scope"] = "project"
+            results.append(m)
+
+    return results
+
+
+class MemoryTool(Tool):
+    name = "Memory"
+    description = "Create, update, or delete persistent memories for future reference."
+    is_read_only = False
+    is_concurrency_safe = False
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["create", "update", "delete", "list"],
+                "description": "The action to perform.",
+            },
+            "title": {
+                "type": "string",
+                "description": (
+                    "Short title capturing the essence of the memory. "
+                    "Required for 'create' and 'update'."
+                ),
+            },
+            "content": {
+                "type": "string",
+                "description": (
+                    "The memory content (no more than a paragraph). "
+                    "Required for 'create' and 'update'."
+                ),
+            },
+            "memory_id": {
+                "type": "string",
+                "description": (
+                    "ID of an existing memory. "
+                    "Required for 'update' and 'delete'."
+                ),
+            },
+            "scope": {
+                "type": "string",
+                "enum": ["project", "global"],
+                "description": (
+                    "Where to store the memory. "
+                    "'project' (default) stores in the current project, "
+                    "'global' stores in ~/.crabcode/ for all projects."
+                ),
+            },
+        },
+        "required": ["action"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Create, update, or delete persistent memories that survive across "
+            "conversations. Memories are automatically loaded into context at "
+            "the start of each session.\n\n"
+            "Actions:\n"
+            "- create: Store a new memory (requires title + content)\n"
+            "- update: Modify an existing memory (requires memory_id + title + content)\n"
+            "- delete: Remove a memory (requires memory_id)\n"
+            "- list: Show all stored memories\n\n"
+            "Scope:\n"
+            "- 'project' (default): Stored in .crabcode/memories.json in the project root\n"
+            "- 'global': Stored in ~/.crabcode/memories.json, available across all projects\n\n"
+            "Guidelines:\n"
+            "- Only create memories when the user explicitly asks to remember something.\n"
+            "- If the user contradicts an existing memory, DELETE the old one rather than updating.\n"
+            "- Keep memories concise — no more than a paragraph each.\n"
+            "- Use 'project' scope for project-specific conventions and preferences.\n"
+            "- Use 'global' scope for general user preferences that apply everywhere."
+        )
+
+    async def validate_input(self, tool_input: dict[str, Any]) -> str | None:
+        action = tool_input.get("action")
+        if action not in ("create", "update", "delete", "list"):
+            return "action must be one of: create, update, delete, list"
+
+        if action == "create":
+            if not tool_input.get("title"):
+                return "title is required for 'create'"
+            if not tool_input.get("content"):
+                return "content is required for 'create'"
+
+        if action == "update":
+            if not tool_input.get("memory_id"):
+                return "memory_id is required for 'update'"
+            if not tool_input.get("title") and not tool_input.get("content"):
+                return "title or content is required for 'update'"
+
+        if action == "delete":
+            if not tool_input.get("memory_id"):
+                return "memory_id is required for 'delete'"
+
+        return None
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        action = tool_input["action"]
+        scope = tool_input.get("scope", "project")
+        path = _memory_path(scope, context.cwd)
+        memories = _load_memories(path)
+
+        if action == "create":
+            entry = {
+                "id": uuid.uuid4().hex[:12],
+                "title": tool_input["title"],
+                "content": tool_input["content"],
+                "created_at": datetime.now(timezone.utc).isoformat(),
+            }
+            memories.append(entry)
+            _save_memories(path, memories)
+            return ToolResult(
+                data=entry,
+                result_for_model=(
+                    f"Memory created (id: {entry['id']}, scope: {scope}):\n"
+                    f"  {entry['title']}"
+                ),
+            )
+
+        if action == "update":
+            memory_id = tool_input["memory_id"]
+            target = next((m for m in memories if m["id"] == memory_id), None)
+            if not target:
+                return ToolResult(
+                    result_for_model=f"Error: memory '{memory_id}' not found in {scope} scope.",
+                    is_error=True,
+                )
+            if tool_input.get("title"):
+                target["title"] = tool_input["title"]
+            if tool_input.get("content"):
+                target["content"] = tool_input["content"]
+            target["updated_at"] = datetime.now(timezone.utc).isoformat()
+            _save_memories(path, memories)
+            return ToolResult(
+                data=target,
+                result_for_model=(
+                    f"Memory updated (id: {memory_id}, scope: {scope}):\n"
+                    f"  {target['title']}"
+                ),
+            )
+
+        if action == "delete":
+            memory_id = tool_input["memory_id"]
+            before = len(memories)
+            memories = [m for m in memories if m["id"] != memory_id]
+            if len(memories) == before:
+                return ToolResult(
+                    result_for_model=f"Error: memory '{memory_id}' not found in {scope} scope.",
+                    is_error=True,
+                )
+            _save_memories(path, memories)
+            return ToolResult(
+                result_for_model=f"Memory deleted (id: {memory_id}, scope: {scope}).",
+            )
+
+        if action == "list":
+            all_memories = load_all_memories(context.cwd)
+            if not all_memories:
+                return ToolResult(
+                    result_for_model="No memories stored.",
+                )
+            lines = []
+            for m in all_memories:
+                s = m.pop("_scope", "?")
+                lines.append(
+                    f"- [{s}] {m['id']}: {m['title']}\n  {m['content']}"
+                )
+            return ToolResult(
+                data={"count": len(all_memories)},
+                result_for_model=f"{len(all_memories)} memory(ies):\n" + "\n".join(lines),
+            )
+
+        return ToolResult(
+            result_for_model=f"Unknown action: {action}",
+            is_error=True,
+        )