projectinator 0.3.0 → 0.4.0

package/src/tui/notify.ts

@@ -1,21 +0,0 @@
-// Fire a desktop notification + sound when a build finishes, so you can look away
-// during a build and get pinged. macOS uses osascript; other platforms ring the bell.
-
-import { spawn } from "node:child_process";
-
-export function notifyBuildDone(title: string, message: string): void {
-  try {
-    if (process.platform === "darwin") {
-      const script = `display notification ${JSON.stringify(message)} with title ${JSON.stringify(title)} sound name "Glass"`;
-      const child = spawn("osascript", ["-e", script], { detached: true, stdio: "ignore" });
-      child.unref();
-    } else if (process.platform === "win32") {
-      // PowerShell balloon-free ping: just the console bell.
-      process.stdout.write("\x07");
-    } else {
-      process.stdout.write("\x07"); // terminal bell
-    }
-  } catch {
-    /* best effort — never break the build on a notification failure */
-  }
-}

package/src/tui/panels.tsx

@@ -1,89 +0,0 @@
-// Small PM panels: the AI Team roster, the Standup summary line, and a List view.
-
-import React from "react";
-import { Box, Text } from "ink";
-import Spinner from "ink-spinner";
-import { C, ROLE_META, Panel, Chip } from "./components.js";
-import { groupByEpic, type BoardTask } from "./Kanban.js";
-import { effectiveRoster, modelLabel } from "./engine.js";
-
-/** The AI team: each role and the model playing it right now. */
-export function Team(): React.ReactElement {
-  const rows = effectiveRoster();
-  return (
-    <Panel title="Your team">
-      {rows.map((r) => (
-        <Box key={r.capability}>
-          <Text>{ROLE_META[r.capability].emoji} </Text>
-          <Box width={16}><Text color={C.dim}>{ROLE_META[r.capability].label}</Text></Box>
-          <Text color={C.text}>{modelLabel(r.model ?? "—")}</Text>
-        </Box>
-      ))}
-    </Panel>
-  );
-}
-
-function isDone(t: BoardTask): boolean {
-  return t.status === "done" || t.status === "skipped";
-}
-
-/** One-line standup: what's done, running, ready, spent, and needing attention. */
-export function Standup({ tasks, spent }: { tasks: BoardTask[]; spent?: number }): React.ReactElement {
-  const done = tasks.filter(isDone).length;
-  const running = tasks.filter((t) => t.status === "running").length;
-  const failed = tasks.filter((t) => t.status === "failed" || t.verdict === "FAIL").length;
-  const doneIds = new Set(tasks.filter(isDone).map((t) => t.id));
-  const ready = tasks.filter((t) => t.status === "pending" && (t.dependsOn ?? []).every((d) => doneIds.has(d))).length;
-  const backlog = tasks.filter((t) => t.status === "pending" && !(t.dependsOn ?? []).every((d) => doneIds.has(d))).length;
-  const cost = spent ?? tasks.reduce((a, t) => a + (t.cost ?? 0), 0);
-
-  return (
-    <Box gap={1} flexWrap="wrap">
-      <Chip label={`${done} done`} dotColor={C.good} />
-      {running > 0 ? <Chip label={`${running} running`} dotColor={C.info} /> : null}
-      <Chip label={`${ready} ready`} dotColor="cyan" />
-      <Chip label={`${backlog} backlog`} />
-      <Chip label={`$${cost.toFixed(2)}`} dotColor={C.accent} />
-      {failed > 0 ? <Chip label={`${failed} review`} dotColor={C.bad} active /> : null}
-    </Box>
-  );
-}
-
-const STATUS_MARK: Record<BoardTask["status"], { m: string; c: string }> = {
-  done: { m: "✓", c: C.good },
-  skipped: { m: "·", c: C.dim },
-  running: { m: "●", c: "cyan" },
-  failed: { m: "✗", c: C.bad },
-  pending: { m: "○", c: C.dim },
-};
-
-/** Flat list view, grouped by epic. Read-only alternative to the board. */
-export function ListView({ tasks }: { tasks: BoardTask[] }): React.ReactElement {
-  const lanes = groupByEpic(tasks);
-  return (
-    <Box flexDirection="column">
-      {lanes.map((lane) => (
-        <Box key={lane.epic} flexDirection="column" marginBottom={1}>
-          <Text color={C.accent}>▊ {lane.epic}</Text>
-          {lane.tasks.map((t) => {
-            const s = STATUS_MARK[t.status];
-            return (
-              <Box key={t.id}>
-                <Box width={2}>
-                  {t.status === "running" ? <Text color="cyan"><Spinner type="dots" /></Text> : <Text color={s.c}>{s.m}</Text>}
-                </Box>
-                <Box width={7}><Text color={C.dim}>{t.id}</Text></Box>
-                <Box width={3}><Text>{ROLE_META[t.capability].emoji}</Text></Box>
-                <Box flexGrow={1}><Text color={C.text} wrap="truncate-end">{t.title}</Text></Box>
-                <Box width={10} justifyContent="flex-end">
-                  {t.verdict ? <Text color={t.verdict === "FAIL" ? C.bad : t.verdict === "PASS*" ? C.warn : C.good}>{t.verdict}</Text>
-                    : t.cost ? <Text color={C.dim}>${t.cost.toFixed(2)}</Text> : <Text> </Text>}
-                </Box>
-              </Box>
-            );
-          })}
-        </Box>
-      ))}
-    </Box>
-  );
-}

