safe-agent-cli 0.2.0__py2.py3-none-any.whl

safe_agent/__init__.py

@@ -0,0 +1,12 @@
+"""
+Safe Agent - An AI coding agent you can actually trust.
+
+Uses impact-preview to show exactly what will change before any action executes.
+"""
+
+__version__ = "0.2.0"
+
+from safe_agent.agent import SafeAgent
+from safe_agent.cli import main
+
+__all__ = ["SafeAgent", "main", "__version__"]

safe_agent/agent.py

@@ -0,0 +1,309 @@
+"""
+Safe Agent - Core agent logic with impact preview integration.
+"""
+
+import os
+from pathlib import Path
+from typing import Any
+
+import anthropic
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.syntax import Syntax
+from rich.table import Table
+
+# Import impact-preview components (package is impact-preview, module is agent_polis)
+from agent_polis.actions.analyzer import ImpactAnalyzer
+from agent_polis.actions.diff import format_diff_plain
+from agent_polis.actions.models import ActionRequest, ActionType, RiskLevel
+
+console = Console()
+
+
+class SafeAgent:
+    """
+    An AI coding agent with built-in impact preview.
+    
+    Every file operation is analyzed and previewed before execution.
+    """
+    
+    def __init__(
+        self,
+        model: str = "claude-sonnet-4-20250514",
+        auto_approve_low_risk: bool = False,
+        dry_run: bool = False,
+        working_directory: str | None = None,
+    ):
+        self.model = model
+        self.auto_approve_low_risk = auto_approve_low_risk
+        self.dry_run = dry_run
+        self.working_directory = working_directory or os.getcwd()
+        
+        self.client = anthropic.Anthropic()
+        self.analyzer = ImpactAnalyzer(working_directory=self.working_directory)
+        
+        # Track changes for summary
+        self.changes_made: list[dict] = []
+        self.changes_rejected: list[dict] = []
+    
+    async def run(self, task: str) -> dict[str, Any]:
+        """
+        Execute a coding task with impact preview on all file operations.
+        """
+        console.print("\n[bold]🤖 Planning changes...[/bold]\n")
+        
+        # Get Claude to plan the changes
+        plan = await self._plan_changes(task)
+        
+        if not plan.get("changes"):
+            console.print("[yellow]No file changes needed for this task.[/yellow]")
+            return {"success": True, "changes": []}
+        
+        # Show plan
+        self._show_plan(plan)
+        
+        # Execute each change with preview
+        for i, change in enumerate(plan["changes"], 1):
+            console.print(f"\n[bold]Step {i}/{len(plan['changes'])}[/bold]")
+            
+            approved = await self._preview_and_approve(change)
+            
+            if approved and not self.dry_run:
+                self._execute_change(change)
+                self.changes_made.append(change)
+            elif not approved:
+                self.changes_rejected.append(change)
+                console.print("[yellow]Skipped[/yellow]")
+        
+        # Summary
+        self._show_summary()
+        
+        return {
+            "success": True,
+            "changes_made": self.changes_made,
+            "changes_rejected": self.changes_rejected,
+        }
+    
+    async def _plan_changes(self, task: str) -> dict[str, Any]:
+        """Use Claude to plan what file changes are needed."""
+        
+        system_prompt = """You are a coding assistant that plans file changes.
+
+Given a task, analyze what file changes are needed and output a structured plan.
+
+IMPORTANT: You must respond with ONLY a valid JSON object, no markdown, no explanation.
+
+The JSON must have this structure:
+{
+    "summary": "Brief description of what you'll do",
+    "changes": [
+        {
+            "action": "create" | "modify" | "delete",
+            "path": "relative/path/to/file.py",
+            "description": "What this change does",
+            "content": "Full file content (for create/modify)"
+        }
+    ]
+}
+
+Rules:
+- Only include file changes, not commands to run
+- Use relative paths from the current directory
+- For modifications, include the COMPLETE new file content
+- Keep changes minimal and focused on the task
+"""
+        
+        # List current files for context
+        files_context = self._get_files_context()
+        
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=4096,
+            system=system_prompt,
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"Current directory: {self.working_directory}\n\nFiles:\n{files_context}\n\nTask: {task}"
+                }
+            ],
+        )
+        
+        # Parse response
+        try:
+            import json
+            text = response.content[0].text.strip()
+            # Handle markdown code blocks
+            if text.startswith("```"):
+                text = text.split("```")[1]
+                if text.startswith("json"):
+                    text = text[4:]
+                text = text.strip()
+            return json.loads(text)
+        except Exception as e:
+            console.print(f"[red]Failed to parse plan: {e}[/red]")
+            console.print(f"Response: {response.content[0].text[:500]}")
+            return {"summary": "Failed to plan", "changes": []}
+    
+    def _get_files_context(self) -> str:
+        """Get a summary of files in the working directory."""
+        lines = []
+        try:
+            for item in Path(self.working_directory).rglob("*"):
+                if item.is_file():
+                    rel_path = item.relative_to(self.working_directory)
+                    # Skip hidden files and common ignores
+                    parts = str(rel_path).split("/")
+                    if any(p.startswith(".") or p in ["node_modules", "__pycache__", "venv", ".venv"] for p in parts):
+                        continue
+                    lines.append(str(rel_path))
+        except Exception:
+            pass
+        return "\n".join(lines[:100])  # Limit to 100 files
+    
+    def _show_plan(self, plan: dict[str, Any]) -> None:
+        """Display the planned changes."""
+        table = Table(title="📝 Planned Changes")
+        table.add_column("Action", style="cyan")
+        table.add_column("File", style="white")
+        table.add_column("Description", style="dim")
+        
+        for change in plan.get("changes", []):
+            action_color = {
+                "create": "green",
+                "modify": "yellow",
+                "delete": "red",
+            }.get(change["action"], "white")
+            
+            table.add_row(
+                f"[{action_color}]{change['action'].upper()}[/{action_color}]",
+                change["path"],
+                change.get("description", "")[:50],
+            )
+        
+        console.print(table)
+    
+    async def _preview_and_approve(self, change: dict) -> bool:
+        """Preview a change using impact-preview and get approval."""
+        
+        action = change["action"]
+        path = change["path"]
+        full_path = os.path.join(self.working_directory, path)
+        
+        # Map to ActionType
+        if action == "create":
+            action_type = ActionType.FILE_CREATE
+        elif action == "modify":
+            action_type = ActionType.FILE_WRITE
+        elif action == "delete":
+            action_type = ActionType.FILE_DELETE
+        else:
+            console.print(f"[red]Unknown action: {action}[/red]")
+            return False
+        
+        # Create request
+        request = ActionRequest(
+            action_type=action_type,
+            target=full_path,
+            description=change.get("description", f"{action} {path}"),
+            payload={"content": change.get("content", "")},
+        )
+        
+        # Analyze with impact-preview
+        preview = await self.analyzer.analyze(request)
+        
+        # Display preview
+        risk_emoji = {
+            RiskLevel.LOW: "🟢",
+            RiskLevel.MEDIUM: "🟡",
+            RiskLevel.HIGH: "🟠",
+            RiskLevel.CRITICAL: "🔴",
+        }.get(preview.risk_level, "⚪")
+        
+        console.print(Panel(
+            f"[bold]{change.get('description', path)}[/bold]\n\n"
+            f"**File:** `{path}`\n"
+            f"**Action:** {action.upper()}\n"
+            f"**Risk:** {risk_emoji} {preview.risk_level.value.upper()}",
+            title=f"Impact Preview",
+            border_style="yellow" if preview.risk_level in [RiskLevel.HIGH, RiskLevel.CRITICAL] else "blue",
+        ))
+        
+        # Show risk factors
+        if preview.risk_factors:
+            console.print("[bold]Risk Factors:[/bold]")
+            for factor in preview.risk_factors:
+                console.print(f"  ⚠️  {factor}")
+        
+        # Show diff
+        if preview.file_changes:
+            console.print("\n[bold]Diff:[/bold]")
+            diff_text = format_diff_plain(preview.file_changes)
+            console.print(Syntax(diff_text, "diff", theme="monokai"))
+        elif action == "create" and change.get("content"):
+            console.print("\n[bold]New file content:[/bold]")
+            # Guess language from extension
+            ext = Path(path).suffix.lstrip(".")
+            lang = {"py": "python", "js": "javascript", "ts": "typescript", "json": "json", "md": "markdown"}.get(ext, "text")
+            console.print(Syntax(change["content"][:1000], lang, theme="monokai", line_numbers=True))
+            if len(change["content"]) > 1000:
+                console.print(f"[dim]... ({len(change['content'])} total characters)[/dim]")
+        
+        console.print()
+        
+        # Auto-approve low risk if enabled
+        if self.auto_approve_low_risk and preview.risk_level == RiskLevel.LOW:
+            console.print("[green]✓ Auto-approved (low risk)[/green]")
+            return True
+        
+        # Dry run mode
+        if self.dry_run:
+            console.print("[yellow]Dry run - not executing[/yellow]")
+            return False
+        
+        # Ask for approval
+        if preview.risk_level == RiskLevel.CRITICAL:
+            console.print("[bold red]⚠️  CRITICAL RISK - Please review carefully![/bold red]")
+        
+        return Confirm.ask("Apply this change?", default=preview.risk_level == RiskLevel.LOW)
+    
+    def _execute_change(self, change: dict) -> None:
+        """Execute an approved change."""
+        action = change["action"]
+        path = os.path.join(self.working_directory, change["path"])
+        
+        try:
+            if action == "create" or action == "modify":
+                # Ensure directory exists
+                os.makedirs(os.path.dirname(path), exist_ok=True)
+                with open(path, "w") as f:
+                    f.write(change.get("content", ""))
+                console.print(f"[green]✓ {action.title()}d: {change['path']}[/green]")
+                
+            elif action == "delete":
+                if os.path.exists(path):
+                    os.remove(path)
+                    console.print(f"[green]✓ Deleted: {change['path']}[/green]")
+                else:
+                    console.print(f"[yellow]File not found: {change['path']}[/yellow]")
+                    
+        except Exception as e:
+            console.print(f"[red]✗ Failed: {e}[/red]")
+    
+    def _show_summary(self) -> None:
+        """Show a summary of all changes."""
+        console.print("\n" + "=" * 50)
+        console.print("[bold]Summary[/bold]\n")
+        
+        if self.changes_made:
+            console.print(f"[green]✓ {len(self.changes_made)} changes applied[/green]")
+            for change in self.changes_made:
+                console.print(f"  - {change['action']}: {change['path']}")
+        
+        if self.changes_rejected:
+            console.print(f"[yellow]⊘ {len(self.changes_rejected)} changes skipped[/yellow]")
+            for change in self.changes_rejected:
+                console.print(f"  - {change['action']}: {change['path']}")
+        
+        if not self.changes_made and not self.changes_rejected:
+            console.print("[dim]No changes to report[/dim]")

