cortex-llm 1.0.9__py3-none-any.whl → 1.0.11__py3-none-any.whl

cortex/tools/search.py

@@ -0,0 +1,135 @@
+"""Search utilities for repo tools."""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from cortex.tools.errors import ToolError, ValidationError
+from cortex.tools.fs_ops import RepoFS
+
+
+class RepoSearch:
+    """Search helper constrained to a repo root."""
+
+    _DEFAULT_SKIP_DIRS = {
+        ".git",
+        ".cortex",
+        ".eggs",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        ".tox",
+        ".venv",
+        "__pycache__",
+        "build",
+        "dist",
+        "node_modules",
+        "venv",
+    }
+
+    def __init__(self, repo_fs: RepoFS) -> None:
+        self.repo_fs = repo_fs
+
+    def search(self, query: str, path: str = ".", use_regex: bool = True, max_results: int = 100) -> Dict[str, List[Dict[str, object]]]:
+        if not isinstance(query, str) or not query:
+            raise ValidationError("query must be a non-empty string")
+        if isinstance(max_results, bool) or not isinstance(max_results, int):
+            raise ValidationError("max_results must be an int")
+        if max_results < 1:
+            raise ValidationError("max_results must be >= 1")
+        if not isinstance(use_regex, bool):
+            raise ValidationError("use_regex must be a bool")
+        target = self.repo_fs.resolve_path(path)
+        if not target.exists():
+            raise ValidationError("path does not exist")
+
+        if shutil.which("rg"):
+            return {"results": self._rg_search(query, target, use_regex, max_results)}
+        return {"results": self._python_search(query, target, use_regex, max_results)}
+
+    def _rg_search(self, query: str, target: Path, use_regex: bool, max_results: int) -> List[Dict[str, object]]:
+        args = ["rg", "--line-number", "--with-filename", "--no-heading"]
+        if not use_regex:
+            args.append("-F")
+        args.extend(["-e", query, str(target)])
+        result = subprocess.run(args, cwd=self.repo_fs.root, capture_output=True, text=True)
+        if result.returncode not in (0, 1):
+            raise ToolError(f"rg failed: {result.stderr.strip()}")
+        matches: List[Dict[str, object]] = []
+        for line in result.stdout.splitlines():
+            try:
+                file_path, line_no, text = line.split(":", 2)
+            except ValueError:
+                continue
+            matches.append({"path": file_path, "line": int(line_no), "text": text})
+            if len(matches) >= max_results:
+                break
+        return matches
+
+    def _python_search(self, query: str, target: Path, use_regex: bool, max_results: int) -> List[Dict[str, object]]:
+        pattern: Optional[re.Pattern[str]] = None
+        if use_regex:
+            try:
+                pattern = re.compile(query)
+            except re.error as e:
+                raise ValidationError(f"invalid regex: {e}") from e
+        results: List[Dict[str, object]] = []
+
+        if target.is_file():
+            if self._looks_binary(target):
+                return results
+            self._scan_file(target, pattern, query, results, max_results)
+            return results
+
+        skip_dirs = set(self._DEFAULT_SKIP_DIRS)
+        if target.name in skip_dirs:
+            skip_dirs.remove(target.name)
+
+        for dirpath, dirnames, filenames in os.walk(target):
+            dirnames[:] = [d for d in dirnames if d not in skip_dirs]
+            for name in filenames:
+                path = Path(dirpath) / name
+                if self._looks_binary(path):
+                    continue
+                if self._scan_file(path, pattern, query, results, max_results):
+                    return results
+        return results
+
+    def _scan_file(
+        self,
+        path: Path,
+        pattern: Optional[re.Pattern[str]],
+        query: str,
+        results: List[Dict[str, object]],
+        max_results: int,
+    ) -> bool:
+        try:
+            with path.open("r", encoding="utf-8", errors="ignore") as handle:
+                for idx, line in enumerate(handle, start=1):
+                    found = bool(pattern.search(line)) if pattern else (query in line)
+                    if found:
+                        results.append(
+                            {
+                                "path": str(path.relative_to(self.repo_fs.root)),
+                                "line": idx,
+                                "text": line.rstrip("\n"),
+                            }
+                        )
+                        if len(results) >= max_results:
+                            return True
+        except OSError:
+            return False
+        return False
+
+    def _looks_binary(self, path: Path, sniff_bytes: int = 4096) -> bool:
+        try:
+            with path.open("rb") as handle:
+                chunk = handle.read(sniff_bytes)
+        except OSError:
+            return True
+        return b"\x00" in chunk

