iriai-build 0.1.0

package/cli/commands/setup.js

@@ -0,0 +1,80 @@
+// setup.js — `iriai-build setup` command.
+// Interactive config for Slack tokens and tool paths.
+
+import { input, confirm } from "@inquirer/prompts";
+import * as config from "../config.js";
+import { banner, systemMsg, successMsg, errorMsg } from "../display.js";
+
+export async function setupCommand() {
+  banner();
+  systemMsg("Configure iriai-build. Values are saved to " + config.configPath());
+  console.log("");
+
+  const current = config.load();
+
+  // Slack tokens
+  console.log("\x1b[1mSlack Configuration\x1b[0m");
+  console.log("\x1b[2mRequired for `iriai-build slack` and `iriai-build transfer-to-slack`.\x1b[0m");
+  console.log("\x1b[2mEnv vars (SLACK_APP_TOKEN, etc.) always override these values.\x1b[0m\n");
+
+  const appToken = await input({
+    message: "Slack App Token (xapp-...):",
+    default: current.slack_app_token || "",
+  });
+
+  const botToken = await input({
+    message: "Slack Bot Token (xoxb-...):",
+    default: current.slack_bot_token || "",
+  });
+
+  const channelId = await input({
+    message: "Slack Planning Channel ID (C...):",
+    default: current.slack_channel_id || "",
+  });
+
+  // QA Feedback tool path
+  console.log("\n\x1b[1mTool Paths\x1b[0m");
+  console.log("\x1b[2mOptional — leave blank to use defaults (tool on PATH).\x1b[0m\n");
+
+  const claudeBin = await input({
+    message: "claude CLI path:",
+    default: current.claude_bin || "claude",
+  });
+
+  const qaFeedbackBin = await input({
+    message: "iriai-feedback CLI path:",
+    default: current.qa_feedback_bin || "iriai-feedback",
+  });
+
+  // Save
+  const updates = {};
+  if (appToken) updates.slack_app_token = appToken;
+  if (botToken) updates.slack_bot_token = botToken;
+  if (channelId) updates.slack_channel_id = channelId;
+  if (claudeBin && claudeBin !== "claude") updates.claude_bin = claudeBin;
+  if (qaFeedbackBin && qaFeedbackBin !== "iriai-feedback") updates.qa_feedback_bin = qaFeedbackBin;
+
+  config.update(updates);
+
+  console.log("");
+  successMsg(`Config saved to ${config.configPath()}`);
+
+  // Validate
+  if (appToken && botToken && channelId) {
+    const shouldTest = await confirm({
+      message: "Test Slack connection?",
+      default: true,
+    });
+
+    if (shouldTest) {
+      try {
+        const { WebClient } = await import("@slack/web-api");
+        const web = new WebClient(botToken);
+        const auth = await web.auth.test();
+        successMsg(`Connected as ${auth.user} (${auth.user_id}) in workspace ${auth.team}`);
+      } catch (err) {
+        errorMsg(`Slack connection failed: ${err.message}`);
+      }
+    }
+  }
+}

package/cli/commands/slack.js

