devpilot-agentic-cli 1.0.0__py3-none-any.whl

agent/tools/fs.py

@@ -0,0 +1,411 @@
+"""
+agent/tools/fs.py
+─────────────────
+Filesystem tools — read_file, write_file, list_files.
+
+Improvements over original:
+  - ReadFileTool: records reads into RepoContext for awareness tracking
+  - WriteFileTool: computes and displays a syntax-highlighted unified diff
+    before writing; records writes into RepoContext
+"""
+
+from __future__ import annotations
+
+import ast
+import difflib
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from agent.tools.base import BaseTool, ToolResult, ToolSchema
+
+if TYPE_CHECKING:
+    from agent.config import Config
+    from agent.context import RepoContext
+
+
+def _safe_path(workdir: str, path: str) -> Path:
+    """
+    Resolve path relative to workdir and ensure it doesn't escape.
+    Raises ValueError if the resolved path is outside workdir.
+    """
+    workdir_path = Path(workdir).resolve()
+    candidate = Path(path) if Path(path).is_absolute() else workdir_path / path
+    resolved = candidate.resolve()
+    if not str(resolved).startswith(str(workdir_path)):
+        raise ValueError(f"Path '{path}' escapes the working directory.")
+    return resolved
+
+
+def _unified_diff(old_text: str, new_text: str, path: str) -> str:
+    """Return a unified diff string between old and new content."""
+    old_lines = old_text.splitlines(keepends=True)
+    new_lines = new_text.splitlines(keepends=True)
+    diff = difflib.unified_diff(
+        old_lines,
+        new_lines,
+        fromfile=f"a/{path}",
+        tofile=f"b/{path}",
+        lineterm="",
+    )
+    return "".join(diff)
+
+
+def _lint_content(path: str, content: str) -> str | None:
+    """
+    Perform pre-flight syntax checks on code content before writing.
+    Returns an error message if linting fails, or None if successful.
+    """
+    suffix = Path(path).suffix.lower()
+    if suffix == ".py":
+        try:
+            ast.parse(content)
+            return None
+        except SyntaxError as e:
+            error_line = e.text.rstrip() if e.text else ""
+            marker = " " * ((e.offset or 1) - 1) + "^" if e.offset else ""
+            return f"SyntaxError in {path} at line {e.lineno}:\n{error_line}\n{marker}\n{e.msg}"
+        except Exception as e:
+            return f"Error parsing {path}: {e}"
+
+    elif suffix in {".js", ".jsx", ".ts", ".tsx"}:
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False, mode="w", encoding="utf-8") as f:
+            f.write(content)
+            tmp_path = f.name
+
+        try:
+            if suffix in {".js", ".jsx"}:
+                cmd = ["node", "--check", tmp_path]
+            else:
+                cmd = ["npx.cmd" if sys.platform == "win32" else "npx", "tsc", "--noEmit", tmp_path]
+
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode != 0:
+                error_output = result.stderr if result.stderr else result.stdout
+                error_output = error_output.replace(tmp_path, path)
+                return f"Syntax Error in {path}:\n{error_output}"
+            return None
+        except FileNotFoundError:
+            # node or npx not installed, skip gracefully
+            return None
+        except Exception as e:
+            return f"Error linting {path}: {e}"
+        finally:
+            if os.path.exists(tmp_path):
+                try:
+                    os.remove(tmp_path)
+                except OSError:
+                    pass
+
+    return None
+
+
+class ReadFileTool(BaseTool):
+    """Read any file inside the working directory."""
+
+    def __init__(self, config: "Config", context: "RepoContext | None" = None) -> None:
+        self._workdir = config.workdir
+        self._context = context
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="read_file",
+            description=(
+                "Read the contents of a file. Path is relative to the working directory. "
+                "Always read a file before modifying it. "
+                "Check the session context — if the file is already listed as read and not "
+                "marked stale, you can rely on your memory of it."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Relative path to the file (e.g. 'src/main.py').",
+                    },
+                    "start_line": {
+                        "type": "integer",
+                        "description": "Optional 1-based start line for partial reads.",
+                    },
+                    "end_line": {
+                        "type": "integer",
+                        "description": "Optional 1-based end line for partial reads.",
+                    },
+                },
+                "required": ["path"],
+            },
+            required=["path"],
+            sprint="Sprint 1",
+        )
+
+    async def execute(  # type: ignore[override]
+        self,
+        path: str,
+        start_line: int | None = None,
+        end_line: int | None = None,
+    ) -> ToolResult:
+        try:
+            safe_p = _safe_path(self._workdir, path)
+            if not safe_p.exists():
+                return ToolResult(f"Error: File not found: {path}", is_error=True)
+            if not safe_p.is_file():
+                return ToolResult(f"Error: Path is not a file: {path}", is_error=True)
+
+            content = safe_p.read_text(encoding="utf-8", errors="replace")
+
+            # Record full content into context regardless of slice
+            if self._context is not None:
+                self._context.record_read(path, content)
+
+            lines = content.splitlines()
+            start_idx = max(0, start_line - 1) if start_line else 0
+            end_idx = min(len(lines), end_line) if end_line else len(lines)
+            sliced = lines[start_idx:end_idx]
+
+            numbered = "\n".join(
+                f"{i + start_idx + 1:>4}: {line}" for i, line in enumerate(sliced)
+            )
+            return ToolResult(
+                f"Contents of {path} (lines {start_idx + 1}-{end_idx}):\n\n{numbered}",
+                is_error=False,
+            )
+        except Exception as e:
+            return ToolResult(f"Error reading {path}: {e}", is_error=True)
+
+
+class WriteFileTool(BaseTool):
+    """Write or overwrite a file. Renders a diff and asks permission before writing."""
+
+    def __init__(self, config: "Config", context: "RepoContext | None" = None) -> None:
+        self._config = config
+        self._context = context
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="write_file",
+            description=(
+                "Write content to a file, creating it if it doesn't exist or "
+                "overwriting it if it does. Always shows a diff before writing. "
+                "CRITICAL: You MUST provide the ENTIRE full file content. "
+                "NEVER use placeholders like '... existing code ...' or write short stubs. "
+                "If modifying an existing file, you must include all unmodified lines exactly as they were."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Relative path to the file.",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "Full new content of the file.",
+                    },
+                },
+                "required": ["path", "content"],
+            },
+            required=["path", "content"],
+            is_destructive=True,
+            sprint="Sprint 1",
+        )
+
+    async def execute(self, path: str, content: str) -> ToolResult:  # type: ignore[override]
+        try:
+            safe_p = _safe_path(self._config.workdir, path)
+
+            lint_error = _lint_content(path, content)
+            if lint_error:
+                return ToolResult(f"Pre-Flight Linting Failed:\n{lint_error}", is_error=True)
+
+            # Compute and display diff before writing
+            if safe_p.exists() and safe_p.is_file():
+                old_content = safe_p.read_text(encoding="utf-8", errors="replace")
+                diff = _unified_diff(old_content, content, path)
+                if diff:
+                    from agent.ui import UI
+                    UI.print_diff(path, diff)
+                else:
+                    from agent.ui import UI
+                    UI.print_info(f"No changes to {path} (content identical).")
+                    return ToolResult(f"No changes written — content of {path} is identical.", is_error=False)
+            else:
+                # New file — show full content as a creation diff
+                from agent.ui import UI
+                diff = _unified_diff("", content, path)
+                UI.print_diff(path, diff, is_new=True)
+
+            safe_p.parent.mkdir(parents=True, exist_ok=True)
+            safe_p.write_text(content, encoding="utf-8")
+
+            # Record write in context
+            if self._context is not None:
+                self._context.record_write(path, content)
+
+            return ToolResult(f"✓ Written {len(content)} characters to {path}", is_error=False)
+        except Exception as e:
+            return ToolResult(f"Error writing {path}: {e}", is_error=True)
+
+
+class EditFileTool(BaseTool):
+    """Surgically edit a file by replacing a specific block of text."""
+
+    def __init__(self, config: "Config", context: "RepoContext | None" = None) -> None:
+        self._config = config
+        self._context = context
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="edit_file",
+            description=(
+                "Edit an existing file by replacing a specific block of text. "
+                "This is much faster and cheaper than write_file for large files. "
+                "You must provide the exact old_content you wish to replace. "
+                "The old_content must be unique within the file."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Relative path to the file.",
+                    },
+                    "old_content": {
+                        "type": "string",
+                        "description": "The exact existing text block to be replaced. Must match the file exactly, including whitespace.",
+                    },
+                    "new_content": {
+                        "type": "string",
+                        "description": "The new text block that will replace old_content.",
+                    },
+                },
+                "required": ["path", "old_content", "new_content"],
+            },
+            required=["path", "old_content", "new_content"],
+            is_destructive=True,
+            sprint="Sprint 2",
+        )
+
+    async def execute(self, path: str, old_content: str, new_content: str) -> ToolResult:  # type: ignore[override]
+        try:
+            safe_p = _safe_path(self._config.workdir, path)
+            if not safe_p.exists() or not safe_p.is_file():
+                return ToolResult(f"Error: File not found or is not a file: {path}", is_error=True)
+
+            file_content = safe_p.read_text(encoding="utf-8", errors="replace")
+            
+            # Validation as requested in Phase 1
+            occurrences = file_content.count(old_content)
+            if occurrences == 0:
+                return ToolResult(
+                    f"Error: The provided old_content was not found in the file. "
+                    "Make sure you have an exact match including leading spaces and newlines.",
+                    is_error=True
+                )
+            elif occurrences > 1:
+                return ToolResult(
+                    f"Error: The provided old_content appears {occurrences} times in the file. "
+                    "Include more surrounding context to make the block unique.",
+                    is_error=True
+                )
+
+            # Perform surgical replacement
+            updated_content = file_content.replace(old_content, new_content)
+
+            lint_error = _lint_content(path, updated_content)
+            if lint_error:
+                return ToolResult(f"Pre-Flight Linting Failed:\n{lint_error}", is_error=True)
+
+            # Compute and display diff before writing
+            diff = _unified_diff(file_content, updated_content, path)
+            if diff:
+                from agent.ui import UI
+                UI.print_diff(path, diff)
+            else:
+                from agent.ui import UI
+                UI.print_info(f"No changes to {path} (content identical).")
+                return ToolResult(f"No changes written — content of {path} is identical.", is_error=False)
+
+            # Write the file
+            safe_p.write_text(updated_content, encoding="utf-8")
+
+            # Record write in context
+            if self._context is not None:
+                self._context.record_write(path, updated_content)
+
+            return ToolResult(f"✓ Edited {path} successfully.", is_error=False)
+        except Exception as e:
+            return ToolResult(f"Error editing {path}: {e}", is_error=True)
+
+
+
+class ListFilesTool(BaseTool):
+    """List files and directories in the working directory."""
+
+    def __init__(self, config: "Config", context: "RepoContext | None" = None) -> None:
+        self._workdir = config.workdir
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="list_files",
+            description=(
+                "List files and directories. Use before read or write to "
+                "confirm paths. Defaults to the working directory root."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Relative path to list (default: '.').",
+                        "default": ".",
+                    },
+                    "recursive": {
+                        "type": "boolean",
+                        "description": "If true, list all files recursively.",
+                        "default": False,
+                    },
+                },
+                "required": [],
+            },
+            sprint="Sprint 1",
+        )
+
+    async def execute(self, path: str = ".", recursive: bool = False) -> ToolResult:  # type: ignore[override]
+        try:
+            safe_p = _safe_path(self._workdir, path)
+            if not safe_p.exists():
+                return ToolResult(f"Error: Path not found: {path}", is_error=True)
+            if not safe_p.is_dir():
+                return ToolResult(f"Error: Not a directory: {path}", is_error=True)
+
+            entries: list[str] = []
+
+            def _scan(directory: Path, prefix: str = "") -> None:
+                for entry in sorted(directory.iterdir()):
+                    if entry.name.startswith(".") and entry.name != ".env":
+                        continue
+                    rel_path = prefix + entry.name
+                    if entry.is_dir():
+                        entries.append(f"  📁 {rel_path}/")
+                        if recursive:
+                            _scan(entry, prefix=rel_path + "/")
+                    else:
+                        size = entry.stat().st_size
+                        entries.append(f"  📄 {rel_path}  ({size:,} bytes)")
+
+            _scan(safe_p)
+
+            if not entries:
+                return ToolResult(f"Directory {path} is empty.", is_error=False)
+
+            return ToolResult(f"Contents of {path}:\n" + "\n".join(entries), is_error=False)
+
+        except Exception as e:
+            return ToolResult(f"Error listing {path}: {e}", is_error=True)

