projectinator 0.3.1 → 0.4.0

package/src/run-build.ts

@@ -1,203 +0,0 @@
-// Phase 4 entry — run a whole build end to end.
-//
-//   npm run build -- "an idea"                 dry: decompose + toposort + routing plan, NO spend
-//   npm run build -- --mini                     dry: tiny fixed 3-task backlog (design->code->test)
-//   npm run build -- --live --mini              LIVE: run the mini backlog (cheap end-to-end)
-//   npm run build -- --live --lock anthropic "an idea"   LIVE: full pipeline on one provider
-//
-// --lock <provider> routes every role to one provider (use the one you hold a key for).
-// Default lock is anthropic.
-
-import { mkdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
-import type { Provider, Task } from "./types.js";
-import { DEFAULT_POLICY } from "./router.js";
-import { toposort, runBacklog, type OrchestratorEvent } from "./orchestrator.js";
-import { lockRegistryToProvider, makePiExecutor } from "./roles.js";
-import { estimateTokens } from "./estimate.js";
-import { route } from "./router.js";
-import { decomposeIdea } from "./pm.js";
-import { newBuildState, saveState, loadState, completedIds, type BuildState } from "./build-state.js";
-import { initRepo, commitTask } from "./git.js";
-
-const args = process.argv.slice(2);
-const live = args.includes("--live");
-const mini = args.includes("--mini");
-const fan = args.includes("--fan");
-const resume = args.includes("--resume");
-const lockIdx = args.indexOf("--lock");
-const lockProvider = (lockIdx >= 0 ? args[lockIdx + 1] : "anthropic") as Provider;
-const concIdx = args.indexOf("--concurrency");
-const concurrency = Math.max(1, parseInt((concIdx >= 0 ? args[concIdx + 1] : "1") ?? "1", 10) || 1);
-const capIdx = args.indexOf("--task-cap");
-const tmoIdx = args.indexOf("--task-timeout");
-const consumed = new Set(
-  ["--live", "--mini", "--fan", "--resume", "--lock", lockIdx >= 0 ? args[lockIdx + 1] : "",
-    "--concurrency", concIdx >= 0 ? args[concIdx + 1] : "",
-    "--task-cap", capIdx >= 0 ? args[capIdx + 1] : "",
-    "--task-timeout", tmoIdx >= 0 ? args[tmoIdx + 1] : ""].filter(Boolean),
-);
-const idea = args.filter((a) => !consumed.has(a)).join(" ").trim() ||
-  "A one-page site with a headline and a contact form.";
-
-const money = (n: number) => `$${n.toFixed(2)}`;
-const registry = lockRegistryToProvider(lockProvider);
-// --task-cap USD / --task-timeout MIN override the per-task limits (0 = unlimited).
-const taskLimits = {
-  costCapUSD: capIdx >= 0 ? parseFloat(args[capIdx + 1] ?? "") : DEFAULT_POLICY.taskLimits.costCapUSD,
-  timeoutMs: tmoIdx >= 0 ? parseFloat(args[tmoIdx + 1] ?? "") * 60_000 : DEFAULT_POLICY.taskLimits.timeoutMs,
-};
-const policy = { ...DEFAULT_POLICY, backendMode: "api" as const, budgetCapUSD: mini ? 10 : 25, taskLimits };
-
-// --- a tiny fixed backlog for cheap end-to-end proof ---
-function miniBacklog(): Task[] {
-  const mk = (id: string, cap: Task["capability"], diff: Task["difficulty"], title: string, deps: string[] = []): Task => ({
-    id, title, capability: cap, difficulty: diff, dependsOn: deps, estTokens: estimateTokens(cap, diff),
-  });
-  return [
-    mk("D-1", "design", "low", "Write a short design spec for a centered card that says 'Hello from Projectinator' on a soft gradient background."),
-    mk("C-1", "code", "low", "Create index.html implementing the design spec exactly. Single self-contained file with embedded CSS.", ["D-1"]),
-    mk("R-1", "review", "trivial", "Review index.html against the design spec: file present, no unresolved references, runs on double-click.", ["C-1"]),
-    mk("T-1", "test", "trivial", "Open/read index.html and verify it is valid HTML and matches the design spec (centered card, the headline text, a gradient).", ["R-1"]),
-  ];
-}
-
-// A fan-out backlog with independent branches, to show parallel execution:
-// two design tasks (independent) -> two code tasks -> one test that joins them.
-function fanBacklog(): Task[] {
-  const mk = (id: string, cap: Task["capability"], diff: Task["difficulty"], title: string, deps: string[] = []): Task => ({
-    id, title, capability: cap, difficulty: diff, dependsOn: deps, estTokens: estimateTokens(cap, diff),
-  });
-  return [
-    mk("DA", "design", "low", "Design spec for a 'Newsletter signup' card (email input + button)."),
-    mk("DB", "design", "low", "Design spec for an 'FAQ' accordion (3 questions)."),
-    mk("CA", "code", "low", "Create newsletter.html from the newsletter design spec.", ["DA"]),
-    mk("CB", "code", "low", "Create faq.html from the FAQ design spec.", ["DB"]),
-    mk("RA", "review", "trivial", "Review newsletter.html against its spec.", ["CA"]),
-    mk("RB", "review", "trivial", "Review faq.html against its spec.", ["CB"]),
-    mk("TJ", "test", "trivial", "Verify newsletter.html and faq.html are valid and match their specs.", ["RA", "RB"]),
-  ];
-}
-
-async function getTasks(): Promise<Task[]> {
-  if (fan) return fanBacklog();
-  if (mini) return miniBacklog();
-  if (!live) {
-    // Dry + full idea: we can't call the PM without spending, so show the mini path.
-    console.log("  (Full-idea decomposition needs the PM model. Use --mini for a dry preview, or add --live.)\n");
-    return miniBacklog();
-  }
-  console.log("  Decomposing idea with PM...\n");
-  const res = await decomposeIdea(idea, {
-    backend: "api",
-    modelOverride: { provider: lockProvider, model: lockRegistryToProvider(lockProvider).find((e) => e.capability === "plan")!.byBackend.api.model },
-  });
-  console.log(`  PM produced ${res.tasks.length} tasks.\n`);
-  return res.tasks;
-}
-
-const variant = fan ? " / fan" : mini ? " / mini" : "";
-console.log(`\n  Projectinator — Phase 4 full build   [${live ? "LIVE" : "DRY"}${variant}]   lock=${lockProvider}   concurrency=${concurrency}\n`);
-if (!mini && !fan) console.log(`  Idea: ${idea}\n`);
-
-let tasks = await getTasks();
-
-// Dry: show plan only.
-if (!live) {
-  const ordered = toposort(tasks);
-  console.log("  Execution order (toposorted):");
-  let est = 0;
-  for (const t of ordered) {
-    const d = route(t, { policy, registry, runningTotalBefore: est });
-    est = d.runningTotal;
-    const dep = t.dependsOn?.length ? ` <- ${t.dependsOn.join(",")}` : "";
-    console.log(`    ${t.id.padEnd(6)} [${t.capability}/${t.difficulty}] -> ${d.model.name.padEnd(20)} ${money(d.cost)}${dep}`);
-  }
-  console.log(`\n  Estimated total: ${money(est)}   (cap ${money(policy.budgetCapUSD)})`);
-  console.log("  Dry run. Add --live to actually build.\n");
-  process.exit(0);
-}
-
-// Live: key check.
-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`);
-  process.exit(1);
-}
-
-const projectRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-const workspace = join(projectRoot, ".workspace", fan ? "fan-build" : mini ? "mini-build" : "build");
-mkdirSync(workspace, { recursive: true });
-const statePath = join(workspace, "build-state.json");
-
-// Resume: load prior state, reuse its saved backlog, seed finished outcomes.
-let state: BuildState;
-let seedOutcomes = undefined;
-const prior = resume ? loadState(statePath) : undefined;
-if (prior) {
-  state = prior;
-  state.status = "running";
-  tasks = prior.tasks; // authoritative backlog from the interrupted run
-  seedOutcomes = prior.outcomes;
-  const doneCount = completedIds(prior).size;
-  console.log(`  Resuming: ${doneCount} task(s) already done, restored ${money(prior.totalCost)}.`);
-} else {
-  if (resume) console.log("  (No prior state found — starting fresh.)");
-  state = newBuildState(fan ? "fan-build" : mini ? "mini-build" : "build", tasks);
-}
-console.log(`  Workspace: ${workspace}\n  Building...\n`);
-
-// Version the workspace + commit after each task.
-initRepo(workspace);
-const titleById = new Map(tasks.map((t) => [t.id, t.title]));
-
-const onEvent = (_e: AgentSessionEvent) => {};
-const executor = makePiExecutor({
-  workspace,
-  backend: "api",
-  onEvent,
-  onFallback: (info) => console.log(`    ↪ ${info.taskId}: ${info.from} failed — fell back to ${info.to}/${info.model}`),
-});
-
-const onProgress = (e: OrchestratorEvent) => {
-  if (e.type === "task_start") console.log(`  ▶ ${e.task.id} [${e.task.capability}] -> ${e.provider}/${e.modelId} (round ${e.round})`);
-  else if (e.type === "task_done") {
-    const hash = commitTask(workspace, e.outcome.taskId, titleById.get(e.outcome.taskId) ?? e.outcome.taskId);
-    console.log(`    ✓ ${e.outcome.taskId} ${money(e.outcome.cost)}  running ${money(e.runningTotal)}${e.outcome.verdict ? `  verdict=${e.outcome.verdict.passed ? (e.outcome.verdict.runtimeChecked ? "PASS" : "PASS* (app not executed — no Chromium)") : "FAIL"}` : ""}${hash ? `  [${hash}]` : ""}`);
-  }
-  else if (e.type === "task_failed") console.log(`    ⛔ ${e.outcome.taskId} ABORTED (${e.outcome.error}) — billed ${money(e.outcome.cost)}, halting`);
-  else if (e.type === "task_skipped") console.log(`    · ${e.taskId} skipped (already done)`);
-  else if (e.type === "test_failed") console.log(`    ✗ ${e.taskId} FAILED (${e.bugs} bugs) — round ${e.round}`);
-  else if (e.type === "retry_dev") console.log(`    ↻ re-running ${e.taskId} to fix ${e.forTest}`);
-  else if (e.type === "budget_halt") console.log(`    ⚠ BUDGET HALT at ${money(e.runningTotal)} (cap ${money(e.cap)})`);
-};
-
-// Checkpoint after every task so a crash/cancel loses at most one task.
-const onCheckpoint = (outcomes: typeof state.outcomes, totalCost: number) => {
-  state.outcomes = outcomes;
-  state.totalCost = totalCost;
-  saveState(state, statePath);
-};
-
-const result = await runBacklog(tasks, { policy, execute: executor, registry, onProgress, seedOutcomes, onCheckpoint, concurrency });
-
-state.outcomes = result.outcomes;
-state.totalCost = result.totalCost;
-state.status = result.halted ? "halted" : "complete";
-state.haltReason = result.haltReason;
-saveState(state, statePath);
-
-console.log(`\n  --- BUILD ${result.halted ? "HALTED" : "COMPLETE"} ---`);
-console.log(`  Steps run: ${result.outcomes.length}`);
-console.log(`  Total cost: ${money(result.totalCost)}`);
-if (result.haltReason) console.log(`  Halt reason: ${result.haltReason}  (re-run with --resume to continue)`);
-const finalFiles = result.outcomes.at(-1)?.files ?? [];
-console.log(`  Files in workspace: ${finalFiles.join(", ") || "(none)"}`);
-console.log(`  State saved: ${statePath}\n`);

package/src/run-web.ts

@@ -1,87 +0,0 @@
-// EXPERIMENTAL web-login CLI.
-//
-//   npm run web -- login claude              open a browser, log in once (session saved)
-//   npm run web -- ask claude "2+2? one word"   send a prompt via your web session
-//
-// This is the standalone proof-of-concept. Wiring it into the full build pipeline
-// (parsing tasks/verdicts/code from text) is a separate step.
-
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { webLogin, webComplete, webDump, closeWebSessions, isWebProvider, PROVIDERS } from "./web/session.js";
-import { buildAuthorizeUrl, exchangeCode, oauthTest } from "./web/oauth-anthropic.js";
-
-const [cmd, provider, ...rest] = process.argv.slice(2);
-
-function usage(): never {
-  console.log("\n  Usage:");
-  console.log("    npm run web -- login <provider>");
-  console.log('    npm run web -- ask <provider> "your prompt"');
-  console.log("    npm run web -- oauth           # Claude: OAuth connect (subscription)");
-  console.log("    npm run web -- oauth-test      # Claude: probe if the token still works");
-  console.log(`\n  Providers: ${Object.keys(PROVIDERS).join(", ")}\n`);
-  process.exit(1);
-}
-
-function ask(q: string): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => rl.question(q, (a) => { rl.close(); resolve(a); }));
-}
-
-// ---- Claude OAuth (subscription) — the enforcement experiment ----
-if (cmd === "oauth") {
-  const pending = buildAuthorizeUrl();
-  console.log("\n  Opening your browser to approve Claude access…");
-  console.log("  If it doesn't open, paste this URL manually:\n");
-  console.log("    " + pending.url + "\n");
-  try { spawn("open", [pending.url], { stdio: "ignore", detached: true }).unref(); } catch { /* print-only */ }
-  const code = await ask("  After approving, copy the code shown on the page and paste it here:\n  code> ");
-  try {
-    await exchangeCode(code, pending);
-    console.log("\n  Token stored. Testing whether it survives enforcement…\n");
-    const reply = await oauthTest();
-    console.log(`  ✅ Works. Reply: ${reply}\n`);
-  } catch (e) {
-    console.error(`\n  ❌ ${e instanceof Error ? e.message : e}\n`);
-    process.exit(1);
-  }
-  process.exit(0);
-} else if (cmd === "oauth-test") {
-  try {
-    const reply = await oauthTest();
-    console.log(`\n  ✅ Works. Reply: ${reply}\n`);
-  } catch (e) {
-    console.error(`\n  ❌ ${e instanceof Error ? e.message : e}\n`);
-    process.exit(1);
-  }
-  process.exit(0);
-}
-
-if (!cmd || !provider || !isWebProvider(provider)) usage();
-
-if (cmd === "login") {
-  await webLogin(provider);
-  console.log(`  Logged in to ${PROVIDERS[provider].label}. Try: npm run web -- ask ${provider} "hello"\n`);
-} else if (cmd === "ask") {
-  const prompt = rest.join(" ").trim();
-  if (!prompt) usage();
-  console.log(`  Asking ${PROVIDERS[provider].label} via your web session…\n`);
-  try {
-    const reply = await webComplete(provider, prompt);
-    console.log("  --- reply ---");
-    console.log(reply.split("\n").map((l) => "  " + l).join("\n"));
-    console.log("");
-  } catch (e) {
-    console.error(`  Failed: ${e instanceof Error ? e.message : e}`);
-    console.error(`  If selectors are stale, edit src/web/session.ts. If not logged in, run: npm run web -- login ${provider}\n`);
-    await closeWebSessions();
-    process.exit(1);
-  }
-  await closeWebSessions(); // one-shot CLI: shut the background browser down
-} else if (cmd === "dump") {
-  const prompt = rest.join(" ").trim() || "say hello in one word";
-  console.log(`  Diagnosing ${PROVIDERS[provider].label} DOM…\n`);
-  await webDump(provider, prompt);
-} else {
-  usage();
-}

package/src/scout.ts

@@ -1,121 +0,0 @@
-// The Scout — keeps the registry current.
-//
-// Input: findings (best model per capability+tier, from a research/benchmark pass —
-//   the same kind of verified output the deep-research harness produces).
-// Output: a proposed registry + a human-readable diff. SEMI-AUTO by design: the Scout
-//   proposes, you approve, then apply. Nothing changes routing without a look.
-//
-// Pure + testable: no network. Feed it findings; it computes the delta.
-
-import type { Backend, Capability, Provider, RegistryEntry, Tier } from "./types.js";
-import { MODELS } from "./models.js";
-
-export interface Finding {
-  capability: Capability;
-  tier: Tier;
-  /** Which backend slot this evidence informs. Benchmarks mostly inform "api". */
-  backend: Backend;
-  provider: Provider;
-  model: string;
-  evidence: string;
-  date?: string;
-}
-
-export type ChangeKind = "add" | "update" | "noop" | "unknown-model";
-
-export interface RegistryChange {
-  kind: ChangeKind;
-  capability: Capability;
-  tier: Tier;
-  backend: Backend;
-  from?: string;
-  to: string;
-  evidence: string;
-}
-
-export interface Proposal {
-  updated: RegistryEntry[];
-  changes: RegistryChange[];
-}
-
-const keyOf = (c: Capability, t: Tier) => `${c}/${t}`;
-
-/** Compute a proposed registry from the current one + findings. Pure. */
-export function proposeUpdate(current: RegistryEntry[], findings: Finding[]): Proposal {
-  // Clone entries so we don't mutate the input.
-  const map = new Map<string, RegistryEntry>(
-    current.map((e) => [keyOf(e.capability, e.tier), cloneEntry(e)]),
-  );
-  const changes: RegistryChange[] = [];
-
-  for (const f of findings) {
-    const k = keyOf(f.capability, f.tier);
-    const known = !!MODELS[f.model];
-    const existing = map.get(k);
-
-    if (!existing) {
-      // New capability/tier slot — seed both backends with the finding, mark others later.
-      map.set(k, {
-        capability: f.capability,
-        tier: f.tier,
-        byBackend: {
-          web: { provider: f.provider, model: f.model },
-          api: { provider: f.provider, model: f.model },
-        },
-        evidence: f.evidence,
-        updated: f.date ?? "scout",
-      });
-      changes.push({
-        kind: known ? "add" : "unknown-model",
-        capability: f.capability, tier: f.tier, backend: f.backend,
-        to: f.model, evidence: f.evidence,
-      });
-      continue;
-    }
-
-    const cur = existing.byBackend[f.backend];
-    if (cur.model === f.model && cur.provider === f.provider) {
-      changes.push({
-        kind: "noop", capability: f.capability, tier: f.tier, backend: f.backend,
-        from: cur.model, to: f.model, evidence: f.evidence,
-      });
-      continue;
-    }
-
-    existing.byBackend[f.backend] = { provider: f.provider, model: f.model };
-    existing.evidence = f.evidence;
-    existing.updated = f.date ?? "scout";
-    changes.push({
-      kind: known ? "update" : "unknown-model",
-      capability: f.capability, tier: f.tier, backend: f.backend,
-      from: cur.model, to: f.model, evidence: f.evidence,
-    });
-  }
-
-  return { updated: [...map.values()], changes };
-}
-
-/** Only the changes that actually alter routing (drops noops). */
-export function meaningfulChanges(changes: RegistryChange[]): RegistryChange[] {
-  return changes.filter((c) => c.kind !== "noop");
-}
-
-export function formatProposal(changes: RegistryChange[]): string {
-  const real = meaningfulChanges(changes);
-  if (!real.length) return "  No changes — registry already matches the findings.";
-  const icon: Record<ChangeKind, string> = { add: "+", update: "~", noop: " ", "unknown-model": "!" };
-  return real
-    .map((c) => {
-      const arrow = c.from ? `${c.from} -> ${c.to}` : c.to;
-      const warn = c.kind === "unknown-model" ? "  [!] model not in models.ts — add it before applying" : "";
-      return `  ${icon[c.kind]} ${c.capability}/${c.tier} [${c.backend}]  ${arrow}\n      ${c.evidence}${warn}`;
-    })
-    .join("\n");
-}
-
-function cloneEntry(e: RegistryEntry): RegistryEntry {
-  return {
-    ...e,
-    byBackend: { web: { ...e.byBackend.web }, api: { ...e.byBackend.api } },
-  };
-}

package/src/session-cost.ts

@@ -1,17 +0,0 @@
-// Running total of money spent in THIS process (session). Every Pi session adds its
-// own cost here after it finishes, so it captures builds, planning, breakdowns — all of it.
-// Resets on process restart (module-level state).
-
-let total = 0;
-
-export function addSessionCost(n: number): void {
-  if (Number.isFinite(n) && n > 0) total += n;
-}
-
-export function sessionCost(): number {
-  return Math.round(total * 100) / 100;
-}
-
-export function resetSessionCost(): void {
-  total = 0;
-}

package/src/stack.ts

@@ -1,46 +0,0 @@
-// Target stack — the platform + framework a build should target. The choice is
-// turned into a short instruction appended to the brief, so the PM and dev build
-// the right thing. Kept build-free on purpose (CDN React, no Vite/npm) so the
-// existing static test/preview/deploy pipeline works unchanged.
-
-export type Platform = "web" | "mobile" | "desktop";
-
-/** Web framework ids. "ai" = let the PM decide; any other string = custom. */
-export type Framework = "vanilla" | "react" | "ai" | (string & {});
-
-export interface StackChoice {
-  platform: Platform;
-  framework: Framework;
-}
-
-export const WEB_FRAMEWORKS: { id: Framework; label: string }[] = [
-  { id: "vanilla", label: "Vanilla HTML / CSS / JS (no framework)" },
-  { id: "react", label: "React (via CDN, no build step)" },
-  { id: "ai", label: "Let the AI decide" },
-];
-
-const WEB_DESC: Record<string, string> = {
-  vanilla: "vanilla HTML, CSS, and JavaScript — no framework, no build step",
-  react:
-    "React loaded from a CDN (no build step): a single index.html that imports React and ReactDOM " +
-    "from https://esm.sh/react and https://esm.sh/react-dom/client as ES modules, uses function " +
-    "components and hooks, and mounts into a <div id=\"root\">. Put styles in styles.css. Do NOT use " +
-    "Vite, JSX files, npm, or any build tooling — everything must run by opening index.html.",
-};
-
-/** The instruction appended to the brief for the chosen stack (empty = AI decides). */
-export function stackInstruction(choice: StackChoice): string {
-  const { platform, framework } = choice;
-  if (platform !== "web") {
-    return `\n\nTarget platform: ${platform}. Native ${platform} toolchains aren't wired up yet — build a responsive web app (single index.html) styled to feel like a ${platform} app.`;
-  }
-  if (!framework || framework === "ai") return ""; // let the PM pick a web approach
-  const desc = WEB_DESC[framework] ?? `the ${framework} stack (no build step; must run by opening index.html)`;
-  return `\n\nTarget stack: ${desc}.`;
-}
-
-/** Human label for a stored choice, for display. */
-export function stackLabel(choice: StackChoice): string {
-  if (choice.platform !== "web") return `${choice.platform} (as web)`;
-  return WEB_FRAMEWORKS.find((f) => f.id === choice.framework)?.label ?? String(choice.framework);
-}