package/src/tui/templates.ts

@@ -1,119 +0,0 @@
-// Starter templates — curated, detailed idea prompts. Picking one skips the blank
-// page and gives the PM a strong brief to decompose. Users can also save their own
-// (persisted in ~/.projectinator/templates.json) and share them as portable files.
-
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export interface Template {
-  name: string;
-  blurb: string;
-  idea: string;
-}
-
-export const TEMPLATES: Template[] = [
-  {
-    name: "Product landing page",
-    blurb: "Hero, features, pricing, CTA",
-    idea: "A single-page product landing site: a hero with headline + subheadline + call-to-action button, a 3-column features section, a simple pricing table, a short testimonials row, and a footer. Clean modern design, responsive, self-contained HTML with embedded CSS.",
-  },
-  {
-    name: "Personal portfolio",
-    blurb: "About, projects, contact",
-    idea: "A personal portfolio site: a hero with my name and one-line intro, an about section, a projects grid with 3 sample cards (image, title, short description, link), and a contact section with a simple form. Tasteful typography, responsive, single self-contained HTML file.",
-  },
-  {
-    name: "Link-in-bio page",
-    blurb: "Avatar, bio, link buttons",
-    idea: "A centered link-in-bio page: a round avatar, a name, a one-line bio, and a vertical stack of 4 link buttons (Twitter, GitHub, Email, Website). Soft gradient background, mobile-first, single self-contained HTML file.",
-  },
-  {
-    name: "Coming-soon / waitlist",
-    blurb: "Countdown + email signup",
-    idea: "A coming-soon page: a big headline, a short pitch, a live countdown timer to a launch date, and an email signup form with inline validation and a success message. Bold, centered, single self-contained HTML file.",
-  },
-  {
-    name: "Restaurant / cafe site",
-    blurb: "Hero, menu, hours, contact",
-    idea: "A cafe website: a hero with the cafe name and a photo-style gradient banner, a menu section grouped into Coffee / Food / Pastries with prices, an opening-hours block, a location + contact section with a simple form. Warm, inviting design, responsive, single self-contained HTML file.",
-  },
-  {
-    name: "Blog home page",
-    blurb: "Header, post list, sidebar",
-    idea: "A blog home page: a header with the blog title and nav, a main column listing 4 post previews (title, date, excerpt, read-more link), a sidebar with an about box and a tag list, and a footer. Readable editorial typography, responsive, single self-contained HTML file.",
-  },
-  {
-    name: "SaaS dashboard UI",
-    blurb: "Sidebar, stat cards, table",
-    idea: "A SaaS dashboard UI (front-end only, mock data): a left sidebar nav, a top bar, a row of 4 stat cards, a simple line-chart placeholder, and a recent-activity table. Clean product design, responsive, single self-contained HTML file with embedded CSS/JS.",
-  },
-];
-
-// ---- user templates (saved + shared) ----
-
-function homeDir(): string {
-  const d = join(homedir(), ".projectinator");
-  mkdirSync(d, { recursive: true });
-  return d;
-}
-function userTemplatesPath(): string {
-  return join(homeDir(), "templates.json");
-}
-function slug(name: string): string {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "template";
-}
-
-export function loadUserTemplates(): Template[] {
-  try {
-    const raw = JSON.parse(readFileSync(userTemplatesPath(), "utf8")) as Template[];
-    return Array.isArray(raw) ? raw : [];
-  } catch {
-    return [];
-  }
-}
-function writeUserTemplates(list: Template[]): void {
-  writeFileSync(userTemplatesPath(), JSON.stringify(list, null, 2) + "\n");
-}
-
-/** Built-in + user templates, tagged. */
-export function allTemplates(): (Template & { builtin: boolean })[] {
-  return [
-    ...TEMPLATES.map((t) => ({ ...t, builtin: true })),
-    ...loadUserTemplates().map((t) => ({ ...t, builtin: false })),
-  ];
-}
-
-/** Save (or overwrite by name) a user template. */
-export function saveUserTemplate(t: Template): void {
-  const list = loadUserTemplates().filter((x) => x.name !== t.name);
-  list.push(t);
-  writeUserTemplates(list);
-}
-
-export function deleteUserTemplate(name: string): void {
-  writeUserTemplates(loadUserTemplates().filter((x) => x.name !== name));
-}
-
-/** Write a template to a portable file others can import. Returns the path. */
-export function exportTemplate(t: Template): string {
-  const dir = join(homeDir(), "exports");
-  mkdirSync(dir, { recursive: true });
-  const p = join(dir, `${slug(t.name)}.pitemplate.json`);
-  writeFileSync(p, JSON.stringify(t, null, 2) + "\n");
-  return p;
-}
-
-/** Import a template from a shared file. Adds it to the user's templates. */
-export function importTemplate(filePath: string): Template {
-  const clean = filePath.trim().replace(/^['"]|['"]$/g, "").replace(/\\(.)/g, "$1");
-  const abs = clean.startsWith("~") ? homedir() + clean.slice(1) : clean;
-  if (!existsSync(abs)) throw new Error(`File not found: ${abs}`);
-  const raw = JSON.parse(readFileSync(abs, "utf8")) as Partial<Template>;
-  if (!raw || typeof raw.name !== "string" || typeof raw.idea !== "string") {
-    throw new Error("Not a valid template file (needs name + idea).");
-  }
-  const t: Template = { name: raw.name, blurb: String(raw.blurb ?? ""), idea: raw.idea };
-  saveUserTemplate(t);
-  return t;
-}

package/src/tui/theme.ts

@@ -1,44 +0,0 @@
-// Custom @inkjs/ui theme — recolors the library's components (blue/green by default)
-// to our amber accent so the whole app reads as one system.
-
-import { defaultTheme, extendTheme } from "@inkjs/ui";
-
-const AMBER = "#e0a72d";
-
-export const uiTheme = extendTheme(defaultTheme, {
-  components: {
-    Select: {
-      styles: {
-        focusIndicator: () => ({ color: AMBER }),
-        selectedIndicator: () => ({ color: AMBER }),
-        // Unselected items are explicitly white (not `undefined`, which renders
-        // as the terminal's default fg and reads gray) so Select rows match the
-        // custom GroupedMenu's white unselected rows.
-        label: ({ isFocused, isSelected }: { isFocused: boolean; isSelected: boolean }) => ({
-          color: isFocused || isSelected ? AMBER : "white",
-        }),
-        highlightedText: () => ({ color: AMBER, bold: true }),
-      },
-    },
-    MultiSelect: {
-      styles: {
-        focusIndicator: () => ({ color: AMBER }),
-        selectedIndicator: () => ({ color: AMBER }),
-        label: ({ isFocused, isSelected }: { isFocused: boolean; isSelected: boolean }) => ({
-          color: isFocused || isSelected ? AMBER : "white",
-        }),
-        highlightedText: () => ({ color: AMBER, bold: true }),
-      },
-    },
-    Spinner: {
-      styles: {
-        frame: () => ({ color: AMBER }),
-      },
-    },
-    ProgressBar: {
-      styles: {
-        completed: () => ({ color: AMBER }),
-      },
-    },
-  },
-});

package/src/tui/validate.ts

@@ -1,53 +0,0 @@
-// Validate an API key by hitting each provider's models endpoint (free, no tokens).
-// 200 = the key works; 401/403 = rejected. Used before saving a key in Settings so
-// bad keys never get stored (the root cause of silent 0-token routing failures).
-
-import type { Provider } from "../types.js";
-
-export interface KeyCheck {
-  ok: boolean;
-  error?: string;
-}
-
-async function withTimeout(url: string, init: RequestInit, ms = 8000): Promise<Response> {
-  const ctrl = new AbortController();
-  const timer = setTimeout(() => ctrl.abort(), ms);
-  try {
-    return await fetch(url, { ...init, signal: ctrl.signal });
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-export async function validateKey(provider: Provider, key: string): Promise<KeyCheck> {
-  if (!key.trim()) return { ok: false, error: "Empty key." };
-  try {
-    let res: Response;
-    if (provider === "anthropic") {
-      res = await withTimeout("https://api.anthropic.com/v1/models", {
-        headers: { "x-api-key": key, "anthropic-version": "2023-06-01" },
-      });
-    } else if (provider === "openai") {
-      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)}`,
-        {},
-      );
-    }
-    if (res.ok) return { ok: true };
-    if (res.status === 401 || res.status === 403) return { ok: false, error: "Key rejected — check it's correct and active." };
-    if (res.status === 400) return { ok: false, error: "Key rejected (bad request) — likely wrong key." };
-    return { ok: false, error: `Provider returned HTTP ${res.status}.` };
-  } catch (e) {
-    const msg = e instanceof Error && e.name === "AbortError" ? "Timed out — check your connection." : "Couldn't reach the provider.";
-    return { ok: false, error: msg };
-  }
-}

package/src/types.ts

@@ -1,208 +0,0 @@
-// Core domain types for Projectinator's brain layer.
-// Phase 1 is pure data + logic — no Pi, no network, no agents.
-
-/** How we reach a model. `api` = metered + stable. `web` = user's existing
- *  web subscription, ~free but brittle (breaks on UI changes, no structured output). */
-export type Backend = "api" | "web";
-
-/** What kind of work a task needs. Roles bind to capabilities, never to model names. */
-export type Capability = "plan" | "design" | "code" | "review" | "test" | "ops";
-
-/** How hard the task is. Drives which tier of model we spend on. */
-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" | "openrouter";
-
-// ---------------------------------------------------------------------------
-// Model pricing — mirrors Pi's models.json `cost` shape so it ports 1:1 later.
-// All rates are USD per 1,000,000 tokens.
-// ---------------------------------------------------------------------------
-
-export interface CostTier {
-  /** This tier applies once cumulative input tokens exceed this threshold. */
-  inputTokensAbove: number;
-  input: number;
-  output: number;
-  cacheRead?: number;
-  cacheWrite?: number;
-}
-
-export interface ModelCost {
-  input: number;
-  output: number;
-  cacheRead?: number;
-  cacheWrite?: number;
-  /** Optional volume tiers; highest matching threshold wins. */
-  tiers?: CostTier[];
-}
-
-export interface Model {
-  id: string;
-  provider: Provider;
-  name: string;
-  contextWindow: number;
-  cost: ModelCost;
-}
-
-// ---------------------------------------------------------------------------
-// Registry — the swappable brain. capability + tier -> model, per backend.
-// ---------------------------------------------------------------------------
-
-export interface BackendPick {
-  provider: Provider;
-  /** Model id, must exist in the model table. */
-  model: string;
-}
-
-export interface RegistryEntry {
-  capability: Capability;
-  tier: Tier;
-  /** Model depends on how you connect. Web (free) can afford the best;
-   *  API (paid) can pick a cheaper equivalent. */
-  byBackend: Record<Backend, BackendPick>;
-  /** On API, prompt the user which model to use for this role. */
-  ask?: boolean;
-  /** Why this pick — benchmark / source note. */
-  evidence?: string;
-  updated?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Task — what the PM emits, what the router reads.
-// ---------------------------------------------------------------------------
-
-export interface TokenEstimate {
-  input: number;
-  output: number;
-  /** Fraction of input served from cache (0..1). Cuts cost via cacheRead rate. */
-  cachedInputFraction?: number;
-}
-
-export interface Task {
-  id: string;
-  title: string;
-  capability: Capability;
-  difficulty: Difficulty;
-  estTokens: TokenEstimate;
-  epic?: string;
-  story?: string;
-  dependsOn?: string[];
-  /** Human-only annotation shown on the board. Never sent to any model. */
-  notes?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Policy — the user's knobs.
-// ---------------------------------------------------------------------------
-
-export type BackendMode = "ask" | "cost-first" | "api" | "web";
-
-export interface RoutingPolicy {
-  backendMode: BackendMode;
-  /** Halt the run and ask the user if the cumulative bill would cross this. */
-  budgetCapUSD: number;
-  difficultyToTier: Record<Difficulty, Tier>;
-  /** Tester -> Developer feedback loop stop condition (used later, in the orchestrator). */
-  maxFeedbackRounds: number;
-  /** Per-task limits. A task that runs longer or spends more is aborted, recorded as
-   *  failed, and the build halts (resumable). 0 = unlimited. */
-  taskLimits: TaskLimits;
-}
-
-export interface TaskLimits {
-  timeoutMs: number;
-  costCapUSD: number;
-}
-
-/** Thrown by an executor when a task breaches its limits. The orchestrator turns it
- *  into a failed outcome + halt instead of letting it escape as a crash. */
-export class TaskLimitError extends Error {
-  constructor(
-    public readonly kind: "timeout" | "cost",
-    public readonly taskId: string,
-    /** Money already spent on the aborted attempt (must still be billed). */
-    public readonly costSoFar: number,
-    message: string,
-  ) {
-    super(message);
-    this.name = "TaskLimitError";
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Routing result.
-// ---------------------------------------------------------------------------
-
-export interface RouteDecision {
-  taskId: string;
-  backend: Backend;
-  provider: Provider;
-  model: Model;
-  tier: Tier;
-  /** Estimated USD for this task alone. */
-  cost: number;
-  /** Cumulative USD including this task. */
-  runningTotal: number;
-  /** True if runningTotal crossed the budget cap — caller should confirm with user. */
-  overCap: boolean;
-  /** Human-readable trail of how the decision was made. */
-  reasons: string[];
-}
-
-// ---------------------------------------------------------------------------
-// Orchestration (Phase 4).
-// ---------------------------------------------------------------------------
-
-export interface Bug {
-  severity: "low" | "medium" | "high";
-  description: string;
-  file?: string;
-}
-
-/** A tester's structured judgement of a build. */
-export interface Verdict {
-  passed: boolean;
-  bugs: Bug[];
-  /** True when the tester actually ran the app (headless Chromium). False = it could
-   *  only read the code, so a PASS is weaker than it looks. */
-  runtimeChecked: boolean;
-}
-
-/** What a role produces when it runs a task. */
-export interface RoleResult {
-  /** The agent's final assistant text (design spec, notes, summary). */
-  finalText: string;
-  /** Files present in the workspace after the run (repo-relative). */
-  files: string[];
-  /** Pi's own measured dollar cost for this run. */
-  cost: number;
-  /** Only for test tasks — the pass/fail judgement. */
-  verdict?: Verdict;
-  /** Set when the task was aborted (limit breach). A failed outcome is billed but
-   *  never counts as "done": resume rebuilds it. */
-  error?: string;
-}
-
-/** Executor injected into the orchestrator. Real impl runs Pi; tests pass a fake. */
-export type RoleExecutor = (input: {
-  task: Task;
-  decision: RouteDecision;
-  /** Handoff text gathered from this task's dependencies. */
-  contextText: string;
-  /** 0 on first attempt, 1+ during a Tester→Developer feedback round. */
-  round: number;
-  /** Per-task limits the executor must enforce (throw TaskLimitError on breach). */
-  limits: TaskLimits;
-}) => Promise<RoleResult>;
-
-/** One recorded step of a build run. */
-export interface TaskOutcome extends RoleResult {
-  taskId: string;
-  capability: Capability;
-  provider: Provider;
-  modelId: string;
-  round: number;
-}