vamp-cli 0.1.0__py3-none-any.whl

vamp_cli/persistence/transcript.py

@@ -0,0 +1,160 @@
+"""
+Render a chain as a human-readable transcript using prompt_toolkit.
+"""
+
+from __future__ import annotations
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import FormattedText
+
+from vamp_cli.persistence.loader import build_shadow_map
+
+
+def _truncate(text: str, limit: int = 400) -> str:
+    if len(text) <= limit:
+        return text
+    return text[:limit] + f" ... [{len(text) - limit} chars truncated]"
+
+
+def render_transcript(
+    chain: list[dict],
+    *,
+    max_content_chars: int = 400,
+    max_reasoning_chars: int = 240,
+    use_color: bool = True,
+) -> FormattedText:
+    """
+    Return the chain as prompt_toolkit formatted text.
+
+    Shadowed events are skipped; summary is shown in their place.
+    All styling is represented by prompt_toolkit style fragments rather
+    than raw ANSI escape sequences.
+    """
+    shadowed, compaction_by_uuid = build_shadow_map(chain)
+
+    # prompt_toolkit style names.
+    DIM = "dim"
+    BOLD_CYAN = "bold cyan"
+    BOLD_GREEN = "bold green"
+    GREEN = "green"
+    YELLOW = "yellow"
+    RED = "red"
+
+    out: list[tuple[str, str]] = []
+
+    def add(text: str, style: str = "") -> None:
+        if use_color and style:
+            out.append((style, text))
+        else:
+            out.append(("", text))
+
+    pending_tool_calls: dict[str, dict] = {}
+
+    for ev in chain:
+        u = ev.get("uuid")
+        t = ev.get("type")
+        d = ev.get("data") or {}
+
+        if u in shadowed:
+            continue
+
+        if t in ("session_start", "session_end"):
+            continue
+
+        if t == "mode_switch":
+            add(
+                f"-- mode: {d.get('from')} -> {d.get('to')} --",
+                DIM,
+            )
+            add("\n")
+            continue
+
+        if t == "compaction":
+            summary = (d.get("summary") or "").strip()
+            add(
+                f"-- [compacted {d.get('event_count', '?')} messages] --",
+                YELLOW,
+            )
+            add("\n")
+            if summary:
+                add("   " + summary.replace("\n", "\n   "), DIM)
+                add("\n")
+            continue
+
+        if t == "user_message":
+            content = d.get("content", "")
+            add("\n")
+            add("You:", BOLD_CYAN)
+            add("\n")
+            add(content)
+            add("\n")
+            continue
+
+        if t == "assistant_message":
+            reasoning = d.get("reasoning_content") or ""
+            content = d.get("content") or ""
+            tool_calls = d.get("tool_calls") or []
+
+            if reasoning:
+                add(
+                    "  (thinking) " + _truncate(reasoning, max_reasoning_chars),
+                    DIM,
+                )
+                add("\n")
+
+            if content:
+                add("\n")
+                add("Agent:", BOLD_GREEN)
+                add("\n")
+                add(content)
+                add("\n")
+
+            for tc in tool_calls:
+                pending_tool_calls[tc.get("id") or ""] = tc
+                name = tc.get("name") or "?"
+                add(f"  >> {name}(...)", DIM)
+                add("\n")
+            continue
+
+        if t == "interrupt_request":
+            kind = d.get("kind") or "?"
+            add(f"-- interrupt: {kind} requested --", YELLOW)
+            add("\n")
+            continue
+
+        if t == "interrupt_response":
+            verdict = "approved" if d.get("approved") else "denied"
+            add(
+                f"-- interrupt: {d.get('kind')} {verdict} --",
+                GREEN if d.get("approved") else RED,
+            )
+            add("\n")
+            continue
+
+        if t == "fork":
+            add(
+                f"-- fork: {d.get('reason', '')} -> thread {d.get('thread_id')} --",
+                DIM,
+            )
+            add("\n")
+            continue
+
+    # Remove trailing newlines
+    while out and out[0][1].strip() == "":
+        out.pop(0)
+    while out and out[-1][1].strip() == "":
+        out.pop()
+
+    return FormattedText(out)
+
+
+def print_transcript(chain: list[dict], *, header: str | None = None) -> None:
+    """wrapper for main.py."""
+    if header:
+        print_formatted_text(FormattedText([("", f"\n{header}\n")]))
+
+    body = render_transcript(chain)
+    if body:
+        print_formatted_text(body)
+    else:
+        print_formatted_text(FormattedText([("", "(no prior messages)")]))

