iriai-build 0.1.0

package/v3/constants.js

@@ -0,0 +1,170 @@
+// constants.js — Paths, timeouts, signal file names for bridge v3.
+// Ported from lib/constants.js with DB_PATH addition.
+
+import path from "node:path";
+
+const HOME = process.env.HOME;
+
+// ─── Base Directories ────────────────────────────────────────────────────────
+
+export const IMPL_BASE =
+  process.env.IMPL_SIGNAL_BASE ||
+  path.join(HOME, "src/iriai/.implementation");
+
+export const IRIAI_TEAM_DIR =
+  process.env.IRIAI_TEAM_DIR ||
+  path.join(HOME, "src/iriai/iriai-team");
+
+export const V3_ROLES_DIR = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
+  "roles",
+);
+
+export const SCRIPTS_DIR = path.join(IRIAI_TEAM_DIR, "scripts");
+
+export const DASHBOARD_LOG = path.join(IRIAI_TEAM_DIR, ".dashboard-log");
+export const DASHBOARD_FILE = path.join(IRIAI_TEAM_DIR, "DASHBOARD.md");
+export const FEATURE_STATUS_FILE = path.join(IRIAI_TEAM_DIR, "FEATURE-STATUS.md");
+
+// ─── Database ───────────────────────────────────────────────────────────────
+
+export const DB_PATH =
+  process.env.BRIDGE_DB_PATH ||
+  path.join(HOME, ".iriai", "bridge-v3.db");
+
+// ─── Planning Roles ─────────────────────────────────────────────────────────
+
+export const PLANNING_ROLES = ["pm", "designer", "architect", "plan-compiler"];
+
+export const PLANNING_ROLE_LABELS = {
+  pm: "PM",
+  designer: "Designer",
+  architect: "Architect",
+  "plan-compiler": "Plan Compiler",
+};
+
+export const ROLE_LABELS = {
+  ...PLANNING_ROLE_LABELS,
+  lead: "Feature Lead",
+};
+
+export const PIPELINE_ORDER = ["pm", "designer", "architect", "plan-compiler"];
+
+// ─── Timeouts (milliseconds) ────────────────────────────────────────────────
+
+export const ROLE_HARD_TIMEOUT_MS = 75 * 60 * 1000;      // 75 min
+export const ROLE_SOFT_TIMEOUT_MS = 15 * 60 * 1000;      // 15 min
+export const ORCH_SOFT_TIMEOUT_MS = 45 * 60 * 1000;      // 45 min
+export const PLANNING_TIMEOUT_MS = 30 * 60 * 1000;       // 30 min
+export const OPERATOR_TIMEOUT_MS = 2 * 60 * 1000;        // 2 min
+export const FL_SOFT_TIMEOUT_MS = 45 * 60 * 1000;        // 45 min
+export const FL_CONTEXT_EXHAUST_MS = 5 * 60 * 1000;      // 5 min
+
+export const OPERATOR_RELAY_TIMEOUT_MS = 90_000;             // 90s
+export const RSS_CEILING_KB = 8_388_608;                   // 8 GB
+export const STUCK_THRESHOLD_MS = 10 * 60 * 1000;         // 10 min
+export const HEALTH_CHECK_INTERVAL_MS = 30_000;            // 30s
+export const STALE_SCAN_INTERVAL_MS = 5 * 60 * 1000;      // 5 min
+
+// ─── Retry Limits ────────────────────────────────────────────────────────────
+
+export const MAX_ROLE_RETRIES = 3;
+export const MAX_ORCH_RETRIES = 3;
+export const MAX_FL_RETRIES = 5;
+export const MAX_FL_INIT_RETRIES = 3;
+export const MAX_PLANNING_RETRIES = 5;
+export const MAX_OPERATOR_RETRIES = 3;
+
+// ─── History Limits ─────────────────────────────────────────────────────────
+
+export const HISTORY_CHAR_LIMIT = 6000;          // Max chars for history in operator prompt
+export const HISTORY_RECENT_EVENTS = 10;         // Recent events kept verbatim (not summarized)
+export const HISTORY_FULL_BACKUP_EVENTS = 100;   // Full backup event count
+
+// ─── Artifact Summarizer ────────────────────────────────────────────────────
+
+export const ARTIFACT_SUMMARY_THRESHOLD_KB = 30;   // Summarize plan dir if total artifacts > 30 KB
+export const ARTIFACT_SUMMARY_FILE = ".artifact-summary.md";
+export const SUMMARIZER_TIMEOUT_MS = 90_000;        // 90s — summarizer should be fast
+export const SUMMARIZER_MODEL = "sonnet";
+
+// ─── Backoff (seconds) ──────────────────────────────────────────────────────
+
+export const FAST_EXIT_THRESHOLD_MS = 15_000;
+export const FAST_EXIT_BACKOFF_S = 30;
+export const NORMAL_BACKOFF_S = 5;
+export const FL_NORMAL_BACKOFF_S = 10;
+
+// ─── Signal File Names ──────────────────────────────────────────────────────
+
+export const SIGNAL = {
+  TASK: ".task",
+  ACTIVE_TASK: ".active-task",
+  DONE: ".done",
+  OUTPUT: ".output",
+  AGENT_RESPONSE: ".agent-response",
+  USER_MESSAGE: ".user-message",
+  QUESTION: ".question",
+  ANSWER: ".answer",
+  NEEDS_RESTART: ".needs-restart",
+  HANDOVER: ".handover",
+  KILL: ".kill",
+  STUCK: ".stuck",
+  CRASHED: ".crashed",
+  STARTED: ".started",
+  RUNNING: ".running",
+  GATE_READY: ".gate-ready",
+  GATE_APPROVED: ".gate-approved",
+  PHASE_DONE: ".phase-done",
+  FEATURE_COMPLETE: ".feature-complete",
+  CONTEXT_REFRESH: ".context-refresh",
+  CONVERSATION_HISTORY: ".conversation-history",
+  CLAUDE_SESSION_LOG: ".claude-session.log",
+  RUNNER_LOG: ".runner.log",
+  DASHBOARD_LOG: ".dashboard-log",
+  BRIDGE_STATE: ".bridge-state.json",
+  TEAM_CONFIG: ".team-config",
+  NEEDS_REPOS: ".needs-repos",
+  GATE_EVIDENCE: ".gate-evidence.yaml",
+  OUTPUT_PARTIAL: ".output.partial",
+};
+
+// ─── Known Repos ─────────────────────────────────────────────────────────────
+
+export const KNOWN_REPOS = [
+  "first-party-apps/directory/directory-backend",
+  "first-party-apps/directory/directory-frontend",
+  "first-party-apps/events/events-backend",
+  "first-party-apps/events/events-frontend",
+  "first-party-apps/subdomain-home/subdomain-home-frontend",
+  "first-party-apps/subdomain-home/subdomain-home-server",
+  "frontend-apps/iriai-app/iriai-app-bff",
+  "frontend-apps/iriai-app/iriai-app-frontend",
+  "packages/auth-python",
+  "packages/auth-react",
+  "platform/auth/auth-frontend",
+  "platform/auth/auth-service",
+  "platform/deploy-console/deploy-console-frontend",
+  "platform/deploy-console/deploy-console-service",
+  "platform/integration-engine/integration-engine-service",
+];
+
+// ─── Templates ──────────────────────────────────────────────────────────────
+
+export const TEMPLATES_DIR = path.join(HOME, "src/iriai/templates");
+export const AVAILABLE_TEMPLATES = ["fastapi-postgres", "react-parcel"];
+
+// ─── Feature Review Roles ────────────────────────────────────────────────────
+
+// ─── Artifact Portal ────────────────────────────────────────────────────────
+
+export const PORTAL_PORT = process.env.PORTAL_PORT ? parseInt(process.env.PORTAL_PORT) : 8900;
+
+// ─── Feature Review Roles ────────────────────────────────────────────────────
+
+export const FEATURE_REVIEW_ROLES = [
+  "integration-tester",
+  "code-reviewer",
+  "security-auditor",
+  "health-monitor",
+];

