omni-pi 0.1.0

package/src/memory.ts

@@ -0,0 +1,25 @@
+import { type StarterFile, starterFiles } from "./templates.js";
+
+export function listStarterFiles(): StarterFile[] {
+  return starterFiles;
+}
+
+export function getStarterFile(path: string): StarterFile | undefined {
+  return starterFiles.find((file) => file.path === path);
+}
+
+export function buildStarterFileMap(): Record<string, string> {
+  return Object.fromEntries(
+    starterFiles.map((file) => [file.path, file.content]),
+  );
+}
+
+export function updateStateSummary(
+  content: string,
+  nextSummary: string,
+): string {
+  return content.replace(
+    /Status Summary:.*/u,
+    `Status Summary: ${nextSummary}`,
+  );
+}

package/src/pi.ts

@@ -0,0 +1,240 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  Theme,
+} from "@mariozechner/pi-coding-agent";
+import { Box, Text } from "@mariozechner/pi-tui";
+
+export interface AppCommandContext {
+  cwd: string;
+  args?: string[];
+  runtime?: {
+    pi: ExtensionAPI;
+    ctx: ExtensionCommandContext;
+  };
+}
+
+export interface StructuredResult {
+  text: string;
+  messageType?: string;
+  details?: Record<string, unknown>;
+}
+
+export type CommandResult = string | StructuredResult;
+
+export interface AppCommandDefinition {
+  name: string;
+  description: string;
+  execute: (context: AppCommandContext) => Promise<CommandResult>;
+}
+
+function splitArgs(rawArgs: string): string[] {
+  const trimmed = rawArgs.trim();
+  return trimmed.length > 0 ? trimmed.split(/\s+/u) : [];
+}
+
+async function emitResult(
+  result: string,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  if (result.trim().length === 0) {
+    return;
+  }
+
+  if (ctx.hasUI) {
+    ctx.ui.notify(result, "info");
+  } else {
+    console.log(result);
+  }
+}
+
+interface VerificationDetails {
+  title?: string;
+  passed?: boolean;
+  checksRun?: string[];
+  failureSummary?: string[];
+}
+
+interface StatusDetails {
+  title?: string;
+  phase?: string;
+  activeTask?: string;
+  blockers?: string[];
+  nextStep?: string;
+  recoveryOptions?: string[];
+}
+
+interface EscalationDetails {
+  title?: string;
+  taskId?: string;
+  priorAttempts?: number;
+  failedChecks?: string[];
+}
+
+function renderVerificationMessage(
+  message: { content: unknown; details?: unknown },
+  expanded: boolean,
+  theme: Theme,
+): { box: InstanceType<typeof Box> } {
+  const body =
+    typeof message.content === "string"
+      ? message.content
+      : String(message.content ?? "");
+  const details = (message.details ?? {}) as VerificationDetails;
+  const icon = details.passed ? "✓" : "✗";
+  const color = details.passed ? "accent" : "error";
+  const header = theme.fg(
+    color,
+    theme.bold(`${icon} ${details.title ?? "Verification"}`),
+  );
+  const checksLine = details.checksRun?.length
+    ? `Checks: ${details.checksRun.join(", ")}`
+    : "";
+  const failureLine = details.failureSummary?.length
+    ? `Failures: ${details.failureSummary.join("; ")}`
+    : "";
+  const lines = [header, body, checksLine, failureLine].filter(Boolean);
+  const box = new Box(1, 1, (text: string) =>
+    theme.bg("customMessageBg", text),
+  );
+  box.addChild(
+    new Text(expanded ? lines.join("\n\n") : lines.join("\n"), 0, 0),
+  );
+  return { box };
+}
+
+function renderStatusMessage(
+  message: { content: unknown; details?: unknown },
+  expanded: boolean,
+  theme: Theme,
+): { box: InstanceType<typeof Box> } {
+  const body =
+    typeof message.content === "string"
+      ? message.content
+      : String(message.content ?? "");
+  const details = (message.details ?? {}) as StatusDetails;
+  const header = theme.fg(
+    "accent",
+    theme.bold(details.title ?? "Omni-Pi Status"),
+  );
+  const lines = [header];
+  if (details.phase) lines.push(`Phase: ${details.phase}`);
+  if (details.activeTask) lines.push(`Task: ${details.activeTask}`);
+  if (expanded) lines.push(body);
+  if (details.blockers?.length)
+    lines.push(`Blockers: ${details.blockers.join("; ")}`);
+  if (details.nextStep) lines.push(`Next: ${details.nextStep}`);
+  if (details.recoveryOptions?.length) {
+    lines.push("Recovery options:");
+    for (const option of details.recoveryOptions) lines.push(`  - ${option}`);
+  }
+  const box = new Box(1, 1, (text: string) =>
+    theme.bg("customMessageBg", text),
+  );
+  box.addChild(new Text(lines.join("\n"), 0, 0));
+  return { box };
+}
+
+function renderEscalationMessage(
+  message: { content: unknown; details?: unknown },
+  expanded: boolean,
+  theme: Theme,
+): { box: InstanceType<typeof Box> } {
+  const body =
+    typeof message.content === "string"
+      ? message.content
+      : String(message.content ?? "");
+  const details = (message.details ?? {}) as EscalationDetails;
+  const header = theme.fg(
+    "warning",
+    theme.bold(`⚠ ${details.title ?? "Escalation"}`),
+  );
+  const lines = [header];
+  if (details.taskId) lines.push(`Task: ${details.taskId}`);
+  if (details.priorAttempts != null)
+    lines.push(`Prior attempts: ${details.priorAttempts}`);
+  if (details.failedChecks?.length)
+    lines.push(`Failed checks: ${details.failedChecks.join(", ")}`);
+  if (expanded) lines.push(body);
+  const box = new Box(1, 1, (text: string) =>
+    theme.bg("customMessageBg", text),
+  );
+  box.addChild(new Text(lines.join("\n"), 0, 0));
+  return { box };
+}
+
+export function registerOmniMessageRenderer(api: ExtensionAPI): void {
+  api.registerMessageRenderer("omni-update", (message, { expanded }, theme) => {
+    const body =
+      typeof message.content === "string"
+        ? message.content
+        : String(message.content ?? "");
+    const details = (message.details ?? {}) as { title?: string };
+    const lines = [
+      theme.fg("accent", theme.bold(details.title ?? "Omni-Pi")),
+      body,
+    ];
+    const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+    box.addChild(
+      new Text(expanded ? lines.join("\n\n") : lines.join("\n"), 0, 0),
+    );
+    return box;
+  });
+
+  api.registerMessageRenderer(
+    "omni-verification",
+    (message, { expanded }, theme) => {
+      return renderVerificationMessage(message, expanded, theme).box;
+    },
+  );
+
+  api.registerMessageRenderer("omni-status", (message, { expanded }, theme) => {
+    return renderStatusMessage(message, expanded, theme).box;
+  });
+
+  api.registerMessageRenderer(
+    "omni-escalation",
+    (message, { expanded }, theme) => {
+      return renderEscalationMessage(message, expanded, theme).box;
+    },
+  );
+}
+
+function normalizeResult(raw: CommandResult): StructuredResult {
+  if (typeof raw === "string") {
+    return { text: raw };
+  }
+  return raw;
+}
+
+export function registerPiCommands(
+  api: ExtensionAPI,
+  commands: AppCommandDefinition[],
+): void {
+  for (const command of commands) {
+    api.registerCommand(command.name, {
+      description: command.description,
+      handler: async (args, ctx) => {
+        const raw = await command.execute({
+          cwd: ctx.cwd,
+          args: splitArgs(args),
+          runtime: {
+            pi: api,
+            ctx,
+          },
+        });
+        const result = normalizeResult(raw);
+        if (result.text.trim().length > 0 && ctx.hasUI) {
+          api.sendMessage({
+            customType: result.messageType ?? "omni-update",
+            content: result.text,
+            display: true,
+            details: { title: command.name, ...result.details },
+          });
+        } else {
+          await emitResult(result.text, ctx);
+        }
+      },
+    });
+  }
+}

