vamp-cli 0.1.0__py3-none-any.whl

vamp_cli/sandbox/result.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CommandResult:
+    command: str
+
+    stdout: str
+    stderr: str
+
+    exit_code: int
+
+    timed_out: bool = False
+    truncated: bool = False

vamp_cli/sandbox/terminal.py

@@ -0,0 +1,151 @@
+import re
+from typing import Any
+
+from vamp_cli.sandbox.base import Sandbox
+from vamp_cli.sandbox.result import CommandResult
+
+
+ANSI_ESCAPE_RE = re.compile(
+    r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])"
+)
+
+def _strip_ansi(text: str) -> str:
+    return ANSI_ESCAPE_RE.sub("", text)
+
+
+def _truncate_output(
+    text: str,
+    max_chars: int = 10000,
+) -> tuple[str, bool]:
+    if len(text) <= max_chars:
+        return text, False
+
+    half = max_chars // 2
+    omitted = len(text) - max_chars
+
+    output = (
+        f"{text[:half]}\n\n"
+        f"... [Output truncated: {omitted} characters omitted] ...\n\n"
+        f"{text[-half:]}"
+    )
+
+    return output, True
+
+
+class Terminal:
+    """
+    Shell interface exposed to the agent.
+    """
+
+    def __init__(self, sandbox: Sandbox) -> None:
+        self.sandbox = sandbox
+
+    async def execute(
+        self,
+        command: str,
+        cwd: str = ".",
+        timeout: int = 60,
+        max_output_chars: int = 12000,
+    ) -> dict[str, Any]:
+        """
+        Execute a shell command inside the configured sandbox.
+
+        Args:
+            command:
+                Shell command to execute.
+
+            cwd:
+                Working directory relative to /workspace.
+
+            timeout:
+                Maximum execution time in seconds.
+
+            max_output_chars:
+                Maximum amount of combined stdout/stderr returned
+                to the model.
+
+        Returns:
+            Dictionary containing execution status and output.
+        """
+
+        if not command.strip():
+            return {
+                "success": False,
+                "command": command,
+                "exit_code": -1,
+                "error": "Command cannot be empty.",
+            }
+
+        if timeout <= 0:
+            return {
+                "success": False,
+                "command": command,
+                "exit_code": -1,
+                "error": "Timeout must be greater than zero.",
+            }
+
+        if max_output_chars <= 0:
+            return {
+                "success": False,
+                "command": command,
+                "exit_code": -1,
+                "error": "max_output_chars must be greater than zero.",
+            }
+
+        try:
+            result: CommandResult = await self.sandbox.execute(
+                command=command,
+                cwd=cwd,
+                timeout=timeout,
+            )
+
+        except ValueError as e:
+            return {
+                "success": False,
+                "command": command,
+                "exit_code": -1,
+                "error": str(e),
+            }
+
+        except Exception as e:
+            return {
+                "success": False,
+                "command": command,
+                "exit_code": -1,
+                "error": f"Failed to execute command: {str(e)}",
+            }
+
+        stdout = _strip_ansi(result.stdout or "")
+        stderr = _strip_ansi(result.stderr or "")
+
+        if stderr:
+            combined_output = (
+                stdout + "\n" + stderr
+            ).strip()
+        else:
+            combined_output = stdout.strip()
+
+        combined_output, truncated = _truncate_output(
+            combined_output,
+            max_output_chars,
+        )
+
+        if result.timed_out:
+            return {
+                "success": False,
+                "command": command,
+                "exit_code": 124,
+                "error": f"Command timed out after {timeout} seconds.",
+                "output": combined_output or "(No output)",
+                "timed_out": True,
+                "truncated": truncated,
+            }
+
+        return {
+            "success": result.exit_code == 0,
+            "command": command,
+            "exit_code": result.exit_code,
+            "output": combined_output or "(No output)",
+            "timed_out": False,
+            "truncated": truncated,
+        }

