simulai-cli 2.0.1__tar.gz → 2.1.0__tar.gz

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulai-cli
-Version: 2.0.1
+Version: 2.1.0
 Summary: SimulAI CLI — persistent AI chat in your terminal. SmartRoute across 20+ models, Naira billing, and import your Claude Code / Codex sessions.
 Author-email: Simul AI <hello@trysimulai.com>
 License: MIT
@@ -62,6 +62,7 @@ conversation you can continue on any model.
 | Command | What it does |
 |---|---|
 | `simulai login` | Log in (unlocks everything) |
+| `simulai code "task"` | **Agentic coding** — reads, greps, edits and tests this repo |
 | `simulai chat` | Resume this directory's conversation |
 | `simulai chat "msg"` | One-shot |
 | `simulai chat -m <model>` | Force a specific model |

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/README.md

@@ -36,6 +36,7 @@ conversation you can continue on any model.
 | Command | What it does |
 |---|---|
 | `simulai login` | Log in (unlocks everything) |
+| `simulai code "task"` | **Agentic coding** — reads, greps, edits and tests this repo |
 | `simulai chat` | Resume this directory's conversation |
 | `simulai chat "msg"` | One-shot |
 | `simulai chat -m <model>` | Force a specific model |

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simulai-cli"
-version = "2.0.1"
+version = "2.1.0"
 description = "SimulAI CLI — persistent AI chat in your terminal. SmartRoute across 20+ models, Naira billing, and import your Claude Code / Codex sessions."
 readme = "README.md"
 license = { text = "MIT" }

simulai_cli-2.1.0/simulai_cli/agent.py

