iriai-build 0.1.0

package/v3/operator.js

@@ -0,0 +1,364 @@
+// operator.js — Ephemeral operator: context assembly from SQLite, spawn, parse response.
+// Operator is a stateless function: (event, context) → formatted_response.
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { getClaudeBin } from "../cli/config.js";
+import * as queries from "./queries.js";
+import { buildOperatorPrompt, buildOperatorRelayPrompt } from "./prompt-builder.js";
+import {
+  HISTORY_CHAR_LIMIT, HISTORY_RECENT_EVENTS, HISTORY_FULL_BACKUP_EVENTS,
+} from "./constants.js";
+
+/**
+ * Invoke the Operator for a given event. Assembles context from SQLite,
+ * spawns a one-shot claude CLI, and lets the response flow through the
+ * normal file-based signal path (.agent-response → fileIO → slack).
+ *
+ * @param {object} opts
+ * @param {object} opts.feature - Feature row from SQLite
+ * @param {string} opts.operatorDir - Operator signal directory
+ * @param {string} opts.flDir - Feature Lead signal directory
+ * @param {string} opts.featureDir - Feature signal tree root
+ * @param {string} opts.userMessage - The triggering event/message
+ * @param {AgentSupervisor} opts.supervisor - Agent supervisor instance
+ * @param {number} opts.agentId - Operator agent DB id
+ */
+export async function invokeOperator({ feature, operatorDir, flDir, featureDir, userMessage, supervisor, agentId, planDir, activePlanningRole }) {
+  // 1. Assemble context from SQLite (async — Haiku summarization is non-blocking)
+  const history = await assembleHistory(feature.id);
+  const activeAgents = assembleActiveAgents(feature.id);
+  const pendingDecision = assemblePendingDecision(feature.id);
+
+  const HOME = process.env.HOME;
+  const directoryMap = `${HOME}/src/iriai/DIRECTORY_MAP.MD`;
+
+  // 2. Build prompt
+  const prompt = buildOperatorPrompt({
+    featureName: feature.slug,
+    operatorDir,
+    flDir,
+    featureDir,
+    history,
+    userMessage,
+    activeAgents,
+    pendingDecision,
+    planDir,
+    activePlanningRole,
+    directoryMap,
+  });
+
+  // 3. Spawn claude via supervisor with --continue for session context
+  // The supervisor handles PID tracking, exit detection, .runner.log
+  // Response flows through .agent-response → fileIO → slack adapter
+  supervisor.spawn(agentId, prompt, { continue: true });
+
+  // Record the event
+  queries.insertEvent(feature.id, "user-message", "bridge", `Operator invoked for: ${userMessage.slice(0, 100)}`);
+}
+
+/**
+ * Invoke the Operator in relay mode — format another agent's output for Slack.
+ * Returns a promise that the caller manages (wait for operatorResponse or timeout).
+ *
+ * @param {object} opts
+ * @param {object} opts.feature - Feature row from SQLite
+ * @param {object} opts.queueEntry - Relay queue entry { id, source_agent, event_hint, raw_content }
+ * @param {AgentSupervisor} opts.supervisor - Agent supervisor instance
+ * @param {number} opts.agentId - Operator agent DB id
+ * @param {string} opts.operatorDir - Operator signal directory
+ * @param {string} opts.featureDir - Feature signal tree root
+ */
+export async function invokeOperatorRelay({ feature, queueEntry, supervisor, agentId, operatorDir, featureDir, continue: cont = false }) {
+  const history = await assembleHistory(feature.id);
+  const activeAgents = assembleActiveAgents(feature.id);
+  const pendingDecision = assemblePendingDecision(feature.id);
+
+  const prompt = buildOperatorRelayPrompt({
+    featureName: feature.slug,
+    operatorDir,
+    featureDir,
+    history,
+    activeAgents,
+    pendingDecision,
+    sourceAgent: queueEntry.source_agent,
+    eventHint: queueEntry.event_hint,
+    rawContent: queueEntry.raw_content,
+  });
+
+  supervisor.spawn(agentId, prompt, { continue: cont });
+  queries.insertEvent(feature.id, "system", "bridge",
+    `Operator relay invoked for ${queueEntry.source_agent} (${queueEntry.event_hint})`);
+}
+
+/**
+ * Format a single event into a log line.
+ */
+function formatEvent(e) {
+  const time = e.created_at ? e.created_at.split(" ")[1] || "" : "";
+  const source = e.source || "unknown";
+  const type = e.event_type;
+  const content = (e.content || "").slice(0, 500);
+
+  switch (type) {
+    case "user-message":
+      return `[${time}] ${source}: ${content}`;
+    case "agent-response":
+      return `[${time}] ${source}: ${content}`;
+    case "operator-response":
+      return `[${time}] operator: ${content}`;
+    case "phase-transition":
+      return `[${time}] SYSTEM: Phase transition — ${content}`;
+    case "gate-approved":
+      return `[${time}] SYSTEM: Gate approved`;
+    case "gate-rejected":
+      return `[${time}] SYSTEM: Gate rejected — ${content}`;
+    case "agent-crashed":
+      return `[${time}] SYSTEM: Agent crashed — ${content}`;
+    case "question":
+      return `[${time}] ${source} QUESTION: ${content}`;
+    case "system":
+      return `[${time}] SYSTEM: ${content}`;
+    default:
+      return `[${time}] [${type}] ${source}: ${content}`;
+  }
+}
+
+/**
+ * Assemble conversation history from SQLite events.
+ *
+ * Strategy: keep recent events verbatim, summarize older events via Haiku
+ * if total history exceeds HISTORY_CHAR_LIMIT. Full history is always
+ * saved to disk as a backup.
+ */
+export async function assembleHistory(featureId) {
+  const allEvents = queries.getRecentEvents(featureId, HISTORY_FULL_BACKUP_EVENTS);
+  if (!allEvents.length) return "(no prior conversation)";
+
+  // Reverse to chronological order (DB returns DESC)
+  const chronological = allEvents.reverse();
+  const allLines = chronological.map(formatEvent);
+  const fullHistory = allLines.join("\n");
+
+  // Save full backup to disk
+  saveFullHistoryBackup(featureId, fullHistory);
+
+  // If within limit, return as-is
+  if (fullHistory.length <= HISTORY_CHAR_LIMIT) {
+    return fullHistory;
+  }
+
+  // Split: recent events stay verbatim, older ones get summarized
+  const recentCount = Math.min(HISTORY_RECENT_EVENTS, chronological.length);
+  const olderLines = allLines.slice(0, -recentCount);
+  const recentLines = allLines.slice(-recentCount);
+
+  const recentText = recentLines.join("\n");
+  const olderText = olderLines.join("\n");
+
+  // Summarize older events via Haiku (async — doesn't block event loop)
+  const summary = await summarizeViaHaiku(olderText);
+
+  return `### Earlier Context (summarized)\n${summary}\n\n### Recent Events\n${recentText}`;
+}
+
+/**
+ * Save full history to disk as backup.
+ */
+function saveFullHistoryBackup(featureId, fullHistory) {
+  try {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+    const backupDir = path.join(
+      process.env.HOME, "src/iriai/.implementation/features", feature.slug, "operator"
+    );
+    fs.mkdirSync(backupDir, { recursive: true });
+    fs.writeFileSync(path.join(backupDir, ".history-full.log"), fullHistory);
+  } catch { /* non-critical */ }
+}
+
+/**
+ * Summarize older history via a one-shot Haiku call (async).
+ * Falls back to simple truncation if Haiku fails.
+ */
+function summarizeViaHaiku(olderText) {
+  const prompt = `Summarize the following conversation history between a user and AI agents working on a software feature. Preserve:
+- All decisions made (user choices, architectural decisions)
+- Current phase and what's been completed
+- Any pending questions or blockers
+- Key context needed for continuity
+
+Be concise — under 800 words. Use bullet points.
+
+--- HISTORY ---
+${olderText}
+--- END HISTORY ---`;
+
+  return new Promise((resolve) => {
+    const child = execFile(getClaudeBin(), [
+      "--dangerously-skip-permissions",
+      "--model", "haiku",
+      "-p", prompt,
+    ], {
+      timeout: 30_000,
+      encoding: "utf-8",
+      env: { ...process.env, CLAUDECODE: undefined },
+    }, (err, stdout) => {
+      if (!err && stdout.trim().length > 0) {
+        resolve(stdout.trim());
+        return;
+      }
+      if (err) console.error("[operator] Haiku summarization failed:", err.message);
+      // Fallback: truncate older history to fit
+      const budget = HISTORY_CHAR_LIMIT - 2000;
+      resolve(olderText.slice(-budget) + "\n[...earlier history truncated]");
+    });
+  });
+}
+
+/**
+ * Assemble a summary of active agents.
+ */
+export function assembleActiveAgents(featureId) {
+  const agents = queries.getRunningAgents(featureId);
+  if (!agents.length) return "(no agents running)";
+
+  return agents.map(a => {
+    const elapsed = a.started_at
+      ? Math.round((Date.now() - new Date(a.started_at + "Z").getTime()) / 60000)
+      : "?";
+    return `- ${a.agent_key} (${a.agent_type}, ${a.status}, ${elapsed}min)`;
+  }).join("\n");
+}
+
+/**
+ * Assemble pending decision info.
+ */
+export function assemblePendingDecision(featureId) {
+  const decision = queries.getPendingDecision(featureId);
+  if (!decision) return null;
+
+  const options = JSON.parse(decision.options || "[]");
+  const optionsList = options.map(o => `  - ${o.label}${o.description ? `: ${o.description}` : ""}`).join("\n");
+
+  return `PENDING DECISION: ${decision.title}
+Type: ${decision.decision_type}
+Context: ${decision.context_text || "(none)"}
+Options:
+${optionsList}
+Permalink: ${decision.permalink || "(not yet posted)"}`;
+}
+
+/**
+ * Parse Operator response for structured blocks.
+ * Extracts [DECISION], [ROUTE:agent_key], and [RESOLVE_DECISION] blocks.
+ *
+ * @param {string} responseText - Raw operator response
+ * @returns {{ plainText: string, decisions: Array, routes: Array, resolutions: Array }}
+ */
+export function parseOperatorResponse(responseText) {
+  const decisions = [];
+  const routes = [];
+  const resolutions = [];
+
+  // Extract [RESOLVE_DECISION] blocks
+  let text = responseText.replace(
+    /\[RESOLVE_DECISION\]([\s\S]*?)\[\/RESOLVE_DECISION\]/gi,
+    (match, content) => {
+      const resolution = parseResolutionBlock(content.trim());
+      if (resolution) resolutions.push(resolution);
+      return "";
+    }
+  );
+
+  // Extract [DECISION] blocks (also accepts legacy [SLACK:decision] for backward compatibility)
+  text = text.replace(
+    /\[(?:DECISION|SLACK:decision)\]([\s\S]*?)\[\/(?:DECISION|SLACK:decision)\]/gi,
+    (match, content) => {
+      const decision = parseDecisionBlock(content.trim());
+      if (decision) decisions.push(decision);
+      return "";
+    }
+  );
+
+  // Extract [ROUTE:agent_key] blocks
+  text = text.replace(
+    /\[ROUTE:([^\]]+)\]\s*([\s\S]*?)(?=\[ROUTE:|$)/gi,
+    (match, agentKey, content) => {
+      routes.push({ agentKey: agentKey.trim(), content: content.trim() });
+      return "";
+    }
+  );
+
+  return {
+    plainText: text.trim(),
+    decisions,
+    routes,
+    resolutions,
+  };
+}
+
+/**
+ * Parse a [RESOLVE_DECISION] block.
+ * Format:
+ *   id: <decision-id>
+ *   option: <selected-option-id>
+ *   feedback: <optional feedback text>
+ */
+function parseResolutionBlock(content) {
+  const resolution = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("id:")) {
+      resolution.id = trimmed.replace("id:", "").trim();
+    } else if (trimmed.startsWith("option:")) {
+      resolution.option = trimmed.replace("option:", "").trim();
+    } else if (trimmed.startsWith("feedback:")) {
+      resolution.feedback = trimmed.replace("feedback:", "").trim();
+    }
+  }
+  return resolution.id && resolution.option ? resolution : null;
+}
+
+/**
+ * Parse a decision block's YAML-like content.
+ */
+function parseDecisionBlock(content) {
+  const lines = content.split("\n");
+  const decision = { options: [] };
+
+  let inOptions = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (trimmed.startsWith("id:")) {
+      decision.id = trimmed.replace("id:", "").trim();
+    } else if (trimmed.startsWith("type:")) {
+      decision.type = trimmed.replace("type:", "").trim();
+    } else if (trimmed.startsWith("title:")) {
+      decision.title = trimmed.replace("title:", "").trim();
+    } else if (trimmed.startsWith("context:")) {
+      decision.context = trimmed.replace("context:", "").trim();
+    } else if (trimmed.startsWith("options:")) {
+      inOptions = true;
+    } else if (inOptions && trimmed.startsWith("-")) {
+      const optLine = trimmed.replace(/^-\s*/, "");
+      const opt = {};
+      for (const part of optLine.split(",")) {
+        const [key, ...val] = part.split(":");
+        if (key && val.length) {
+          opt[key.trim()] = val.join(":").trim();
+        }
+      }
+      if (opt.id && opt.label) {
+        decision.options.push(opt);
+      }
+    }
+  }
+
+  return decision.id && decision.title ? decision : null;
+}