forgecommandline 0.8.0__py3-none-any.whl

forgecli/parallel.py

@@ -0,0 +1,308 @@
+"""Parallel sub-agents. Off unless the user asks: /parallel <task> || <task>, or
+/parallel on to let the main agent split work itself with the run_parallel tool.
+
+Each sub-agent gets a copy of the whole conversation so far (so it knows what
+was already done), works on its own task in a thread, and starts its failover
+chain at a different provider so the load spreads across keys. Their reports
+go back into the main conversation, so every later reply knows what they did."""
+from __future__ import annotations
+
+import copy
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.markdown import Markdown
+from rich.text import Text
+
+from .ui import UI, console
+
+CONFIRM_LOCK = threading.Lock()   # one approval prompt on screen at a time
+COLORS = ["#67e8f9", "#fbbf24", "#4ade80", "#f472b6", "#93c5fd", "#fb923c", "#a3e635", "#e879f9"]
+
+SCHEMA = {
+    "type": "function",
+    "function": {
+        "name": "run_parallel",
+        "description": (
+            "Run 2 or more independent tasks at the same time, each by its own sub-agent with a copy of "
+            "this conversation. Use only when the work splits into parts that don't depend on each other "
+            "and don't edit the same files. You get back each agent's report."),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "tasks": {
+                    "type": "array", "minItems": 2,
+                    "items": {"type": "string", "description": "Full, self-contained instructions for one agent"},
+                },
+                "isolate": {
+                    "type": "boolean",
+                    "description": ("Give each agent its own git worktree and branch so their edits can't "
+                                    "collide (git projects only). Use when agents might touch the same files."),
+                },
+            },
+            "required": ["tasks"],
+        },
+    },
+}
+
+
+DELEGATE_SCHEMA = {
+    "type": "function",
+    "function": {
+        "name": "delegate",
+        "description": (
+            "Hand tasks to team members (other models) that run at the same time, each with a copy of this "
+            "conversation. Pick the worker whose strengths fit each task, from the team list in your "
+            "instructions. Tasks must be independent and must not edit the same files. You get back each "
+            "worker's report; then check, combine, and finish the job."),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "tasks": {
+                    "type": "array", "minItems": 1,
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "task": {"type": "string", "description": "Full, self-contained instructions"},
+                            "worker": {"type": "string", "description": "Worker id from the team list, e.g. nvidia:minimaxai/minimax-m3.1-flash"},
+                            "why": {"type": "string", "description": "One short reason this worker fits"},
+                        },
+                        "required": ["task", "worker"],
+                    },
+                },
+            },
+            "required": ["tasks"],
+        },
+    },
+}
+
+
+def split_tasks(text: str) -> list[str]:
+    return [t.strip() for t in text.split("||") if t.strip()]
+
+
+def parse_tasks(items) -> list[dict]:
+    """Normalise tasks to {task, worker, why}. Accepts plain strings, '@worker task'
+    strings, or dicts from the delegate tool."""
+    out = []
+    for it in items or []:
+        if isinstance(it, dict):
+            task = str(it.get("task", "")).strip()
+            worker, why = str(it.get("worker", "")).strip(), str(it.get("why", "")).strip()
+        else:
+            task, worker, why = str(it).strip(), "", ""
+            if task.startswith("@"):
+                head, _, rest = task.partition(" ")
+                worker, task = head[1:], rest.strip()
+        if task:
+            out.append({"task": task, "worker": worker, "why": why})
+    return out
+
+
+class SubUI(UI):
+    """Quiet, labelled output for a sub-agent running in a thread."""
+
+    def __init__(self, parent: UI, n: int):
+        super().__init__(parent.verbose)
+        self.n = n
+        self.color = COLORS[(n - 1) % len(COLORS)]
+        self.final = ""
+
+    def _tag(self) -> Text:
+        return Text(f"  [{self.n}] ", style=f"bold {self.color}")
+
+    def start_spinner(self, label: str = "thinking") -> None: ...
+    def stop_spinner(self) -> None: ...
+    def tool_result(self, text: str) -> None: ...
+
+    def log(self, msg: str) -> None:
+        if self.verbose:
+            console.print(self._tag().append(f"↳ {msg}", style="faint"))
+
+    def tool(self, name: str, summary: str) -> None:
+        console.print(self._tag().append(name, style="tool").append("  ").append(summary[:120], style="muted"))
+
+    def assistant(self, text: str, meta: str = "") -> None:
+        self.final = text   # shown when the agent finishes
+
+    def info(self, msg: str) -> None:
+        console.print(self._tag().append(msg, style="muted"))
+
+    def warn(self, msg: str) -> None:
+        console.print(self._tag().append(msg, style="warn"))
+
+    def error(self, msg: str) -> None:
+        console.print(self._tag().append("✗ " + msg, style="err"))
+
+    def confirm(self, title: str, detail: str, why: str = ""):
+        with CONFIRM_LOCK:
+            return super().confirm(f"[agent {self.n}] {title}", detail, why)
+
+    def action(self, verb: str, target: str, note: str = "") -> None:
+        console.print(self._tag().append(verb, style="tool").append(f"({target[:110]})", style="muted"))
+
+    def result(self, first: str, body=None) -> None:
+        console.print(self._tag().append("  ⎿  " + first, style="faint"))
+
+    def peek(self, kind: str, target: str) -> None: ...
+    def flush(self) -> None: ...
+    def failover(self, msg: str) -> None:
+        console.print(self._tag().append("⚠ " + msg, style="warn"))
+
+
+def _handoff_packet(parent, task: str, reason: str) -> str:
+    goal = parent._goal() if hasattr(parent, "_goal") else ""
+    if not goal:
+        goal = next((str(m.get("content") or "") for m in reversed(parent.messages)
+                     if m.get("role") == "user"), "")
+    lines = [f"Original user goal: {goal}",
+             f"Why this task was handed off: {reason or 'independent tasks requested'}"]
+
+    reads, changes, attempts = [], [], []
+    for step in parent.tools.ledger.steps:
+        path = str(step.args.get("path", "")).strip()
+        if step.name == "read_file" and path:
+            reads.append(path)
+        elif step.name in ("write_file", "edit_file") and path:
+            (changes if step.ok else attempts).append(path)
+        if step.name == "run_shell":
+            command = str(step.args.get("command", "")).strip()
+            if command:
+                status = "succeeded" if step.ok else "failed"
+                detail = " ".join(step.out.split())[:220]
+                attempts.append(f"command {command!r} ({status})" +
+                                (f": {detail}" if detail else ""))
+        elif not step.ok:
+            detail = " ".join(step.out.split())[:220]
+            attempts.append(f"{step.name} failed" + (f": {detail}" if detail else ""))
+
+    if reads:
+        lines.append("Files already read:\n" + "\n".join(f"- {p}" for p in dict.fromkeys(reads)))
+    if changes:
+        lines.append("Files already changed:\n" + "\n".join(f"- {p}" for p in dict.fromkeys(changes)))
+    if attempts:
+        lines.append("What was tried:\n" + "\n".join(f"- {item}" for item in dict.fromkeys(attempts)))
+
+    skill_results = {m.get("tool_call_id"): m.get("content", "") for m in parent.messages
+                     if m.get("role") == "tool"}
+    skills = []
+    for message in parent.messages:
+        if message.get("role") != "assistant":
+            continue
+        for call in message.get("tool_calls") or []:
+            fn = call.get("function") or {}
+            if fn.get("name") == "use_skill" and call.get("id") in skill_results:
+                skills.append(skill_results[call["id"]])
+    if skills:
+        lines.append("Loaded skill instructions:\n" + "\n\n".join(dict.fromkeys(skills)))
+
+    lines.append(
+        f"Assigned task: {task}\n\nDo only this task. Avoid files changed above unless necessary. "
+        "Return a short report of actions, changed files, verification, and anything unresolved.")
+    return "\n\n".join(lines)
+
+
+def coordinator_packet(parent, reason: str) -> str:
+    return "[Coordinator hand-off packet]\n" + _handoff_packet(
+        parent, "Continue the original user goal without repeating completed work.", reason)
+
+
+def run_tasks(parent, tasks: list, reason: str = "", isolate: bool | None = None) -> str:
+    """Run tasks concurrently. Tasks are strings ('@worker task' allowed) or
+    {task, worker, why} dicts. Returns a combined report (also used as a tool result)."""
+    from .agent import Agent   # local import: agent imports this module
+    from . import roster
+
+    ui: UI = parent.ui
+    tasks = parse_tasks(tasks)
+    if any(t["worker"] for t in tasks):
+        workers = roster.build(parent.router)
+        for t in tasks:
+            selected = roster.resolve(workers, t["worker"]) if t["worker"] else None
+            t["w"] = selected if selected and roster.usable(selected, parent.router) else None
+    limit = parent.settings.max_agents
+    was_limited = len(tasks) > limit
+    if was_limited:
+        tasks = tasks[:limit]
+    cancel = threading.Event()
+    from . import worktrees
+    repo = worktrees.repo_root(parent.tools.root) if worktrees.wanted(isolate) and len(tasks) > 1 else None
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+
+    ui.stop_spinner()
+    if not getattr(parent, "_handoff_status_shown", False):
+        targets = list(dict.fromkeys(t["w"].id for t in tasks if t.get("w")))
+        target = ", ".join(targets[:3]) if targets else "automatic worker routing"
+        if len(targets) > 3:
+            target += f" +{len(targets) - 3}"
+        status = f"◆ Handed to {target} · {reason or 'independent tasks requested'}"
+        if was_limited:
+            status += f" · capped at {limit} tasks"
+        ui.info(status)
+        parent._handoff_status_shown = True
+
+    def work(i: int, t: dict) -> dict:
+        task = t["task"]
+        sub_ui = SubUI(ui, i)
+        sub = Agent(parent.settings, sub_ui, router=parent.router, ephemeral=True)
+        sub.tools.auto_approve = parent.tools.auto_approve
+        sub.tools.always = parent.tools.always          # "always" answers are shared
+        sub.offset = i - 1                               # start at a different provider
+        sub.prefer = t["w"].prefer if t.get("w") else None   # assigned model goes first
+        sub.cancel = cancel
+        tree = worktrees.create(repo, i, stamp) if repo else None
+        packet = _handoff_packet(parent, task, reason or t.get("why", ""))
+        if tree:
+            sub.tools.root = tree[0]
+            sub.messages[0] = dict(sub.messages[0], content=str(sub.messages[0]["content"]).replace(
+                str(parent.tools.root), str(tree[0])))
+            packet += (f"\n\nYou work in your own git worktree: {tree[0]} (branch {tree[1]}). Use relative "
+                       "paths or paths inside it and pass cwd for shell commands; other agents work in their "
+                       "own copies. Don't commit: Forge commits your changes when you finish.")
+        sub.messages = [sub.messages[0], {"role": "user", "content": packet}]
+        started = time.time()
+        try:
+            sub._loop()
+        except Exception as e:   # one agent failing must not take down the others
+            sub_ui.final = sub_ui.final or f"Agent crashed: {e}"
+        if tree:
+            sub_ui.final = (sub_ui.final or "") + "\n\nWorktree: " + worktrees.finish(repo, tree[0], tree[1], task)
+        who = sub.last_answer or "no provider answered"
+        assigned = t["w"].id if t.get("w") else ""
+        if assigned and sub.last_answer and sub.last_answer.replace(" · ", ":") != assigned:
+            who += f" (assigned {assigned}, which failed, so failover answered)"
+        return {"n": i, "task": task, "report": sub_ui.final or "(no report — it may have failed or been stopped)",
+                "who": who, "assigned": assigned, "secs": time.time() - started,
+                "evidence": copy.deepcopy(sub.tools.ledger.steps)}
+
+    results: list[dict] = []
+    city = getattr(ui, "city", None)
+    if city is not None:              # helper cubs join the delivery run, one per agent
+        city.set_helpers(len(tasks))
+        ui.act("delegating")
+    pool = ThreadPoolExecutor(max_workers=len(tasks), thread_name_prefix="forge-agent")
+    futures = [pool.submit(work, i, t) for i, t in enumerate(tasks, 1)]
+    try:
+        for f in futures:
+            while not f.done():   # short sleeps keep ctrl+c responsive on Windows
+                time.sleep(0.2)
+            results.append(f.result())
+    except KeyboardInterrupt:
+        cancel.set()
+        ui.warn("stopping agents after their current step…")
+        results = [f.result() for f in futures]
+    finally:
+        pool.shutdown(wait=True)
+        if city is not None:
+            city.set_helpers(0)
+            ui.act("thinking")        # back to the main agent, which reads the reports
+
+    for result in results:
+        parent.tools.ledger.steps.extend(result["evidence"])
+
+    for r in results:
+        ui.panel(Markdown(r["report"].strip(), code_theme="monokai"),
+                 title=f"agent {r['n']} · {r['task'][:60]}", subtitle=f"{r['who'][:90]} · {r['secs']:.0f}s")
+    return "\n\n".join(f"### Agent {r['n']}: {r['task']}\n(answered by {r['who']})\n\n{r['report']}"
+                       for r in results)