@@ -0,0 +1,403 @@
+"""
+The `simulai code` agent loop.
+
+    user prompt
+      → POST /v1/code/agent with the tool schema
+      → model streams prose and/or tool calls
+      → tools execute HERE, with approval for anything destructive
+      → results go back as role:"tool" messages
+      → repeat until the model stops asking for tools
+
+Design decisions that matter for output quality:
+
+• LOW TEMPERATURE (0.2, set server-side). Agent work wants determinism.
+• EDITS ARE PREVIEWED AS DIFFS before they touch disk. You approve a diff,
+  not a promise.
+• SYNTAX IS CHECKED BEFORE THE WRITE, and a failure is reported back to the
+  model as a tool error — so it repairs inside the loop instead of handing
+  you code that doesn't parse.
+• A VERIFICATION PASS runs the project's tests after edits land, and
+  failures are fed back for up to two repair rounds. This is the single
+  biggest quality lever available without changing models.
+• STEP CAP. Runaway loops burn credits; 25 steps is generous for real work
+  and cheap to raise.
+"""
+
+import json
+from typing import List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.syntax import Syntax
+
+from . import render
+from .api import ApiError, SimulAIClient
+from .tools import (
+    DESTRUCTIVE,
+    TOOL_SCHEMA,
+    ToolExecutor,
+    Workspace,
+    detect_test_command,
+    git_status,
+    is_environment_failure,
+)
+
+console = Console()
+
+MAX_STEPS = 25
+MAX_REPAIR_ROUNDS = 2
+
+SYSTEM_PROMPT = """You are a coding agent working directly in a developer's repository.
+
+Rules that matter:
+- Investigate before you edit. Use grep to locate code and read_file with line
+  ranges to inspect it. Never guess at file contents or API signatures.
+- Prefer edit_file over write_file for existing files. old_string must match
+  the file byte-for-byte and appear exactly once — include surrounding lines
+  to disambiguate.
+- Make the smallest change that fixes the problem. Do not reformat, rename,
+  or "improve" code you were not asked to touch.
+- If an edit is rejected for syntax or ambiguity, read the file again and fix
+  your input. Do not retry the identical call.
+- After changing code, propose a command that verifies it (the test suite, a
+  type-checker, or the specific failing test).
+- When you are done, state plainly what you changed and what the user should
+  check. Do not claim you ran something you did not run.
+
+You cannot see the repository except through your tools. The user sees every
+tool call and approves anything destructive."""
+
+
+def _tool_signature(name: str, args: dict) -> str:
+    """A stable fingerprint, used to catch the model retrying the identical
+    failing call — a common and expensive loop."""
+    return f"{name}:{json.dumps(args, sort_keys=True)[:400]}"
+
+
+def run_agent(
+    client: SimulAIClient,
+    prompt: str,
+    root: str,
+    model: Optional[str] = None,
+    auto_approve: bool = False,
+    dry_run: bool = False,
+    effort: str = "balanced",
+    verify: bool = True,
+) -> None:
+    workspace = Workspace(root)
+    executor = ToolExecutor(workspace, auto_approve=auto_approve, dry_run=dry_run)
+
+    git = git_status(root)
+    if git["repo"] and git["dirty"] and not dry_run and not auto_approve:
+        console.print(
+            f"[yellow]⚠ Uncommitted changes on branch '{git['branch']}'.[/yellow] "
+            "[dim]Commit or stash first so you can undo cleanly.[/dim]"
+        )
+        if Prompt.ask("Continue anyway?", choices=["y", "n"], default="n") == "n":
+            return
+    if not git["repo"]:
+        console.print(
+            "[yellow]⚠ Not a git repository — edits cannot be rolled back with git.[/yellow]"
+        )
+
+    messages: List[dict] = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": f"Workspace root: {root}\n\n{prompt}"},
+    ]
+
+    seen_calls: set = set()
+    steps = 0
+    repair_rounds = 0
+    tokens_in = tokens_out = 0
+
+    while steps < MAX_STEPS:
+        steps += 1
+        text, tool_calls, usage = _stream_turn(client, messages, model, effort)
+        tokens_in += usage.get("input", 0)
+        tokens_out += usage.get("output", 0)
+
+        # NOTE: no markdown re-render here. _stream_turn already printed the
+        # text live as it arrived; rendering it again duplicated every final
+        # message. Live streaming wins over syntax highlighting in an agent
+        # run — the substance is in the diffs, which are highlighted, and
+        # prose between tool calls is short.
+
+        # ── Tool-capability check ────────────────────────────────────────
+        # If the very first turn comes back with no tool calls at all, the
+        # routed model almost certainly cannot call functions — OpenRouter
+        # silently drops the `tools` field for models that do not support
+        # it, so the model just answers in prose (usually by asking the user
+        # a question it could have answered with grep). The catalog has no
+        # supports_tools flag to filter on, so detect it here and say so
+        # plainly rather than letting the user think the agent is broken.
+        if steps == 1 and not tool_calls and executor.files_changed == []:
+            console.print(
+                "\n[yellow]⚠ The model made no tool calls.[/yellow] "
+                "[dim]It likely doesn't support function calling.[/dim]\n"
+                "  Retry with a tool-capable model:\n"
+                "    [bold]simulai models[/bold]  then  "
+                "[bold]simulai code -m <model-id> \"...\"[/bold]\n"
+            )
+
+        if not tool_calls:
+            # Model answered in prose — either it's done, or verification
+            # found problems worth one more round.
+            if verify and executor.files_changed and repair_rounds < MAX_REPAIR_ROUNDS:
+                failure = _verify(executor, root)
+                if failure:
+                    repair_rounds += 1
+                    console.print(
+                        f"[yellow]Verification failed — asking for a fix "
+                        f"(round {repair_rounds}/{MAX_REPAIR_ROUNDS})[/yellow]"
+                    )
+                    messages.append({"role": "assistant", "content": text or "(done)"})
+                    messages.append(
+                        {
+                            "role": "user",
+                            "content": (
+                                "The test suite failed after your changes.\n\n"
+                                "Fix the SOURCE CODE you changed. Do not:\n"
+                                "- install packages or modify the environment\n"
+                                "- add config files, wrappers or scripts\n"
+                                "- change or delete the test to make it pass\n"
+                                "If the failure is unrelated to your edit, say so "
+                                "plainly and stop.\n\n"
+                                f"{failure}"
+                            ),
+                        }
+                    )
+                    continue
+            break
+
+        # Persist the assistant's tool-call turn exactly as the API expects.
+        messages.append(
+            {
+                "role": "assistant",
+                "content": text or None,
+                "tool_calls": [
+                    {
+                        "id": call["id"],
+                        "type": "function",
+                        "function": {
+                            "name": call["name"],
+                            "arguments": call["arguments"],
+                        },
+                    }
+                    for call in tool_calls
+                ],
+            }
+        )
+
+        for call in tool_calls:
+            result_text = _execute(executor, call, seen_calls)
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": call["id"],
+                    "content": result_text,
+                }
+            )
+
+    if steps >= MAX_STEPS:
+        console.print(f"[yellow]Stopped at the {MAX_STEPS}-step cap.[/yellow]")
+
+    _summary(executor, tokens_in, tokens_out, git)
+
+
+def _stream_turn(
+    client: SimulAIClient, messages: List[dict], model: Optional[str], effort: str
+) -> tuple:
+    """One request. Returns (text, tool_calls, usage)."""
+    text = ""
+    tool_calls: List[dict] = []
+    usage = {"input": 0, "output": 0}
+
+    console.print()
+    try:
+        for event in client.stream_agent(
+            messages=messages, tools=TOOL_SCHEMA, model=model, effort=effort
+        ):
+            kind = event["type"]
+            if kind == "text":
+                text += event["text"]
+                console.print(event["text"], end="")
+            elif kind == "tool_calls":
+                tool_calls = event["tool_calls"]
+            elif kind == "usage":
+                usage["input"] += event.get("input", 0)
+                usage["output"] += event.get("output", 0)
+            elif kind == "done":
+                break
+    except ApiError as exc:
+        render.error(exc.message)
+        return "", [], usage
+    except KeyboardInterrupt:
+        console.print("\n[dim]interrupted[/dim]")
+        return text, [], usage
+
+    console.print()
+    return text, tool_calls, usage
+
+
+def _execute(executor: ToolExecutor, call: dict, seen: set) -> str:
+    """Run one tool call, prompting when destructive. Returns model-facing text."""
+    name = call["name"]
+    try:
+        args = json.loads(call["arguments"] or "{}")
+    except json.JSONDecodeError:
+        return "Error: your tool arguments were not valid JSON. Resend them correctly."
+
+    signature = _tool_signature(name, args)
+    if signature in seen and name in DESTRUCTIVE:
+        return (
+            "Error: you already made this exact call and it failed. "
+            "Read the current file contents before trying again."
+        )
+    seen.add(signature)
+
+    try:
+        # ── read-only tools: run immediately ──────────────────────────────
+        if name == "read_file":
+            result = executor.read_file(
+                args.get("path", ""), args.get("start_line"), args.get("end_line")
+            )
+        elif name == "list_files":
+            result = executor.list_files(args.get("path", "."), args.get("depth", 2))
+        elif name == "grep":
+            result = executor.grep(
+                args.get("pattern", ""), args.get("path", "."), args.get("glob")
+            )
+
+        # ── destructive tools: preview, approve, then apply ───────────────
+        elif name == "edit_file":
+            result, diff = executor.edit_file(
+                args.get("path", ""), args.get("old_string", ""), args.get("new_string", "")
+            )
+            if not result.ok:
+                console.print(f"  [red]✗ {name} {args.get('path','')}[/red]")
+                return result.output
+            if not _approve(f"Edit {args.get('path')}", diff, executor):
+                return "The user declined this edit. Ask what they would prefer."
+            result = executor.apply_edit(
+                args.get("path", ""), args.get("old_string", ""), args.get("new_string", "")
+            )
+
+        elif name == "write_file":
+            result, diff = executor.write_file(args.get("path", ""), args.get("content", ""))
+            if not result.ok:
+                console.print(f"  [red]✗ {name} {args.get('path','')}[/red]")
+                return result.output
+            if not _approve(f"Write {args.get('path')}", diff, executor):
+                return "The user declined this write. Ask what they would prefer."
+            result = executor.apply_write(args.get("path", ""), args.get("content", ""))
+
+        elif name == "run_command":
+            command = args.get("command", "")
+            reason = args.get("reason", "")
+            if not _approve(
+                f"Run: {command}" + (f"\n[dim]{reason}[/dim]" if reason else ""),
+                None,
+                executor,
+            ):
+                return "The user declined to run this command."
+            result = executor.run_command(command, reason)
+
+        else:
+            return f"Error: unknown tool '{name}'."
+
+    except PermissionError as exc:
+        console.print(f"  [red]✗ {exc}[/red]")
+        return f"Error: {exc}"
+    except Exception as exc:
+        console.print(f"  [red]✗ {name} failed: {exc}[/red]")
+        return f"Error running {name}: {exc}"
+
+    marker = "[green]✓[/green]" if result.ok else "[red]✗[/red]"
+    console.print(f"  {marker} [dim]{result.display or name}[/dim]")
+    return result.output or ("Done." if result.ok else "Failed.")
+
+
+def _approve(title: str, diff: Optional[str], executor: ToolExecutor) -> bool:
+    if executor.auto_approve or executor.dry_run:
+        return True
+    console.print()
+    if diff:
+        console.print(
+            Panel(
+                Syntax(diff, "diff", theme="monokai", word_wrap=True),
+                title=title,
+                border_style="yellow",
+            )
+        )
+    else:
+        console.print(Panel(title, border_style="yellow"))
+    answer = Prompt.ask("Apply?", choices=["y", "n", "a"], default="y")
+    if answer == "a":
+        executor.auto_approve = True
+        console.print("[dim]Auto-approving the rest of this run.[/dim]")
+        return True
+    return answer == "y"
+
+
+def _verify(executor: ToolExecutor, root: str) -> Optional[str]:
+    """Run the project's tests. → failure text, or None if clean/unrunnable.
+
+    Three guards learned from a real run that went wrong:
+
+    1. If the model ALREADY ran the tests during the loop, don't run them
+       again. Re-running duplicates a billed round trip and, worse, can
+       contradict what the model just concluded.
+    2. If the command cannot RUN (not installed, not on PATH), that is an
+       environment problem, not a code problem. Report it and stop — do not
+       hand it to the model as a failure to fix.
+    3. Only genuine test failures trigger a repair round.
+    """
+    command = detect_test_command(root)
+    if not command:
+        console.print(
+            "[dim]No test command detected — skipping verification. "
+            "Review the diff yourself.[/dim]"
+        )
+        return None
+
+    already = [c for c in executor.commands_run if "pytest" in c or "test" in c]
+    if already:
+        console.print(
+            f"[dim]Tests already run during the session ({already[-1][:60]}) "
+            "— skipping duplicate verification.[/dim]"
+        )
+        return None
+
+    console.print(f"\n[dim]Verifying with: {command}[/dim]")
+    result = executor.run_command(command, "post-edit verification")
+
+    if result.ok:
+        console.print("  [green]✓ tests pass[/green]")
+        return None
+
+    if is_environment_failure(result.output, 1):
+        console.print(
+            "  [yellow]⚠ Verification could not run — the test tool isn't "
+            "installed or isn't on PATH.[/yellow]\n"
+            "  [dim]This is an environment issue, not a problem with the "
+            "edit. Run your tests manually to confirm.[/dim]"
+        )
+        return None
+
+    console.print("  [red]✗ tests fail[/red]")
+    return result.output
+
+
+def _summary(executor: ToolExecutor, tokens_in: int, tokens_out: int, git: dict) -> None:
+    console.print()
+    if executor.files_changed:
+        console.print("[bold]Files changed:[/bold]")
+        for path in executor.files_changed:
+            console.print(f"  • {path}")
+        if git["repo"]:
+            console.print("\n[dim]Review with: git diff   ·   Undo with: git checkout -- .[/dim]")
+    else:
+        console.print("[dim]No files were modified.[/dim]")
+    if tokens_in or tokens_out:
+        console.print(f"[dim]{tokens_in} in / {tokens_out} out tokens this run[/dim]")

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/simulai_cli/api.py