@@ -0,0 +1,97 @@
+// slack.js — `iriai-build slack` command.
+// Wraps the existing bridge-v3.js Slack bridge startup.
+// Also syncs terminal-created features to Slack channels.
+
+import { spawn } from "node:child_process";
+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 * as queries from "../../v3/queries.js";
+import { DB_PATH } from "../../v3/constants.js";
+import * as config from "../config.js";
+import { systemMsg, successMsg, errorMsg } from "../display.js";
+
+export async function slackCommand() {
+  const slack = config.getSlackConfig();
+
+  if (!slack.appToken || !slack.botToken || !slack.channelId) {
+    errorMsg("Slack not configured. Run `iriai-build setup` first, or set SLACK_APP_TOKEN, SLACK_BOT_TOKEN, SLACK_CHANNEL_ID env vars.");
+    process.exit(1);
+  }
+
+  console.log("Starting Iriai Slack Bridge v3...");
+
+  // Prevent macOS from sleeping while the bridge is running
+  const caffeinate = spawn("caffeinate", ["-dims"], {
+    stdio: "ignore",
+    detached: true,
+  });
+  caffeinate.unref();
+
+  db.open(DB_PATH);
+
+  const adapter = new SlackAdapter({
+    appToken: slack.appToken,
+    botToken: slack.botToken,
+    planningChannel: slack.channelId,
+  });
+  await adapter.connect();
+  console.log(`Slack connected. Bot user: ${adapter.botUserId}`);
+
+  const reviewSessions = new ReviewSessionManager();
+  const orchestrator = new Orchestrator({ adapter, reviewSessions });
+  adapter.setOrchestrator(orchestrator);
+
+  const recovery = new Recovery({ orchestrator, adapter });
+  await recovery.run();
+
+  // Sync terminal-created features to Slack
+  await syncTerminalFeatures(adapter);
+
+  orchestrator.startStaleScan();
+  console.log("Bridge v3 ready.");
+
+  // Graceful shutdown
+  const shutdown = async (signal) => {
+    console.log(`\n[bridge] ${signal} — shutting down...`);
+    caffeinate.kill();
+    await orchestrator.shutdown();
+    db.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("unhandledRejection", (err) => {
+    console.error("[bridge] Unhandled rejection:", err?.message || err);
+  });
+}
+
+async function syncTerminalFeatures(adapter) {
+  const terminalFeatures = queries.getTerminalFeatures();
+  if (terminalFeatures.length === 0) return;
+
+  systemMsg(`Syncing ${terminalFeatures.length} terminal-created feature(s) to Slack...`);
+
+  for (const feature of terminalFeatures) {
+    try {
+      const channelId = await adapter.createFeatureChannel(feature.id, feature.slug);
+      if (channelId) {
+        queries.updateFeatureChannel(feature.id, channelId);
+        await adapter.postMessage(feature.id,
+          `Feature *${feature.slug}* was created via terminal. Phase: ${feature.phase}.`);
+
+        // Post plan artifacts if plan-approval or later
+        if (feature.phase !== "planning") {
+          const planDir = `${feature.signal_dir}/plans`;
+          await adapter.postMessage(feature.id, `Plan artifacts: ${planDir}`);
+        }
+
+        successMsg(`Synced: ${feature.slug} -> ${channelId}`);
+      }
+    } catch (err) {
+      console.error(`Failed to sync ${feature.slug}:`, err.message);
+    }
+  }
+}

package/cli/commands/transfer.js

@@ -0,0 +1,111 @@
+// transfer.js — `iriai-build transfer-to-slack` command.
+// Connects to Slack, syncs all active CLI features, and stays running as the Slack bridge.
+
+import { spawn } from "node:child_process";
+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 * as queries from "../../v3/queries.js";
+import { DB_PATH } from "../../v3/constants.js";
+import * as config from "../config.js";
+import { banner, systemMsg, successMsg, errorMsg } from "../display.js";
+
+export async function transferToSlackCommand() {
+  banner();
+
+  const slack = config.getSlackConfig();
+  if (!slack.appToken || !slack.botToken || !slack.channelId) {
+    errorMsg("Slack not configured. Run `iriai-build setup` first, or set SLACK_APP_TOKEN, SLACK_BOT_TOKEN, SLACK_CHANNEL_ID env vars.");
+    process.exit(1);
+  }
+
+  // Open DB (may already be open if coming from a CLI session)
+  try { db.open(DB_PATH); } catch { /* already open */ }
+
+  const activeFeatures = queries.getActiveFeatures();
+  const cliFeatures = activeFeatures.filter(f => {
+    const ch = f.feature_channel;
+    return ch && !/^[CGD][A-Z0-9]+$/.test(ch);
+  });
+
+  systemMsg(`Found ${activeFeatures.length} active feature(s), ${cliFeatures.length} need Slack sync.`);
+
+  // Prevent macOS from sleeping while the bridge is running
+  const caffeinate = spawn("caffeinate", ["-dims"], {
+    stdio: "ignore",
+    detached: true,
+  });
+  caffeinate.unref();
+
+  // Connect Slack
+  systemMsg("Connecting to Slack...");
+  const adapter = new SlackAdapter({
+    appToken: slack.appToken,
+    botToken: slack.botToken,
+    planningChannel: slack.channelId,
+  });
+  await adapter.connect();
+  successMsg(`Slack connected. Bot user: ${adapter.botUserId}`);
+
+  // Create orchestrator
+  const reviewSessions = new ReviewSessionManager();
+  const orchestrator = new Orchestrator({ adapter, reviewSessions });
+  adapter.setOrchestrator(orchestrator);
+
+  // Sync CLI features to Slack channels
+  if (cliFeatures.length > 0) {
+    systemMsg("Syncing CLI features to Slack...");
+    for (const feature of cliFeatures) {
+      try {
+        const channelId = await adapter.createFeatureChannel(feature.id, feature.slug);
+        if (channelId) {
+          queries.updateFeatureChannel(feature.id, channelId);
+
+          // Announce in #planning
+          await adapter.web.chat.postMessage({
+            channel: slack.channelId,
+            text: `[FEATURE][CLI SYNC] ${feature.slug} → <#${channelId}>`,
+          });
+
+          // Post status in feature channel
+          const phase = feature.phase || "planning";
+          const meta = JSON.parse(feature.metadata || "{}");
+          const lines = [`*Feature:* \`${feature.slug}\``, `*Phase:* ${phase}`];
+          if (meta.awaiting_phase_review) lines.push(`*Status:* Awaiting ${meta.phase_review_role} phase review`);
+          lines.push("_Transferred from CLI to Slack._");
+          await adapter.postMessage(feature.id, lines.join("\n"));
+
+          successMsg(`  ${feature.slug} → <#${channelId}>`);
+        }
+      } catch (err) {
+        errorMsg(`  Failed to sync ${feature.slug}: ${err.message}`);
+      }
+    }
+  }
+
+  // Run recovery (re-post pending decisions, resume agents)
+  systemMsg("Running recovery...");
+  const recovery = new Recovery({ orchestrator, adapter });
+  await recovery.run();
+
+  orchestrator.startStaleScan();
+  successMsg("Transfer complete. Slack bridge is now running.");
+  systemMsg("Press Ctrl+C to stop.\n");
+
+  // Graceful shutdown
+  const shutdown = async (signal) => {
+    console.log(`\n[bridge] ${signal} — shutting down...`);
+    caffeinate.kill();
+    if (reviewSessions) await reviewSessions.stopAll();
+    await orchestrator.shutdown();
+    db.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("unhandledRejection", (err) => {
+    console.error("[bridge] Unhandled rejection:", err?.message || err);
+  });
+}

package/cli/config.js

@@ -0,0 +1,92 @@
+// config.js — Persistent config for iriai-build.
+// Stores Slack tokens, tool paths, and preferences in ~/.iriai/config.json.
+// Env vars always override config file values.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const CONFIG_DIR = path.join(process.env.HOME, ".iriai");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+
+let _cache = null;
+
+function ensureDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load config from disk (cached after first read).
+ */
+export function load() {
+  if (_cache) return _cache;
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+    _cache = JSON.parse(raw);
+  } catch {
+    _cache = {};
+  }
+  return _cache;
+}
+
+/**
+ * Save config to disk.
+ */
+export function save(config) {
+  ensureDir();
+  _cache = config;
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * Update specific keys (shallow merge).
+ */
+export function update(partial) {
+  const config = load();
+  Object.assign(config, partial);
+  save(config);
+  return config;
+}
+
+/**
+ * Get a config value. Env var overrides config file.
+ */
+export function get(key, envVar) {
+  if (envVar && process.env[envVar]) return process.env[envVar];
+  return load()[key] || null;
+}
+
+/**
+ * Get Slack config, resolved from env vars or config file.
+ */
+export function getSlackConfig() {
+  return {
+    appToken: get("slack_app_token", "SLACK_APP_TOKEN"),
+    botToken: get("slack_bot_token", "SLACK_BOT_TOKEN"),
+    channelId: get("slack_channel_id", "SLACK_CHANNEL_ID"),
+  };
+}
+
+/**
+ * Check if Slack is configured (either env vars or config file).
+ */
+export function isSlackConfigured() {
+  const { appToken, botToken, channelId } = getSlackConfig();
+  return !!(appToken && botToken && channelId);
+}
+
+/**
+ * Get the claude CLI binary path. Env var CLAUDE_BIN overrides config file.
+ * Defaults to "claude" (assumes it's on PATH).
+ */
+export function getClaudeBin() {
+  return get("claude_bin", "CLAUDE_BIN") || "claude";
+}
+
+/**
+ * Get the config file path (for display purposes).
+ */
+export function configPath() {
+  return CONFIG_PATH;
+}

package/cli/display.js

@@ -0,0 +1,121 @@
+// display.js — Terminal output formatting for iriai-build CLI.
+// Colored agent labels, decision prompts, pipeline status.
+// When the TUI is active, output is routed through setOutputFn().
+
+let _outputFn = null;
+
+/**
+ * Set the output function for TUI mode. Pass null to reset to console.log.
+ */
+export function setOutputFn(fn) {
+  _outputFn = fn;
+}
+
+function _print(text) {
+  if (_outputFn) {
+    _outputFn(text);
+  } else {
+    console.log(text);
+  }
+}
+
+const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  magenta: "\x1b[35m",
+  blue: "\x1b[34m",
+  white: "\x1b[37m",
+  bgBlue: "\x1b[44m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bgRed: "\x1b[41m",
+};
+
+const AGENT_COLORS = {
+  PM: COLORS.cyan,
+  Designer: COLORS.magenta,
+  Architect: COLORS.blue,
+  "Plan Compiler": COLORS.green,
+  "Feature Lead": COLORS.yellow,
+  Operator: COLORS.white,
+};
+
+export function agentMsg(slug, agentLabel, text) {
+  const color = AGENT_COLORS[agentLabel] || COLORS.white;
+  const prefix = `${COLORS.dim}[${slug}]${COLORS.reset} ${color}${COLORS.bold}${agentLabel}${COLORS.reset}`;
+  _print(`${prefix} ${text}`);
+}
+
+export function pipelineMsg(slug, text) {
+  _print(`${COLORS.dim}[${slug}]${COLORS.reset} ${COLORS.bgBlue}${COLORS.white} Pipeline ${COLORS.reset} ${text}`);
+}
+
+export function systemMsg(text) {
+  _print(`${COLORS.dim}[system]${COLORS.reset} ${text}`);
+}
+
+export function errorMsg(text) {
+  _print(`${COLORS.red}${COLORS.bold}Error:${COLORS.reset} ${text}`);
+}
+
+export function successMsg(text) {
+  _print(`${COLORS.green}${COLORS.bold}${text}${COLORS.reset}`);
+}
+
+export function decisionHeader(title) {
+  _print(`\n${COLORS.bgYellow}${COLORS.bold} DECISION ${COLORS.reset} ${COLORS.bold}${title}${COLORS.reset}`);
+}
+
+export function featureComplete(slug) {
+  _print(`\n${COLORS.bgGreen}${COLORS.bold} COMPLETE ${COLORS.reset} Feature ${COLORS.bold}${slug}${COLORS.reset} — all gates passed!`);
+}
+
+export function separator() {
+  _print(`${COLORS.dim}${"─".repeat(60)}${COLORS.reset}`);
+}
+
+export function banner() {
+  _print(`${COLORS.bold}${COLORS.cyan}iriai-build${COLORS.reset} — AI agent orchestration CLI`);
+  separator();
+}
+
+export function formatFeatureChoice(feature) {
+  const age = timeAgo(feature.updated_at || feature.created_at);
+  const phase = feature.phase;
+  let detail = phase;
+
+  if (phase === "planning" && feature.active_planning_role) {
+    detail = `planning: ${feature.active_planning_role} phase`;
+  } else if (phase === "plan-approval") {
+    detail = "plan-approval: awaiting approval";
+  } else if (phase === "impl") {
+    const gate = feature.gate_number || 0;
+    detail = `impl: gate ${gate}`;
+  } else if (phase === "launching") {
+    detail = "launching: setting up implementation";
+  }
+
+  return `${feature.slug} (${detail}, ${age})`;
+}
+
+function timeAgo(dateStr) {
+  if (!dateStr) return "unknown";
+  // SQLite datetime('now') returns "YYYY-MM-DD HH:MM:SS" without T or Z.
+  // Normalize to ISO format for reliable parsing.
+  const normalized = dateStr.includes("T") ? dateStr : dateStr.replace(" ", "T") + "Z";
+  const then = new Date(normalized).getTime();
+  if (Number.isNaN(then)) return "unknown";
+  const diffMs = Date.now() - then;
+  if (diffMs < 0) return "just now";
+  const mins = Math.floor(diffMs / 60000);
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}