projectinator 0.3.0 → 0.4.0

package/src/demo.ts

@@ -1,106 +0,0 @@
-// Phase 1 demo — proves the brain before wiring any agents.
-// Feeds a fake "landing page + contact form" backlog through the router and prints
-// backend, model, and estimated cost per task, plus the total.
-//
-// Run: npm run demo            (cost-first / web backend)
-//      npm run demo -- api      (force API backend)
-//      npm run demo -- ask      (interactive-style; here stubbed to demonstrate)
-
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-import type { RoutingPolicy, Task } from "./types.js";
-import { DEFAULT_POLICY, routeBacklog } from "./router.js";
-import { loadRegistry, OVERRIDES_FILENAME } from "./registry-store.js";
-
-const BACKLOG: Task[] = [
-  {
-    id: "T-01", epic: "E-1", story: "S-1", title: "Break brief into backlog",
-    capability: "plan", difficulty: "medium",
-    estTokens: { input: 10_000, output: 5_000 },
-  },
-  {
-    id: "T-02", epic: "E-1", story: "S-2", title: "Design hero + layout system",
-    capability: "design", difficulty: "high",
-    estTokens: { input: 20_000, output: 15_000 },
-  },
-  {
-    id: "T-03", epic: "E-2", story: "S-3", title: "Build page + contact form",
-    capability: "code", difficulty: "high", dependsOn: ["T-02"],
-    estTokens: { input: 400_000, output: 60_000, cachedInputFraction: 0.6 },
-  },
-  {
-    id: "T-04", epic: "E-2", story: "S-4", title: "Wire form handler",
-    capability: "code", difficulty: "low", dependsOn: ["T-03"],
-    estTokens: { input: 30_000, output: 8_000, cachedInputFraction: 0.5 },
-  },
-  {
-    id: "T-05", epic: "E-3", story: "S-5", title: "Review + test the build",
-    capability: "test", difficulty: "trivial", dependsOn: ["T-03", "T-04"],
-    estTokens: { input: 80_000, output: 15_000 },
-  },
-  {
-    id: "T-06", epic: "E-3", story: "S-6", title: "Run it, drive the CI/preview",
-    capability: "ops", difficulty: "high", dependsOn: ["T-04"],
-    estTokens: { input: 100_000, output: 20_000, cachedInputFraction: 0.4 },
-  },
-];
-
-const arg = process.argv[2];
-const policy: RoutingPolicy = { ...DEFAULT_POLICY };
-if (arg === "api") policy.backendMode = "api";
-if (arg === "web") policy.backendMode = "web";
-
-// For "ask" mode we'd wire real prompts; here we stub a chooser so the demo runs headless.
-const prompts =
-  arg === "ask"
-    ? {
-        chooseBackend: () => "api" as const,
-        chooseModel: (_t: Task, _e: unknown, _b: unknown) => undefined, // accept defaults
-      }
-    : undefined;
-if (arg === "ask") policy.backendMode = "ask";
-
-// Load the effective registry (seed + any Scout overrides), so applied Scout
-// changes are reflected here.
-const projectRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-const registry = loadRegistry(join(projectRoot, OVERRIDES_FILENAME));
-
-const decisions = routeBacklog(BACKLOG, { policy, registry, prompts });
-
-const pad = (s: string, n: number) => s.padEnd(n);
-const money = (n: number) => `$${n.toFixed(2)}`;
-
-console.log(`\n  Projectinator — routing plan   [backendMode=${policy.backendMode}, cap=${money(policy.budgetCapUSD)}]\n`);
-console.log(
-  "  " +
-    pad("TASK", 7) + pad("CAPABILITY", 11) + pad("DIFF", 9) +
-    pad("BACKEND", 9) + pad("MODEL", 20) + pad("TIER", 6) + pad("COST", 9) + "RUNNING",
-);
-console.log("  " + "-".repeat(78));
-
-for (const d of decisions) {
-  const task = BACKLOG.find((t) => t.id === d.taskId)!;
-  const flag = d.overCap ? "  ⚠ OVER CAP" : "";
-  console.log(
-    "  " +
-      pad(d.taskId, 7) +
-      pad(task.capability, 11) +
-      pad(task.difficulty, 9) +
-      pad(d.backend, 9) +
-      pad(d.model.name, 20) +
-      pad(d.tier, 6) +
-      pad(money(d.cost), 9) +
-      money(d.runningTotal) +
-      flag,
-  );
-}
-
-const total = decisions.at(-1)?.runningTotal ?? 0;
-console.log("  " + "-".repeat(78));
-console.log(`  TOTAL ESTIMATED: ${money(total)}\n`);
-
-console.log("  Decision trail for T-03 (the developer task):");
-for (const r of decisions.find((d) => d.taskId === "T-03")!.reasons) {
-  console.log("    · " + r);
-}
-console.log("");