forgecli/prices.py

@@ -0,0 +1,72 @@
+"""What a session's tokens would cost. Most of Forge's providers are free tiers (cost $0); for paid
+ones this is an estimate from public list prices per million tokens, which change - put your own in
+~/.forge/prices.json as {"provider:model" or "model": [input_per_million, output_per_million]}.
+Cached-input discounts are not counted, so real bills can be lower."""
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+
+# (input $, output $) per 1M tokens. Matched against "provider:model", then the model name, then a
+# substring of the model name. Unknown paid models show "price unknown" rather than a guess.
+LIST = {
+    "gpt-4o-mini": (0.15, 0.60),
+    "gpt-4o": (2.50, 10.00),
+    "gpt-4.1-mini": (0.40, 1.60),
+    "gpt-4.1": (2.00, 8.00),
+    "o4-mini": (1.10, 4.40),
+    "claude-haiku": (1.00, 5.00),
+    "claude-sonnet": (3.00, 15.00),
+    "claude-opus": (15.00, 75.00),
+    "gemini-2.5-flash": (0.30, 2.50),
+    "gemini-2.5-pro": (1.25, 10.00),
+    "deepseek-chat": (0.27, 1.10),
+    "deepseek-reasoner": (0.55, 2.19),
+}
+# Providers whose keys in Forge are free tiers: no money changes hands.
+FREE_PROVIDERS = {"groq", "cerebras", "nvidia", "llm7", "ovh", "kilo", "github", "cloudflare", "sambanova",
+                  "mistral", "cohere", "chutes", "pollinations"}
+
+
+def _user_prices() -> dict:
+    p = pathlib.Path(os.environ.get("FORGE_HOME", pathlib.Path.home() / ".forge")) / "prices.json"
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+        return {str(k).lower(): (float(v[0]), float(v[1])) for k, v in data.items()}
+    except (OSError, ValueError, TypeError, IndexError, AttributeError):
+        return {}
+
+
+def price(provider: str, model: str) -> tuple[float, float] | None:
+    """(input, output) dollars per million tokens; (0, 0) for free; None when unknown."""
+    prov, mod = (provider or "").lower(), (model or "").lower()
+    user = _user_prices()
+    for key in (f"{prov}:{mod}", mod):
+        if key in user:
+            return user[key]
+    if prov in FREE_PROVIDERS or mod.endswith(":free") or "/free" in mod or mod == "free":
+        return (0.0, 0.0)
+    if prov == "openrouter" and mod.endswith(":free"):
+        return (0.0, 0.0)
+    for name in sorted(LIST, key=len, reverse=True):
+        if name in mod:
+            return LIST[name]
+    return None
+
+
+def summary(by_model: dict) -> tuple[list[str], float, bool]:
+    """Lines for /cost, the total in dollars, and whether any model's price was unknown."""
+    lines, total, unknown = [], 0.0, False
+    for key, (tin, tout) in sorted(by_model.items(), key=lambda kv: -(kv[1][0] + kv[1][1])):
+        prov, _, mod = key.partition(":")
+        p = price(prov, mod)
+        if p is None:
+            unknown = True
+            cost = "price unknown"
+        else:
+            dollars = (tin * p[0] + tout * p[1]) / 1_000_000
+            total += dollars
+            cost = "free" if p == (0.0, 0.0) else f"${dollars:,.4f}"
+        lines.append(f"{prov} · {mod}: {tin:,} in / {tout:,} out — {cost}")
+    return lines, total, unknown

