forgecommandline 0.8.0__py3-none-any.whl

forgecli/config.py

@@ -0,0 +1,194 @@
+"""Settings, .env loading and provider definitions."""
+from __future__ import annotations
+
+import os
+import pathlib
+import platform
+from dataclasses import dataclass, field
+
+APP_DIR = pathlib.Path(__file__).resolve().parent.parent
+HOME_DIR = pathlib.Path.home() / ".forge"
+
+# Built-in OpenAI-compatible providers: name -> (base_url, default model).
+# Any other name works too if you set <NAME>_BASE_URL and <NAME>_MODEL.
+KNOWN_PROVIDERS = {
+    "groq": ("https://api.groq.com/openai/v1", "openai/gpt-oss-120b"),
+    "cerebras": ("https://api.cerebras.ai/v1", "gpt-oss-120b"),
+    "nvidia": ("https://integrate.api.nvidia.com/v1", "minimaxai/minimax-m3.1-flash"),
+    "mistral": ("https://api.mistral.ai/v1", "mistral-medium-latest"),
+    "github": ("https://models.github.ai/inference", "openai/gpt-4.1"),
+    "sambanova": ("https://api.sambanova.ai/v1", "Meta-Llama-3.3-70B-Instruct"),
+    "huggingface": ("https://router.huggingface.co/v1", "openai/gpt-oss-120b"),
+    "together": ("https://api.together.xyz/v1", "meta-llama/Llama-3.3-70B-Instruct-Turbo"),
+    "cohere": ("https://api.cohere.ai/compatibility/v1", "command-a-03-2025"),
+    "deepseek": ("https://api.deepseek.com/v1", "deepseek-chat"),
+    "openrouter": ("https://openrouter.ai/api/v1", "nvidia/nemotron-3-ultra-550b-a55b:free"),
+    "openai": ("https://api.openai.com/v1", "gpt-4.1-mini"),
+    "gemini": ("https://generativelanguage.googleapis.com/v1beta/openai", "gemini-2.5-flash"),
+    # More free tiers (from github.com/mnfst/awesome-free-llm-apis); used once you add a key.
+    "zai": ("https://open.bigmodel.cn/api/paas/v4", "glm-4.7-flash"),
+    "gonka": ("https://proxy.gonkabroker.com/v1", "deepseek-ai/DeepSeek-V4-Flash-0731"),
+    "aion": ("https://api.aionlabs.ai/v1", "aion-labs/aion-3.0-mini"),
+    "modelscope": ("https://api-inference.modelscope.cn/v1", "Qwen/Qwen3.5-35B-A3B"),
+    "siliconflow": ("https://api.siliconflow.cn/v1", "Qwen/Qwen3-8B"),
+    # No key needed at all. Tried last, as a safety net when every keyed provider is resting.
+    # They are shared public gateways: FORGE_KEYLESS=0 turns them off.
+    "kilo": ("https://api.kilo.ai/api/gateway", "kilo-auto/free"),
+    "llm7": ("https://api.llm7.io/v1", "gpt-oss:20b"),
+    "ovh": ("https://oai.endpoints.kepler.ai.cloud.ovh.net/v1", "gpt-oss-120b"),
+}
+
+# Providers that work without a key (verified 2026-11-08 with tool calls), with extra models.
+KEYLESS = {
+    "kilo": ["nvidia/nemotron-3.5-lightning:free", "nvidia/nemotron-3-ultra-550b-a55b:free"],
+    "llm7": [],
+    "ovh": ["Qwen3.5-397B-A17B"],
+}
+ANON_KEY = "anonymous"   # placeholder key: no Authorization header is sent
+
+
+def load_dotenv(path: pathlib.Path) -> None:
+    """Minimal .env reader. Real environment variables always win."""
+    if not path.is_file():
+        return
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, v = line.split("=", 1)
+        os.environ.setdefault(k.strip(), v.strip().strip('"').strip("'"))
+
+
+@dataclass
+class ProviderConfig:
+    name: str
+    base_url: str
+    model: str
+    keys: list[str]
+    models: list[str] = field(default_factory=list)   # extra models on the same keys (<NAME>_MODELS)
+
+
+@dataclass
+class Settings:
+    providers: list[ProviderConfig] = field(default_factory=list)
+    max_tokens: int = 4096
+    temperature: float = 0.2
+    request_timeout: int = 30        # give up on a silent provider after this many seconds
+    stream: bool = True               # show replies as they are written
+    fastest_first: bool = True        # among equally capable models, try the fastest first
+    routing: str = "quality"          # "quality": most capable model first, kept for the whole task; "speed": fastest first
+    auto_open: bool = True            # open pages/servers a turn built in the browser
+    auto_skill: bool = True           # load the skill a request needs automatically
+    keys_per_provider: int = 4        # cap pool attempts per provider per chain pass
+    retry_rounds: int = 3             # whole-chain retries (jittered backoff)
+    max_wait: int = 150               # longest to wait for a rate limit to clear before giving up
+    max_continuations: int = 3        # for replies cut off by max_tokens
+    max_steps: int = 40               # tool-use steps per user turn
+    guards: bool = True               # check final answers' claims against what tools did (FORGE_GUARDS=0 turns off)
+    max_agents: int = 5               # parallel sub-agents at once
+    coordinator: str = ""             # "provider:model" that plans and delegates in team mode
+    team: bool = False                # start in team (coordinator) mode
+    context_chars: int = 80_000       # compact history beyond this (~20k tokens)
+    approval: str = "smart"           # smart | ask | auto  (see safety.py)
+    shell: str = "powershell"
+    auto_approve: bool = False
+    verbose: bool = False
+
+
+def _int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, default))
+    except ValueError:
+        return default
+
+
+def load_settings() -> Settings:
+    # Only trusted locations: the app folder and ~/.forge. A .env in whatever
+    # project you are working in is NOT loaded, so a repo cannot redirect your
+    # keys to another server.
+    load_dotenv(APP_DIR / ".env")
+    load_dotenv(HOME_DIR / ".env")
+
+    s = Settings()
+    # Default: every built-in provider, in the order above. Ones without keys are skipped.
+    order = os.environ.get("FORGE_PROVIDERS") or ",".join(KNOWN_PROVIDERS)
+    names = [n.strip().lower() for n in order.split(",") if n.strip()]
+    keyless_on = os.environ.get("FORGE_KEYLESS", "1").strip().lower() not in ("0", "off", "false", "no")
+    # Keys added with /keys or /setup (NEXT 7): OS keychain or ~/.forge/keys.json, any number per
+    # provider, plus custom OpenAI-compatible providers. A broken store never stops startup.
+    stored: dict[str, list[str]] = {}
+    custom: dict[str, dict] = {}
+    try:
+        from . import keyvault
+        store = keyvault.KeyStore()
+        stored, custom = store.load(), store.custom()
+    except Exception:
+        pass
+    names += [n for n in list(stored) + list(custom) if n not in names and n not in KEYLESS]
+    if keyless_on:
+        names += [n for n in KEYLESS if n not in names]   # always last unless you place them
+    for name in names:
+        up = name.upper()
+        base, model = KNOWN_PROVIDERS.get(name, ("", ""))
+        if name in custom:
+            base, model = custom[name].get("base_url", base), custom[name].get("model", model)
+        base = os.environ.get(f"{up}_BASE_URL", base).rstrip("/")
+        model = os.environ.get(f"{up}_MODEL", model)
+        raw = os.environ.get(f"{up}_API_KEYS") or os.environ.get(f"{up}_API_KEY", "")
+        keys = [k.strip() for k in raw.split(",") if k.strip()]
+        keys += [k for k in stored.get(name, []) if k not in keys]
+        extra = [m.strip() for m in os.environ.get(f"{up}_MODELS", "").split(",") if m.strip()]
+        if name in KEYLESS and not keys:
+            if not keyless_on:
+                continue
+            keys = [ANON_KEY]
+            extra = extra or list(KEYLESS[name])
+        if base and model and keys:
+            s.providers.append(ProviderConfig(name, base, model, keys, [m for m in extra if m != model]))
+
+    s.max_tokens = _int("FORGE_MAX_TOKENS", s.max_tokens)
+    s.request_timeout = _int("FORGE_TIMEOUT", s.request_timeout)
+    s.stream = os.environ.get("FORGE_STREAM", "1").strip().lower() not in ("0", "off", "false", "no")
+    s.auto_open = os.environ.get("FORGE_AUTO_OPEN", "1").strip().lower() not in ("0", "off", "false", "no")
+    s.auto_skill = os.environ.get("FORGE_AUTO_SKILL", "1").strip().lower() not in ("0", "off", "false", "no")
+    s.fastest_first = os.environ.get("FORGE_FASTEST_FIRST", "1").strip().lower() not in ("0", "off", "false", "no")
+    s.routing = "speed" if os.environ.get("FORGE_ROUTING", "").strip().lower() == "speed" else "quality"
+    s.keys_per_provider = _int("FORGE_KEYS_PER_PROVIDER", s.keys_per_provider)
+    s.retry_rounds = _int("FORGE_RETRY_ROUNDS", s.retry_rounds)
+    s.max_wait = _int("FORGE_MAX_WAIT", s.max_wait)
+    s.max_continuations = _int("FORGE_MAX_CONTINUATIONS", s.max_continuations)
+    s.max_steps = _int("FORGE_MAX_STEPS", s.max_steps)
+    s.guards = os.environ.get("FORGE_GUARDS", "1").strip().lower() not in ("0", "false", "no", "off")
+    s.max_agents = max(1, _int("FORGE_MAX_AGENTS", s.max_agents))
+    s.coordinator = os.environ.get("FORGE_COORDINATOR", "").strip()
+    s.team = os.environ.get("FORGE_TEAM", "").strip().lower() in ("1", "on", "true", "yes")
+    s.context_chars = _int("FORGE_CONTEXT_CHARS", s.context_chars)
+    s.approval = (os.environ.get("FORGE_APPROVAL") or s.approval).strip().lower()
+    default_shell = "powershell" if platform.system() == "Windows" else "bash"
+    s.shell = os.environ.get("FORGE_SHELL", default_shell).lower()
+    return s
+
+
+# --- user preferences (chosen models, pinned provider) ----------------------
+PREFS_FILE = HOME_DIR / "config.json"
+
+
+def load_prefs() -> dict:
+    try:
+        import json
+        return json.loads(PREFS_FILE.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+
+
+def save_prefs(prefs: dict) -> None:
+    import json
+    HOME_DIR.mkdir(parents=True, exist_ok=True)
+    PREFS_FILE.write_text(json.dumps(prefs, indent=2), encoding="utf-8")
+
+
+def apply_prefs(settings: Settings, prefs: dict) -> None:
+    """Models picked with /model override the .env defaults."""
+    for p in settings.providers:
+        if p.name in prefs.get("models", {}):
+            p.model = prefs["models"][p.name]

forgecli/courier.py

@@ -0,0 +1,177 @@
+"""The neon courier: a pixel-art kid pushing a wheelbarrow, drawn with half-block characters.
+
+It replaces the spinner while Forge works and acts out real agent events (the state machine is
+city.Barrow): loads parcels at the pile while the model thinks, pushes them to the door when a tool
+runs and waits there until it finishes, unloads, walks back empty. Waiting on rate limits he stands
+dimmed; done turns the door green with a tick; a failure spills the parcels and turns it red.
+
+The frames come from courier_data.py (baked from the GIF at several sizes); the size follows the
+terminal: taller windows get a bigger, sharper courier. FORGE_COURIER=off falls back to the
+one-line wheelbarrow; FORGE_COURIER_ROWS=4..12 fixes the size.
+"""
+from __future__ import annotations
+
+import os
+
+from rich.text import Text
+
+from .courier_data import ALPHA, SIZES
+
+# Parcels keep their own amber/cyan colours, like the original art. Set a kind here to recolour.
+KIND_RGB: dict = {}
+GROUND = (74, 52, 128)
+DOOR = (156, 60, 140)
+DOOR_LIT = (255, 79, 216)
+OK = (125, 255, 154)
+BAD = (255, 95, 109)
+STEP_PX = 2.0          # pixels walked per animation frame, so the legs match the ground speed
+
+_cache: dict = {}
+
+
+def _hex(c) -> str:
+    return "#%02x%02x%02x" % c
+
+
+def _rgb(h: str):
+    return int(h[1:3], 16), int(h[3:5], 16), int(h[5:7], 16)
+
+
+def frames(rows: int):
+    """(w, h, [frame pixels], [cargo masks]) for a size; pixels are rgb tuples or None."""
+    got = _cache.get(rows)
+    if got:
+        return got
+    w, h, palette, fr, cargo = SIZES[rows]
+    pal = [_rgb(p) for p in palette]
+    idx = {ch: i for i, ch in enumerate(ALPHA)}
+    px = [[[None if ch == " " else pal[idx[ch]] for ch in row] for row in f] for f in fr]
+    masks = [[[ch == "1" for ch in row] for row in m] for m in cargo]
+    _cache[rows] = got = (w, h, px, masks)
+    return got
+
+
+def pick_rows(term_h: int, term_w: int) -> int:
+    """Courier size for this window: as big as fits without crowding the conversation."""
+    env = os.environ.get("FORGE_COURIER_ROWS", "")
+    if env.isdigit():
+        return max(min(SIZES), min(max(SIZES), int(env)))
+    rows = 5 if term_h < 24 else 6 if term_h < 30 else 8 if term_h < 40 else 10 if term_h < 52 else 12
+    while rows > min(SIZES) and SIZES[rows][0] * 3 + 40 > term_w:   # lane plus the status text
+        rows -= 1
+    return rows
+
+
+def enabled() -> bool:
+    return os.environ.get("FORGE_COURIER", "on").lower() not in ("off", "0", "no", "false")
+
+
+def _tint(c, kind_rgb, a: float = 1.0):
+    lum = (0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2]) / 255
+    k = min(1.0, 0.25 + lum * 1.25) * a
+    return tuple(min(255, int(v * k)) for v in kind_rgb)
+
+
+def scene(barrow, now: float, rows: int) -> list[Text]:
+    """The lane (pile, courier, door) as `rows` lines of rich Text."""
+    snap = barrow.snapshot(now)
+    w, h, px, masks = frames(rows)
+    travel = w + 4                                   # how far he walks: a bit more than his length
+    pile_w, door_w = 4, 3
+    lane_w = pile_w + 1 + travel + w + 1 + door_w
+    grid = [[None] * lane_w for _ in range(h)]
+
+    st = snap["state"]
+    x0 = pile_w + 1 + round(snap["pos"] / snap["track"] * travel)
+    moving = snap["moving"]
+    f = int(snap["walked"] * travel / snap["track"] / STEP_PX) % len(px) if moving else 0
+    sprite, mask = px[f], masks[f]
+    dim = 0.55 if st in ("waiting", "cancelled") else 1.0
+    kind_rgb = KIND_RGB.get(snap["kind"])
+    fill = snap["fill"]                              # 0..1: how much of the load is in the tub
+    cargo_rows = [y for y in range(h) if any(mask[y])]
+    top = cargo_rows[0] if cargo_rows else 0
+    span = (cargo_rows[-1] - top + 1) if cargo_rows else 1
+    show_from = top + span - span * fill             # parcels appear from the bottom up
+
+    # ground: a dashed neon line along the whole lane
+    for x in range(lane_w):
+        if (x // 2) % 3 != 2:
+            grid[h - 1][x] = GROUND
+    # the pile of parcels at the left
+    pile_rgb = kind_rgb or (255, 150, 60)
+    for (px_, py_, bw, bh) in ((0, h - 5, 3, 3), (1, h - 8, 3, 3)):
+        for yy in range(max(0, py_), min(h - 1, py_ + bh)):
+            for xx in range(px_, min(pile_w, px_ + bw)):
+                edge = yy == py_ or xx == px_
+                grid[yy][xx] = _tint((255, 200, 120) if edge else (200, 110, 40), pile_rgb, 0.9 * dim)
+    # the door at the right
+    door_x = lane_w - door_w
+    door_h = max(4, int(h * 0.7))
+    lit = snap["at_door"] and (snap["busy"] or snap["parked"])
+    pulse = (int(now * 3) % 2 == 0) or not snap["motion"]
+    door = OK if st == "completed" else BAD if st == "failed" else (DOOR_LIT if lit and pulse else DOOR)
+    for yy in range(h - 1 - door_h, h - 1):
+        for xx in range(door_x, lane_w):
+            if yy == h - 1 - door_h or xx in (door_x, lane_w - 1):
+                grid[yy][xx] = door
+    if st == "completed":                          # a tick in the doorway
+        cx, cy = door_x + 1, h - 3
+        for (dx, dy) in ((-1, -1), (0, 0), (1, -1), (2, -2)):
+            if 0 <= cy + dy < h and 0 <= cx + dx < lane_w:
+                grid[cy + dy][cx + dx] = OK
+    # the courier (mirrored when walking back)
+    flip = not snap["right"]
+    for y in range(h):
+        row, mrow = sprite[y], mask[y]
+        for x in range(w):
+            sx = w - 1 - x if flip else x
+            c = row[sx]
+            if c is None:
+                continue
+            if mrow[sx]:
+                if st == "failed" or y < show_from:
+                    continue
+                if kind_rgb:
+                    c = _tint(c, kind_rgb)
+            if dim < 1:
+                c = tuple(int(v * dim) for v in c)
+            gx = x0 + x
+            if 0 <= gx < lane_w:
+                grid[y][gx] = c
+    if st == "failed":                             # spilled parcels on the ground behind him
+        for i, xx in enumerate(range(x0 - 3, x0 + w + 3, 4)):
+            if 0 <= xx < lane_w - door_w:
+                grid[h - 2][xx] = BAD if i % 2 else (255, 150, 60)
+    if st == "waiting" and snap["motion"]:         # a little z drifting up
+        zx, zy = x0 + w // 3, max(0, 1 - int(now * 2) % 2)
+        for xx in range(zx, zx + 3):
+            if 0 <= xx < lane_w:
+                grid[zy][xx] = (160, 150, 220)
+    return _to_text(grid, lane_w, h)
+
+
+def _to_text(grid, w: int, h: int) -> list[Text]:
+    lines = []
+    styles: dict = {}
+    for y in range(0, h - 1, 2):
+        t = Text()
+        top, bot = grid[y], grid[y + 1]
+        for x in range(w):
+            a, b = top[x], bot[x]
+            if a is None and b is None:
+                t.append(" ")
+                continue
+            key = (a, b)
+            st = styles.get(key)
+            if st is None:
+                if a is not None and b is not None:
+                    st = (_hex(a) + " on " + _hex(b), "▀") if a != b else (_hex(a), "█")
+                elif a is not None:
+                    st = (_hex(a), "▀")
+                else:
+                    st = (_hex(b), "▄")
+                styles[key] = st
+            t.append(st[1], style=st[0])
+        lines.append(t)
+    return lines