package/src/estimate.ts

@@ -1,111 +0,0 @@
-// Token estimation lives in CODE, not in the model.
-// The Phase 2 live run proved models estimate their own token use terribly
-// (a "high" single-file task used ~1.5k output, not the 12k a model guessed).
-// So the PM only tags capability + difficulty; we map that to a token budget here.
-//
-// CALIBRATION (2026-07-15) — retuned against real getSessionStats from live runs:
-//   Phase 2 dev (code, single-file): output ~1.5k, input almost entirely cached
-//     (fresh 4 of ~3.3k tokens).
-//   Phase 4 mini: design/low, code/low ~ $0.03-0.04 each; test/trivial ~ $0.02.
-// Takeaways baked in below:
-//   - a "task" is ONE atomic unit (a file / component / spec), not a whole feature,
-//     so outputs are small — and output dominates cost (priced ~5-6x input).
-//   - Pi caches context aggressively, so most input bills at the cheap cacheRead rate.
-// These stay heuristic; wire measured actuals back in for self-calibration later.
-
-import type { Capability, Difficulty, TokenEstimate } from "./types.js";
-import { calibratedTokens, allSamples } from "./calibration.js";
-
-type Bucket = { input: number; output: number };
-
-const BUCKETS: Record<Capability, Record<Difficulty, Bucket>> = {
-  plan: {
-    trivial: { input: 2_000, output: 800 },
-    low: { input: 4_000, output: 1_500 },
-    medium: { input: 8_000, output: 3_000 },
-    high: { input: 12_000, output: 5_000 },
-  },
-  design: {
-    trivial: { input: 4_000, output: 2_000 },
-    low: { input: 6_000, output: 3_500 },
-    medium: { input: 10_000, output: 6_000 },
-    high: { input: 15_000, output: 9_000 },
-  },
-  code: {
-    trivial: { input: 6_000, output: 1_500 },
-    low: { input: 10_000, output: 3_000 },
-    medium: { input: 25_000, output: 7_000 },
-    high: { input: 60_000, output: 14_000 },
-  },
-  // Review reads the same tree the tester does but never runs it — shorter output.
-  review: {
-    trivial: { input: 15_000, output: 800 },
-    low: { input: 25_000, output: 1_500 },
-    medium: { input: 50_000, output: 3_000 },
-    high: { input: 80_000, output: 5_000 },
-  },
-  test: {
-    trivial: { input: 15_000, output: 1_200 },
-    low: { input: 25_000, output: 2_500 },
-    medium: { input: 50_000, output: 5_000 },
-    high: { input: 80_000, output: 9_000 },
-  },
-  ops: {
-    trivial: { input: 10_000, output: 2_000 },
-    low: { input: 20_000, output: 4_000 },
-    medium: { input: 40_000, output: 7_000 },
-    high: { input: 70_000, output: 12_000 },
-  },
-};
-
-// Pi auto-caches system prompt + context aggressively (live run: fresh input 4 tokens
-// of ~3.3k). Real cached share is often 80-99%; 0.55 is a conservative planning value.
-const DEFAULT_CACHED_INPUT_FRACTION = 0.55;
-
-export function estimateTokens(capability: Capability, difficulty: Difficulty): TokenEstimate {
-  // Prefer the learned average once we have enough real samples; else the static bucket.
-  const learned = calibratedTokens(capability, difficulty);
-  if (learned) return learned;
-  const b = BUCKETS[capability][difficulty];
-  return { input: b.input, output: b.output, cachedInputFraction: DEFAULT_CACHED_INPUT_FRACTION };
-}
-
-/** The static baseline (pre-calibration) token budget for a bucket. */
-export function baselineTokens(capability: Capability, difficulty: Difficulty): Bucket {
-  return BUCKETS[capability][difficulty];
-}
-
-export interface AccuracyRow {
-  capability: Capability;
-  difficulty: Difficulty;
-  baseOutput: number;
-  actualOutput: number;
-  baseInput: number;
-  actualInput: number;
-  n: number;
-  active: boolean; // true once calibration overrides the baseline (enough samples)
-}
-
-/** Baseline vs measured tokens for every bucket that has real samples. */
-export function estimateAccuracy(): AccuracyRow[] {
-  const samples = allSamples();
-  const rows: AccuracyRow[] = [];
-  for (const cap of Object.keys(BUCKETS) as Capability[]) {
-    for (const diff of Object.keys(BUCKETS[cap]) as Difficulty[]) {
-      const s = samples[`${cap}/${diff}`];
-      if (!s) continue;
-      const b = BUCKETS[cap][diff];
-      rows.push({
-        capability: cap,
-        difficulty: diff,
-        baseOutput: b.output,
-        actualOutput: Math.round(s.output),
-        baseInput: b.input,
-        actualInput: Math.round(s.input),
-        n: s.n,
-        active: !!calibratedTokens(cap, diff),
-      });
-    }
-  }
-  return rows;
-}