forgecli/procs.py

@@ -0,0 +1,144 @@
+"""Running shell commands without ever hanging the chat.
+
+Output goes to a log file instead of pipes. (On Windows, a pipe stays open while any
+grandchild holds it, so a server started through powershell made subprocess.run wait
+forever even after its timeout.) A command that turns out to be a server (it prints a
+local URL and keeps running) is moved to the background automatically, so the agent can
+carry on and open it in the browser. Background processes are stopped when Forge exits."""
+from __future__ import annotations
+
+import atexit
+import os
+import re
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+LOG_DIR = Path(tempfile.gettempdir()) / "forge-cli-logs"
+URL_RE = re.compile(r"https?://(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\]|[\w.-]+):\d{2,5}[^\s'\"<>]*", re.I)
+SERVER_HINT = re.compile(r"running on|listening|serving|server (?:is )?(?:running|started)|"
+                         r"press ctrl\+c|ready in|local:|started server|development server", re.I)
+WIN = os.name == "nt"
+
+
+@dataclass
+class Proc:
+    id: int
+    command: str
+    cwd: str
+    popen: subprocess.Popen
+    log: Path
+    started: float = field(default_factory=time.time)
+
+    def alive(self) -> bool:
+        return self.popen.poll() is None
+
+    def output(self, tail: int = 8000) -> str:
+        try:
+            data = self.log.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return ""
+        return data[-tail:]
+
+    def urls(self) -> list[str]:
+        seen = []
+        for u in URL_RE.findall(self.output(200_000)):
+            u = u.rstrip(".,);]").replace("0.0.0.0", "127.0.0.1")
+            if u not in seen:
+                seen.append(u)
+        return seen
+
+    def state(self) -> str:
+        return "running" if self.alive() else f"exited ({self.popen.returncode})"
+
+
+_PROCS: dict[int, Proc] = {}
+_LOCK = threading.Lock()
+_NEXT = [1]
+
+
+def argv_for(shell: str, command: str) -> list[str]:
+    if shell == "powershell":
+        return ["powershell", "-NoProfile", "-NonInteractive", "-Command", command]
+    if shell == "pwsh":
+        return ["pwsh", "-NoProfile", "-NonInteractive", "-Command", command]
+    if shell == "cmd":
+        return ["cmd", "/c", command]
+    return [shell, "-lc", command]
+
+
+def start(shell: str, command: str, cwd: str, argv: list[str] | None = None) -> Proc:
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    with _LOCK:
+        pid_n = _NEXT[0]
+        _NEXT[0] += 1
+    log = LOG_DIR / f"{os.getpid()}-{pid_n}.log"
+    fh = open(log, "wb")
+    env = dict(os.environ, PYTHONUNBUFFERED="1", PYTHONIOENCODING="utf-8")
+    kw = {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP} if WIN else {"start_new_session": True}
+    try:
+        popen = subprocess.Popen(argv or argv_for(shell, command), cwd=cwd, stdout=fh, stderr=subprocess.STDOUT,
+                                 stdin=subprocess.DEVNULL, env=env, **kw)
+    finally:
+        fh.close()   # the child has its own handle
+    p = Proc(pid_n, command, cwd, popen, log)
+    with _LOCK:
+        _PROCS[pid_n] = p
+    return p
+
+
+def kill(p: Proc) -> None:
+    """Stop the process and everything it started."""
+    if not p.alive():
+        return
+    try:
+        if WIN:
+            subprocess.run(["taskkill", "/T", "/F", "/PID", str(p.popen.pid)],
+                           capture_output=True, timeout=15)
+        else:
+            import signal
+            os.killpg(p.popen.pid, signal.SIGTERM)
+    except Exception:
+        pass
+    try:
+        p.popen.wait(timeout=5)
+    except Exception:
+        try:
+            p.popen.kill()
+        except Exception:
+            pass
+
+
+def forget(p: Proc) -> None:
+    with _LOCK:
+        _PROCS.pop(p.id, None)
+    try:
+        p.log.unlink()
+    except OSError:
+        pass
+
+
+def get(n) -> Proc | None:
+    try:
+        return _PROCS.get(int(n))
+    except (TypeError, ValueError):
+        return None
+
+
+def all_procs() -> list[Proc]:
+    return list(_PROCS.values())
+
+
+def looks_like_server(p: Proc) -> bool:
+    out = p.output(20_000)
+    return bool(URL_RE.search(out)) or bool(SERVER_HINT.search(out))
+
+
+@atexit.register
+def _cleanup() -> None:
+    for p in all_procs():
+        kill(p)
+        forget(p)