package/src/planning.ts

@@ -0,0 +1,303 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import type {
+  ConversationBrief,
+  ImplementationSpec,
+  PresetConfig,
+  TaskBrief,
+} from "./contracts.js";
+import { WORKFLOW_PRESETS } from "./contracts.js";
+import type { RepoSignals } from "./repo.js";
+import { escapeTaskTableCell } from "./tasks.js";
+
+export interface PlanningContext {
+  existingDecisions: string[];
+  sessionNotes: string[];
+  priorScope: string[];
+  completedTaskIds: string[];
+}
+
+export async function gatherPlanningContext(
+  rootDir: string,
+): Promise<PlanningContext> {
+  const ctx: PlanningContext = {
+    existingDecisions: [],
+    sessionNotes: [],
+    priorScope: [],
+    completedTaskIds: [],
+  };
+
+  try {
+    const decisions = await readFile(
+      path.join(rootDir, ".omni", "DECISIONS.md"),
+      "utf8",
+    );
+    ctx.existingDecisions = decisions
+      .split("\n")
+      .filter((line) => line.trim().startsWith("- Decision:"))
+      .map((line) => line.replace(/^.*- Decision:\s*/u, "").trim())
+      .filter(Boolean);
+  } catch {
+    /* no decisions file yet */
+  }
+
+  try {
+    const session = await readFile(
+      path.join(rootDir, ".omni", "SESSION-SUMMARY.md"),
+      "utf8",
+    );
+    const progressMatch = session.match(
+      /## Recent progress\n\n([\s\S]*?)(?=\n## |$)/u,
+    );
+    if (progressMatch) {
+      ctx.sessionNotes = progressMatch[1]
+        .split("\n")
+        .map((line) => line.replace(/^- /u, "").trim())
+        .filter((line) => line.length > 0 && line !== "-");
+    }
+  } catch {
+    /* no session summary yet */
+  }
+
+  try {
+    const spec = await readFile(path.join(rootDir, ".omni", "SPEC.md"), "utf8");
+    const scopeMatch = spec.match(/## Scope\n\n([\s\S]*?)(?=\n## |$)/u);
+    if (scopeMatch) {
+      ctx.priorScope = scopeMatch[1]
+        .split("\n")
+        .map((line) => line.replace(/^- /u, "").trim())
+        .filter((line) => line.length > 0);
+    }
+  } catch {
+    /* no spec yet */
+  }
+
+  try {
+    const tasks = await readFile(
+      path.join(rootDir, ".omni", "TASKS.md"),
+      "utf8",
+    );
+    ctx.completedTaskIds = tasks
+      .split("\n")
+      .filter((line) => line.startsWith("| T") && line.includes("| done |"))
+      .map((line) => line.split("|")[1]?.trim())
+      .filter((id): id is string => Boolean(id));
+  } catch {
+    /* no tasks yet */
+  }
+
+  return ctx;
+}
+
+function buildBootstrapTasks(repoSignals: RepoSignals): TaskBrief[] {
+  const tasks: TaskBrief[] = [
+    {
+      id: "T01",
+      title: "Confirm the initial project direction",
+      objective:
+        "Refine the problem statement, constraints, and success criteria into a stable first-pass spec.",
+      contextFiles: [".omni/PROJECT.md", ".omni/IDEAS.md", ".omni/SPEC.md"],
+      skills: ["omni-planning"],
+      doneCriteria: [
+        "The problem statement is clear.",
+        "Initial constraints are captured.",
+        "Success criteria are explicit.",
+      ],
+      role: "worker",
+      status: "todo",
+      dependsOn: [],
+    },
+    {
+      id: "T02",
+      title: "Define the first implementation slice",
+      objective:
+        "Break the first meaningful delivery slice into bounded tasks with clear verification steps.",
+      contextFiles: [".omni/SPEC.md", ".omni/TASKS.md", ".omni/TESTS.md"],
+      skills: ["omni-planning"],
+      doneCriteria: [
+        "The first slice is broken into bounded tasks.",
+        "Each task has explicit done criteria.",
+        "Verification requirements are listed.",
+      ],
+      role: "worker",
+      status: "todo",
+      dependsOn: ["T01"],
+    },
+  ];
+
+  if (
+    repoSignals.tools.includes("playwright") ||
+    repoSignals.tools.includes("cypress")
+  ) {
+    tasks.push({
+      id: "T03",
+      title: "Align browser testing expectations",
+      objective:
+        "Document how browser-based checks should be used during future work.",
+      contextFiles: [".omni/TESTS.md", ".omni/SPEC.md"],
+      skills: ["agent-browser", "omni-verification"],
+      doneCriteria: [
+        "Browser testing expectations are documented.",
+        "The verification plan names the browser toolchain.",
+      ],
+      role: "worker",
+      status: "todo",
+      dependsOn: ["T02"],
+    });
+  }
+
+  return tasks;
+}
+
+export function createInitialSpec(
+  brief: ConversationBrief,
+  repoSignals: RepoSignals,
+  planningCtx?: PlanningContext,
+): ImplementationSpec {
+  const presetConfig: PresetConfig | undefined = brief.preset
+    ? WORKFLOW_PRESETS[brief.preset]
+    : undefined;
+  const scopeItems = [
+    brief.summary,
+    ...brief.constraints,
+    ...brief.userSignals,
+    ...(presetConfig
+      ? [`Workflow preset: ${presetConfig.name} — ${presetConfig.description}`]
+      : []),
+  ].filter(Boolean);
+
+  if (planningCtx?.priorScope.length) {
+    for (const item of planningCtx.priorScope) {
+      if (!scopeItems.includes(item)) {
+        scopeItems.push(item);
+      }
+    }
+  }
+
+  const architecture = [
+    "Use `.omni/` as the durable project memory layer.",
+    "Keep the user-facing brain simple and route deeper work through planner, worker, verifier, and expert roles.",
+    `Detected repo signals: languages=${repoSignals.languages.join(", ") || "unknown"}; frameworks=${repoSignals.frameworks.join(", ") || "unknown"}; tools=${repoSignals.tools.join(", ") || "unknown"}.`,
+  ];
+
+  if (presetConfig) {
+    architecture.push(`Worker hint: ${presetConfig.workerHint}`);
+  }
+
+  if (planningCtx?.existingDecisions.length) {
+    architecture.push(
+      `Prior decisions to honor: ${planningCtx.existingDecisions.join("; ")}`,
+    );
+  }
+
+  const acceptanceCriteria = [
+    "The project direction is captured in `.omni/PROJECT.md` and `.omni/SPEC.md`.",
+    "The next tasks are small, verifiable, and ready for guided execution.",
+    "The verification plan names the checks needed for the first slice.",
+  ];
+
+  if (planningCtx?.sessionNotes.length) {
+    acceptanceCriteria.push(
+      `Build on recent progress: ${planningCtx.sessionNotes.slice(0, 3).join("; ")}`,
+    );
+  }
+
+  let tasks = buildBootstrapTasks(repoSignals);
+  if (presetConfig && tasks.length > presetConfig.maxTasks) {
+    tasks = tasks.slice(0, presetConfig.maxTasks);
+  }
+  if (planningCtx?.completedTaskIds.length) {
+    for (const task of tasks) {
+      if (planningCtx.completedTaskIds.includes(task.id)) {
+        task.status = "done";
+      }
+    }
+  }
+
+  return {
+    title: brief.desiredOutcome || "Initial Omni-Pi plan",
+    scope: scopeItems,
+    architecture,
+    taskSlices: tasks,
+    acceptanceCriteria,
+  };
+}
+
+export function renderSpecMarkdown(spec: ImplementationSpec): string {
+  return `# Spec
+
+## Title
+
+${spec.title}
+
+## Scope
+
+${spec.scope.map((item) => `- ${item}`).join("\n")}
+
+## Architecture
+
+${spec.architecture.map((item) => `- ${item}`).join("\n")}
+
+## Acceptance Criteria
+
+${spec.acceptanceCriteria.map((item) => `- ${item}`).join("\n")}
+
+## Risks
+
+- To be identified during planning.
+
+## Open Questions
+
+- To be captured during the understand phase.
+`;
+}
+
+export function renderTasksMarkdown(tasks: TaskBrief[]): string {
+  const rows = tasks.map((task) => {
+    const dependsOn =
+      task.dependsOn.length > 0 ? task.dependsOn.join(", ") : "-";
+    const doneCriteria = task.doneCriteria.join("; ");
+    return `| ${escapeTaskTableCell(task.id)} | ${escapeTaskTableCell(task.title)} | ${escapeTaskTableCell(task.role)} | ${escapeTaskTableCell(dependsOn)} | ${escapeTaskTableCell(task.status)} | ${escapeTaskTableCell(doneCriteria)} |`;
+  });
+
+  return `# Tasks
+
+## Task slices
+
+| ID | Title | Role | Depends On | Status | Done Criteria |
+| --- | --- | --- | --- | --- | --- |
+${rows.join("\n")}
+`;
+}
+
+export function renderTestsMarkdown(repoSignals: RepoSignals): string {
+  const projectChecks = ["npm test"];
+
+  if (repoSignals.tools.includes("vitest")) {
+    projectChecks.push("npm run test");
+  }
+
+  if (repoSignals.tools.includes("playwright")) {
+    projectChecks.push("npx playwright test");
+  }
+
+  return `# Tests
+
+## Project-wide checks
+
+${projectChecks.map((check) => `- ${check}`).join("\n")}
+
+## Task-specific checks
+
+- Add task-level checks as each slice is planned.
+
+## Retry policy
+
+- Worker retries before expert takeover: 2
+
+## Escalation threshold
+
+- Escalate after repeated failures or when the planner marks the task as high-risk.
+`;
+}