itamar-agentcli 0.1.0__tar.gz

itamar_agentcli-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: itamar-agentcli
+Version: 0.1.0
+Summary: Local AI Agent CLI
+Requires-Python: >=3.12
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: pydantic>=2
+Requires-Dist: requests>=2

itamar_agentcli-0.1.0/itamar_agentcli.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: itamar-agentcli
+Version: 0.1.0
+Summary: Local AI Agent CLI
+Requires-Python: >=3.12
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: pydantic>=2
+Requires-Dist: requests>=2

itamar_agentcli-0.1.0/itamar_agentcli.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+pyproject.toml
+itamar_agentcli.egg-info/PKG-INFO
+itamar_agentcli.egg-info/SOURCES.txt
+itamar_agentcli.egg-info/dependency_links.txt
+itamar_agentcli.egg-info/entry_points.txt
+itamar_agentcli.egg-info/requires.txt
+itamar_agentcli.egg-info/top_level.txt
+localagent/__init__.py
+localagent/agent_parser.py
+localagent/cli.py
+localagent/agent/__init__.py
+localagent/agent/planner.py
+localagent/core/__init__.py
+localagent/core/context.py
+localagent/core/errors.py
+localagent/core/models.py
+localagent/gateway/__init__.py
+localagent/gateway/openai_compat.py
+localagent/safety/__init__.py
+localagent/safety/approval.py
+localagent/tools/__init__.py
+localagent/tools/exec.py
+localagent/tools/files.py
+localagent/tools/python_runner.py

itamar_agentcli-0.1.0/itamar_agentcli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

itamar_agentcli-0.1.0/itamar_agentcli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentcli = localagent.cli:app

itamar_agentcli-0.1.0/itamar_agentcli.egg-info/requires.txt

@@ -0,0 +1,4 @@
+typer>=0.12
+rich>=13
+pydantic>=2
+requests>=2

itamar_agentcli-0.1.0/itamar_agentcli.egg-info/top_level.txt

@@ -0,0 +1 @@
+localagent

itamar_agentcli-0.1.0/localagent/agent_parser.py

@@ -0,0 +1,22 @@
+import re
+
+def parse_command(text: str) -> str | None:
+    text = text.lower()
+
+    # install packages
+    if "nmap" in text:
+        return "sudo dnf install -y nmap"
+
+    if "ffmpeg" in text:
+        return "sudo dnf install -y ffmpeg --allowerasing"
+
+    if "yt-dlp" in text or "youtube" in text:
+        return "sudo dnf install -y yt-dlp"
+
+    if "update" in text or "עדכן" in text:
+        return "sudo dnf update -y"
+
+    if "נקה" in text or "clean" in text:
+        return "sudo dnf autoremove -y"
+
+    return None

itamar_agentcli-0.1.0/localagent/cli.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from localagent.tools.exec import CommandExecutor
+
+console = Console()
+app = typer.Typer(add_completion=False)
+
+
+@app.command()
+def main(
+    command: str = typer.Argument(
+        ...,
+        help='Command to run. Quote it if it contains spaces, e.g. "ls -la"',
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        help="Auto-approve ONLY whitelisted dangerous commands (dnf install/update/upgrade/remove).",
+    ),
+    stream: bool = typer.Option(
+        False,
+        "--stream",
+        help="Stream stdout live while running.",
+    ),
+):
+    """LocalAgent command runner (with approvals)."""
+    executor = CommandExecutor(console=console, auto_yes=yes)
+    result = executor.run(command=command, require_approval=True, stream=stream)
+    raise typer.Exit(code=result.exit_code)
+
+
+if __name__ == "__main__":
+    app()