cortex/tools/tool_runner.py

@@ -0,0 +1,204 @@
+"""Tool runner and specifications for Cortex."""
+
+from __future__ import annotations
+
+import difflib
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from cortex.tools.errors import ToolError, ValidationError
+from cortex.tools.fs_ops import RepoFS
+from cortex.tools.search import RepoSearch
+
+
+ConfirmCallback = Callable[[str], bool]
+
+
+class ToolRunner:
+    """Execute tool calls with safety checks."""
+
+    def __init__(self, root: Path, confirm_callback: Optional[ConfirmCallback] = None) -> None:
+        self.fs = RepoFS(root)
+        self.search = RepoSearch(self.fs)
+        self.confirm_callback = confirm_callback
+
+    def set_confirm_callback(self, callback: ConfirmCallback) -> None:
+        self.confirm_callback = callback
+
+    def tool_spec(self) -> Dict[str, Any]:
+        return {
+            "list_dir": {"args": {"path": "string", "recursive": "bool", "max_depth": "int", "max_entries": "int"}},
+            "read_file": {"args": {"path": "string", "start_line": "int", "end_line": "int", "max_bytes": "int"}},
+            "search": {"args": {"query": "string", "path": "string", "use_regex": "bool", "max_results": "int"}},
+            "write_file": {"args": {"path": "string", "content": "string", "expected_sha256": "string"}},
+            "create_file": {"args": {"path": "string", "content": "string", "overwrite": "bool"}},
+            "delete_file": {"args": {"path": "string"}},
+            "replace_in_file": {"args": {"path": "string", "old": "string", "new": "string", "expected_replacements": "int"}},
+            "insert_after": {"args": {"path": "string", "anchor": "string", "content": "string", "expected_matches": "int"}},
+            "insert_before": {"args": {"path": "string", "anchor": "string", "content": "string", "expected_matches": "int"}},
+        }
+
+    def tool_instructions(self) -> str:
+        spec = json.dumps(self.tool_spec(), ensure_ascii=True, indent=2)
+        repo_root = str(self.fs.root)
+        return (
+            "[CORTEX_TOOL_INSTRUCTIONS v3]\n"
+            "You have access to repo-scoped file tools.\n"
+            "Use tools ONLY when the user asks for repo file operations or when repo data is required to answer.\n"
+            "Never use tools for general conversation, creative writing, or questions unrelated to the repo.\n"
+            "If a tool is required, respond ONLY with a <tool_calls> JSON block.\n"
+            "Do not include any other text when calling tools.\n"
+            f"Repo root: {repo_root}\n"
+            "All paths must be relative to the repo root (use '.' for root). Do not use absolute paths or ~.\n"
+            "For create/write/replace/insert/delete, paths must be file paths (not '.' or directories).\n"
+            "If you are unsure about paths, call list_dir with path '.' first.\n"
+            "Format:\n"
+            "<tool_calls>{\"calls\":[{\"id\":\"call_1\",\"name\":\"tool_name\",\"arguments\":{...}}]}</tool_calls>\n"
+            "Available tools:\n"
+            f"{spec}"
+        )
+
+    def run_calls(self, calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        results: List[Dict[str, Any]] = []
+        for call in calls:
+            call_id = call.get("id", "unknown")
+            name = call.get("name")
+            args = call.get("arguments") or {}
+            try:
+                if name == "list_dir":
+                    result = self.fs.list_dir(**args)
+                elif name == "read_file":
+                    result = self.fs.read_text(**args)
+                elif name == "search":
+                    result = self.search.search(**args)
+                elif name == "write_file":
+                    result = self._write_file(**args)
+                elif name == "create_file":
+                    result = self._create_file(**args)
+                elif name == "delete_file":
+                    result = self._delete_file(**args)
+                elif name == "replace_in_file":
+                    result = self._replace_in_file(**args)
+                elif name == "insert_after":
+                    result = self._insert_relative(after=True, **args)
+                elif name == "insert_before":
+                    result = self._insert_relative(after=False, **args)
+                else:
+                    raise ValidationError(f"unknown tool: {name}")
+                results.append({"id": call_id, "name": name, "ok": True, "result": result, "error": None})
+            except Exception as e:
+                results.append({"id": call_id, "name": name, "ok": False, "result": None, "error": str(e)})
+        return results
+
+    def _write_file(self, path: str, content: str, expected_sha256: Optional[str] = None) -> Dict[str, Any]:
+        self._validate_str("content", content)
+        expected_sha256 = self._validate_sha256(expected_sha256)
+        before = self.fs.read_full_text(path)
+        self._confirm_change(path, before, content, "write")
+        return self.fs.write_text(path, content, expected_sha256=expected_sha256)
+
+    def _create_file(self, path: str, content: str, overwrite: bool = False) -> Dict[str, Any]:
+        target = self._validate_create_path(path)
+        self._validate_str("content", content)
+        self._validate_bool("overwrite", overwrite)
+        if target.exists() and not overwrite:
+            raise ValidationError("path already exists")
+        before = self.fs.read_full_text(path) if target.exists() else ""
+        self._confirm_change(path, before, content, "create")
+        return self.fs.create_text(path, content, overwrite=overwrite)
+
+    def _delete_file(self, path: str) -> Dict[str, Any]:
+        target = self.fs.resolve_path(path)
+        if not target.exists() or not target.is_file():
+            raise ValidationError("path does not exist or is not a file")
+        if not self.fs.is_git_tracked(target):
+            raise ToolError("delete blocked: file is not tracked by git")
+        before = self.fs.read_full_text(path)
+        self._confirm_change(path, before, "", "delete")
+        return self.fs.delete_file(path)
+
+    def _replace_in_file(self, path: str, old: str, new: str, expected_replacements: int = 1) -> Dict[str, Any]:
+        self._validate_non_empty_str("old", old)
+        self._validate_str("new", new)
+        expected_replacements = self._validate_int("expected_replacements", expected_replacements, minimum=1)
+        content = self.fs.read_full_text(path)
+        count = content.count(old)
+        if count != expected_replacements:
+            raise ToolError(f"expected {expected_replacements} replacements, found {count}")
+        updated = content.replace(old, new)
+        self._confirm_change(path, content, updated, "replace")
+        return self.fs.write_text(path, updated)
+
+    def _insert_relative(self, path: str, anchor: str, content: str, expected_matches: int = 1, after: bool = True) -> Dict[str, Any]:
+        self._validate_non_empty_str("anchor", anchor)
+        self._validate_str("content", content)
+        expected_matches = self._validate_int("expected_matches", expected_matches, minimum=1)
+        original = self.fs.read_full_text(path)
+        count = original.count(anchor)
+        if count != expected_matches:
+            raise ToolError(f"expected {expected_matches} matches, found {count}")
+        insert_text = anchor + content if after else content + anchor
+        updated = original.replace(anchor, insert_text, count if expected_matches > 1 else 1)
+        self._confirm_change(path, original, updated, "insert")
+        return self.fs.write_text(path, updated)
+
+    def _confirm_change(self, path: str, before: str, after: str, action: str) -> None:
+        if self.confirm_callback is None:
+            raise ToolError("confirmation required but no callback configured")
+        if before == after:
+            raise ToolError("no changes to apply")
+        diff = "\n".join(
+            difflib.unified_diff(
+                before.splitlines(),
+                after.splitlines(),
+                fromfile=f"{path} (before)",
+                tofile=f"{path} (after)",
+                lineterm="",
+            )
+        )
+        prompt = f"Apply {action} to {path}?\n{diff}\n"
+        if not self.confirm_callback(prompt):
+            raise ToolError("change declined by user")
+
+    def _validate_str(self, name: str, value: object) -> None:
+        if not isinstance(value, str):
+            raise ValidationError(f"{name} must be a string")
+
+    def _validate_non_empty_str(self, name: str, value: object) -> None:
+        if not isinstance(value, str) or not value:
+            raise ValidationError(f"{name} must be a non-empty string")
+
+    def _validate_bool(self, name: str, value: object) -> None:
+        if not isinstance(value, bool):
+            raise ValidationError(f"{name} must be a bool")
+
+    def _validate_int(self, name: str, value: object, minimum: int = 0) -> int:
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise ValidationError(f"{name} must be an int")
+        if value < minimum:
+            raise ValidationError(f"{name} must be >= {minimum}")
+        return value
+
+    def _validate_sha256(self, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValidationError("expected_sha256 must be a string")
+        normalized = value.lower()
+        if not re.fullmatch(r"[0-9a-f]{64}", normalized):
+            raise ValidationError("expected_sha256 must be a 64-character hex string")
+        return normalized
+
+    def _validate_create_path(self, path: str) -> Path:
+        self._validate_non_empty_str("path", path)
+        if path in {".", ""}:
+            raise ValidationError("path must be a file path, not a directory")
+        if path.endswith(("/", os.sep)):
+            raise ValidationError("path must be a file path, not a directory")
+        target = self.fs.resolve_path(path)
+        if target.exists() and target.is_dir():
+            raise ValidationError("path already exists and is a directory")
+        return target

cortex/ui/box_rendering.py

@@ -0,0 +1,97 @@
+"""Box rendering utilities for CLI."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import List, Optional
+
+
+def get_visible_length(text: str) -> int:
+    """Get visible length of text, ignoring ANSI escape codes and accounting for wide characters."""
+    ansi_escape = re.compile(r"\x1b\[[0-9;]*m")
+    visible_text = ansi_escape.sub("", text)
+
+    display_width = 0
+    for char in visible_text:
+        width = unicodedata.east_asian_width(char)
+        if width in ("W", "F"):
+            display_width += 2
+        elif width == "A" and char in "●○":
+            display_width += 1
+        else:
+            display_width += 1
+
+    return display_width
+
+
+def print_box_line(content: str, width: int, align: str = "left") -> None:
+    """Print a single line in a box with proper padding."""
+    visible_len = get_visible_length(content)
+    padding = width - visible_len - 2
+
+    if align == "center":
+        left_pad = padding // 2
+        right_pad = padding - left_pad
+        print(f"│{' ' * left_pad}{content}{' ' * right_pad}│")
+    else:
+        print(f"│{content}{' ' * padding}│")
+
+
+def print_box_header(title: str, width: int) -> None:
+    """Print a box header with title."""
+    if title:
+        title_with_color = f" \033[96m{title}\033[0m "
+        visible_len = get_visible_length(title_with_color)
+        padding = width - visible_len - 3
+        print(f"╭─{title_with_color}" + "─" * padding + "╮")
+    else:
+        print("╭" + "─" * (width - 2) + "╮")
+
+
+def print_box_footer(width: int) -> None:
+    """Print a box footer."""
+    print("╰" + "─" * (width - 2) + "╯")
+
+
+def print_box_separator(width: int) -> None:
+    """Print a separator line inside a box."""
+    print("├" + "─" * (width - 2) + "┤")
+
+
+def print_empty_line(width: int) -> None:
+    """Print an empty line inside a box."""
+    print("│" + " " * (width - 2) + "│")
+
+
+def create_box(
+    lines: List[str],
+    *,
+    width: Optional[int],
+    terminal_width: int,
+) -> str:
+    """Create a box with Unicode borders."""
+    if width is None:
+        width = min(terminal_width - 2, 80)
+
+    top_left = "╭"
+    top_right = "╮"
+    bottom_left = "╰"
+    bottom_right = "╯"
+    horizontal = "─"
+    vertical = "│"
+
+    inner_width = width - 4
+
+    result = []
+    result.append(top_left + horizontal * (width - 2) + top_right)
+
+    for line in lines:
+        visible_len = get_visible_length(line)
+        padding_needed = inner_width - visible_len
+        padded = f" {line}{' ' * padding_needed} "
+        result.append(vertical + padded + vertical)
+
+    result.append(bottom_left + horizontal * (width - 2) + bottom_right)
+
+    return "\n".join(result)