vamp_cli/prompts/prompts.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from string import Template
+from typing import Any, Iterable
+
+log = logging.getLogger(__name__)
+
+
+# This file is at vamp_cli/prompts/prompts.py, so .parent == vamp_cli/prompts/
+PROMPTS_DIR: Path = Path(__file__).resolve().parent
+
+
+class PromptNotFoundError(FileNotFoundError):
+    """Raised when a prompt path cannot be resolved."""
+
+
+class PromptMissingVariableError(KeyError):
+    """Raised when a declared template variable is not supplied."""
+
+
+@dataclass(frozen=True)
+class Prompt:
+    name: str
+    path: Path
+    body: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def variables(self) -> list[str]:
+        return list(self.metadata.get("variables", []))
+
+    def render(self, **values: Any) -> str:
+        missing = [v for v in self.variables if v not in values]
+        if missing:
+            raise PromptMissingVariableError(
+                f"Prompt '{self.name}' missing variable(s): {', '.join(missing)}"
+            )
+        return Template(self.body).safe_substitute(values)
+
+
+class PromptStore:
+    """
+    Loads prompts from `vamp_cli/prompts/`.
+    Accepts both `"agent.md"` and `"prompts/agent.md"` as input 
+    """
+
+    _ROOT = PROMPTS_DIR
+
+    def __init__(self, *, hot_reload: bool = False) -> None:
+        self._hot_reload = hot_reload
+        self._cache: dict[Path, Prompt] = {}
+        self._mtime: dict[Path, float] = {}
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def load(self, path: str) -> str:
+        """Return the raw body of the prompt. What runtime.py calls."""
+        return self._get(path).body
+
+    def load_prompt(self, path: str) -> Prompt:
+        return self._get(path)
+
+    def render(self, path: str, **values: Any) -> str:
+        return self._get(path).render(**values)
+
+    def exists(self, path: str) -> bool:
+        try:
+            self._resolve(path)
+            return True
+        except PromptNotFoundError:
+            return False
+
+    def preload(self, paths: Iterable[str]) -> None:
+        """Fail-fast load of every referenced prompt. Call from bootstrap()."""
+        for path in paths:
+            self._get(path)
+        log.info("Preloaded %d prompt(s)", len(self._cache))
+
+    def reload(self) -> None:
+        self._cache.clear()
+        self._mtime.clear()
+
+    def list_available(self) -> list[str]:
+        """Relative paths of every .md file under vamp_cli/prompts/."""
+        return sorted(
+            p.relative_to(self._ROOT).as_posix()
+            for p in self._ROOT.rglob("*.md")
+        )
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+    def _get(self, path: str) -> Prompt:
+        resolved = self._resolve(path)
+
+        if self._hot_reload:
+            mtime = resolved.stat().st_mtime
+            if self._cache.get(resolved) is None or self._mtime.get(resolved) != mtime:
+                self._cache[resolved] = self._parse(resolved)
+                self._mtime[resolved] = mtime
+            return self._cache[resolved]
+
+        cached = self._cache.get(resolved)
+        if cached is not None:
+            return cached
+
+        prompt = self._parse(resolved)
+        self._cache[resolved] = prompt
+        self._mtime[resolved] = resolved.stat().st_mtime
+        return prompt
+
+    def _resolve(self, path: str) -> Path:
+        # Normalize: "prompts/agent.md" -> "agent.md"
+        rel = path.lstrip("/\\")
+        if rel.startswith("prompts/"):
+            rel = rel[len("prompts/"):]
+
+        candidate = (self._ROOT / rel).resolve()
+
+        # Guard against ".." escaping the prompts directory.
+        if self._ROOT not in candidate.parents and candidate != self._ROOT:
+            raise PromptNotFoundError(
+                f"Prompt path escapes vamp_cli/prompts/: {path}"
+            )
+
+        if not candidate.is_file():
+            raise PromptNotFoundError(
+                f"Prompt not found: {path} "
+                f"(looked in {self._ROOT}; available: {self.list_available()})"
+            )
+        return candidate
+
+    @staticmethod
+    def _parse(path: Path) -> Prompt:
+        raw = path.read_text(encoding="utf-8")
+        metadata: dict[str, Any] = {}
+        body = raw
+
+        if raw.startswith("---\n"):
+            end = raw.find("\n---", 4)
+            if end != -1:
+                metadata = _parse_front_matter(raw[4:end])
+                body = raw[end + 4:].lstrip("\n")
+
+        name = metadata.get("name") or path.stem
+        return Prompt(name=name, path=path, body=body, metadata=metadata)
+
+
+def _parse_front_matter(text: str) -> dict[str, Any]:
+    """Minimal `key: value` + `key:\\n  - item` parser. No pyyaml dependency."""
+    result: dict[str, Any] = {}
+    current_list: list[str] | None = None
+
+    for line in text.splitlines():
+        if not line.strip() or line.lstrip().startswith("#"):
+            continue
+        if line.startswith("  - ") and current_list is not None:
+            current_list.append(line[4:].strip())
+            continue
+        if ":" in line:
+            key, _, val = line.partition(":")
+            key, val = key.strip(), val.strip()
+            if not val:
+                current_list = []
+                result[key] = current_list
+            else:
+                current_list = None
+                result[key] = _coerce(val)
+    return result
+
+
+def _coerce(val: str) -> Any:
+    if val.lower() in ("true", "false"):
+        return val.lower() == "true"
+    try:
+        return int(val)
+    except ValueError:
+        return val.strip("'\"")

