llmcode-cli 1.0.0__py3-none-any.whl

llm_code/tools/grep_search.py

@@ -0,0 +1,144 @@
+"""GrepSearchTool — regex search across files."""
+from __future__ import annotations
+
+import pathlib
+import re
+from typing import Callable
+
+from pydantic import BaseModel
+
+from llm_code.tools.base import PermissionLevel, Tool, ToolProgress, ToolResult
+
+_MAX_MATCHES = 100
+_MAX_FILES_SCANNED = 500
+_PROGRESS_INTERVAL = 100  # emit a progress event every N files scanned
+
+
+class GrepSearchInput(BaseModel):
+    pattern: str
+    path: str = "."
+    glob: str = "**/*"
+    context: int = 0
+
+
+class GrepSearchTool(Tool):
+    @property
+    def name(self) -> str:
+        return "grep_search"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Search for a regex pattern across files in a directory. "
+            "Returns up to 100 matches across up to 500 files."
+        )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "pattern": {"type": "string", "description": "Regex pattern to search for"},
+                "path": {
+                    "type": "string",
+                    "description": "Directory to search in (default: current dir)",
+                },
+                "glob": {
+                    "type": "string",
+                    "description": "Glob filter for filenames (e.g. *.py)",
+                },
+                "context": {
+                    "type": "integer",
+                    "description": "Lines of context to include before and after each match",
+                    "default": 0,
+                },
+            },
+            "required": ["pattern"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    @property
+    def input_model(self) -> type[GrepSearchInput]:
+        return GrepSearchInput
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        return self._search(args, on_progress=None)
+
+    def execute_with_progress(
+        self,
+        args: dict,
+        on_progress: Callable[[ToolProgress], None],
+    ) -> ToolResult:
+        return self._search(args, on_progress=on_progress)
+
+    def _search(
+        self,
+        args: dict,
+        on_progress: Callable[[ToolProgress], None] | None,
+    ) -> ToolResult:
+        pattern_str: str = args["pattern"]
+        search_path = pathlib.Path(args.get("path", "."))
+        glob_filter: str = args.get("glob", "**/*")
+        context_lines: int = int(args.get("context", 0))
+
+        try:
+            regex = re.compile(pattern_str)
+        except re.error as exc:
+            return ToolResult(output=f"Invalid regex: {exc}", is_error=True)
+
+        # Collect candidate files
+        try:
+            candidates = [p for p in search_path.glob(glob_filter) if p.is_file()]
+        except Exception as exc:
+            return ToolResult(output=f"Glob error: {exc}", is_error=True)
+
+        candidates = candidates[:_MAX_FILES_SCANNED]
+        total = len(candidates)
+
+        results: list[str] = []
+        match_count = 0
+
+        for file_idx, file_path in enumerate(candidates, start=1):
+            if match_count >= _MAX_MATCHES:
+                break
+
+            # Emit progress every PROGRESS_INTERVAL files
+            if on_progress is not None and file_idx % _PROGRESS_INTERVAL == 0:
+                percent = round(file_idx / total * 100.0, 1) if total else 100.0
+                on_progress(
+                    ToolProgress(
+                        tool_name=self.name,
+                        message=f"Scanned {file_idx}/{total} files",
+                        percent=percent,
+                    )
+                )
+
+            try:
+                lines = file_path.read_text(errors="replace").splitlines()
+            except Exception:
+                continue
+
+            for i, line in enumerate(lines):
+                if match_count >= _MAX_MATCHES:
+                    break
+                if regex.search(line):
+                    # Gather context
+                    start = max(0, i - context_lines)
+                    end = min(len(lines), i + context_lines + 1)
+                    block = [f"{file_path}:{start + j + 1}: {lines[start + j]}" for j in range(end - start)]
+                    results.append("\n".join(block))
+                    match_count += 1
+
+        if not results:
+            return ToolResult(output=f"No matches found for: {pattern_str}")
+
+        return ToolResult(output="\n---\n".join(results))

llm_code/tools/ide_diagnostics.py

@@ -0,0 +1,59 @@
+"""IDEDiagnosticsTool — get diagnostics from the connected IDE."""
+from __future__ import annotations
+
+import asyncio
+
+from llm_code.ide.bridge import IDEBridge
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class IDEDiagnosticsTool(Tool):
+    def __init__(self, bridge: IDEBridge) -> None:
+        self._bridge = bridge
+
+    @property
+    def name(self) -> str:
+        return "ide_diagnostics"
+
+    @property
+    def description(self) -> str:
+        return "Get diagnostics (errors, warnings) for a file from the connected IDE."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Absolute path to the file"},
+            },
+            "required": ["path"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        path = args["path"]
+        loop = asyncio.get_event_loop()
+        diags = loop.run_until_complete(self._bridge.get_diagnostics(path))
+
+        if not diags:
+            return ToolResult(output=f"No diagnostics for {path}.")
+
+        lines: list[str] = [f"Diagnostics for {path} ({len(diags)} issues):"]
+        for d in diags:
+            line_num = d.get("line", "?")
+            severity = d.get("severity", "info")
+            message = d.get("message", "")
+            source = d.get("source", "")
+            src_str = f" [{source}]" if source else ""
+            lines.append(f"  L{line_num} {severity}: {message}{src_str}")
+
+        return ToolResult(output="\n".join(lines))

llm_code/tools/ide_open.py

@@ -0,0 +1,58 @@
+"""IDEOpenTool — ask the connected IDE to open a file."""
+from __future__ import annotations
+
+import asyncio
+
+from llm_code.ide.bridge import IDEBridge
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class IDEOpenTool(Tool):
+    def __init__(self, bridge: IDEBridge) -> None:
+        self._bridge = bridge
+
+    @property
+    def name(self) -> str:
+        return "ide_open"
+
+    @property
+    def description(self) -> str:
+        return "Open a file in the connected IDE at an optional line number."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Absolute path to the file"},
+                "line": {
+                    "type": "integer",
+                    "description": "Line number to jump to (optional)",
+                },
+            },
+            "required": ["path"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        if not self._bridge.is_connected:
+            return ToolResult(output="No IDE connected. Use /ide connect first.", is_error=True)
+
+        path = args["path"]
+        line = args.get("line")
+        loop = asyncio.get_event_loop()
+        ok = loop.run_until_complete(self._bridge.open_file(path, line=line))
+
+        if ok:
+            line_str = f" at line {line}" if line else ""
+            return ToolResult(output=f"Opened {path}{line_str} in IDE.")
+        return ToolResult(output=f"Failed to open {path} in IDE.", is_error=True)

llm_code/tools/ide_selection.py

@@ -0,0 +1,52 @@
+"""IDESelectionTool — get the current editor selection from the connected IDE."""
+from __future__ import annotations
+
+import asyncio
+
+from llm_code.ide.bridge import IDEBridge
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class IDESelectionTool(Tool):
+    def __init__(self, bridge: IDEBridge) -> None:
+        self._bridge = bridge
+
+    @property
+    def name(self) -> str:
+        return "ide_selection"
+
+    @property
+    def description(self) -> str:
+        return "Get the currently selected text in the connected IDE's editor."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {},
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        loop = asyncio.get_event_loop()
+        sel = loop.run_until_complete(self._bridge.get_selection())
+
+        if sel is None:
+            return ToolResult(output="No selection — no IDE connected or nothing selected.")
+
+        path = sel.get("path", "unknown")
+        start = sel.get("start_line", "?")
+        end = sel.get("end_line", "?")
+        text = sel.get("text", "")
+
+        header = f"Selection in {path} (lines {start}-{end}):"
+        return ToolResult(output=f"{header}\n{text}")

llm_code/tools/memory_tools.py

@@ -0,0 +1,138 @@
+"""Memory tools: store, recall, and list cross-session memory entries."""
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from llm_code.runtime.memory import MemoryStore
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+
+
+class MemoryStoreInput(BaseModel):
+    key: str
+    value: str
+
+
+class MemoryRecallInput(BaseModel):
+    key: str
+
+
+class MemoryStoreTool(Tool):
+    """Store a value in persistent memory under a given key."""
+
+    def __init__(self, memory: MemoryStore) -> None:
+        self._memory = memory
+
+    @property
+    def name(self) -> str:
+        return "memory_store"
+
+    @property
+    def description(self) -> str:
+        return "Store a value in persistent cross-session memory under a given key."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "key": {"type": "string", "description": "The memory key"},
+                "value": {"type": "string", "description": "The value to store"},
+            },
+            "required": ["key", "value"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.WORKSPACE_WRITE
+
+    @property
+    def input_model(self) -> type[MemoryStoreInput]:
+        return MemoryStoreInput
+
+    def execute(self, args: dict) -> ToolResult:
+        self._memory.store(args["key"], args["value"])
+        return ToolResult(output=f"Stored: {args['key']}")
+
+
+class MemoryRecallTool(Tool):
+    """Recall a value from persistent memory by key."""
+
+    def __init__(self, memory: MemoryStore) -> None:
+        self._memory = memory
+
+    @property
+    def name(self) -> str:
+        return "memory_recall"
+
+    @property
+    def description(self) -> str:
+        return "Recall a value from persistent cross-session memory by key."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "key": {"type": "string", "description": "The memory key to recall"},
+            },
+            "required": ["key"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    @property
+    def input_model(self) -> type[MemoryRecallInput]:
+        return MemoryRecallInput
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def is_concurrency_safe(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        value = self._memory.recall(args["key"])
+        if value is None:
+            return ToolResult(output=f"No memory found for key: {args['key']}", is_error=True)
+        return ToolResult(output=value)
+
+
+class MemoryListTool(Tool):
+    """List all keys and values stored in persistent memory."""
+
+    def __init__(self, memory: MemoryStore) -> None:
+        self._memory = memory
+
+    @property
+    def name(self) -> str:
+        return "memory_list"
+
+    @property
+    def description(self) -> str:
+        return "List all keys and values stored in persistent cross-session memory."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {},
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.READ_ONLY
+
+    def is_read_only(self, args: dict) -> bool:
+        return True
+
+    def execute(self, args: dict) -> ToolResult:
+        entries = self._memory.get_all()
+        if not entries:
+            return ToolResult(output="No memories stored.")
+        lines = [
+            f"- {k}: {v.value[:50]}..." if len(v.value) > 50 else f"- {k}: {v.value}"
+            for k, v in entries.items()
+        ]
+        return ToolResult(output="\n".join(lines))

llm_code/tools/multi_edit.py

@@ -0,0 +1,143 @@
+"""MultiEditTool — atomic multi-file search-and-replace."""
+from __future__ import annotations
+
+import pathlib
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from llm_code.runtime.file_protection import check_write
+from llm_code.tools.base import PermissionLevel, Tool, ToolResult
+from llm_code.tools.edit_file import _apply_edit
+
+if TYPE_CHECKING:
+    from llm_code.runtime.overlay import OverlayFS
+
+_MAX_EDITS = 20
+
+
+class SingleEdit(BaseModel):
+    path: str
+    old: str
+    new: str
+    replace_all: bool = False
+
+
+class MultiEditInput(BaseModel):
+    edits: list[SingleEdit]
+
+
+class MultiEditTool(Tool):
+    @property
+    def name(self) -> str:
+        return "multi_edit"
+
+    @property
+    def description(self) -> str:
+        return "Atomic multi-file search-and-replace. All edits succeed or none are applied."
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "edits": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "path": {"type": "string", "description": "Absolute path to file"},
+                            "old": {"type": "string", "description": "Text to search for"},
+                            "new": {"type": "string", "description": "Replacement text"},
+                            "replace_all": {"type": "boolean", "default": False},
+                        },
+                        "required": ["path", "old", "new"],
+                    },
+                    "minItems": 1,
+                    "maxItems": _MAX_EDITS,
+                }
+            },
+            "required": ["edits"],
+        }
+
+    @property
+    def required_permission(self) -> PermissionLevel:
+        return PermissionLevel.WORKSPACE_WRITE
+
+    @property
+    def input_model(self) -> type[MultiEditInput]:
+        return MultiEditInput
+
+    def execute(self, args: dict, overlay: "OverlayFS | None" = None) -> ToolResult:
+        edits_raw = args.get("edits", [])
+
+        if len(edits_raw) > _MAX_EDITS:
+            return ToolResult(
+                output=f"Too many edits ({len(edits_raw)}). Maximum is {_MAX_EDITS}.",
+                is_error=True,
+            )
+
+        edits = [SingleEdit(**e) if isinstance(e, dict) else e for e in edits_raw]
+
+        # Phase 1: Pre-validate (existence + write permission)
+        errors: list[str] = []
+        for i, edit in enumerate(edits):
+            path = pathlib.Path(edit.path)
+            if overlay is None:
+                if not path.exists():
+                    errors.append(f"Edit {i + 1}: File not found: {path}")
+                    continue
+            else:
+                try:
+                    overlay.read(path)
+                except FileNotFoundError:
+                    errors.append(f"Edit {i + 1}: File not found: {path}")
+                    continue
+            protection = check_write(str(path))
+            if not protection.allowed:
+                errors.append(f"Edit {i + 1}: {protection.reason}")
+        if errors:
+            return ToolResult(output="Validation failed:\n" + "\n".join(errors), is_error=True)
+
+        # Phase 2: Snapshot original contents
+        snapshots: dict[str, str] = {}
+        for edit in edits:
+            p = str(edit.path)
+            if p not in snapshots:
+                path = pathlib.Path(p)
+                if overlay is not None:
+                    snapshots[p] = overlay.read(path)
+                else:
+                    snapshots[p] = path.read_text(encoding="utf-8")
+
+        # Phase 3: Apply all edits in memory
+        applied: list[str] = []
+        current_contents: dict[str, str] = dict(snapshots)
+        for i, edit in enumerate(edits):
+            p = str(edit.path)
+            result = _apply_edit(current_contents[p], edit.old, edit.new, edit.replace_all)
+            if not result.success:
+                # Rollback: restore snapshots to real FS (overlay needs no rollback
+                # — caller discards the overlay on failure)
+                if overlay is None:
+                    for sp, sc in snapshots.items():
+                        pathlib.Path(sp).write_text(sc, encoding="utf-8")
+                return ToolResult(
+                    output=f"Edit {i + 1} failed ({edit.path}): {result.error}. All edits rolled back.",
+                    is_error=True,
+                )
+            current_contents[p] = result.new_content
+            applied.append(f"Edit {i + 1}: {edit.path} ({result.replaced} replacement(s))")
+
+        # Phase 4: Write all files
+        for p, content in current_contents.items():
+            path = pathlib.Path(p)
+            if overlay is not None:
+                overlay.write(path, content)
+            else:
+                path.write_text(content, encoding="utf-8")
+
+        return ToolResult(
+            output=f"Applied {len(edits)} edits:\n" + "\n".join(applied),
+            metadata={"edits_applied": len(edits)},
+        )