package/src/executor.ts

@@ -1,169 +0,0 @@
-// Phase 2 — the Executor. Runs ONE task on a real Pi agent session with the model
-// the router chose. Writes real files to a workspace dir, then reads back Pi's own
-// token usage + cost so we can compare estimated vs actual.
-//
-// Constructing a session and resolving models is offline + free. Only session.prompt()
-// hits the provider API and spends money — that path is guarded by the caller.
-
-import {
-  ModelRuntime,
-  createAgentSession,
-  type AgentSession,
-  type AgentSessionEvent,
-} from "@earendil-works/pi-coding-agent";
-import { readdirSync, statSync } from "node:fs";
-import { join, relative } from "node:path";
-import type { Provider, RouteDecision, Task } from "./types.js";
-import { estimateCost } from "./cost.js";
-import { getModel } from "./models.js";
-import { addSessionCost } from "./session-cost.js";
-
-/** Pi's own Model type, derived so we don't depend on a deep sub-path import. */
-export type PiModel = NonNullable<ReturnType<ModelRuntime["getModel"]>>;
-
-/** Pi's model/auth runtime: built-in catalog + env keys / ~/.pi/agent/auth.json.
- *  Created per call on purpose — a key added in Settings must apply to the next session. */
-export function piRuntime(): Promise<ModelRuntime> {
-  return ModelRuntime.create();
-}
-
-/** Resolve a Projectinator (provider, modelId) to Pi's executable Model.
- *  Offline + free — reads Pi's built-in registry. Throws with a clear message
- *  if the id isn't one Pi knows (our ids are kept identical to Pi's on purpose). */
-export function resolvePiModel(
-  runtime: ModelRuntime,
-  provider: Provider,
-  modelId: string,
-): PiModel {
-  const m = runtime.getModel(provider, modelId);
-  if (!m) {
-    throw new Error(
-      `Pi has no model "${provider}/${modelId}". ` +
-        `Check src/models.ts uses Pi's exact built-in id.`,
-    );
-  }
-  return m;
-}
-
-export interface ExecuteOptions {
-  /** Directory the agent builds into (its cwd). */
-  workspace: string;
-  /** Extended-thinking level. Pi clamps to model capability. */
-  thinkingLevel?: "off" | "low" | "medium" | "high";
-  /** Optional progress hook — receives raw Pi session events. */
-  onEvent?: (event: AgentSessionEvent) => void;
-  /** Tools the agent may use. Default: the coding set. */
-  tools?: string[];
-}
-
-export interface ExecuteResult {
-  taskId: string;
-  provider: Provider;
-  modelId: string;
-  /** Files present in the workspace after the run (repo-relative). */
-  files: string[];
-  /** Pi's own measured usage for the run. */
-  actual: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number };
-  /** Pi's own computed dollar cost. */
-  actualCost: number;
-  /** What we predicted before running, for calibration. */
-  estCost: number;
-  /** actualCost - estCost. Positive = we under-estimated. */
-  costDelta: number;
-}
-
-/** Build the Developer role's instruction for a single task. */
-export function buildDeveloperPrompt(task: Task): string {
-  return [
-    `You are the DEVELOPER on an autonomous build team. Complete exactly this task and nothing more.`,
-    ``,
-    `Task ${task.id}: ${task.title}`,
-    task.story ? `Story: ${task.story}` : ``,
-    ``,
-    `Rules:`,
-    `- Write real files into the current working directory using your file tools.`,
-    `- Keep it minimal and correct; no placeholders, no TODOs.`,
-    `- Do not explain at length. Build, then stop.`,
-  ]
-    .filter(Boolean)
-    .join("\n");
-}
-
-/**
- * Execute one task on a live Pi session. THIS SPENDS MONEY (session.prompt).
- * Caller is responsible for gating on a live flag + present API key.
- */
-export async function executeTask(
-  task: Task,
-  decision: RouteDecision,
-  opts: ExecuteOptions,
-): Promise<ExecuteResult> {
-  const runtime = await piRuntime();
-  const model = resolvePiModel(runtime, decision.provider, decision.model.id);
-
-  const { session } = await createAgentSession({
-    model,
-    cwd: opts.workspace,
-    modelRuntime: runtime,
-    thinkingLevel: opts.thinkingLevel ?? "medium",
-    tools: opts.tools ?? ["read", "write", "edit", "bash", "ls", "grep", "find"],
-  });
-
-  let unsubscribe: (() => void) | undefined;
-  if (opts.onEvent) unsubscribe = session.subscribe(opts.onEvent);
-
-  try {
-    await session.prompt(buildDeveloperPrompt(task));
-    const stats = session.getSessionStats();
-    addSessionCost(stats.cost);
-
-    const estCost = estimateCost(task.estTokens, getModel(decision.model.id));
-    const actualCost = round2(stats.cost);
-
-    return {
-      taskId: task.id,
-      provider: decision.provider,
-      modelId: decision.model.id,
-      files: listFiles(opts.workspace),
-      actual: {
-        input: stats.tokens.input,
-        output: stats.tokens.output,
-        cacheRead: stats.tokens.cacheRead,
-        cacheWrite: stats.tokens.cacheWrite,
-        total: stats.tokens.total,
-      },
-      actualCost,
-      estCost,
-      costDelta: round2(actualCost - estCost),
-    };
-  } finally {
-    unsubscribe?.();
-    session.dispose();
-  }
-}
-
-/** List files in a workspace, skipping Pi/session/VCS noise. */
-function listFiles(dir: string): string[] {
-  const out: string[] = [];
-  const skip = new Set([".pi", ".git", "node_modules"]);
-  const walk = (d: string) => {
-    let entries: string[];
-    try {
-      entries = readdirSync(d);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (skip.has(name)) continue;
-      const full = join(d, name);
-      if (statSync(full).isDirectory()) walk(full);
-      else out.push(relative(dir, full));
-    }
-  };
-  walk(dir);
-  return out.sort();
-}
-
-function round2(n: number): number {
-  return Math.round(n * 100) / 100;
-}

