projectinator 0.1.2 → 0.1.4

package/README.md

@@ -7,7 +7,7 @@
 [![npm](https://img.shields.io/npm/v/projectinator.svg?color=e0a72d&label=npm)](https://www.npmjs.com/package/projectinator)
 ![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)
 ![node](https://img.shields.io/badge/node-%E2%89%A520-brightgreen.svg)
-![tests: 134 passing](https://img.shields.io/badge/tests-134%20passing-brightgreen.svg)
+![tests: 140 passing](https://img.shields.io/badge/tests-140%20passing-brightgreen.svg)
 ![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178c6.svg)
 ![built on Pi](https://img.shields.io/badge/built%20on-Pi%20agent%20harness-e0a72d.svg)
 
@@ -16,6 +16,10 @@ project-manager model breaks it into a Scrum backlog, and each task is dispatche
 model that's best — and cheapest — for that exact job (planning, design, code, test). You
 watch it happen from a terminal cockpit: a live board, budget bar, and a standup.
 
+<p align="center">
+  <img src="docs/cockpit.png" alt="Projectinator cockpit — the live Scrum board mid-build" width="860" />
+</p>
+
 Built on the [Pi](https://pi.dev) agent harness (Node/TypeScript). Bring your own API key.
 
 **Install & run** (Node ≥ 20):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projectinator",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Your AI build team in the terminal — hand it an app idea, a PM model plans a Scrum backlog, and the best model per role designs, codes, and tests it into working files. Bring your own API key.",
   "type": "module",
   "private": false,

package/src/bakeoff.ts

@@ -95,7 +95,7 @@ async function runCandidate(task: Task, cand: Candidate): Promise<BakeoffEntry>
         ms,
         outputTokens: stats.tokens.output,
       };
-      if (stats.tokens.total === 0) out.error = "returned 0 tokens (key likely can't access this model)";
+      if (stats.tokens.total === 0) out.error = "returned 0 tokens (invalid key, no credit/balance, or no model access)";
       return out;
     } finally {
       session.dispose(); // dispose even when prompt() throws (expected for inaccessible models)

package/src/models.ts

@@ -4,6 +4,7 @@
 // for models whose exact cache rates we haven't pinned — refine against provider docs).
 
 import type { Model } from "./types.js";
+import { findOpenRouterModel } from "./openrouter.js";
 
 export const MODELS: Record<string, Model> = {
   // ---- OpenAI: GPT-5.6 family ----
@@ -83,10 +84,44 @@ export const MODELS: Record<string, Model> = {
     contextWindow: 1_000_000,
     cost: { input: 0.5, output: 3, cacheRead: 0.05, cacheWrite: 0.625 },
   },
+
+  // ---- OpenRouter (one key → frontier models). ids are Pi's OpenRouter-catalog
+  // slugs (vendor/model). Pricing mirrors the underlying model (OpenRouter passes
+  // it through, ~small margin); ACTUAL cost still comes from Pi per run.
+  "anthropic/claude-opus-4.8": {
+    id: "anthropic/claude-opus-4.8",
+    provider: "openrouter",
+    name: "Claude Opus 4.8 (OpenRouter)",
+    contextWindow: 1_000_000,
+    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  },
+  "anthropic/claude-sonnet-4.6": {
+    id: "anthropic/claude-sonnet-4.6",
+    provider: "openrouter",
+    name: "Claude Sonnet 4.6 (OpenRouter)",
+    contextWindow: 1_000_000,
+    cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  },
+  "openai/gpt-5.6-luna": {
+    id: "openai/gpt-5.6-luna",
+    provider: "openrouter",
+    name: "GPT-5.6 Luna (OpenRouter)",
+    contextWindow: 272_000,
+    cost: { input: 1, output: 6, cacheRead: 0.1, cacheWrite: 1.25 },
+  },
 };
 
 export function getModel(id: string): Model {
   const m = MODELS[id];
-  if (!m) throw new Error(`Unknown model id: "${id}". Add it to src/models.ts.`);
-  return m;
+  if (m) return m;
+  // OpenRouter slugs (vendor/model) aren't in the static table — price them from
+  // the OpenRouter catalog (live cache or Pi's built-in list). Fall back to a
+  // rough estimate so a build never crashes on an unpriced model (actual cost
+  // still comes from Pi per run).
+  if (id.includes("/")) {
+    const or = findOpenRouterModel(id);
+    if (or) return { ...or, provider: "openrouter" };
+    return { id, provider: "openrouter", name: id, contextWindow: 200_000, cost: { input: 1, output: 3, cacheRead: 0.1, cacheWrite: 1.25 } };
+  }
+  throw new Error(`Unknown model id: "${id}". Add it to src/models.ts.`);
 }

package/src/openrouter.ts

@@ -0,0 +1,113 @@
+// The OpenRouter model catalog — so users can pick ANY OpenRouter model by name
+// (Kimi, DeepSeek, Qwen, …) instead of typing slugs.
+//
+//  - refreshOpenRouterModels(): live-fetch openrouter.ai/api/v1/models (freshest
+//    names + pricing), cache to disk. Falls back to Pi's built-in OR catalog.
+//  - openRouterModels() / findOpenRouterModel(): SYNC reads (disk cache, else Pi's
+//    built-in list) so cost estimation (getModel) can price any picked model.
+
+import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { Model, ModelCost } from "./types.js";
+
+/** A pickable OpenRouter model: our Model shape minus the provider (always "openrouter"). */
+export type ORModel = Omit<Model, "provider">;
+
+const CACHE = join(homedir(), ".projectinator", "openrouter-models.json");
+
+let builtinMemo: ORModel[] | null = null;
+let diskMemo: ORModel[] | null | undefined; // undefined = not read yet, null = no cache
+
+/** Pi's built-in OpenRouter catalog — offline, always available, names + pricing. */
+export function builtinOpenRouterModels(): ORModel[] {
+  if (builtinMemo) return builtinMemo;
+  try {
+    const reg = ModelRegistry.create(AuthStorage.create());
+    const all = (reg.getAll() as unknown as Array<{ id: string; provider: string; name?: string; contextWindow?: number; cost?: ModelCost }>);
+    builtinMemo = all
+      .filter((m) => m.provider === "openrouter" && m.cost)
+      .map((m) => ({
+        id: m.id,
+        name: m.name ?? m.id,
+        contextWindow: m.contextWindow ?? 200_000,
+        cost: m.cost as ModelCost,
+      }))
+      .sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    builtinMemo = [];
+  }
+  return builtinMemo;
+}
+
+function readDiskCache(): ORModel[] | null {
+  if (diskMemo !== undefined) return diskMemo;
+  try {
+    if (existsSync(CACHE)) {
+      const parsed = JSON.parse(readFileSync(CACHE, "utf8")) as { models?: ORModel[] };
+      diskMemo = Array.isArray(parsed.models) && parsed.models.length ? parsed.models : null;
+    } else diskMemo = null;
+  } catch {
+    diskMemo = null;
+  }
+  return diskMemo;
+}
+
+/** The list to show / price against: live-fetched disk cache if present, else Pi's built-in. */
+export function openRouterModels(): ORModel[] {
+  const cached = readDiskCache();
+  return cached && cached.length ? cached : builtinOpenRouterModels();
+}
+
+/** Look up one model's pricing/name by slug (cache first, then built-in). Sync. */
+export function findOpenRouterModel(id: string): ORModel | undefined {
+  return openRouterModels().find((m) => m.id === id) ?? builtinOpenRouterModels().find((m) => m.id === id);
+}
+
+/** Map OpenRouter's API pricing (USD per token, strings) to our per-1M-token cost. */
+function mapApiModel(m: {
+  id: string;
+  name?: string;
+  context_length?: number;
+  pricing?: { prompt?: string; completion?: string; input_cache_read?: string; input_cache_write?: string };
+}): ORModel | null {
+  const p = m.pricing ?? {};
+  const input = Number(p.prompt) * 1e6;
+  const output = Number(p.completion) * 1e6;
+  if (!Number.isFinite(input) || !Number.isFinite(output)) return null;
+  const cacheRead = p.input_cache_read != null ? Number(p.input_cache_read) * 1e6 : input * 0.1;
+  const cacheWrite = p.input_cache_write != null ? Number(p.input_cache_write) * 1e6 : input * 1.25;
+  return {
+    id: m.id,
+    name: m.name ?? m.id,
+    contextWindow: m.context_length ?? 200_000,
+    cost: { input, output, cacheRead, cacheWrite },
+  };
+}
+
+/** Live-fetch the catalog and cache it. Falls back to the current list on any failure. */
+export async function refreshOpenRouterModels(timeoutMs = 8000): Promise<ORModel[]> {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch("https://openrouter.ai/api/v1/models", { signal: ctrl.signal });
+    if (!res.ok) return openRouterModels();
+    const json = (await res.json()) as { data?: Array<Parameters<typeof mapApiModel>[0]> };
+    const list = (json.data ?? []).map(mapApiModel).filter((m): m is ORModel => m !== null)
+      .sort((a, b) => a.name.localeCompare(b.name));
+    if (list.length) {
+      try {
+        mkdirSync(join(homedir(), ".projectinator"), { recursive: true });
+        writeFileSync(CACHE, JSON.stringify({ fetchedAt: Date.now(), models: list }));
+        diskMemo = list;
+      } catch { /* cache write is best-effort */ }
+      return list;
+    }
+    return openRouterModels();
+  } catch {
+    return openRouterModels();
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/pm.ts

@@ -273,10 +273,12 @@ export async function decomposeIdea(idea: string, opts: DecomposeOptions): Promi
     if (!raw || !raw.tasks?.length) {
       const stats = session.getSessionStats();
       if (stats.tokens.total === 0) {
-        // The provider call returned nothing — almost always a bad/inaccessible key.
+        // The provider call returned nothing — bad/inaccessible key, OR (very common)
+        // the account has no credit/balance so the API rejects the request.
         throw new Error(
-          `The ${pick.provider} model returned nothing (0 tokens). Its API key is likely invalid or ` +
-            `lacks access to ${pick.model}. Set a working key, or pick a different provider in Settings → Preferred provider.`,
+          `The ${pick.provider} model returned nothing (0 tokens). Likely causes: the API key is invalid, ` +
+            `the account has no credit/balance, or the key lacks access to ${pick.model}. Add credit or set a ` +
+            `working key, or pick a different provider in Settings → Preferred provider.`,
         );
       }
       const said = lastAssistantText(session).slice(0, 200).replace(/\s+/g, " ").trim();

package/src/roles.ts

@@ -147,6 +147,7 @@ const PROVIDER_MODELS: Record<Provider, { strong: string; mid: string; cheap: st
   anthropic: { strong: "claude-opus-4-8", mid: "claude-sonnet-4-6", cheap: "claude-haiku-4-5" },
   openai: { strong: "gpt-5.6-sol", mid: "gpt-5.6-terra", cheap: "gpt-5.6-luna" },
   google: { strong: "gemini-3.1-pro-preview", mid: "gemini-3.1-pro-preview", cheap: "gemini-3-flash-preview" },
+  openrouter: { strong: "anthropic/claude-opus-4.8", mid: "anthropic/claude-sonnet-4.6", cheap: "openai/gpt-5.6-luna" },
 };
 
 const CAP_STRENGTH: Record<Capability, "strong" | "mid" | "cheap"> = {
@@ -194,6 +195,7 @@ const ENV_KEYS: Record<Provider, string[]> = {
   anthropic: ["ANTHROPIC_API_KEY"],
   openai: ["OPENAI_API_KEY"],
   google: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
 };
 
 function providersWithKeys(): Provider[] {
@@ -340,7 +342,7 @@ export function makePiExecutor(opts: PiExecutorOptions): RoleExecutor {
           if (i > 0) opts.onFallback?.({ taskId: task.id, from: decision.provider, to: cand.provider, model: cand.model });
           return att.result;
         }
-        lastErr = new Error(`${cand.provider}/${cand.model} returned 0 tokens (key likely can't access this model)`);
+        lastErr = new Error(`${cand.provider}/${cand.model} returned 0 tokens (invalid key, no account credit/balance, or no access to this model)`);
       } catch (e) {
         lastErr = e;
       }

package/src/run-build.ts

@@ -114,6 +114,7 @@ const envKey: Record<Provider, string[]> = {
   anthropic: ["ANTHROPIC_API_KEY"],
   openai: ["OPENAI_API_KEY"],
   google: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
 };
 if (!(envKey[lockProvider] ?? []).some((k) => process.env[k])) {
   console.error(`  No API key for ${lockProvider}. Set: ${(envKey[lockProvider] ?? []).join(", ")}\n`);

package/src/tui/App.tsx

@@ -4,6 +4,7 @@
 import React, { useEffect, useState } from "react";
 import { Box, Text, useApp, useInput } from "ink";
 import { Spinner, StatusMessage } from "@inkjs/ui";
+import InkSpinner from "ink-spinner"; // a Text-based spinner, safe as an inline glyph inside <Text>
 import type { Provider } from "../types.js";
 import type { OrchestratorEvent } from "../orchestrator.js";
 import { C, BudgetBar, Panel, Chip, Menu as SelectInput, GroupedMenu, KeyHint, useTermRows, TextField as TextInput, type TaskView, type MenuGroup } from "./components.js";
@@ -1586,7 +1587,7 @@ export default function App(): React.ReactElement {
     return (
       <Box flexDirection="column">
         <Box>
-          <Text color="cyan"><Spinner type="dots" /></Text>
+          <Text color="cyan"><InkSpinner type="dots" /></Text>
           <Text bold>{"  "}Building</Text>
           <Text color={C.textSubtle}>{`     ${running} running`}</Text>
         </Box>

package/src/tui/Settings.tsx

@@ -12,8 +12,9 @@ import { estimateAccuracy } from "../estimate.js";
 import { availableProviders, effectiveRoster, allModels, setRoleModel, PROVIDER_LABEL } from "./engine.js";
 import { setKey, getPrefs, setPrefs, loadConfig, setPreferredProvider, getDefaultMode, setDefaultMode, getNotify, setNotify, getPreferredStack, setPreferredStack, ENV_VAR } from "./config.js";
 import { validateKey } from "./validate.js";
+import { openRouterModels, refreshOpenRouterModels } from "../openrouter.js";
 
-type Sub = "menu" | "keys" | "keyEntry" | "models" | "modelPick" | "prefs" | "provider" | "workflow" | "weblogin" | "accuracy" | "stack";
+type Sub = "menu" | "keys" | "keyEntry" | "models" | "modelPick" | "orBrowse" | "orPick" | "prefs" | "provider" | "workflow" | "weblogin" | "accuracy" | "stack";
 
 export function Settings({ onExit }: { onExit: () => void }): React.ReactElement {
   const [sub, setSub] = useState<Sub>("menu");
@@ -23,6 +24,7 @@ export function Settings({ onExit }: { onExit: () => void }): React.ReactElement
   const [keyError, setKeyError] = useState("");
   const [role, setRole] = useState<{ capability: Capability; tier: Tier; label: string } | null>(null);
   const [notice, setNotice] = useState("");
+  const [orQuery, setOrQuery] = useState(""); // OpenRouter model-browser filter
   const [, force] = useState(0);
   const refresh = () => force((n) => n + 1);
 
@@ -72,7 +74,7 @@ export function Settings({ onExit }: { onExit: () => void }): React.ReactElement
   // ---------- API keys ----------
   if (sub === "keys") {
     const have = new Set(availableProviders());
-    const providers: Provider[] = ["anthropic", "openai", "google"];
+    const providers: Provider[] = ["anthropic", "openai", "google", "openrouter"];
     return (
       <Box flexDirection="column">
         <Panel title="API keys">
@@ -170,7 +172,11 @@ export function Settings({ onExit }: { onExit: () => void }): React.ReactElement
                   const [capability, tier] = i.value.split(":") as [Capability, Tier];
                   const r = rows.find((x) => x.capability === capability && x.tier === tier)!;
                   setRole({ capability, tier, label: r.label });
-                  setSub("modelPick");
+                  if (lock === "openrouter") {
+                    setOrQuery("");
+                    void refreshOpenRouterModels().then(() => refresh()); // freshen catalog in the background
+                    setSub("orBrowse");
+                  } else setSub("modelPick");
                 }
               }}
             />
@@ -209,11 +215,73 @@ export function Settings({ onExit }: { onExit: () => void }): React.ReactElement
     );
   }
 
+  // ---------- OpenRouter model browser: filter the whole catalog by name ----------
+  if ((sub === "orBrowse" || sub === "orPick") && role) {
+    const all = openRouterModels();
+    const q = orQuery.trim().toLowerCase();
+    const matches = q ? all.filter((m) => m.id.toLowerCase().includes(q) || m.name.toLowerCase().includes(q)) : all;
+    const price = (m: (typeof all)[number]) => `$${m.cost.input}/$${m.cost.output}`;
+
+    if (sub === "orBrowse") {
+      return (
+        <Box flexDirection="column">
+          <Panel title={`OpenRouter model for ${role.label}`}>
+            <Text color={C.textMuted}>Type to filter {all.length} models by name or slug — e.g. “kimi”, “deepseek”, “coder”.</Text>
+            <Box marginTop={1}>
+              <Text color={C.accent}>{"filter › "}</Text>
+              <TextInput
+                value={orQuery}
+                onChange={setOrQuery}
+                placeholder="kimi"
+                onSubmit={() => {
+                  if (!orQuery.trim()) { setSub("models"); return; }
+                  if (matches.length) setSub("orPick");
+                }}
+              />
+            </Box>
+            <Box marginTop={1} flexDirection="column">
+              <Text color={C.textSubtle}>{matches.length} match{matches.length === 1 ? "" : "es"}{matches.length ? " — Enter to choose:" : ""}</Text>
+              {matches.slice(0, 6).map((m) => (
+                <Text key={m.id} wrap="truncate-end"><Text color={C.textMuted}>{m.name}</Text>  <Text color={C.textSubtle}>{m.id}  {price(m)}</Text></Text>
+              ))}
+              {matches.length > 6 ? <Text color={C.textSubtle}>  …refine to narrow</Text> : null}
+            </Box>
+            <Box marginTop={1}><KeyHint hints={[{ keys: "Enter", label: "choose" }, { keys: "empty Enter", label: "back" }]} /></Box>
+          </Panel>
+        </Box>
+      );
+    }
+
+    // orPick — select from the filtered matches
+    return (
+      <Box flexDirection="column">
+        <Panel title={`Pick a model  ·  “${orQuery}”  (${matches.length})`}>
+          <SelectInput
+            limit={12}
+            items={[
+              ...matches.slice(0, 50).map((m) => ({ label: `${m.name}   ${m.id}   ${price(m)}`, value: m.id })),
+              { label: "← Refine filter", value: "__refine" },
+              { label: "Back", value: "__back" },
+            ]}
+            onSelect={(i) => {
+              if (i.value === "__refine") { setSub("orBrowse"); return; }
+              if (i.value === "__back") { setSub("models"); return; }
+              setRoleModel(role.capability, role.tier, i.value);
+              setNotice(`${role.label} → ${i.value}`);
+              refresh();
+              setSub("models");
+            }}
+          />
+        </Panel>
+      </Box>
+    );
+  }
+
   // ---------- preferred provider ----------
   if (sub === "provider") {
     const have = new Set(availableProviders());
     const current = loadConfig().preferredProvider;
-    const providers: Provider[] = ["anthropic", "openai", "google"];
+    const providers: Provider[] = ["anthropic", "openai", "google", "openrouter"];
     return (
       <Box flexDirection="column">
         <Panel title="Preferred provider">

package/src/tui/config.ts

@@ -29,6 +29,7 @@ export const ENV_VAR: Record<Provider, string> = {
   anthropic: "ANTHROPIC_API_KEY",
   openai: "OPENAI_API_KEY",
   google: "GEMINI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
 };
 
 function dir(): string {

package/src/tui/engine.ts

@@ -27,12 +27,14 @@ const PROVIDER_KEYS: Record<Provider, string[]> = {
   anthropic: ["ANTHROPIC_API_KEY"],
   openai: ["OPENAI_API_KEY"],
   google: ["GEMINI_API_KEY", "GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
 };
 
 export const PROVIDER_LABEL: Record<Provider, string> = {
   anthropic: "Anthropic (Claude)",
   openai: "OpenAI (GPT)",
   google: "Google (Gemini)",
+  openrouter: "OpenRouter",
 };
 
 /** Which providers have a usable API key right now (presence only). */

package/src/tui/validate.ts

@@ -31,6 +31,11 @@ export async function validateKey(provider: Provider, key: string): Promise<KeyC
       res = await withTimeout("https://api.openai.com/v1/models", {
         headers: { Authorization: `Bearer ${key}` },
       });
+    } else if (provider === "openrouter") {
+      // Returns the key's rate-limit/usage info; 401 if the key is bad.
+      res = await withTimeout("https://openrouter.ai/api/v1/key", {
+        headers: { Authorization: `Bearer ${key}` },
+      });
     } else {
       res = await withTimeout(
         `https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(key)}`,

package/src/types.ts

@@ -14,7 +14,7 @@ export type Difficulty = "trivial" | "low" | "medium" | "high";
 /** Capability tier — the abstract "how strong a model" axis. */
 export type Tier = "fast" | "mid" | "high";
 
-export type Provider = "anthropic" | "openai" | "google";
+export type Provider = "anthropic" | "openai" | "google" | "openrouter";
 
 // ---------------------------------------------------------------------------
 // Model pricing — mirrors Pi's models.json `cost` shape so it ports 1:1 later.