velune-cli 0.9.0__py3-none-any.whl

velune/tools/code/search.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from velune.execution.path_guard import PathGuard
+from velune.tools.base.tool import BaseTool
+
+
+class SemanticCodeSearch(BaseTool):
+    """Tool for semantic code search."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "semantic_code_search"
+
+    def get_description(self) -> str:
+        return "Search code semantically"
+
+    async def execute(
+        self,
+        query: str,
+        directory: str = ".",
+        limit: int = 10,
+    ) -> list[dict]:
+        """Search code semantically."""
+        from velune.tools.filesystem.search import GrepFiles
+
+        grep = GrepFiles(workspace=self.workspace)
+        results = await grep.execute(pattern=query, directory=directory)
+
+        return results[:limit]
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "Search query",
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Directory to search in",
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of results to return",
+                },
+            },
+            "required": ["query"],
+        }
+
+
+class SymbolSearch(BaseTool):
+    """Tool for searching symbols."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "symbol_search"
+
+    def get_description(self) -> str:
+        return "Search for symbols in code"
+
+    async def execute(
+        self,
+        symbol_name: str,
+        directory: str = ".",
+    ) -> list[dict]:
+        """Search for symbols."""
+        from velune.repository.parser import ASTParser
+        from velune.repository.scanner import FilesystemScanner
+
+        guard = PathGuard(self.workspace)
+        root_path = guard.validate(directory)
+
+        scanner = FilesystemScanner(root_path)
+        files = scanner.scan([".py"])
+
+        parser = ASTParser()
+
+        results = []
+        for file_path in files:
+            try:
+                with open(file_path, encoding="utf-8", errors="ignore") as f:
+                    code = f.read()
+            except Exception:
+                continue
+
+            symbols, _ = parser.parse(file_path, code)
+            for symbol in symbols:
+                if symbol.name == symbol_name:
+                    results.append(
+                        {
+                            "name": symbol.name,
+                            "kind": symbol.kind.value
+                            if hasattr(symbol.kind, "value")
+                            else symbol.kind,
+                            "file": str(file_path),
+                            "line": symbol.line_start,
+                        }
+                    )
+
+        return results
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "symbol_name": {
+                    "type": "string",
+                    "description": "Symbol name to search for",
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Directory to search in",
+                },
+            },
+            "required": ["symbol_name"],
+        }

velune/tools/filesystem/read.py

@@ -0,0 +1,75 @@
+"""Filesystem read tools."""
+
+from pathlib import Path
+
+from velune.execution.path_guard import validate_workspace_path
+from velune.tools.base.tool import BaseTool
+
+
+class ReadFile(BaseTool):
+    """Tool for reading file contents."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = workspace or Path.cwd()
+
+    def get_name(self) -> str:
+        return "read_file"
+
+    def get_description(self) -> str:
+        return "Read the contents of a file"
+
+    async def execute(self, file_path: str) -> str:
+        """Read file contents."""
+        path = Path(file_path)
+        validate_workspace_path(path, self.workspace, label="ReadFile")
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file to read",
+                }
+            },
+            "required": ["file_path"],
+        }
+
+
+class ReadDirectory(BaseTool):
+    """Tool for reading directory contents."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = workspace or Path.cwd()
+
+    def get_name(self) -> str:
+        return "read_directory"
+
+    def get_description(self) -> str:
+        return "List the contents of a directory"
+
+    async def execute(self, directory_path: str) -> list[str]:
+        """List directory contents."""
+        path = Path(directory_path)
+        validate_workspace_path(path, self.workspace, label="ReadDirectory")
+        if not path.exists() or not path.is_dir():
+            raise NotADirectoryError(f"Directory not found: {directory_path}")
+
+        return [item.name for item in path.iterdir()]
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "directory_path": {
+                    "type": "string",
+                    "description": "Path to the directory to list",
+                }
+            },
+            "required": ["directory_path"],
+        }

