iriai-build 0.1.0

package/bin/iriai-build.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// iriai-build — CLI entry point for AI agent orchestration.
+// Drives the same v3 engine as bridge-v3.js, with inline terminal prompts.
+
+import { Command } from "commander";
+import { bareCommand } from "../cli/commands/index.js";
+import { planCommand } from "../cli/commands/plan.js";
+import { implementationCommand } from "../cli/commands/implementation.js";
+import { launchCommand } from "../cli/commands/launch.js";
+import { slackCommand } from "../cli/commands/slack.js";
+import { setupCommand } from "../cli/commands/setup.js";
+import { transferToSlackCommand } from "../cli/commands/transfer.js";
+
+function handleError(err) {
+  // @inquirer/prompts throws ExitPromptError on Ctrl+C — exit silently
+  if (err?.name === "ExitPromptError") {
+    process.exit(0);
+  }
+  console.error("Fatal:", err);
+  process.exit(1);
+}
+
+const program = new Command();
+
+program
+  .name("iriai-build")
+  .description("AI agent orchestration CLI — plan, implement, and ship features")
+  .version("0.1.0");
+
+program
+  .command("plan [description]")
+  .description("Run planning pipeline. After plan approved, prompts to continue to implementation.")
+  .action(async (description) => {
+    await planCommand(description);
+  });
+
+program
+  .command("implementation")
+  .alias("impl")
+  .description("Select from planned/in-progress features and run implementation.")
+  .action(async () => {
+    await implementationCommand();
+  });
+
+program
+  .command("launch [description]")
+  .description("Full flow: planning -> implementation -> complete. Without arg: select or create.")
+  .action(async (description) => {
+    await launchCommand(description);
+  });
+
+program
+  .command("slack")
+  .description("Launch the Slack bridge (replaces `node bridge-v3.js`).")
+  .action(async () => {
+    await slackCommand();
+  });
+
+program
+  .command("setup")
+  .description("Configure Slack tokens, tool paths, and preferences.")
+  .action(async () => {
+    await setupCommand();
+  });
+
+program
+  .command("transfer-to-slack")
+  .description("Sync all CLI features to Slack and start the Slack bridge.")
+  .action(async () => {
+    await transferToSlackCommand();
+  });
+
+// Bare invocation: interactive menu
+if (process.argv.length <= 2) {
+  bareCommand().catch(handleError);
+} else {
+  program.parseAsync(process.argv).catch(handleError);
+}