package/v3/db.js

@@ -0,0 +1,76 @@
+// db.js — SQLite setup (WAL mode), migrations, transaction helper.
+// Uses node:sqlite (Node 22+ built-in).
+
+import { DatabaseSync } from "node:sqlite";
+import fs from "node:fs";
+import path from "node:path";
+import { DB_PATH } from "./constants.js";
+
+let _db = null;
+
+/**
+ * Open (or create) the SQLite database and apply the schema.
+ * Returns the DatabaseSync instance.
+ */
+export function open(dbPath = DB_PATH) {
+  if (_db) return _db;
+
+  // Ensure parent directory exists
+  const dir = path.dirname(dbPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  _db = new DatabaseSync(dbPath);
+
+  // WAL mode for crash consistency and concurrent reads
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA foreign_keys = ON");
+  _db.exec("PRAGMA busy_timeout = 5000");
+
+  // Apply schema
+  const schemaPath = path.join(import.meta.dirname, "schema.sql");
+  const schemaSql = fs.readFileSync(schemaPath, "utf-8");
+
+  // Split on semicolons and execute each statement (skip PRAGMAs already run)
+  for (const stmt of schemaSql.split(";")) {
+    const trimmed = stmt.trim();
+    if (!trimmed || trimmed.startsWith("PRAGMA")) continue;
+    _db.exec(trimmed);
+  }
+
+  return _db;
+}
+
+/**
+ * Get the active database instance (must call open() first).
+ */
+export function get() {
+  if (!_db) throw new Error("Database not opened. Call db.open() first.");
+  return _db;
+}
+
+/**
+ * Run a function inside a transaction. Automatically commits on success,
+ * rolls back on error. Returns the function's return value.
+ */
+export function transaction(fn) {
+  const db = get();
+  db.exec("BEGIN");
+  try {
+    const result = fn(db);
+    db.exec("COMMIT");
+    return result;
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+/**
+ * Close the database connection.
+ */
+export function close() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}

package/v3/file-io.js

@@ -0,0 +1,216 @@
+// file-io.js — Agent task/response filesystem transport + chokidar.
+// Watches specific signal files per agent, emits events when they appear.
+
+import { EventEmitter } from "node:events";
+import fs from "node:fs";
+import path from "node:path";
+import { watch } from "chokidar";
+import { SIGNAL } from "./constants.js";
+import { readSignal } from "./helpers.js";
+
+export class FileIO extends EventEmitter {
+  constructor() {
+    super();
+    this._watchers = [];
+  }
+
+  /**
+   * Watch per-feature planning signal directories and operator dir during planning phase.
+   */
+  watchFeaturePlanningSignals(slug, planningTree, operatorDir) {
+    // Watch directories (not individual files) — chokidar reliably detects
+    // add/change in existing dirs, even for files that get deleted and recreated.
+    const dirsToWatch = Object.values(planningTree);
+    if (operatorDir) dirsToWatch.push(operatorDir);
+
+    const watcher = watch(dirsToWatch, {
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 500 },
+      disableGlobbing: true,
+      depth: 0,
+    });
+
+    const handler = (filePath) => this._handleFeaturePlanningSignal(slug, filePath, planningTree, operatorDir);
+    watcher.on("add", handler);
+    watcher.on("change", handler);
+
+    watcher._slug = slug;
+    this._watchers.push(watcher);
+    console.log(`[file-io] Watching planning signals for ${slug}`);
+  }
+
+  _handleFeaturePlanningSignal(slug, filePath, planningTree, operatorDir) {
+    const fileName = path.basename(filePath);
+    const dir = path.dirname(filePath);
+
+    // Operator signals
+    if (operatorDir && dir === operatorDir) {
+      if (fileName === ".agent-response") {
+        this.emit("impl:operatorResponse", { slug, filePath });
+      } else if (fileName === ".user-message") {
+        this.emit("impl:userMessage", { slug, agent: "operator", filePath });
+      } else if (fileName === ".needs-repos") {
+        this.emit("impl:needsRepos", { slug, filePath });
+      }
+      return;
+    }
+
+    // Planning role signals
+    const role = Object.entries(planningTree).find(([, d]) => d === dir)?.[0];
+    if (!role) return;
+
+    if (fileName === SIGNAL.AGENT_RESPONSE || fileName === SIGNAL.AGENT_RESPONSE.slice(1)) {
+      this.emit("planning:response", { slug, role, filePath });
+    } else if (fileName === SIGNAL.QUESTION || fileName === SIGNAL.QUESTION.slice(1)) {
+      this.emit("planning:question", { slug, role, filePath });
+    } else if (fileName === SIGNAL.DONE || fileName === SIGNAL.DONE.slice(1)) {
+      this.emit("planning:done", { slug, role, filePath });
+    } else if (fileName === SIGNAL.NEEDS_RESTART || fileName === SIGNAL.NEEDS_RESTART.slice(1)) {
+      this.emit("impl:needsRestart", { slug, dir, filePath });
+    }
+  }
+
+  /**
+   * Watch implementation signal files for a specific feature.
+   */
+  watchFeatureSignals(slug, signalTree) {
+    // Watch directories (not individual files) — chokidar reliably detects
+    // add/change in existing dirs, even for files that get deleted and recreated.
+    const dirsToWatch = new Set();
+
+    if (signalTree.featureLead) dirsToWatch.add(signalTree.featureLead);
+    if (signalTree.operator) dirsToWatch.add(signalTree.operator);
+
+    for (const [, team] of Object.entries(signalTree.teams || {})) {
+      if (team.orchestrator) dirsToWatch.add(team.orchestrator);
+      for (const [, roleDir] of Object.entries(team.roles || {})) {
+        dirsToWatch.add(roleDir);
+      }
+    }
+
+    for (const [, reviewDir] of Object.entries(signalTree.featureReview || {})) {
+      dirsToWatch.add(reviewDir);
+    }
+
+    const watcher = watch([...dirsToWatch], {
+      ignoreInitial: true,
+      awaitWriteFinish: { stabilityThreshold: 500 },
+      disableGlobbing: true,
+      depth: 0,
+    });
+
+    const handler = (filePath) => this._handleImplSignal(slug, filePath, signalTree);
+    watcher.on("add", handler);
+    watcher.on("change", handler);
+
+    watcher._slug = slug;
+    this._watchers.push(watcher);
+    console.log(`[file-io] Watching impl signals for ${slug}`);
+  }
+
+  _handleImplSignal(slug, filePath, tree) {
+    const fileName = path.basename(filePath);
+    const dir = path.dirname(filePath);
+
+    // Feature Lead
+    if (tree.featureLead && dir === tree.featureLead) {
+      switch (fileName) {
+        case ".agent-response":
+          this.emit("impl:response", { slug, agent: "feature-lead", filePath });
+          return;
+        case ".feature-complete":
+          this.emit("impl:featureComplete", { slug, filePath });
+          return;
+        case ".phase-done":
+          this.emit("impl:phaseDone", { slug, filePath });
+          return;
+        case ".context-refresh":
+          this.emit("impl:contextRefresh", { slug, filePath });
+          return;
+        case ".needs-restart":
+          this.emit("impl:needsRestart", { slug, dir, filePath });
+          return;
+      }
+    }
+
+    // Operator
+    if (tree.operator && dir === tree.operator) {
+      if (fileName === ".agent-response") {
+        this.emit("impl:operatorResponse", { slug, filePath });
+      } else if (fileName === ".user-message") {
+        this.emit("impl:userMessage", { slug, agent: "operator", filePath });
+      }
+      return;
+    }
+
+    // Teams
+    for (const [teamNum, team] of Object.entries(tree.teams || {})) {
+      if (team.orchestrator && dir === team.orchestrator) {
+        switch (fileName) {
+          case ".task":
+            this.emit("impl:orchTask", { slug, teamNum, filePath });
+            return;
+          case ".gate-ready":
+            this.emit("impl:gateReady", { slug, teamNum, filePath });
+            return;
+          case ".question":
+            this.emit("impl:question", { slug, teamNum, filePath });
+            return;
+          case ".crashed":
+            this.emit("impl:crashed", { slug, agent: `orch-${teamNum}`, teamNum, filePath });
+            return;
+          case ".needs-restart":
+            this.emit("impl:needsRestart", { slug, dir, filePath });
+            return;
+        }
+      }
+      for (const [role, roleDir] of Object.entries(team.roles || {})) {
+        if (dir === roleDir) {
+          if (fileName === ".task") {
+            this.emit("impl:task", { slug, teamNum, role, filePath });
+          } else if (fileName === ".done") {
+            this.emit("impl:done", { slug, teamNum, role, agent: `role-${teamNum}-${role}`, filePath });
+          } else if (fileName === ".needs-restart") {
+            this.emit("impl:needsRestart", { slug, dir, filePath });
+          }
+          return;
+        }
+      }
+    }
+
+    // Feature review
+    for (const [role, reviewDir] of Object.entries(tree.featureReview || {})) {
+      if (dir === reviewDir) {
+        if (fileName === ".done") {
+          this.emit("impl:done", { slug, role, agent: `review-${role}`, filePath });
+        } else if (fileName === ".needs-restart") {
+          this.emit("impl:needsRestart", { slug, dir, filePath });
+        }
+        return;
+      }
+    }
+  }
+
+  /**
+   * Stop watching signals for a specific feature.
+   */
+  unwatchFeature(slug) {
+    this._watchers = this._watchers.filter(w => {
+      if (w._slug === slug) {
+        w.close();
+        return false;
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Close all watchers.
+   */
+  async closeAll() {
+    for (const w of this._watchers) {
+      await w.close();
+    }
+    this._watchers = [];
+  }
+}

package/v3/helpers.js

@@ -0,0 +1,174 @@
+// helpers.js — Pure utility functions extracted from slack-helpers.js.
+// These are interface-agnostic: signal I/O, slugify, repo detection.
+
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { IRIAI_TEAM_DIR, KNOWN_REPOS, TEMPLATES_DIR, AVAILABLE_TEMPLATES } from "./constants.js";
+
+export function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 40);
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+/**
+ * Read a signal file, return content, and optionally delete it.
+ */
+export function readSignal(filePath, { deleteAfter = false } = {}) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8").trim();
+    if (deleteAfter) fs.unlinkSync(filePath);
+    return content;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Write content to a signal file (ensures parent dir exists).
+ */
+export function writeSignal(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content);
+}
+
+/**
+ * Extract media markers from message text.
+ */
+export function parseGifMarkers(text) {
+  const gifPaths = [];
+  const evidencePaths = [];
+  const cleaned = text.replace(/\[(gif|img|image|video|screenshot|evidence):([^\]]+)\]/gi, (match, type, filePath) => {
+    if (type.toLowerCase() === "evidence") {
+      evidencePaths.push(filePath.trim());
+    } else {
+      gifPaths.push(filePath.trim());
+    }
+    return "";
+  });
+  return { text: cleaned.trim(), gifPaths, evidencePaths };
+}
+
+export function findArtifact(filename, planDir) {
+  const dir = planDir || path.join(IRIAI_TEAM_DIR, "implementation-plans", "current");
+  try {
+    const files = fs.readdirSync(dir);
+    const match = files.find((f) => f.includes(filename) && f.endsWith(".md"));
+    if (match) return path.join(dir, match);
+  } catch {
+    // Directory doesn't exist yet
+  }
+  return null;
+}
+
+export function parseRole(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("@pm")) return "pm";
+  if (lower.includes("@designer")) return "designer";
+  if (lower.includes("@architect")) return "architect";
+  if (lower.includes("@compiler") || lower.includes("@plan-compiler"))
+    return "plan-compiler";
+  if (lower.includes("@lead")) return "lead";
+  return null;
+}
+
+export function detectReposFromPlan(planDir, featureSlug) {
+  const planPath = findArtifact("implementation-plan", planDir);
+  const detected = [];
+
+  // 1. Text-scan plan artifact against KNOWN_REPOS
+  if (planPath) {
+    const content = fs.readFileSync(planPath, "utf-8");
+    for (const repo of KNOWN_REPOS) {
+      if (content.includes(repo)) detected.push(repo);
+    }
+  }
+
+  // 2. Scan worktree dir for repos already pulled in (catches new repos)
+  if (featureSlug) {
+    const reposDir = path.join(process.env.HOME, "src/iriai/.features", featureSlug, "repos");
+    if (fs.existsSync(reposDir)) {
+      try {
+        const entries = fs.readdirSync(reposDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          const wtPath = path.join(reposDir, entry.name);
+          if (!fs.existsSync(path.join(wtPath, ".git"))) continue;
+          try {
+            const remote = execSync(`git -C "${wtPath}" remote get-url origin`, { stdio: "pipe" }).toString().trim();
+            const projectRoot = path.join(process.env.HOME, "src/iriai");
+            if (remote.startsWith(projectRoot)) {
+              const relPath = remote.slice(projectRoot.length + 1);
+              if (!detected.includes(relPath)) detected.push(relPath);
+            }
+          } catch {
+            // No remote — might be a locally-scaffolded new repo; skip
+          }
+        }
+      } catch { /* reposDir read failed */ }
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * Scaffold a new repo locally: create directory, apply template or bare scaffold,
+ * initialize git. Does NOT create GitHub repo (that happens post-approval).
+ * Returns true on success, false on failure.
+ */
+export function scaffoldNewRepo(localPath, githubName, template) {
+  const projectRoot = path.join(process.env.HOME, "src/iriai");
+  const repoAbsPath = path.join(projectRoot, localPath);
+  const repoBasename = path.basename(localPath);
+
+  // Idempotent: if already exists with .git, skip
+  if (fs.existsSync(path.join(repoAbsPath, ".git"))) {
+    console.log(`[scaffoldNewRepo] ${localPath} already exists with .git, skipping`);
+    return true;
+  }
+
+  try {
+    fs.mkdirSync(repoAbsPath, { recursive: true });
+
+    if (template && AVAILABLE_TEMPLATES.includes(template)) {
+      const templateDir = path.join(TEMPLATES_DIR, template);
+      if (fs.existsSync(templateDir)) {
+        execSync(`rsync -a --exclude '.git' "${templateDir}/" "${repoAbsPath}/"`, { stdio: "pipe" });
+        console.log(`[scaffoldNewRepo] Applied template '${template}' to ${localPath}`);
+      } else {
+        console.warn(`[scaffoldNewRepo] Template dir not found: ${templateDir}, using bare scaffold`);
+        _writeBareScaffold(repoAbsPath, repoBasename);
+      }
+    } else {
+      _writeBareScaffold(repoAbsPath, repoBasename);
+    }
+
+    // Initialize git
+    execSync(`git -C "${repoAbsPath}" init -b main`, { stdio: "pipe" });
+    execSync(`git -C "${repoAbsPath}" add -A`, { stdio: "pipe" });
+    execSync(`git -C "${repoAbsPath}" commit -m "chore: scaffold ${repoBasename}"`, { stdio: "pipe" });
+
+    console.log(`[scaffoldNewRepo] Scaffolded ${localPath} (template: ${template || "bare"})`);
+    return true;
+  } catch (err) {
+    console.error(`[scaffoldNewRepo] Failed to scaffold ${localPath}:`, err.message);
+    return false;
+  }
+}
+
+function _writeBareScaffold(dir, name) {
+  fs.writeFileSync(path.join(dir, "README.md"), `# ${name}\n\nPart of the iriai platform.\n`);
+  fs.writeFileSync(path.join(dir, ".gitignore"), [
+    "node_modules/", "__pycache__/", "*.pyc", ".venv/", "venv/",
+    ".env", ".env.local", ".idea/", ".vscode/", "*.swp",
+    ".DS_Store", "dist/", "build/", "*.egg-info/",
+  ].join("\n") + "\n");
+}