agent/tools/git_ops.py

@@ -0,0 +1,145 @@
+"""
+agent/tools/git_ops.py
+──────────────────────
+Git operations tools using GitPython.
+Separated into GitStatusTool and GitCommitTool for surgical operations.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agent.tools.base import BaseTool, ToolResult, ToolSchema
+
+if TYPE_CHECKING:
+    from agent.config import Config
+
+
+class GitStatusTool(BaseTool):
+    """Check git status and uncommitted changes."""
+
+    def __init__(self, config: "Config") -> None:
+        self._config = config
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="git_status",
+            description="View the current git branch, staged files, modified files, untracked files, and the current working tree diff.",
+            parameters={
+                "type": "object",
+                "properties": {},
+            },
+            sprint="Sprint 2",
+        )
+
+    async def execute(self) -> ToolResult:  # type: ignore[override]
+        try:
+            import git  # type: ignore[import]
+        except ImportError:
+            return ToolResult("Error: GitPython not installed. Run: pip install gitpython", is_error=True)
+
+        workdir = self._config.workdir
+
+        try:
+            repo = git.Repo(workdir, search_parent_directories=True)
+            changed = [item.a_path for item in repo.index.diff(None) if item.a_path is not None]
+            staged = [item.a_path for item in repo.index.diff("HEAD") if item.a_path is not None] if repo.head.is_valid() else []
+            untracked = repo.untracked_files
+            branch_name = repo.active_branch.name if not repo.head.is_detached else "DETACHED HEAD"
+            
+            diff = repo.git.diff()
+            
+            lines = [
+                f"Branch: {branch_name}",
+                f"Staged ({len(staged)}): {', '.join(staged) or 'none'}",
+                f"Modified ({len(changed)}): {', '.join(changed) or 'none'}",
+                f"Untracked ({len(untracked)}): {', '.join(untracked[:10]) or 'none'}",
+                "\n--- Unstaged Diff ---\n" + (diff[:8000] if diff else "No unstaged changes.")
+            ]
+            return ToolResult("\n".join(lines), is_error=False)
+
+        except git.InvalidGitRepositoryError:
+            return ToolResult(f"Error: {workdir} is not a git repository.", is_error=True)
+        except Exception as e:
+            return ToolResult(f"Git error: {e}", is_error=True)
+
+
+class GitCommitTool(BaseTool):
+    """Stage specific files and commit."""
+
+    def __init__(self, config: "Config") -> None:
+        self._config = config
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="git_commit",
+            description=(
+                "Stage specific files and commit them to the repository. "
+                "You must explicitly provide the paths to stage. "
+                "Returns the diff of what was actually committed."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "paths": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "List of file paths to stage (e.g., ['agent/loop.py', 'README.md']).",
+                    },
+                    "message": {
+                        "type": "string",
+                        "description": "The commit message.",
+                    },
+                },
+                "required": ["paths", "message"],
+            },
+            required=["paths", "message"],
+            is_destructive=True,
+            sprint="Sprint 2",
+        )
+
+    async def execute(self, paths: list[str], message: str) -> ToolResult:  # type: ignore[override]
+        try:
+            import git  # type: ignore[import]
+        except ImportError:
+            return ToolResult("Error: GitPython not installed.", is_error=True)
+
+        workdir = self._config.workdir
+
+        try:
+            repo = git.Repo(workdir, search_parent_directories=True)
+            
+            if not paths:
+                return ToolResult("Error: 'paths' list cannot be empty. Specify which files to commit.", is_error=True)
+            if not message:
+                return ToolResult("Error: 'message' is required for commit.", is_error=True)
+
+            # Stage the specific files
+            repo.index.add(paths)
+            
+            # Capture the staged diff before committing
+            # If repo has no commits yet, diff against empty tree
+            try:
+                if not repo.head.is_valid():
+                    # Initial commit staging diff
+                    staged_diff = "Initial commit: All staged files."
+                else:
+                    staged_diff = repo.git.diff("--staged")
+            except Exception:
+                staged_diff = "(Could not compute staged diff)"
+
+            # Commit
+            commit = repo.index.commit(message)
+            
+            res = [
+                f"✓ Committed: {commit.hexsha[:8]} — {message}",
+                f"\n--- Staged Diff ---\n{staged_diff[:8000]}"
+            ]
+            return ToolResult("\n".join(res), is_error=False)
+
+        except git.InvalidGitRepositoryError:
+            return ToolResult(f"Error: {workdir} is not a git repository.", is_error=True)
+        except Exception as e:
+            return ToolResult(f"Git error: {e}", is_error=True)