package/bridge-v3.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+// bridge-v3.js — SQLite-backed agent orchestration bridge.
+//
+// Replaces filesystem state (bridge-v2.js) with SQLite for features, agents,
+// events, and decisions. Filesystem stays only for agent I/O (claude CLI constraint).
+//
+// Usage: node bridge-v3.js   (or via start-bridge.sh + launchd)
+
+import * as db from "./v3/db.js";
+import { SlackAdapter } from "./v3/adapters/slack-adapter.js";
+import { Orchestrator } from "./v3/orchestrator.js";
+import { Recovery } from "./v3/recovery.js";
+import { ReviewSessionManager } from "./v3/review-sessions.js";
+import { DB_PATH, PORTAL_PORT } from "./v3/constants.js";
+import { ArtifactPortal } from "./v3/artifact-portal.js";
+
+let _orchestrator = null;
+let _portal = null;
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+const SLACK_APP_TOKEN = process.env.SLACK_APP_TOKEN;
+const SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
+const PLANNING_CHANNEL = process.env.SLACK_CHANNEL_ID;
+
+if (!SLACK_APP_TOKEN || !SLACK_BOT_TOKEN || !PLANNING_CHANNEL) {
+  console.error("Missing required env vars: SLACK_APP_TOKEN, SLACK_BOT_TOKEN, SLACK_CHANNEL_ID");
+  process.exit(1);
+}
+
+// ─── Startup ─────────────────────────────────────────────────────────────────
+
+async function start() {
+  console.log("Starting Iriai Slack Bridge v3 (SQLite-backed)...");
+
+  // 1. Open database
+  db.open(DB_PATH);
+  console.log(`Database opened: ${DB_PATH}`);
+
+  // 2. Connect Slack
+  const adapter = new SlackAdapter({
+    appToken: SLACK_APP_TOKEN,
+    botToken: SLACK_BOT_TOKEN,
+    planningChannel: PLANNING_CHANNEL,
+  });
+  await adapter.connect();
+  console.log(`Slack connected. Bot user: ${adapter.botUserId}`);
+
+  // 3. Create orchestrator with review session support
+  const reviewSessions = new ReviewSessionManager();
+  const orchestrator = new Orchestrator({ adapter, reviewSessions });
+  _orchestrator = orchestrator;
+  adapter.setOrchestrator(orchestrator);
+
+  // 4. Start artifact portal
+  const portal = new ArtifactPortal({ reviewSessions });
+  _portal = portal;
+  await portal.start(PORTAL_PORT);
+
+  // 5. Run recovery (process stale signals, reattach running agents)
+  const recovery = new Recovery({ orchestrator, adapter });
+  await recovery.run();
+
+  // 6. Start stale signal safety net
+  orchestrator.startStaleScan();
+
+  console.log("Bridge v3 ready.");
+}
+
+// ─── Graceful Shutdown ───────────────────────────────────────────────────────
+
+async function shutdown(signal) {
+  console.log(`\n[bridge] ${signal} received — shutting down gracefully`);
+
+  if (_portal) {
+    await _portal.stop();
+  }
+
+  if (_orchestrator) {
+    await _orchestrator.shutdown();
+  }
+
+  db.close();
+  console.log("[bridge] Database closed. Exiting.");
+  process.exit(0);
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+process.on("unhandledRejection", (err) => {
+  console.error("[bridge] Unhandled rejection (non-fatal):", err?.message || err);
+});
+
+start().catch((err) => {
+  console.error("[bridge] Fatal:", err);
+  process.exit(1);
+});

package/cli/bootstrap.js

@@ -0,0 +1,83 @@
+// bootstrap.js — Shared setup for all CLI commands.
+// Opens DB, creates adapter + orchestrator + recovery, wires input handler.
+
+import * as db from "../v3/db.js";
+import { TerminalAdapter } from "../v3/adapters/terminal-adapter.js";
+import { Orchestrator } from "../v3/orchestrator.js";
+import { Recovery } from "../v3/recovery.js";
+import { ReviewSessionManager } from "../v3/review-sessions.js";
+import { TerminalInput } from "./terminal-input.js";
+import * as queries from "../v3/queries.js";
+import { DB_PATH } from "../v3/constants.js";
+import { slugify } from "../v3/helpers.js";
+
+/**
+ * Bootstrap the engine for CLI use.
+ * Returns { orchestrator, adapter, recovery, input, shutdown }.
+ */
+export function bootstrap() {
+  db.open(DB_PATH);
+
+  const adapter = new TerminalAdapter();
+  const reviewSessions = new ReviewSessionManager();
+  const orchestrator = new Orchestrator({ adapter, reviewSessions });
+  const input = new TerminalInput({ orchestrator });
+  adapter.setInputHandler(input);
+  const recovery = new Recovery({ orchestrator, adapter });
+
+  let _shutdownCalled = false;
+  async function shutdown() {
+    if (_shutdownCalled) return;
+    _shutdownCalled = true;
+    input.stopInputLoop();
+    input.exitScreen();
+    await reviewSessions.stopAll();
+    await orchestrator.shutdown();
+    db.close();
+  }
+
+  // Graceful shutdown on signals (guard against double registration from bare → subcommand)
+  if (!process.__iriaiShutdownRegistered) {
+    process.__iriaiShutdownRegistered = true;
+    const onSignal = async (sig) => {
+      console.log(`\n[iriai-build] ${sig} — shutting down...`);
+      await shutdown();
+      process.exit(0);
+    };
+    process.on("SIGINT", () => onSignal("SIGINT"));
+    process.on("SIGTERM", () => onSignal("SIGTERM"));
+    process.on("unhandledRejection", (err) => {
+      // @inquirer/prompts throws ExitPromptError on Ctrl+C — let SIGINT handler deal with it
+      if (err?.name === "ExitPromptError") return;
+      console.error("[iriai-build] Unhandled rejection:", err?.message || err);
+    });
+  }
+
+  return { orchestrator, adapter, recovery, input, shutdown };
+}
+
+/**
+ * Initialize a new feature from a description string.
+ * Generates slug, creates synthetic thread_ts, starts planning.
+ */
+export async function initNewFeature(orchestrator, description) {
+  let slug = slugify(description);
+
+  // Dedup: if slug already exists, append a numeric suffix
+  const existing = queries.getFeatureBySlug(slug);
+  if (existing) {
+    let suffix = 2;
+    while (queries.getFeatureBySlug(`${slug}-${suffix}`)) {
+      suffix++;
+    }
+    slug = `${slug}-${suffix}`;
+    console.log(`Slug "${slugify(description)}" already exists, using: ${slug}`);
+  }
+
+  const messageTs = `terminal-${Date.now()}`;
+  const userId = "terminal-user";
+
+  console.log(`\nInitializing feature: ${slug}`);
+  const feature = await orchestrator.initializeFeature(slug, messageTs, userId);
+  return feature;
+}

package/cli/commands/implementation.js

@@ -0,0 +1,64 @@
+// implementation.js — `iriai-build implementation` command.
+// Select from planned/in-progress features, run implementation.
+
+import { select } from "@inquirer/prompts";
+import * as queries from "../../v3/queries.js";
+import { bootstrap } from "../bootstrap.js";
+import { banner, formatFeatureChoice, successMsg, systemMsg, errorMsg } from "../display.js";
+import { waitForCompletion } from "../wait.js";
+
+export async function implementationCommand() {
+  banner();
+  const { orchestrator, adapter, recovery, input, shutdown } = bootstrap();
+
+  const features = queries.getFeaturesForImplCommand();
+  if (features.length === 0) {
+    errorMsg("No features ready for implementation. Run `iriai-build plan` first.");
+    await shutdown();
+    return;
+  }
+
+  const choices = features.map((f) => ({
+    name: formatFeatureChoice(f),
+    value: f.id,
+  }));
+
+  const featureId = await select({
+    message: "Select a feature to implement:",
+    choices,
+  });
+
+  const feature = queries.getFeatureById(featureId);
+  input.setActiveFeature(featureId, feature.feature_channel || feature.slug);
+
+  if (feature.phase === "plan-approval") {
+    const shouldStart = await input.promptConfirm("Approve plan and start implementation?");
+    if (!shouldStart) {
+      systemMsg("Exiting.");
+      await shutdown();
+      return;
+    }
+    systemMsg("Launching implementation...");
+    await orchestrator.startImplementation(featureId);
+    successMsg("Implementation launched.");
+  } else if (feature.phase === "impl") {
+    const gate = feature.gate_number || 0;
+    systemMsg(`Resuming implementation — gate ${gate}`);
+    input.startInputLoop();
+    await recovery.runForFeature(featureId);
+  } else {
+    input.startInputLoop();
+  }
+
+  orchestrator.startStaleScan();
+
+  await waitForCompletion(featureId, adapter);
+
+  const finalFeature = queries.getFeatureById(featureId);
+  if (finalFeature?.phase === "failed") {
+    errorMsg(`Feature ${finalFeature.slug} failed.`);
+  } else {
+    successMsg("Feature complete!");
+  }
+  await shutdown();
+}

package/cli/commands/index.js

@@ -0,0 +1,46 @@
+// index.js — `iriai-build` bare command (interactive menu).
+// Delegates to plan/implementation/launch/slack subcommands.
+
+import { select } from "@inquirer/prompts";
+import { planCommand } from "./plan.js";
+import { implementationCommand } from "./implementation.js";
+import { launchCommand } from "./launch.js";
+import { slackCommand } from "./slack.js";
+import { setupCommand } from "./setup.js";
+import { transferToSlackCommand } from "./transfer.js";
+
+export async function bareCommand() {
+  // Don't print banner here — the delegated command will print it.
+  const action = await select({
+    message: "What would you like to do?",
+    choices: [
+      { name: "Launch (full flow: plan -> implement -> complete)", value: "launch" },
+      { name: "Plan (planning only)", value: "plan" },
+      { name: "Implementation (run implementation for a planned feature)", value: "implementation" },
+      { name: "Slack (launch Slack bridge)", value: "slack" },
+      { name: "Transfer to Slack (sync CLI features to Slack)", value: "transfer" },
+      { name: "Setup (configure Slack tokens & tools)", value: "setup" },
+    ],
+  });
+
+  switch (action) {
+    case "launch":
+      await launchCommand();
+      break;
+    case "plan":
+      await planCommand();
+      break;
+    case "implementation":
+      await implementationCommand();
+      break;
+    case "slack":
+      await slackCommand();
+      break;
+    case "transfer":
+      await transferToSlackCommand();
+      break;
+    case "setup":
+      await setupCommand();
+      break;
+  }
+}

package/cli/commands/launch.js

@@ -0,0 +1,153 @@
+// launch.js — `iriai-build launch [description]` command.
+// Full flow: planning -> approve -> implementation -> complete.
+// Without arg: select from active features or start new.
+
+import { select } from "@inquirer/prompts";
+import * as queries from "../../v3/queries.js";
+import { bootstrap, initNewFeature } from "../bootstrap.js";
+import { banner, formatFeatureChoice, successMsg, systemMsg, errorMsg } from "../display.js";
+import { waitForPlanDecision, waitForCompletion } from "../wait.js";
+
+export async function launchCommand(description) {
+  banner();
+  const { orchestrator, adapter, recovery, input, shutdown } = bootstrap();
+
+  let featureId;
+  let isNew = false;
+
+  if (description) {
+    const feature = await initNewFeature(orchestrator, description);
+    featureId = feature.id;
+    isNew = true;
+  } else {
+    const features = queries.getActiveFeatures();
+    const choices = [
+      { name: "[NEW] Start a new feature", value: "__new__" },
+      ...features.map((f) => ({
+        name: formatFeatureChoice(f),
+        value: f.id,
+      })),
+    ];
+
+    const selected = await select({
+      message: "Select a feature or start new:",
+      choices,
+    });
+
+    if (selected === "__new__") {
+      const desc = await input.promptFeatureDescription();
+      if (!desc) {
+        console.log("No description provided. Exiting.");
+        await shutdown();
+        return;
+      }
+      const feature = await initNewFeature(orchestrator, desc);
+      featureId = feature.id;
+      isNew = true;
+    } else {
+      featureId = selected;
+    }
+  }
+
+  const feature = queries.getFeatureById(featureId);
+  input.setActiveFeature(featureId, feature.feature_channel || feature.slug);
+  orchestrator.startStaleScan();
+
+  if (isNew) {
+    // New feature — agents already dispatched by initNewFeature
+    systemMsg("Planning agents starting. The Operator will update you as they progress.");
+    input.startInputLoop();
+    await runPlanningWait(featureId, adapter);
+  } else if (feature.phase === "planning") {
+    printResumeStatus(feature);
+    systemMsg("Recovering state and resuming agents...");
+    input.startInputLoop();
+    await recovery.runForFeature(featureId);
+    systemMsg("Agents resumed. The Operator will present decisions as they come.");
+    await runPlanningWait(featureId, adapter);
+  } else if (feature.phase === "plan-approval") {
+    const shouldStart = await input.promptConfirm("Plan is approved. Start implementation?");
+    if (!shouldStart) {
+      systemMsg("Exiting. Resume later with: iriai-build implementation");
+      await shutdown();
+      return;
+    }
+    systemMsg("Launching implementation...");
+    await orchestrator.startImplementation(featureId);
+    successMsg("Implementation launched.");
+    input.startInputLoop();
+    await waitForCompletion(featureId, adapter);
+    printFinalStatus(featureId, shutdown);
+    return;
+  } else if (feature.phase === "impl") {
+    printResumeStatus(feature);
+    systemMsg("Recovering state and resuming agents...");
+    input.startInputLoop();
+    await recovery.runForFeature(featureId);
+    systemMsg("Agents resumed. The Operator will present decisions as they come.");
+    await waitForCompletion(featureId, adapter);
+    printFinalStatus(featureId, shutdown);
+    return;
+  } else {
+    // complete/failed/closed — nothing to do
+    systemMsg(`Feature ${feature.slug} is already ${feature.phase}.`);
+    await shutdown();
+    return;
+  }
+
+  // Planning wait resolved — check result
+  let current = queries.getFeatureById(featureId);
+  if (current?.phase === "failed") {
+    errorMsg(`Feature ${current.slug} failed.`);
+    await shutdown();
+    return;
+  }
+
+  // Plan approved — start implementation
+  input.stopInputLoop();
+  systemMsg("Starting implementation...");
+  await orchestrator.startImplementation(featureId);
+  successMsg("Implementation launched. The Operator will keep you updated.");
+  input.startInputLoop();
+
+  await waitForCompletion(featureId, adapter);
+  await printFinalStatus(featureId, shutdown);
+}
+
+/**
+ * Wait through planning → plan-approval, handling rejection loops.
+ */
+async function runPlanningWait(featureId, adapter) {
+  await waitForPlanDecision(featureId, adapter);
+
+  let current = queries.getFeatureById(featureId);
+  while (current?.phase === "planning") {
+    await waitForPlanDecision(featureId, adapter);
+    current = queries.getFeatureById(featureId);
+  }
+}
+
+function printResumeStatus(feature) {
+  const meta = JSON.parse(feature.metadata || "{}");
+
+  if (feature.phase === "planning") {
+    const role = feature.active_planning_role || "pm";
+    const review = meta.awaiting_phase_review ? ` (awaiting ${meta.phase_review_role} review)` : "";
+    systemMsg(`Resuming planning — ${role} phase${review}`);
+  } else if (feature.phase === "impl") {
+    const gate = feature.gate_number || 0;
+    systemMsg(`Resuming implementation — gate ${gate}`);
+  } else {
+    systemMsg(`Resuming — ${feature.phase}`);
+  }
+}
+
+async function printFinalStatus(featureId, shutdown) {
+  const finalFeature = queries.getFeatureById(featureId);
+  if (finalFeature?.phase === "failed") {
+    errorMsg(`Feature ${finalFeature.slug} failed.`);
+  } else {
+    successMsg("Feature complete!");
+  }
+  await shutdown();
+}

package/cli/commands/plan.js

@@ -0,0 +1,117 @@
+// plan.js — `iriai-build plan [description]` command.
+// Planning only. After plan approved, prompts "Continue to implementation?"
+
+import { select } from "@inquirer/prompts";
+import * as queries from "../../v3/queries.js";
+import { bootstrap, initNewFeature } from "../bootstrap.js";
+import { banner, formatFeatureChoice, successMsg, systemMsg, errorMsg } from "../display.js";
+import { waitForPlanDecision, waitForCompletion } from "../wait.js";
+
+export async function planCommand(description) {
+  banner();
+  const { orchestrator, adapter, recovery, input, shutdown } = bootstrap();
+
+  // Defer impl launch so we can prompt "Continue to implementation?" first
+  orchestrator.deferImplLaunch = true;
+
+  let featureId;
+  let isNew = false;
+
+  if (description) {
+    const feature = await initNewFeature(orchestrator, description);
+    featureId = feature.id;
+    isNew = true;
+  } else {
+    const features = queries.getFeaturesForPlanCommand();
+    const choices = [
+      { name: "[NEW] Start a new feature", value: "__new__" },
+      ...features.map((f) => ({
+        name: formatFeatureChoice(f),
+        value: f.id,
+      })),
+    ];
+
+    const selected = await select({
+      message: "Select a feature or start new:",
+      choices,
+    });
+
+    if (selected === "__new__") {
+      const desc = await input.promptFeatureDescription();
+      if (!desc) {
+        console.log("No description provided. Exiting.");
+        await shutdown();
+        return;
+      }
+      const feature = await initNewFeature(orchestrator, desc);
+      featureId = feature.id;
+      isNew = true;
+    } else {
+      featureId = selected;
+    }
+  }
+
+  const feature = queries.getFeatureById(featureId);
+  input.setActiveFeature(featureId, feature.feature_channel || feature.slug);
+  orchestrator.startStaleScan();
+
+  if (!isNew && feature.phase === "plan-approval") {
+    // Already approved — skip straight to impl continuation prompt
+    return await promptImplContinuation(orchestrator, adapter, input, featureId, shutdown);
+  }
+
+  if (!isNew && feature.phase === "planning") {
+    const role = feature.active_planning_role || "pm";
+    const meta = JSON.parse(feature.metadata || "{}");
+    const review = meta.awaiting_phase_review ? ` (awaiting ${meta.phase_review_role} review)` : "";
+    systemMsg(`Resuming planning — ${role} phase${review}`);
+    input.startInputLoop();
+    await recovery.runForFeature(featureId);
+  } else {
+    // Start input loop
+    input.startInputLoop();
+  }
+
+  // Wait for plan to be approved
+  await waitForPlanDecision(featureId, adapter);
+
+  // Handle rejection loops
+  let currentFeature = queries.getFeatureById(featureId);
+  while (currentFeature?.phase === "planning") {
+    await waitForPlanDecision(featureId, adapter);
+    currentFeature = queries.getFeatureById(featureId);
+  }
+
+  if (currentFeature?.phase === "failed") {
+    errorMsg(`Feature ${currentFeature.slug} failed.`);
+    await shutdown();
+    return;
+  }
+
+  // Plan approved — prompt for continuation
+  await promptImplContinuation(orchestrator, adapter, input, featureId, shutdown);
+}
+
+async function promptImplContinuation(orchestrator, adapter, input, featureId, shutdown) {
+  const shouldContinue = await input.promptContinueToImpl();
+
+  if (shouldContinue) {
+    orchestrator.deferImplLaunch = false;
+    systemMsg("Starting implementation...");
+    await orchestrator.startImplementation(featureId);
+    successMsg("Implementation launched. Monitoring agents...");
+    input.startInputLoop();
+
+    await waitForCompletion(featureId, adapter);
+    const finalFeature = queries.getFeatureById(featureId);
+    if (finalFeature?.phase === "failed") {
+      errorMsg(`Feature ${finalFeature.slug} failed.`);
+    } else {
+      successMsg("Feature complete!");
+    }
+  } else {
+    systemMsg("Exiting. Resume later with: iriai-build implementation");
+  }
+
+  await shutdown();
+}