itamar_agentcli-0.1.0/localagent/gateway/openai_compat.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+import requests
+from pydantic import BaseModel, Field
+
+
+class ChatMessage(BaseModel):
+    role: str  # "system" | "user" | "assistant" | "tool"
+    content: str
+
+
+class GatewayResponse(BaseModel):
+    content: str
+    raw: Dict[str, Any] = Field(default_factory=dict)
+
+
+class OpenAICompatGateway:
+    """
+    Minimal OpenAI-compatible Chat Completions gateway.
+    Intended for local LLM servers (Ollama OpenAI compatibility, vLLM, etc.).
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:11434/v1",
+        api_key: str = "ollama",  # often ignored by local servers
+        model: str = "llama3.1",
+        timeout_s: int = 120,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.timeout_s = timeout_s
+
+    def chat(
+        self,
+        messages: List[ChatMessage],
+        temperature: float = 0.2,
+        max_tokens: Optional[int] = None,
+        extra: Optional[Dict[str, Any]] = None,
+    ) -> GatewayResponse:
+        url = f"{self.base_url}/chat/completions"
+        payload: Dict[str, Any] = {
+            "model": self.model,
+            "messages": [m.model_dump() for m in messages],
+            "temperature": temperature,
+        }
+        if max_tokens is not None:
+            payload["max_tokens"] = max_tokens
+        if extra:
+            payload.update(extra)
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        r = requests.post(url, json=payload, headers=headers, timeout=self.timeout_s)
+        r.raise_for_status()
+        data = r.json()
+
+        # Standard OpenAI format: choices[0].message.content
+        content = (
+            data.get("choices", [{}])[0]
+            .get("message", {})
+            .get("content", "")
+        )
+
+        return GatewayResponse(content=content, raw=data)

itamar_agentcli-0.1.0/localagent/safety/approval.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Optional, Sequence
+
+
+@dataclass(frozen=True)
+class ApprovalDecision:
+    approved: bool
+    reason: str
+
+
+class ApprovalPolicy:
+    """
+    Heuristic-based approval for shell commands + a small whitelist mechanism
+    for auto-approval (e.g., dnf installs) when --yes is used.
+    """
+
+    DEFAULT_DANGEROUS_PATTERNS: Sequence[str] = (
+        r"\brm\b.*\s-rf\b",
+        r"\brm\b.*\s--no-preserve-root\b",
+        r"\bdd\b",
+        r"\bmkfs\.",
+        r"\bchmod\b\s+777\b",
+        r"\bchown\b.*\s-R\b",
+        r"\bshutdown\b|\breboot\b",
+        r"\bsystemctl\b\s+(stop|disable|mask)\b",
+        r"\bdnf\b\s+(install|remove|upgrade|update)\b",
+        r"\byum\b\s+(install|remove|update|upgrade)\b",
+        r"\bpip\b\s+install\b",
+        r"\bcurl\b.*\|\s*(sh|bash)\b",
+        r"\bwget\b.*\|\s*(sh|bash)\b",
+        r"\bchmod\b.*\+x\b.*\.\w+",
+        r"\bsudo\b",
+    )
+
+    def __init__(self, extra_patterns: Optional[Sequence[str]] = None) -> None:
+        patterns = list(self.DEFAULT_DANGEROUS_PATTERNS)
+        if extra_patterns:
+            patterns.extend(extra_patterns)
+        self._compiled = [re.compile(p, re.IGNORECASE) for p in patterns]
+
+    def requires_approval(self, command: str) -> Optional[str]:
+        cmd = command.strip()
+        for rx in self._compiled:
+            if rx.search(cmd):
+                return f"Matched risky pattern: {rx.pattern}"
+        return None
+
+    def is_autoapprove_whitelisted(self, command: str) -> bool:
+        """
+        Commands allowed for auto-approval when --yes is used.
+        Keep this list tight and explicit.
+        """
+        cmd = command.strip().lower()
+
+        # Allow these admin package operations to auto-approve
+        whitelist_prefixes = (
+            "sudo dnf install",
+            "sudo dnf update",
+            "sudo dnf upgrade",
+            "sudo dnf remove",
+            "dnf install",
+            "dnf update",
+            "dnf upgrade",
+            "dnf remove",
+            "sudo dnf autoremove",
+            "dnf autoremove",
+            "sudo dnf clean",
+            "dnf clean",
+            "sudo dnf makecache",
+            "dnf makecache",
+        )
+        return cmd.startswith(whitelist_prefixes)

itamar_agentcli-0.1.0/localagent/tools/exec.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from localagent.safety.approval import ApprovalPolicy
+
+
+@dataclass
+class CommandResult:
+    command: str
+    cwd: str
+    exit_code: int
+    stdout: str
+    stderr: str
+
+
+class CommandExecutor:
+    """
+    Executes shell commands with human-in-the-loop approval for risky commands.
+    If auto_yes=True, will auto-approve ONLY whitelisted risky commands.
+    """
+
+    def __init__(
+        self,
+        approval: Optional[ApprovalPolicy] = None,
+        console: Optional[Console] = None,
+        default_cwd: Optional[str] = None,
+        env_overrides: Optional[Dict[str, str]] = None,
+        auto_yes: bool = False,
+    ) -> None:
+        self.approval = approval or ApprovalPolicy()
+        self.console = console or Console()
+        self.default_cwd = default_cwd or os.getcwd()
+        self.env_overrides = env_overrides or {}
+        self.auto_yes = auto_yes
+
+    def run(
+        self,
+        command: str,
+        cwd: Optional[str] = None,
+        timeout_s: int = 600,
+        check: bool = False,
+        require_approval: bool = True,
+        stream: bool = False,
+    ) -> CommandResult:
+        cwd_final = cwd or self.default_cwd
+
+        # Approval step
+        if require_approval:
+            reason = self.approval.requires_approval(command)
+            if reason:
+                self.console.print(
+                    Panel.fit(
+                        f"[bold yellow]Approval required[/bold yellow]\n"
+                        f"[bold]Reason:[/bold] {reason}\n\n"
+                        f"[bold]Command:[/bold]\n{command}\n\n"
+                        f"[dim]CWD:[/dim] {cwd_final}",
+                        title="Dangerous Command Detected",
+                    )
+                )
+
+                # Auto-approve only whitelisted commands when --yes is enabled
+                if self.auto_yes and self.approval.is_autoapprove_whitelisted(command):
+                    self.console.print(
+                        "[bold yellow]Auto-approval enabled (--yes + whitelist). Proceeding...[/bold yellow]"
+                    )
+                else:
+                    if not Confirm.ask("Execute this command?", default=False):
+                        return CommandResult(
+                            command=command,
+                            cwd=cwd_final,
+                            exit_code=130,
+                            stdout="",
+                            stderr="User rejected command execution.",
+                        )
+
+        env = os.environ.copy()
+        env.update(self.env_overrides)
+
+        self.console.print(
+            Panel.fit(
+                f"[bold cyan]$[/bold cyan] {command}\n[dim]cwd:[/dim] {cwd_final}",
+                title="Executing",
+            )
+        )
+
+        args: List[str] = shlex.split(command)
+
+        if stream:
+            proc = subprocess.Popen(
+                args,
+                cwd=cwd_final,
+                env=env,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1,
+            )
+            out_lines: List[str] = []
+            err_lines: List[str] = []
+
+            assert proc.stdout is not None
+            assert proc.stderr is not None
+
+            for line in proc.stdout:
+                out_lines.append(line)
+                self.console.print(line.rstrip("\n"))
+
+            err_text = proc.stderr.read()
+            if err_text:
+                err_lines.append(err_text)
+                self.console.print(err_text, style="bold red")
+
+            exit_code = proc.wait(timeout=timeout_s)
+            stdout = "".join(out_lines)
+            stderr = "".join(err_lines)
+        else:
+            completed = subprocess.run(
+                args,
+                cwd=cwd_final,
+                env=env,
+                capture_output=True,
+                text=True,
+                timeout=timeout_s,
+            )
+            exit_code = completed.returncode
+            stdout = completed.stdout or ""
+            stderr = completed.stderr or ""
+
+            if stdout.strip():
+                self.console.print(Panel.fit(stdout.rstrip(), title="stdout"))
+            if stderr.strip():
+                self.console.print(Panel.fit(stderr.rstrip(), title="stderr", style="red"))
+
+        if check and exit_code != 0:
+            raise subprocess.CalledProcessError(exit_code, args, stdout, stderr)
+
+        return CommandResult(
+            command=command,
+            cwd=cwd_final,
+            exit_code=exit_code,
+            stdout=stdout,
+            stderr=stderr,
+        )

itamar_agentcli-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "itamar-agentcli"
+version = "0.1.0"
+description = "Local AI Agent CLI"
+requires-python = ">=3.12"
+dependencies = [
+  "typer>=0.12",
+  "rich>=13",
+  "pydantic>=2",
+  "requests>=2",
+]
+
+[project.scripts]
+agentcli = "localagent.cli:app"

itamar_agentcli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+