vamp_cli/tools/base.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+from abc import ABC
+from typing import Any
+import asyncio
+
+
+
+class InputSchema(BaseModel):
+    type: str
+    properties: dict[str, Any]
+    required: list[str]
+    additionalProperties: bool
+
+
+
+class Tools(ABC):
+    name: str
+    description: str
+    input_schema: InputSchema
+    parallel_safe: bool = False
+
+    def schema(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "input_schema": self.input_schema,
+        }
+
+    def to_openai_tool(self) -> dict[str, Any]:
+        """OpenAI function-calling shape accepted by ChatLiteLLM.bind_tools()."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.input_schema.model_dump(),
+            },
+        }
+
+    def run(self, **kwargs: Any) -> str:
+        raise NotImplementedError
+    
+    async def arun(self, **kwargs: Any) -> str:
+        return await asyncio.to_thread(self.run, **kwargs)

vamp_cli/tools/diagnostic.py

@@ -0,0 +1,120 @@
+import ast
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+from vamp_cli.workspace.workspace import Workspace
+from vamp_cli.utils.error_codes import Error_codes
+
+
+class DiagnosticTools:
+    def __init__(self, workspace: Workspace) -> None:
+        self.workspace = workspace
+
+    def check_file_syntax(self, file_path: str) -> dict[str, Any]:
+        """
+        syntax check for newly modified files
+        """
+        path = self.workspace.safe_path(file_path)
+        
+        if path == Error_codes.PATH_SCOPE_ERROR:
+            return {
+                "parent": path,
+                "error": Error_codes.PATH_SCOPE_ERROR.value
+            }
+        path = Path(path)
+            
+        if not path.is_file():
+            return {"valid": False, "error": f"File '{file_path}' does not exist."}
+            
+        # Python AST Check
+        if path.suffix == ".py":
+            try:
+                code = path.read_text(encoding="utf-8", errors="replace")
+                ast.parse(code, filename=str(path))
+                return {"valid": True, "diagnostics": []}
+            except SyntaxError as e:
+                return {
+                    "valid": False,
+                    "diagnostics": [{
+                        "file": file_path,
+                        "line": e.lineno,
+                        "column": e.offset,
+                        "severity": "error",
+                        "message": f"SyntaxError: {e.msg}",
+                        "source": "python_ast"
+                    }]
+                }
+
+        # JSON Parse Check
+        if path.suffix == ".json":
+            try:
+                json.loads(path.read_text(encoding="utf-8", errors="replace"))
+                return {"valid": True, "diagnostics": []}
+            except json.JSONDecodeError as e:
+                return {
+                    "valid": False,
+                    "diagnostics": [{
+                        "file": file_path,
+                        "line": e.lineno,
+                        "column": e.colno,
+                        "severity": "error",
+                        "message": f"JSONDecodeError: {e.msg}",
+                        "source": "json_parser"
+                    }]
+                }
+
+        return {"valid": True, "diagnostics": []}
+
+    def get_workspace_diagnostics(self, target_path: str = ".") -> dict[str, Any]:
+        """
+        Runs project-level linters if available in the environment and returns 
+        structured diagnostics for the LLM.
+        """
+        diagnostics = []
+        root = Path(self.workspace.root)
+
+        # Python: Fast Ruff check if installed
+        ruff_bin = subprocess.run(["which", "ruff"], capture_output=True, text=True).stdout.strip()
+        if ruff_bin:
+            cmd = ["ruff", "check", target_path, "--output-format=json"]
+            proc = subprocess.run(cmd, cwd=root, capture_output=True, text=True)
+            if proc.stdout.strip():
+                try:
+                    ruff_errors = json.loads(proc.stdout)
+                    for err in ruff_errors[:30]:  # Cap output to avoid context overflow
+                        diagnostics.append({
+                            "file": err.get("filename"),
+                            "line": err.get("location", {}).get("row"),
+                            "column": err.get("location", {}).get("column"),
+                            "severity": "error",
+                            "code": err.get("code"),
+                            "message": err.get("message"),
+                            "source": "ruff"
+                        })
+                except json.JSONDecodeError:
+                    pass
+
+        # TypeScript / JavaScript: Check for tsc if tsconfig exists
+        if (root / "tsconfig.json").is_file():
+            npx_bin = subprocess.run(["which", "npx"], capture_output=True, text=True).stdout.strip()
+            if npx_bin:
+                proc = subprocess.run(
+                    ["npx", "tsc", "--noEmit", "--pretty", "false"],
+                    cwd=root,
+                    capture_output=True,
+                    text=True
+                )
+                for line in proc.stdout.splitlines()[:20]:
+                    if "error TS" in line:
+                        diagnostics.append({
+                            "raw": line.strip(),
+                            "severity": "error",
+                            "source": "tsc"
+                        })
+
+        return {
+            "has_errors": len(diagnostics) > 0,
+            "total_diagnostics": len(diagnostics),
+            "diagnostics": diagnostics
+        }

vamp_cli/tools/execute_cmd.py

@@ -0,0 +1,16 @@
+from vamp_cli.sandbox.terminal import Terminal
+
+class ExecuteCommandTool:
+
+    def __init__(self, terminal: Terminal):
+        self.terminal = terminal
+
+    async def execute_command(
+        self,
+        command: str,
+        cwd: str = ".",
+    ):
+        return await self.terminal.execute(
+            command=command,
+            cwd=cwd,
+        )