vamp_cli/sandbox/base.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from vamp_cli.sandbox.result import CommandResult
+
+class Sandbox(ABC):
+
+    @abstractmethod
+    async def start(self) -> None:
+        ...
+
+    @abstractmethod
+    async def execute(
+        self,
+        command: str,
+        cwd: str = "/workspace",
+        timeout: int = 30,
+        max_output_chars: int = 12000
+    ) -> CommandResult:
+        ...
+
+    @abstractmethod
+    async def stop(self) -> None:
+        ...

vamp_cli/sandbox/config.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class SandboxConfig:
+    image: str = "vamp-sandbox:latest"
+
+    cpu_limit: float = 2.0
+    memory_limit: str = "2g"
+    pids_limit: int = 256
+
+    command_timeout: int = 30
+
+    network_enabled: bool = True
+
+    max_output_bytes: int = 1_000_000

vamp_cli/sandbox/docker.py

@@ -0,0 +1,293 @@
+import os
+import uuid
+import time
+import asyncio
+import platform
+import posixpath
+from pathlib import PurePosixPath
+import subprocess
+from vamp_cli.sandbox.base import Sandbox
+from vamp_cli.sandbox.config import SandboxConfig
+from vamp_cli.sandbox.result import CommandResult
+from vamp_cli.workspace.workspace import Workspace
+
+
+class DockerSandbox(Sandbox):
+
+    def __init__(
+        self,
+        workspace: Workspace,
+        config: SandboxConfig,
+    ):
+        self.workspace = str(workspace.root)
+        self.config = config
+        self.container_name = f"vamp-sandbox-{uuid.uuid4().hex[:8]}"
+
+    async def start(self):
+        
+        await ensure_sandbox_image_exists(self.config.image)
+        
+        command = [
+            "docker",
+            "run",
+            "-d",
+
+            "--name",
+            self.container_name,
+
+            "--cpus",
+            str(self.config.cpu_limit),
+
+            "--memory",
+            self.config.memory_limit,
+
+            "--pids-limit",
+            str(self.config.pids_limit),
+
+            "-v",
+            f"{self.workspace}:/workspace",
+
+            "-w",
+            "/workspace",
+        ]
+        
+        # Fix Linux/WSL file ownership issues
+        if platform.system().lower() == "linux":
+            # Avoid using root inside the container so host files don't lock up
+            command.extend(["--user", f"{os.getuid()}:{os.getgid()}"])
+
+        if not self.config.network_enabled:
+            command.extend([
+                "--network",
+                "none",
+            ])
+
+        command.extend([
+            self.config.image,
+            "sleep",
+            "infinity",
+        ])
+        
+        proc = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        
+        _, stderr = await proc.communicate()
+        
+        if proc.returncode != 0:
+            raise RuntimeError(
+                f"Docker container startup failed:\n{stderr.decode(errors='replace')}"
+            )
+        
+        # try:
+        #     subprocess.run(
+        #         command,
+        #         check=True,
+        #         capture_output=True,
+        #         text=True,
+        #     )
+        # except subprocess.CalledProcessError as e:
+        #     print(f"Docker container startup failed.\nError:\n{e.stderr}")
+        
+        
+    async def execute(
+        self,
+        command: str,
+        cwd: str = "/workspace",
+        timeout: int = 30,
+        max_output_chars: int = 12000
+    ) -> CommandResult:
+
+        safe_cwd = _resolve_cwd(cwd) 
+        
+        proc = await asyncio.create_subprocess_exec(
+            "docker", "exec", "-w", safe_cwd,
+            self.container_name, "/bin/bash", "-lc", command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        
+        # docker_command = [
+        #     "docker",
+        #     "exec",
+        #     "-w",
+        #     safe_cwd,
+        #     self.container_name,
+        #     "/bin/bash",
+        #     "-lc",
+        #     command,
+        # ]
+
+        try:
+            stdout_b, stderr_b = await asyncio.wait_for(
+                proc.communicate(), timeout=timeout,
+            )
+            
+            # result = subprocess.run(
+            #     docker_command,
+            #     capture_output=True,
+            #     text=True,
+            #     timeout=timeout,
+            # )
+
+            # return CommandResult(
+            #     command=command,
+            #     stdout=result.stdout,
+            #     stderr=result.stderr,
+            #     exit_code=result.returncode,
+            # )
+        except asyncio.TimeoutError:
+            try:
+                proc.kill()
+            except:
+                pass
+            
+            try:
+                stdout_b, stderr_b = await proc.communicate()
+            except Exception:
+                stdout_b, stderr_b = b"", b""
+            
+            return CommandResult(
+                command=command,
+                stdout=stdout_b.decode(errors="replace"),
+                stderr=stderr_b.decode(errors="replace"),
+                exit_code=-1,
+                timed_out=True,
+            )
+        
+        return CommandResult(
+            command=command,
+            stdout=stdout_b.decode(errors="replace"),
+            stderr=stderr_b.decode(errors="replace"),
+            exit_code=proc.returncode or 0,
+        )
+
+        # except subprocess.TimeoutExpired as e:
+        #     return CommandResult(
+        #         command=command,
+        #         stdout=e.stdout.decode() if isinstance(e.stdout, bytes) else e.stdout or "",
+        #         stderr=e.stderr.decode() if isinstance(e.stderr, bytes) else e.stderr or "",
+        #         exit_code=-1,
+        #         timed_out=True,
+        #     )
+            
+    async def stop(self):
+        
+        proc = await asyncio.create_subprocess_exec(
+            "docker", "rm", "-f", self.container_name,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        await proc.wait()
+        
+        # subprocess.run(
+        #     [
+        #         "docker",
+        #         "rm",
+        #         "-f",
+        #         self.container_name,
+        #     ],
+        #     capture_output=True,
+        #     text=True,
+        # )
+        
+def _resolve_cwd(cwd: str) -> str:
+
+    if cwd.startswith("/"):
+        raise ValueError(
+            "cwd must be relative to workspace"
+        )
+
+    root = PurePosixPath("/workspace")
+
+    normalized = PurePosixPath(
+        posixpath.normpath(
+            str(root / cwd)
+        )
+    )
+
+    if normalized != root and root not in normalized.parents:
+        raise ValueError(
+            "cwd escapes workspace"
+        )
+
+    return str(normalized)
+
+
+async def ensure_sandbox_image_exists(image_tag: str = SandboxConfig.image):
+    """
+    Checks if the specified Docker image exists locally. 
+    If it doesn't, it dynamically creates a Dockerfile with essential 
+    coding utilities, builds the image, and cleans up the temporary file.
+    """
+    docker_file = "src/vamp_cli/sandbox/Dockerfile"
+    
+    if await _docker_image_exists(image_tag):
+        return True
+    print(f"Image '{image_tag}' not found locally. Building sandbox environment...")
+    print("Downloading and configuring development runtimes (Python, Node, Git)...")
+    
+    proc = await asyncio.create_subprocess_exec(
+        "docker", "build", "-t", image_tag, "-f", docker_file, ".",
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+    
+    assert proc.stdout is not None
+    
+    async for line in proc.stdout:
+        # Live build progress — the user sees what's happening.
+        print(line.decode(errors="replace"), end="", flush=True)
+    
+    await proc.wait()
+    
+    if proc.returncode != 0:
+        raise RuntimeError(
+            f"Failed to auto-compile the coding sandbox image (exit {proc.returncode})."
+        )
+
+    print(f"Successfully compiled sandbox environment: {image_tag}")
+    
+    return True
+    
+    # try:
+    #     # 1. Check if the image already exists in the local Docker daemon
+    #     subprocess.run(
+    #         ["docker", "image", "inspect", image_tag],
+    #         check=True, 
+    #         stdout=subprocess.DEVNULL, 
+    #         stderr=subprocess.DEVNULL
+    #     )
+    #     # Image exists, return immediately without doing anything
+    #     return True
+        
+    # except subprocess.CalledProcessError:
+    #     # 2. Image does not exist -> Start the automated build process
+    #     print(f"Image '{image_tag}' not found locally. Initiating automatic environment build...")
+        
+    #     try:  
+    #         print("Downloading and configuring development runtimes (Python, Node, Git)...")
+            
+    #         # Execute the docker build command
+    #         # (Remove stdout=subprocess.DEVNULL if you want the user to see the progress bar)
+    #         subprocess.run(
+    #             ["docker", "build", "-t", image_tag, "-f", docker_file, "."],
+    #             check=True,
+    #             stdout=subprocess.DEVNULL
+    #         )
+    #         print(f"Successfully compiled sandbox environment: {image_tag}")
+    #         return True
+            
+    #     except subprocess.CalledProcessError as e:
+    #         raise RuntimeError(f"Failed to auto-compile the coding sandbox image architecture: {e}")
+        
+        
+async def _docker_image_exists(image_tag: str) -> bool:
+    proc = await asyncio.create_subprocess_exec(
+        "docker", "image", "inspect", image_tag,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.DEVNULL,
+    )
+    return await proc.wait() == 0

vamp_cli/sandbox/manager.py

@@ -0,0 +1,31 @@
+from vamp_cli.sandbox.base import Sandbox
+from vamp_cli.sandbox.config import SandboxConfig
+from vamp_cli.sandbox.docker import DockerSandbox
+from vamp_cli.workspace.workspace import Workspace
+
+
+class SandboxManager:
+
+    def __init__(self, config: SandboxConfig):
+        self.config = config
+        self.sandbox = None
+
+    async def create(self, workspace: Workspace) -> Sandbox:
+        if self.sandbox is not None:
+            raise RuntimeError("Sandbox already exists")
+
+        self.sandbox = DockerSandbox(
+            workspace=workspace,
+            config=self.config,
+        )
+
+        await self.sandbox.start()
+
+        return self.sandbox
+
+    async def destroy(self):
+        if self.sandbox is None:
+            return
+
+        await self.sandbox.stop()
+        self.sandbox = None