package/src/git.ts

@@ -1,72 +0,0 @@
-// Git-per-build: init a repo in the build workspace and commit after each task,
-// so every build has history + diffs (and a foundation for undo). Best-effort —
-// if git isn't available or a command fails, builds carry on uninterrupted.
-
-import { spawnSync } from "node:child_process";
-import { existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-interface GitOut { ok: boolean; out: string; }
-
-function git(dir: string, args: string[]): GitOut {
-  try {
-    const r = spawnSync("git", args, { cwd: dir, encoding: "utf8" });
-    return { ok: r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
-  } catch {
-    return { ok: false, out: "" };
-  }
-}
-
-export function isRepo(dir: string): boolean {
-  return existsSync(join(dir, ".git"));
-}
-
-/** git init + a local identity + an initial commit. Idempotent. Returns success. */
-export function initRepo(dir: string): boolean {
-  if (isRepo(dir)) return true;
-  const gi = join(dir, ".gitignore");
-  if (!existsSync(gi)) writeFileSync(gi, ".deploy/\nbuild-state.json\nnode_modules/\n");
-  if (!git(dir, ["init"]).ok) return false;
-  // Local identity so commits work even when the user has no global git config.
-  git(dir, ["config", "user.email", "bot@projectinator.local"]);
-  git(dir, ["config", "user.name", "Projectinator"]);
-  git(dir, ["add", "-A"]);
-  git(dir, ["commit", "-m", "chore: initial workspace", "--allow-empty"]);
-  return true;
-}
-
-/** Commit whatever a task produced. Returns the short hash, or null on failure. */
-export function commitTask(dir: string, taskId: string, title: string): string | null {
-  if (!isRepo(dir)) return null;
-  git(dir, ["add", "-A"]);
-  const msg = `${taskId}: ${title}`.replace(/\s+/g, " ").slice(0, 72);
-  const c = git(dir, ["commit", "-m", msg, "--allow-empty"]);
-  if (!c.ok) return null;
-  const h = git(dir, ["rev-parse", "--short", "HEAD"]);
-  return h.ok ? h.out : null;
-}
-
-/** Hard-reset one commit back (undo the last task's file changes). Returns the
- *  reverted task id parsed from the commit message. Refuses to undo past the
- *  initial commit. */
-export function undoLastCommit(dir: string): { ok: boolean; taskId?: string } {
-  if (!isRepo(dir)) return { ok: false };
-  const commits = history(dir);
-  if (commits.length <= 1) return { ok: false }; // nothing but the initial commit
-  const taskId = (commits[0]?.msg.split(":")[0] ?? "").trim() || undefined;
-  const r = git(dir, ["reset", "--hard", "HEAD~1"]);
-  return { ok: r.ok, taskId };
-}
-
-export interface Commit { hash: string; msg: string; }
-
-/** Commit log, newest first. */
-export function history(dir: string): Commit[] {
-  if (!isRepo(dir)) return [];
-  const r = git(dir, ["log", "--oneline", "--no-decorate", "--no-color"]);
-  if (!r.ok || !r.out) return [];
-  return r.out.split("\n").filter(Boolean).map((line) => {
-    const i = line.indexOf(" ");
-    return i < 0 ? { hash: line, msg: "" } : { hash: line.slice(0, i), msg: line.slice(i + 1) };
-  });
-}

package/src/intake.ts

@@ -1,125 +0,0 @@
-// Intake — the PM's clarifying-questions step. Before planning a vague request,
-// the PM asks 2-4 short questions (each with suggested options) to pin down what
-// to build. A clear request returns no questions and skips straight to planning.
-//
-// Forced structured output, same discipline as pm.ts: one tool, permissive
-// schema, coerced/validated in code.
-
-import {
-  createAgentSession,
-  defineTool,
-} from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "typebox";
-import type { Backend, Provider } from "./types.js";
-import { findEntry } from "./registry.js";
-import { piRuntime, resolvePiModel } from "./executor.js"
-import { addSessionCost } from "./session-cost.js";
-
-const IntakeSchema = Type.Object(
-  {
-    needsClarification: Type.Boolean({ description: "true only if the request is too vague to plan well" }),
-    questions: Type.Array(
-      Type.Object(
-        {
-          question: Type.String({ description: "one short clarifying question" }),
-          options: Type.Array(Type.String(), { description: "2-4 concrete pickable answers; may be empty for free text" }),
-          multi: Type.Boolean({ description: "true if several options can apply at once" }),
-        },
-        { additionalProperties: true },
-      ),
-      { description: "empty when needsClarification is false; at most 4" },
-    ),
-  },
-  { additionalProperties: true },
-);
-type IntakeRaw = Static<typeof IntakeSchema>;
-
-export interface IntakeQuestion {
-  question: string;
-  options: string[];
-  multi: boolean;
-}
-
-function buildIntakeTool() {
-  let captured: IntakeRaw | undefined;
-  const tool = defineTool({
-    name: "submit_intake",
-    label: "Submit Intake",
-    description: "Submit whether clarification is needed and, if so, the clarifying questions. Call exactly once.",
-    parameters: IntakeSchema,
-    execute: async (_id, params) => {
-      captured = params as IntakeRaw;
-      return { content: [{ type: "text", text: `Intake: ${params.needsClarification ? `${params.questions.length} questions` : "clear"}.` }], details: {} };
-    },
-  });
-  return { tool, get: () => captured };
-}
-
-const SYSTEM = [
-  "You are the PROJECT MANAGER doing intake for a build request.",
-  "If the request already has enough detail to plan and build — its purpose and the",
-  "must-have features are clear or reasonably inferable — set needsClarification=false",
-  "and questions=[].",
-  "If it is vague (a bare template like 'landing page', a one-liner missing the",
-  "essentials), set needsClarification=true and produce 2-4 SHORT questions that most",
-  "reduce ambiguity: what the product/business actually is, a name, must-have",
-  "sections/features, and style. For each question give 2-4 concrete pickable options;",
-  "set multi=true when several can apply (e.g. which sections). Never more than 4",
-  "questions. Do not ask what you can reasonably assume. Call submit_intake exactly once.",
-].join("\n");
-
-export interface AssessOptions {
-  backend: Backend;
-  modelOverride?: { provider: Provider; model: string };
-}
-
-/** Ask the PM whether the request needs clarification; returns up to 4 questions
- *  (empty = clear enough to plan directly). Never throws — returns [] on trouble. */
-export async function assessIntake(idea: string, opts: AssessOptions): Promise<IntakeQuestion[]> {
-  const runtime = await piRuntime();
-  const { entry } = findEntry("plan", "mid");
-  const pick = opts.modelOverride ?? entry.byBackend[opts.backend];
-
-  try {
-    const model = resolvePiModel(runtime, pick.provider, pick.model);
-    const { tool, get } = buildIntakeTool();
-    const { session } = await createAgentSession({
-      model,
-      modelRuntime: runtime,
-      thinkingLevel: "low",
-      noTools: "all",
-      customTools: [tool],
-      tools: ["submit_intake"],
-    });
-    try {
-      await session.prompt(`${SYSTEM}\n\n--- REQUEST ---\n${idea}`);
-      let raw = get();
-      if (!raw) {
-        await session.prompt("Call submit_intake now.");
-        raw = get();
-      }
-      addSessionCost(session.getSessionStats().cost);
-      if (!raw || !raw.needsClarification) return [];
-      return (raw.questions ?? [])
-        .slice(0, 4)
-        .map((q) => ({
-          question: String(q.question ?? "").trim(),
-          options: (q.options ?? []).map((o) => String(o).trim()).filter(Boolean).slice(0, 6),
-          multi: !!q.multi,
-        }))
-        .filter((q) => q.question);
-    } finally {
-      session.dispose();
-    }
-  } catch {
-    return []; // never block a build on intake — fall through to planning
-  }
-}
-
-/** Fold the collected answers into the brief the PM will plan from. */
-export function enrichBrief(idea: string, answers: { question: string; answer: string }[]): string {
-  const kept = answers.filter((a) => a.answer.trim());
-  if (!kept.length) return idea;
-  const lines = kept.map((a) => `- ${a.question} ${a.answer.trim()}`);
-  return `${idea}\n\nClarifications from the requester:\n${lines.join("\n")}`;
-}