safe_agent/cli.py

@@ -0,0 +1,107 @@
+"""
+Safe Agent CLI - Run AI coding tasks with built-in safety.
+
+Usage:
+    safe-agent "refactor auth to use JWT"
+    safe-agent --file task.md
+    safe-agent --interactive
+"""
+
+import asyncio
+import os
+import sys
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from safe_agent.agent import SafeAgent
+
+console = Console()
+
+
+@click.command()
+@click.argument("task", required=False)
+@click.option("--file", "-f", type=click.Path(exists=True), help="Read task from file")
+@click.option("--interactive", "-i", is_flag=True, help="Interactive mode")
+@click.option("--auto-approve-low", is_flag=True, help="Auto-approve low-risk changes")
+@click.option("--dry-run", is_flag=True, help="Preview only, don't execute")
+@click.option("--model", default="claude-sonnet-4-20250514", help="Claude model to use")
+def main(
+    task: str | None,
+    file: str | None,
+    interactive: bool,
+    auto_approve_low: bool,
+    dry_run: bool,
+    model: str,
+):
+    """
+    Safe Agent - An AI coding agent you can actually trust.
+    
+    Run coding tasks with built-in impact preview. See exactly what will
+    change before any file is modified.
+    
+    Examples:
+    
+        safe-agent "add error handling to api.py"
+        
+        safe-agent "refactor the auth module" --dry-run
+        
+        safe-agent --interactive
+    """
+    # Check for API key
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        console.print("[red]Error: ANTHROPIC_API_KEY environment variable not set[/red]")
+        console.print("\nGet your API key at: https://console.anthropic.com/")
+        console.print("Then run: export ANTHROPIC_API_KEY=your-key-here")
+        sys.exit(1)
+    
+    # Get task
+    if file:
+        with open(file) as f:
+            task = f.read().strip()
+    elif interactive:
+        console.print(Panel(
+            "[bold]Safe Agent[/bold] - Interactive Mode\n\n"
+            "Type your coding task, then press Enter twice to submit.\n"
+            "Type 'quit' to exit.",
+            title="🛡️ Safe Agent",
+        ))
+        lines = []
+        while True:
+            try:
+                line = input()
+                if line.lower() == "quit":
+                    sys.exit(0)
+                if line == "" and lines and lines[-1] == "":
+                    break
+                lines.append(line)
+            except EOFError:
+                break
+        task = "\n".join(lines).strip()
+    
+    if not task:
+        console.print("[red]Error: No task provided[/red]")
+        console.print("\nUsage: safe-agent \"your task here\"")
+        sys.exit(1)
+    
+    # Show task
+    console.print(Panel(task, title="📋 Task", border_style="blue"))
+    
+    # Create agent and run
+    agent = SafeAgent(
+        model=model,
+        auto_approve_low_risk=auto_approve_low,
+        dry_run=dry_run,
+    )
+    
+    try:
+        asyncio.run(agent.run(task))
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted[/yellow]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