velune/tools/filesystem/search.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from velune.execution.path_guard import PathGuard
+from velune.tools.base.tool import BaseTool
+
+
+class GrepFiles(BaseTool):
+    """Tool for searching file contents."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "grep_files"
+
+    def get_description(self) -> str:
+        return "Search for text in files"
+
+    async def execute(
+        self,
+        pattern: str,
+        directory: str = ".",
+        file_pattern: str = "*",
+    ) -> list[dict]:
+        """Search for pattern in files."""
+        import re
+
+        from velune.repository.scanner import FilesystemScanner
+
+        guard = PathGuard(self.workspace)
+        root_path = guard.validate(directory)
+
+        scanner = FilesystemScanner(root_path)
+
+        extensions = None
+        if file_pattern and file_pattern != "*":
+            if file_pattern.startswith("*.") and not any(
+                c in file_pattern[2:] for c in ["*", "?", "[", "]"]
+            ):
+                extensions = [file_pattern[1:]]
+
+        files = scanner.scan(extensions)
+
+        results = []
+        regex = re.compile(pattern, re.IGNORECASE)
+
+        for file_path in files:
+            if file_pattern and not file_path.match(file_pattern):
+                continue
+
+            try:
+                with open(file_path, encoding="utf-8", errors="ignore") as f:
+                    content = f.read()
+
+                if re.search(regex, content):
+                    for match in regex.finditer(content):
+                        results.append(
+                            {
+                                "file": str(file_path),
+                                "match": match.group(),
+                                "line": content[: match.start()].count("\n") + 1,
+                            }
+                        )
+            except Exception:
+                pass
+
+        return results
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "Pattern to search for",
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Directory to search in",
+                },
+                "file_pattern": {
+                    "type": "string",
+                    "description": "File pattern to match",
+                },
+            },
+            "required": ["pattern"],
+        }
+
+
+class FindFiles(BaseTool):
+    """Tool for finding files by name."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "find_files"
+
+    def get_description(self) -> str:
+        return "Find files by name pattern"
+
+    async def execute(
+        self,
+        pattern: str,
+        directory: str = ".",
+    ) -> list[str]:
+        """Find files by pattern."""
+        import fnmatch
+
+        guard = PathGuard(self.workspace)
+        root_path = guard.validate(directory)
+
+        matches = []
+        for file_path in root_path.rglob("*"):
+            if file_path.is_file() and fnmatch.fnmatch(file_path.name, pattern):
+                matches.append(str(file_path))
+
+        return matches
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "File name pattern to match",
+                },
+                "directory": {
+                    "type": "string",
+                    "description": "Directory to search in",
+                },
+            },
+            "required": ["pattern"],
+        }

velune/tools/filesystem/write.py