@@ -398,6 +398,73 @@ class SimulAIClient:
             yield from _iter(self._headers())
 
 
+    def stream_agent(
+        self,
+        messages: List[dict],
+        tools: List[dict],
+        model: Optional[str] = None,
+        effort: str = "balanced",
+        max_tokens: int = 4000,
+    ) -> Iterator[dict]:
+        """Agent turn against /v1/code/agent.
+
+        Same SSE vocabulary as stream_chat plus `tool_calls`, which arrives
+        as ONE event before [DONE] (the backend assembles the fragments —
+        a half-streamed JSON argument string can't be executed).
+        """
+        payload: Dict[str, Any] = {
+            "messages": messages,
+            "tools": tools,
+            "tool_choice": "auto",
+            "effort": effort,
+            "max_tokens": max_tokens,
+        }
+        if model:
+            payload["model"] = model
+
+        def _iter(headers: dict):
+            with httpx.Client(timeout=TIMEOUT) as client:
+                with client.stream(
+                    "POST",
+                    f"{self.base}/v1/code/agent",
+                    headers=headers,
+                    json=payload,
+                ) as response:
+                    if response.status_code == 401:
+                        raise AuthRequired("401")
+                    if response.status_code == 404:
+                        response.read()
+                        raise ApiError(
+                            "This SimulAI server has no agent endpoint yet "
+                            "(POST /v1/code/agent). The backend needs the "
+                            "tool-calling update deployed.",
+                            404,
+                        )
+                    if response.status_code >= 400:
+                        response.read()
+                        raise ApiError(_extract_error(response), response.status_code)
+                    for line in response.iter_lines():
+                        if not line or not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        if data == "[DONE]":
+                            yield {"type": "done"}
+                            return
+                        try:
+                            chunk = json.loads(data)
+                        except Exception:
+                            continue
+                        yield from _normalize(chunk)
+                    yield {"type": "done"}
+
+        try:
+            yield from _iter(self._headers())
+        except AuthRequired:
+            if not self._refresh():
+                raise AuthRequired("Session expired. Run: simulai login")
+            yield from _iter(self._headers())
+
+
 def _normalize(chunk: dict) -> Iterator[dict]:
     event = chunk.get("simulai_event")
     if event == "fallback":