safe_agent/demo.py

@@ -0,0 +1,123 @@
+"""
+Demo scaffolding for recording Safe Agent in action.
+
+Goals:
+- Quickly create a throwaway repo that demonstrates a risky edit being blocked.
+- Provide a repeatable command script users can record via asciinema/ffmpeg.
+
+We keep side effects minimal and self-contained under a temporary directory.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Iterable
+
+DEMO_TASK = "switch database config to production"
+
+
+def prepare_demo_repo(target_dir: str | None = None) -> Path:
+    """
+    Create a minimal demo repo with a risky config change.
+
+    Structure:
+      demo/
+        config/db.yaml   # contains a dev URL
+        README.md        # short instructions for the demo
+    """
+
+    base = Path(target_dir) if target_dir else Path(tempfile.mkdtemp(prefix="safe-agent-demo-"))
+    base.mkdir(parents=True, exist_ok=True)
+
+    config_path = base / "config"
+    config_path.mkdir(parents=True, exist_ok=True)
+
+    (config_path / "db.yaml").write_text(
+        "url: postgresql://localhost:5432/dev\n", encoding="utf-8"
+    )
+
+    (base / "README.md").write_text(
+        "# Safe Agent Demo\n\n"
+        "Goal: show Safe Agent flagging a risky production DB change.\n\n"
+        "Steps:\n"
+        "1) Run the command from demo_script.sh (or below) inside this directory.\n"
+        "2) Approve/deny when prompted.\n"
+        "3) Record with `asciinema rec demo.cast -- safe-agent ...`.\n",
+        encoding="utf-8",
+    )
+
+    (base / "demo_task.txt").write_text(DEMO_TASK, encoding="utf-8")
+    (base / ".gitignore").write_text("*.cast\n*.gif\n", encoding="utf-8")
+
+    # Provide a helper shell script the user can copy/paste.
+    (base / "demo_script.sh").write_text(
+        "#!/usr/bin/env bash\n"
+        "set -euo pipefail\n\n"
+        'echo "Running Safe Agent demo..."\n'
+        f"safe-agent --dry-run \"{DEMO_TASK}\"\n",
+        encoding="utf-8",
+    )
+
+    return base
+
+
+def build_asciinema_command(repo: Path) -> list[str]:
+    """
+    Return a recommended asciinema record command for the demo repo.
+    """
+    return [
+        "asciinema",
+        "rec",
+        "demo.cast",
+        "--title",
+        "Safe Agent Guardrail Demo",
+        "--cwd",
+        str(repo),
+        "--",
+        "safe-agent",
+        "--dry-run",
+        DEMO_TASK,
+    ]
+
+
+def convert_cast_to_gif(cast_file: Path, out_gif: Path) -> list[str]:
+    """
+    Provide a suggested command to convert asciinema cast to GIF.
+
+    We do not invoke the command automatically; we return it so the caller
+    can decide when/how to run (e.g., ffmpeg/asciinema-scenario).
+    """
+    return [
+        "asciinema",
+        "play",
+        "--speed",
+        "1.1",
+        str(cast_file),
+    ], [
+        "agg",
+        str(cast_file),
+        str(out_gif),
+    ]
+
+
+def ensure_tools_available(tools: Iterable[str]) -> dict[str, bool]:
+    """
+    Check for presence of required binaries in PATH.
+    """
+    available: dict[str, bool] = {}
+    for tool in tools:
+        available[tool] = shutil.which(tool) is not None
+    return available
+
+
+def run_if_available(cmd: list[str]) -> int:
+    """
+    Execute a command if the binary is present. Return exit code (0 if skipped).
+    """
+    if shutil.which(cmd[0]) is None:
+        return 0
+    result = subprocess.run(cmd, check=False)
+    return result.returncode

safe_agent/demo_cli.py

@@ -0,0 +1,98 @@
+"""
+CLI helpers to prepare and record a Safe Agent demo.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+from safe_agent import __version__
+from safe_agent.demo import (
+    DEMO_TASK,
+    build_asciinema_command,
+    convert_cast_to_gif,
+    ensure_tools_available,
+    prepare_demo_repo,
+)
+
+console = Console()
+
+
+@click.group()
+def main() -> None:
+    """Create and record the Safe Agent demo scenario."""
+
+
+@main.command()
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    help="Directory to place the demo repo (default: temp dir).",
+)
+def prepare(output: str | None) -> None:
+    """Set up a throwaway repo with the risky config change."""
+
+    repo = prepare_demo_repo(output)
+    console.print(
+        Panel(
+            f"Demo repo ready at: {repo}\n\n"
+            f"Task: \"{DEMO_TASK}\"\n"
+            "Next: run `safe-agent --dry-run \"{task}\"` inside that directory.\n"
+            "To record, see `safe-agent-demo record`.",
+            title="Demo Prepared",
+        )
+    )
+
+
+@main.command()
+@click.option(
+    "--repo",
+    default=None,
+    help="Path to the prepared demo repo (defaults to CWD).",
+)
+def record(repo: str | None) -> None:
+    """
+    Print record commands (asciinema + GIF) for the demo.
+
+    We don't auto-run to avoid messing with user terminals; copy/paste instead.
+    """
+
+    repo_path = Path(repo) if repo else Path.cwd()
+    tools = ensure_tools_available(["asciinema", "agg"])
+    missing = [name for name, ok in tools.items() if not ok]
+
+    cmd = build_asciinema_command(repo_path)
+    gif_cmds = convert_cast_to_gif(Path("demo.cast"), Path("demo.gif"))
+
+    console.print(Panel("Recording commands", title="Demo"))
+    console.print(f"Repo: {repo_path}")
+    console.print("\nRun to record:")
+    console.print(" ".join(cmd))
+    console.print("\nConvert to GIF (requires agg):")
+    console.print(" ".join(gif_cmds[1]))
+
+    if missing:
+        console.print(
+            f"[yellow]Missing tools:[/yellow] {', '.join(missing)}. "
+            "Install asciinema (and agg for GIF) before recording."
+        )
+    else:
+        console.print("[green]All required tools detected.[/green]")
+
+
+@main.command()
+def version() -> None:
+    """Show version for scripting."""
+
+    console.print(f"safe-agent-demo {__version__}")
+
+
+if __name__ == "__main__":
+    main()