@@ -0,0 +1,163 @@
+"""Filesystem write tools — all writes pass through DiffPreview for user
+approval before touching disk."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+
+from velune.execution.path_guard import validate_workspace_path
+from velune.tools.base.tool import BaseTool
+
+
+class WriteFile(BaseTool):
+    """Write content to a file, showing a diff preview first."""
+
+    def __init__(
+        self,
+        workspace: Path | None = None,
+        console: Console | None = None,
+    ) -> None:
+        self.workspace = workspace or Path.cwd()
+        self.console = console or Console()
+
+    def get_name(self) -> str:
+        return "write_file"
+
+    def get_description(self) -> str:
+        return "Write content to a file (shows diff preview before writing)"
+
+    async def execute(self, file_path: str, content: str) -> str:
+        path = Path(file_path)
+        validate_workspace_path(path, self.workspace, label="WriteFile")
+        return await self._write_file_with_preview(path, content)
+
+    async def _write_file_with_preview(
+        self,
+        path: Path,
+        content: str,
+        auto_accept: bool = False,
+    ) -> str:
+        from velune.execution.diff_preview import DiffDecision, DiffPreview
+
+        preview = DiffPreview(self.console)
+        decision = await preview.preview_and_confirm(path, content, auto_accept=auto_accept)
+        if decision == DiffDecision.ACCEPT:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+            self.console.print(f"[green]✓ Written:[/green] {path}")
+            return f"Successfully wrote to {path}"
+        self.console.print(f"[yellow]Skipped:[/yellow] {path}")
+        return f"Skipped (rejected by user): {path}"
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file to write",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "Content to write to the file",
+                },
+            },
+            "required": ["file_path", "content"],
+        }
+
+
+class CreateFile(BaseTool):
+    """Create an empty file, showing a diff preview first."""
+
+    def __init__(
+        self,
+        workspace: Path | None = None,
+        console: Console | None = None,
+    ) -> None:
+        self.workspace = workspace or Path.cwd()
+        self.console = console or Console()
+
+    def get_name(self) -> str:
+        return "create_file"
+
+    def get_description(self) -> str:
+        return "Create an empty file (shows preview before creating)"
+
+    async def execute(self, file_path: str) -> str:
+        path = Path(file_path)
+        validate_workspace_path(path, self.workspace, label="CreateFile")
+
+        from velune.execution.diff_preview import DiffDecision, DiffPreview
+
+        preview = DiffPreview(self.console)
+        # Treat create-empty as a write of empty content so the diff shows "NEW FILE"
+        decision = await preview.preview_and_confirm(path, "", auto_accept=False)
+        if decision == DiffDecision.ACCEPT:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.touch()
+            self.console.print(f"[green]✓ Created:[/green] {path}")
+            return f"Successfully created {file_path}"
+        self.console.print(f"[yellow]Skipped:[/yellow] {path}")
+        return f"Skipped (rejected by user): {path}"
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file to create",
+                },
+            },
+            "required": ["file_path"],
+        }
+
+
+class DeleteFile(BaseTool):
+    """Delete a file, showing a deletion preview first."""
+
+    def __init__(
+        self,
+        workspace: Path | None = None,
+        console: Console | None = None,
+    ) -> None:
+        self.workspace = workspace or Path.cwd()
+        self.console = console or Console()
+
+    def get_name(self) -> str:
+        return "delete_file"
+
+    def get_description(self) -> str:
+        return "Delete a file (shows preview before deleting)"
+
+    async def execute(self, file_path: str) -> str:
+        path = Path(file_path)
+        validate_workspace_path(path, self.workspace, label="DeleteFile")
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        from velune.execution.diff_preview import DiffDecision, DiffPreview
+
+        # proposed="" marks this as a deletion in FileDiff
+        preview = DiffPreview(self.console)
+        decision = await preview.preview_and_confirm(path, "", auto_accept=False)
+        if decision == DiffDecision.ACCEPT:
+            path.unlink()
+            self.console.print(f"[red]✓ Deleted:[/red] {path}")
+            return f"Successfully deleted {file_path}"
+        self.console.print(f"[yellow]Skipped:[/yellow] {path}")
+        return f"Skipped (rejected by user): {path}"
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {
+                    "type": "string",
+                    "description": "Path to the file to delete",
+                },
+            },
+            "required": ["file_path"],
+        }

velune/tools/git/history.py

@@ -0,0 +1,177 @@
+"""Git history tools — GitLog, GitDiff, GitBlame.
+
+All three tools use gitpython (``import git``) rather than raw subprocess so
+that:
+  - No shell is ever invoked.
+  - File-path arguments are validated by ``PathGuard`` before being passed to
+    git, preventing path-traversal escapes.
+  - The ``--`` path separator is always used in commands that accept file paths,
+    preventing user-supplied names from being misinterpreted as git flags or
+    refs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from velune.execution.path_guard import PathGuard
+from velune.tools.base.tool import BaseTool
+
+
+def _open_repo(path: Path):  # type: ignore[return]
+    """Open a gitpython Repo, searching parent directories for .git."""
+    try:
+        import git
+
+        return git.Repo(str(path), search_parent_directories=True)
+    except Exception as exc:
+        raise ValueError(f"Not a git repository: {path}") from exc
+
+
+class GitLog(BaseTool):
+    """Tool for viewing git commit history."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "git_log"
+
+    def get_description(self) -> str:
+        return "View git commit history"
+
+    async def execute(
+        self,
+        directory: str = ".",
+        limit: int = 10,
+    ) -> list[dict]:
+        guard = PathGuard(self.workspace)
+        safe_root = guard.validate(directory)
+        repo = _open_repo(safe_root)
+
+        def _fetch() -> list[dict]:
+            commits = []
+            for commit in repo.iter_commits(max_count=max(1, int(limit))):
+                commits.append(
+                    {
+                        "hash": commit.hexsha,
+                        "author": commit.author.name,
+                        "date": commit.authored_datetime.isoformat(),
+                        "message": commit.message.strip(),
+                    }
+                )
+            return commits
+
+        return await asyncio.to_thread(_fetch)
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "directory": {"type": "string", "description": "Git repository directory"},
+                "limit": {"type": "integer", "description": "Number of commits to show"},
+            },
+        }
+
+
+class GitDiff(BaseTool):
+    """Tool for viewing git diff."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "git_diff"
+
+    def get_description(self) -> str:
+        return "View git diff"
+
+    async def execute(
+        self,
+        directory: str = ".",
+        file_path: str | None = None,
+    ) -> str:
+        guard = PathGuard(self.workspace)
+        safe_root = guard.validate(directory)
+        repo = _open_repo(safe_root)
+
+        def _fetch() -> str:
+            if file_path:
+                # Resolve and validate the file path, then make it relative to
+                # the repo working directory so git can locate it.
+                raw = Path(file_path)
+                if not raw.is_absolute():
+                    raw = safe_root / raw
+                safe_file = guard.validate(raw)
+                rel = str(safe_file.relative_to(Path(repo.working_dir).resolve()))
+                # "--" prevents any path from being interpreted as a git ref.
+                return repo.git.diff("--", rel)
+            return repo.git.diff()
+
+        return await asyncio.to_thread(_fetch)
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "directory": {"type": "string", "description": "Git repository directory"},
+                "file_path": {"type": "string", "description": "Specific file to diff"},
+            },
+        }
+
+
+class GitBlame(BaseTool):
+    """Tool for viewing git blame."""
+
+    def __init__(self, workspace: Path | None = None) -> None:
+        self.workspace = Path(workspace).resolve() if workspace else Path.cwd().resolve()
+
+    def get_name(self) -> str:
+        return "git_blame"
+
+    def get_description(self) -> str:
+        return "View git blame for a file"
+
+    async def execute(
+        self,
+        file_path: str,
+        directory: str = ".",
+    ) -> list[dict]:
+        guard = PathGuard(self.workspace)
+        safe_root = guard.validate(directory)
+        repo = _open_repo(safe_root)
+
+        raw = Path(file_path)
+        if not raw.is_absolute():
+            raw = safe_root / raw
+        safe_file = guard.validate(raw)
+        rel = str(safe_file.relative_to(Path(repo.working_dir).resolve()))
+
+        def _fetch() -> list[dict]:
+            lines: list[dict] = []
+            for commit, line_group in repo.blame("HEAD", rel):
+                for content in line_group:
+                    lines.append(
+                        {
+                            "commit": commit.hexsha,
+                            "author": commit.author.name,
+                            "date": commit.authored_datetime.isoformat(),
+                            "content": content
+                            if isinstance(content, str)
+                            else content.decode("utf-8", errors="replace"),
+                        }
+                    )
+            return lines
+
+        return await asyncio.to_thread(_fetch)
+
+    def get_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "file_path": {"type": "string", "description": "File to blame"},
+                "directory": {"type": "string", "description": "Git repository directory"},
+            },
+            "required": ["file_path"],
+        }