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

simulai_cli-2.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: simulai-cli
+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
+Project-URL: Homepage, https://trysimulai.com
+Project-URL: Documentation, https://docs.trysimulai.com
+Project-URL: Repository, https://github.com/Gracemansam/simulai_client
+Keywords: ai,llm,cli,nigeria,openai,claude,gemini,claude-code,codex,coding-agent,smartroute
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.24.0
+
+# SimulAI CLI v2
+
+Persistent AI chat in your terminal. SmartRoute across 20+ models, Naira
+billing, and one-command import of your Claude Code / Codex CLI sessions.
+
+## Install
+
+```bash
+pip install simulai-cli
+simulai login
+```
+
+## Core ideas
+
+**Your conversation follows you.** Every exchange is saved server-side, so
+a thread started in the terminal continues in the web app and vice versa.
+Inside a repo, `simulai chat` resumes that repo's conversation automatically.
+
+**SmartRoute by default, your call any time.** The same router the web
+dashboard uses picks a model per message. `/model anthropic/claude-sonnet-4`
+takes over whenever you want, and the choice persists.
+
+**Hit a limit in another tool? Bring the session with you.**
+
+```bash
+cd ~/code/my-api
+simulai import claude-code
+```
+
+Shows *this repo's* sessions from the last two weeks — not a month of every
+project you've touched. Pick one, and it lands in SimulAI as a normal
+conversation you can continue on any model.
+
+## Commands
+
+| 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 chat --web` | Live web search |
+| `simulai chat -f file.py` | Attach a file |
+| `simulai chats` | List conversations |
+| `simulai resume` | Pick one and bind it here |
+| `simulai import claude-code` | Import a Claude Code session from this repo |
+| `simulai import codex` | Same for Codex CLI |
+| `simulai import scan` | Check every supported agent |
+| `simulai import file x.jsonl` | Import an exported transcript |
+| `simulai import link <url>` | Import a ChatGPT/Claude share link |
+| `simulai analyze file.py` | Review a file |
+| `simulai models [query]` | Browse models |
+| `simulai wallet` | Credit balance |
+| `simulai usage` | Credit ledger — what you spent, on what |
+| `simulai config effort max` | Change a default |
+
+## In-chat slash commands
+
+`/model` `/models` `/smart` `/effort` `/web` `/mode` `/project` `/new`
+`/title` `/code` `/save` `/file` `/cost` `/usage` `/trim` `/clear` `/exit`
+
+Run `/help` for the full list.

simulai_cli-2.1.0/README.md

@@ -0,0 +1,63 @@
+# SimulAI CLI v2
+
+Persistent AI chat in your terminal. SmartRoute across 20+ models, Naira
+billing, and one-command import of your Claude Code / Codex CLI sessions.
+
+## Install
+
+```bash
+pip install simulai-cli
+simulai login
+```
+
+## Core ideas
+
+**Your conversation follows you.** Every exchange is saved server-side, so
+a thread started in the terminal continues in the web app and vice versa.
+Inside a repo, `simulai chat` resumes that repo's conversation automatically.
+
+**SmartRoute by default, your call any time.** The same router the web
+dashboard uses picks a model per message. `/model anthropic/claude-sonnet-4`
+takes over whenever you want, and the choice persists.
+
+**Hit a limit in another tool? Bring the session with you.**
+
+```bash
+cd ~/code/my-api
+simulai import claude-code
+```
+
+Shows *this repo's* sessions from the last two weeks — not a month of every
+project you've touched. Pick one, and it lands in SimulAI as a normal
+conversation you can continue on any model.
+
+## Commands
+
+| 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 chat --web` | Live web search |
+| `simulai chat -f file.py` | Attach a file |
+| `simulai chats` | List conversations |
+| `simulai resume` | Pick one and bind it here |
+| `simulai import claude-code` | Import a Claude Code session from this repo |
+| `simulai import codex` | Same for Codex CLI |
+| `simulai import scan` | Check every supported agent |
+| `simulai import file x.jsonl` | Import an exported transcript |
+| `simulai import link <url>` | Import a ChatGPT/Claude share link |
+| `simulai analyze file.py` | Review a file |
+| `simulai models [query]` | Browse models |
+| `simulai wallet` | Credit balance |
+| `simulai usage` | Credit ledger — what you spent, on what |
+| `simulai config effort max` | Change a default |
+
+## In-chat slash commands
+
+`/model` `/models` `/smart` `/effort` `/web` `/mode` `/project` `/new`
+`/title` `/code` `/save` `/file` `/cost` `/usage` `/trim` `/clear` `/exit`
+
+Run `/help` for the full list.

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

@@ -1,45 +1,47 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "simulai-cli"
-version = "0.1.1"
-description = "Simul AI — Nigerian AI gateway CLI. Chat with 20+ models, analyze files, manage your wallet."
-readme = "README.md"
-license = { text = "MIT" }
-authors = [
-    { name = "Simul AI", email = "hello@trysimulai.com" }
-]
-keywords = ["ai", "llm", "cli", "nigeria", "openai", "claude", "gemini"]
-classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Environment :: Console",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-]
-requires-python = ">=3.9"
-dependencies = [
-    "typer>=0.9.0",
-    "rich>=13.0.0",
-    "httpx>=0.24.0",
-    "keyring>=24.0.0",
-]
-
-[project.scripts]
-simulai = "simulai_cli.main:app"
-
-[project.urls]
-Homepage = "https://trysimulai.com"
-Documentation = "https://docs.trysimulai.com"
-Repository = "https://github.com/Gracemansam/simulai_client"
-
-[tool.setuptools.packages.find]
-where = ["."]
-include = ["simulai_cli*"]
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simulai-cli"
+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" }
+authors = [
+    { name = "Simul AI", email = "hello@trysimulai.com" }
+]
+keywords = [
+    "ai", "llm", "cli", "nigeria", "openai", "claude", "gemini",
+    "claude-code", "codex", "coding-agent", "smartroute",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "httpx>=0.24.0",
+]
+
+[project.scripts]
+simulai = "simulai_cli.main:app"
+
+[project.urls]
+Homepage = "https://trysimulai.com"
+Documentation = "https://docs.trysimulai.com"
+Repository = "https://github.com/Gracemansam/simulai_client"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["simulai_cli*"]

simulai_cli-2.1.0/simulai_cli/__init__.py

@@ -0,0 +1 @@
+

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]")