@@ -407,6 +474,9 @@ def _normalize(chunk: dict) -> Iterator[dict]:
             "to": chunk.get("to_name") or chunk.get("to_model"),
         }
         return
+    if event == "tool_calls":
+        yield {"type": "tool_calls", "tool_calls": chunk.get("tool_calls") or []}
+        return
     if event == "sources":
         yield {"type": "sources", "sources": chunk.get("sources") or []}
         return

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/simulai_cli/main.py

@@ -634,6 +634,52 @@ def _slash(
 # ── conversations ─────────────────────────────────────────────────────────────
 
 
+@app.command()
+def code(
+    task: Optional[str] = typer.Argument(None, help="What you want done"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Force a model"),
+    directory: Optional[str] = typer.Option(None, "--dir", "-d", help="Workspace root"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Auto-approve all edits and commands"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would change, write nothing"),
+    effort: Optional[str] = typer.Option(None, "--effort", "-e", help="fast | balanced | max"),
+    no_verify: bool = typer.Option(False, "--no-verify", help="Skip the post-edit test run"),
+):
+    """Agentic coding: the model reads, greps, edits and tests in this repo.
+
+    Every edit is previewed as a diff and needs your approval. Syntax is
+    checked before anything is written, and the test suite runs afterwards
+    with failures fed back for repair.
+    """
+    from .agent import run_agent
+    from .discovery import project_root
+
+    client = get_client()
+    cfg = load_config()
+    root = project_root(directory)
+
+    if not task:
+        console.print(
+            Panel(
+                f"[bold green]SimulAI code[/bold green]\n[dim]{root}[/dim]",
+                border_style="green",
+            )
+        )
+        task = Prompt.ask("[bold cyan]What should I do?[/bold cyan]")
+    if not task.strip():
+        return
+
+    run_agent(
+        client=client,
+        prompt=task,
+        root=root,
+        model=model,
+        auto_approve=yes,
+        dry_run=dry_run,
+        effort=effort or cfg["effort"],
+        verify=not no_verify,
+    )
+
+
 @app.command()
 def chats(
     limit: int = typer.Option(20, "--limit", "-l"),
@@ -975,7 +1021,7 @@ def usage(limit: int = typer.Option(15, "--limit", "-l")):
     console.print(f"\n  Balance: [yellow]{wallet.get('total_credits', 0)}[/yellow] credits\n")
 
 
-__version__ = "2.0.1"
+__version__ = "2.1.0"
 
 
 @app.command()

simulai_cli-2.1.0/simulai_cli/tools.py

@@ -0,0 +1,571 @@
+"""
+Local tool execution for `simulai code`.
+
+Everything in this file runs on the developer's machine. The server never
+sees the repo — it only ever receives the specific snippets the model asked
+for, and only after this module decided the request was safe and (for
+anything destructive) the user approved it.
+
+The design targets the "less buggy code with the same model" problem
+directly:
+
+1. RETRIEVAL, NOT DUMPING — read_file supports line ranges and grep returns
+   matches with context, so the model gets the relevant 40 lines instead of
+   a 2,000-line file. Less noise per token = fewer invented APIs.
+
+2. DIFF-BASED EDITS — edit_file does exact string replacement and refuses
+   ambiguous matches. A model that must quote the existing code verbatim to
+   change it cannot hallucinate the surrounding context, which whole-file
+   rewrites happily do.
+
+3. A SAFETY NET THAT ACTUALLY CATCHES — every write is syntax-checked
+   before it lands (ast.parse for .py, json.loads for .json). Failed parse
+   = the edit is rejected and the model is told why, so it fixes it in the
+   loop instead of shipping you broken code.
+
+4. NOTHING DESTRUCTIVE WITHOUT CONSENT — writes and shell commands prompt
+   by default, show exactly what will happen, and are refused outright
+   outside the workspace root.
+"""
+
+import ast
+import difflib
+import json
+import os
+import re
+import shlex
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+MAX_READ_BYTES = 200_000
+MAX_OUTPUT_CHARS = 12_000
+MAX_GREP_MATCHES = 60
+COMMAND_TIMEOUT = 180
+
+# Junk that should never be read, searched or listed — it drowns the
+# context window and none of it is source.
+SKIP_DIRS = {
+    ".git", "node_modules", "__pycache__", ".venv", "venv", "env",
+    "dist", "build", ".next", ".nuxt", "target", ".idea", ".vscode",
+    ".pytest_cache", ".mypy_cache", ".ruff_cache", "coverage", ".tox",
+}
+BINARY_SUFFIXES = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".pdf", ".zip",
+    ".tar", ".gz", ".whl", ".so", ".dylib", ".dll", ".exe", ".bin",
+    ".woff", ".woff2", ".ttf", ".mp4", ".mp3", ".sqlite", ".db",
+}
+
+# Commands refused outright. Not a security boundary — a model with shell
+# access has many ways around a blocklist — but it stops the obvious
+# catastrophes from a confused model, and the approval prompt is the real
+# control.
+# NOTE: no trailing \b — several of these patterns end in '/' or '=', which
+# are non-word characters, so a trailing word boundary would never match and
+# the whole guard would silently pass. (Found exactly that way in testing.)
+DANGEROUS = re.compile(
+    r"(rm\s+-rf?\s+(/|~|\*)"
+    r"|rm\s+-rf?\s+--no-preserve-root"
+    r"|\bmkfs\b|\bdd\s+if="
+    r"|:\(\)\s*\{.*\};\s*:"
+    r"|\bshutdown\b|\breboot\b"
+    r"|chmod\s+-R\s+777\s+/"
+    r"|git\s+push\s+.*--force"
+    r"|git\s+reset\s+--hard\s+origin"
+    r"|(curl|wget)[^|]*\|\s*(ba|z|s)?sh"
+    r"|>\s*/dev/sd[a-z])",
+    re.IGNORECASE,
+)
+
+
+@dataclass
+class ToolResult:
+    ok: bool
+    output: str
+    display: str = ""          # what to show the user (may differ from model output)
+    needs_approval: bool = False
+
+
+def _clip(text: str, limit: int = MAX_OUTPUT_CHARS) -> str:
+    text = text or ""
+    if len(text) <= limit:
+        return text
+    half = limit // 2
+    return (
+        text[:half]
+        + f"\n\n… [{len(text) - limit} characters trimmed] …\n\n"
+        + text[-half:]
+    )
+
+
+class Workspace:
+    """Filesystem access confined to one directory tree."""
+
+    def __init__(self, root: str):
+        self.root = Path(root).resolve()
+
+    def resolve(self, relative: str) -> Path:
+        """Resolve a model-supplied path, refusing anything outside root.
+
+        The model routinely proposes paths like '../config' or an absolute
+        '/etc/passwd' when it's confused about where it is. Refusing here
+        is cheaper than trusting the prompt to have said "don't".
+        """
+        candidate = (self.root / relative).resolve()
+        if candidate != self.root and self.root not in candidate.parents:
+            raise PermissionError(
+                f"Path '{relative}' is outside the workspace ({self.root})."
+            )
+        return candidate
+
+    def rel(self, path: Path) -> str:
+        try:
+            return str(path.relative_to(self.root))
+        except ValueError:
+            return str(path)
+
+
+# ── Tool schema sent to the model ─────────────────────────────────────────────
+
+TOOL_SCHEMA = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": (
+                "Read a text file from the workspace. Prefer a line range for "
+                "large files — read only what you need."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Path relative to workspace root"},
+                    "start_line": {"type": "integer", "description": "1-indexed, optional"},
+                    "end_line": {"type": "integer", "description": "inclusive, optional"},
+                },
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "List files under a directory. Build/junk directories are excluded.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Directory, default workspace root"},
+                    "depth": {"type": "integer", "description": "Max depth, default 2"},
+                },
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "grep",
+            "description": (
+                "Search file contents with a regular expression. Returns matching "
+                "lines with file, line number and surrounding context. Use this "
+                "to locate code instead of reading whole files."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {"type": "string"},
+                    "path": {"type": "string", "description": "Directory to search, optional"},
+                    "glob": {"type": "string", "description": "e.g. '*.py', optional"},
+                },
+                "required": ["pattern"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "edit_file",
+            "description": (
+                "Replace an exact string in a file. old_string must appear EXACTLY "
+                "once — include surrounding lines to make it unique. This is the "
+                "preferred way to change code; it is checked for syntax before "
+                "being written."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string"},
+                    "old_string": {"type": "string", "description": "Exact text to replace"},
+                    "new_string": {"type": "string", "description": "Replacement text"},
+                },
+                "required": ["path", "old_string", "new_string"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": (
+                "Create a new file or fully overwrite an existing one. Use "
+                "edit_file for changes to existing files."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string"},
+                    "content": {"type": "string"},
+                },
+                "required": ["path", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_command",
+            "description": (
+                "Run a shell command in the workspace — tests, linters, build "
+                "steps, git status. Requires user approval."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string"},
+                    "reason": {"type": "string", "description": "Why this is needed"},
+                },
+                "required": ["command"],
+            },
+        },
+    },
+]
+
+DESTRUCTIVE = {"edit_file", "write_file", "run_command"}
+
+
+# ── Verification ──────────────────────────────────────────────────────────────
+
+
+def verify_syntax(path: Path, content: str) -> Optional[str]:
+    """→ an error string if the content is broken, else None.
+
+    Deliberately narrow: this catches "the model produced code that cannot
+    parse", which is the single most common way an AI edit wastes your
+    time. Type errors and logic bugs are the test suite's job.
+    """
+    suffix = path.suffix.lower()
+    try:
+        if suffix == ".py":
+            ast.parse(content)
+        elif suffix == ".json":
+            json.loads(content)
+    except SyntaxError as exc:
+        return f"Python syntax error at line {exc.lineno}: {exc.msg}"
+    except json.JSONDecodeError as exc:
+        return f"Invalid JSON at line {exc.lineno}: {exc.msg}"
+    except Exception as exc:
+        return str(exc)
+    return None
+
+
+def make_diff(before: str, after: str, filename: str) -> str:
+    diff = difflib.unified_diff(
+        before.splitlines(keepends=True),
+        after.splitlines(keepends=True),
+        fromfile=f"a/{filename}",
+        tofile=f"b/{filename}",
+        n=3,
+    )
+    return "".join(diff)
+
+
+# ── Executor ──────────────────────────────────────────────────────────────────
+
+
+class ToolExecutor:
+    def __init__(self, workspace: Workspace, auto_approve: bool = False,
+                 dry_run: bool = False):
+        self.ws = workspace
+        self.auto_approve = auto_approve
+        self.dry_run = dry_run
+        self.files_changed: list[str] = []
+        self.commands_run: list[str] = []
+
+    # -- individual tools ---------------------------------------------------
+
+    def read_file(self, path: str, start_line: int = None, end_line: int = None) -> ToolResult:
+        target = self.ws.resolve(path)
+        if not target.exists():
+            return ToolResult(False, f"File not found: {path}")
+        if target.suffix.lower() in BINARY_SUFFIXES:
+            return ToolResult(False, f"{path} is a binary file — not readable as text.")
+        if target.stat().st_size > MAX_READ_BYTES:
+            return ToolResult(
+                False,
+                f"{path} is {target.stat().st_size // 1024} KB — too large. "
+                "Use grep to find the relevant part, then read with a line range.",
+            )
+        text = target.read_text(errors="replace")
+        lines = text.splitlines()
+        if start_line or end_line:
+            start = max(1, start_line or 1)
+            end = min(len(lines), end_line or len(lines))
+            selected = lines[start - 1:end]
+            numbered = "\n".join(f"{i}: {l}" for i, l in enumerate(selected, start))
+            return ToolResult(True, _clip(numbered), f"read {path}:{start}-{end}")
+        numbered = "\n".join(f"{i}: {l}" for i, l in enumerate(lines, 1))
+        return ToolResult(True, _clip(numbered), f"read {path} ({len(lines)} lines)")
+
+    def list_files(self, path: str = ".", depth: int = 2) -> ToolResult:
+        base = self.ws.resolve(path)
+        if not base.exists():
+            return ToolResult(False, f"Not found: {path}")
+        entries = []
+        base_depth = len(base.parts)
+        for root, dirs, files in os.walk(base):
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+            current = Path(root)
+            if len(current.parts) - base_depth >= depth:
+                dirs[:] = []
+            for name in sorted(files):
+                if Path(name).suffix.lower() in BINARY_SUFFIXES:
+                    continue
+                entries.append(self.ws.rel(current / name))
+            if len(entries) > 400:
+                entries.append("… (truncated)")
+                break
+        return ToolResult(True, "\n".join(entries), f"listed {path} ({len(entries)} files)")
+
+    def grep(self, pattern: str, path: str = ".", glob: str = None) -> ToolResult:
+        base = self.ws.resolve(path)
+        try:
+            regex = re.compile(pattern)
+        except re.error as exc:
+            return ToolResult(False, f"Invalid regex: {exc}")
+
+        matches = []
+        for root, dirs, files in os.walk(base):
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
+            for name in files:
+                if Path(name).suffix.lower() in BINARY_SUFFIXES:
+                    continue
+                if glob and not Path(name).match(glob):
+                    continue
+                file_path = Path(root) / name
+                try:
+                    if file_path.stat().st_size > MAX_READ_BYTES:
+                        continue
+                    lines = file_path.read_text(errors="replace").splitlines()
+                except Exception:
+                    continue
+                for index, line in enumerate(lines, 1):
+                    if regex.search(line):
+                        matches.append(f"{self.ws.rel(file_path)}:{index}: {line.strip()[:200]}")
+                        if len(matches) >= MAX_GREP_MATCHES:
+                            break
+            if len(matches) >= MAX_GREP_MATCHES:
+                break
+        if not matches:
+            return ToolResult(True, f"No matches for /{pattern}/", f"grep {pattern} — 0 hits")
+        return ToolResult(
+            True, "\n".join(matches), f"grep {pattern} — {len(matches)} hits"
+        )
+
+    def edit_file(self, path: str, old_string: str, new_string: str) -> tuple[ToolResult, str]:
+        """→ (result, preview diff). Does not write; caller applies after approval."""
+        target = self.ws.resolve(path)
+        if not target.exists():
+            return ToolResult(False, f"File not found: {path}"), ""
+        original = target.read_text(errors="replace")
+
+        occurrences = original.count(old_string)
+        if occurrences == 0:
+            return ToolResult(
+                False,
+                f"old_string not found in {path}. It must match the file exactly, "
+                "including whitespace and indentation. Read the file again and "
+                "copy the text verbatim.",
+            ), ""
+        if occurrences > 1:
+            return ToolResult(
+                False,
+                f"old_string appears {occurrences} times in {path} — ambiguous. "
+                "Include more surrounding lines so it matches exactly once.",
+            ), ""
+
+        updated = original.replace(old_string, new_string, 1)
+        error = verify_syntax(target, updated)
+        if error:
+            return ToolResult(
+                False,
+                f"Edit rejected — it would break {path}: {error}. "
+                "The file was NOT modified. Fix the syntax and try again.",
+            ), ""
+        return ToolResult(True, "", f"edit {path}", needs_approval=True), make_diff(
+            original, updated, self.ws.rel(target)
+        )
+
+    def apply_edit(self, path: str, old_string: str, new_string: str) -> ToolResult:
+        target = self.ws.resolve(path)
+        original = target.read_text(errors="replace")
+        updated = original.replace(old_string, new_string, 1)
+        if self.dry_run:
+            return ToolResult(True, f"[dry-run] would edit {path}")
+        target.write_text(updated)
+        rel = self.ws.rel(target)
+        if rel not in self.files_changed:
+            self.files_changed.append(rel)
+        changed = len(updated.splitlines()) - len(original.splitlines())
+        return ToolResult(
+            True,
+            f"Edited {path} successfully ({changed:+d} lines). Syntax verified.",
+            f"edited {path}",
+        )
+
+    def write_file(self, path: str, content: str) -> tuple[ToolResult, str]:
+        target = self.ws.resolve(path)
+        existed = target.exists()
+        original = target.read_text(errors="replace") if existed else ""
+        error = verify_syntax(target, content)
+        if error:
+            return ToolResult(
+                False,
+                f"Write rejected — content would not parse: {error}. "
+                f"{path} was NOT modified.",
+            ), ""
+        return ToolResult(True, "", f"write {path}", needs_approval=True), make_diff(
+            original, content, self.ws.rel(target)
+        )
+
+    def apply_write(self, path: str, content: str) -> ToolResult:
+        target = self.ws.resolve(path)
+        if self.dry_run:
+            return ToolResult(True, f"[dry-run] would write {path}")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        existed = target.exists()
+        target.write_text(content)
+        rel = self.ws.rel(target)
+        if rel not in self.files_changed:
+            self.files_changed.append(rel)
+        return ToolResult(
+            True,
+            f"{'Overwrote' if existed else 'Created'} {path} "
+            f"({len(content.splitlines())} lines). Syntax verified.",
+            f"wrote {path}",
+        )
+
+    def run_command(self, command: str, reason: str = "") -> ToolResult:
+        if DANGEROUS.search(command):
+            return ToolResult(
+                False,
+                "Command refused: it matches a destructive pattern. "
+                "Ask the user to run it themselves if it is genuinely needed.",
+            )
+        if self.dry_run:
+            return ToolResult(True, f"[dry-run] would run: {command}")
+        started = time.time()
+        try:
+            proc = subprocess.run(
+                command,
+                shell=True,
+                cwd=str(self.ws.root),
+                capture_output=True,
+                text=True,
+                timeout=COMMAND_TIMEOUT,
+            )
+        except subprocess.TimeoutExpired:
+            return ToolResult(False, f"Command timed out after {COMMAND_TIMEOUT}s.")
+        except Exception as exc:
+            return ToolResult(False, f"Failed to run: {exc}")
+
+        self.commands_run.append(command)
+        elapsed = time.time() - started
+        output = (proc.stdout or "") + (("\n[stderr]\n" + proc.stderr) if proc.stderr else "")
+        return ToolResult(
+            proc.returncode == 0,
+            f"exit code {proc.returncode} ({elapsed:.1f}s)\n\n{_clip(output)}",
+            f"ran: {command} → exit {proc.returncode}",
+        )
+
+
+# ── git safety ────────────────────────────────────────────────────────────────
+
+
+def git_status(root: str) -> dict:
+    """→ {'repo': bool, 'dirty': bool, 'branch': str|None}.
+
+    Used to warn before an agent edits a tree with uncommitted work — the
+    difference between "I can undo this" and "I lost an hour".
+    """
+    def run(args):
+        return subprocess.run(
+            args, cwd=root, capture_output=True, text=True, timeout=10
+        )
+
+    try:
+        inside = run(["git", "rev-parse", "--is-inside-work-tree"])
+        if inside.returncode != 0:
+            return {"repo": False, "dirty": False, "branch": None}
+        dirty = bool(run(["git", "status", "--porcelain"]).stdout.strip())
+        branch = run(["git", "rev-parse", "--abbrev-ref", "HEAD"]).stdout.strip()
+        return {"repo": True, "dirty": dirty, "branch": branch or None}
+    except Exception:
+        return {"repo": False, "dirty": False, "branch": None}
+
+
+# Output that means "the tool isn't installed / isn't on PATH", NOT "your
+# code is broken". Windows says "is not recognized"; POSIX says "command not
+# found"; python -m says "No module named". Treating these as test failures
+# is what sent one run chasing a PATH problem and writing a pytest.bat into
+# the user's repo.
+_ENV_FAILURE_MARKERS = (
+    "is not recognized",
+    "command not found",
+    "no module named",
+    "not found: pytest",
+    "cannot find the path",
+    "executable file not found",
+    "no such file or directory",
+)
+
+
+def is_environment_failure(output: str, exit_code: int) -> bool:
+    """True when the verification command could not RUN, as opposed to ran
+    and found failing tests."""
+    if exit_code in (127, 9009):        # POSIX / Windows "not found"
+        return True
+    lowered = (output or "").lower()
+    return any(marker in lowered for marker in _ENV_FAILURE_MARKERS)
+
+
+def detect_test_command(root: str) -> Optional[str]:
+    """Guess how this project runs its tests, for the verification pass.
+
+    Python commands are built from sys.executable rather than a bare
+    `pytest`, because the bare name depends on the interpreter's Scripts
+    directory being on PATH — frequently false on Windows, and a source of
+    false verification failures that look like broken code.
+    """
+    import sys
+
+    path = Path(root)
+    python = f'"{sys.executable}"' if " " in sys.executable else sys.executable
+
+    if (path / "pytest.ini").exists() or (path / "tests").is_dir():
+        return f"{python} -m pytest -q"
+    if (path / "package.json").exists():
+        try:
+            data = json.loads((path / "package.json").read_text())
+            if "test" in (data.get("scripts") or {}):
+                return "npm test"
+        except Exception:
+            pass
+    if (path / "pyproject.toml").exists():
+        return f"{python} -m pytest -q"
+    if (path / "go.mod").exists():
+        return "go test ./..."
+    if (path / "Cargo.toml").exists():
+        return "cargo test"
+    return None

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/simulai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simulai-cli
-Version: 2.0.1
+Version: 2.1.0
 Summary: SimulAI CLI — persistent AI chat in your terminal. SmartRoute across 20+ models, Naira billing, and import your Claude Code / Codex sessions.
 Author-email: Simul AI <hello@trysimulai.com>
 License: MIT
@@ -62,6 +62,7 @@ conversation you can continue on any model.
 | Command | What it does |
 |---|---|
 | `simulai login` | Log in (unlocks everything) |
+| `simulai code "task"` | **Agentic coding** — reads, greps, edits and tests this repo |
 | `simulai chat` | Resume this directory's conversation |
 | `simulai chat "msg"` | One-shot |
 | `simulai chat -m <model>` | Force a specific model |

{simulai_cli-2.0.1 → simulai_cli-2.1.0}/simulai_cli.egg-info/SOURCES.txt

@@ -1,11 +1,13 @@
 README.md
 pyproject.toml
 simulai_cli/__init__.py
+simulai_cli/agent.py
 simulai_cli/api.py
 simulai_cli/config.py
 simulai_cli/discovery.py
 simulai_cli/main.py
 simulai_cli/render.py
+simulai_cli/tools.py
 simulai_cli.egg-info/PKG-INFO
 simulai_cli.egg-info/SOURCES.txt
 simulai_cli.egg-info/dependency_links.txt