iriai-build 0.1.0

package/v3/adapters/slack-helpers.js

@@ -0,0 +1,179 @@
+// slack-helpers.js — Slack-specific helper functions.
+// Markdown conversion, Block Kit builders, media upload.
+
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Convert standard Markdown to Slack mrkdwn format.
+ */
+export function markdownToMrkdwn(text) {
+  if (!text) return text;
+
+  const codeBlocks = [];
+  let result = text.replace(/```[\s\S]*?```/g, (match) => {
+    codeBlocks.push(match);
+    return `\x00CODE${codeBlocks.length - 1}\x00`;
+  });
+
+  const inlineCode = [];
+  result = result.replace(/`[^`]+`/g, (match) => {
+    inlineCode.push(match);
+    return `\x00INLINE${inlineCode.length - 1}\x00`;
+  });
+
+  // Headers -> bold
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+
+  // Bold: **text** -> *text*
+  result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+
+  // Links: [text](url) -> <url|text>
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "<$2|$1>");
+
+  // Image refs: ![alt](path) -> [img:path]
+  result = result.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, "[img:$2]");
+
+  // Restore inline code
+  result = result.replace(/\x00INLINE(\d+)\x00/g, (_, i) => inlineCode[i]);
+
+  // Restore code blocks
+  result = result.replace(/\x00CODE(\d+)\x00/g, (_, i) => codeBlocks[i]);
+
+  return result;
+}
+
+function isMediaPathAllowed(filePath) {
+  const resolved = path.resolve(filePath);
+  const ALLOWED_DIRS = [
+    path.resolve("/Users/danielzhang/src/iriai"),
+    "/tmp",
+    "/private/tmp",
+  ];
+  return ALLOWED_DIRS.some(dir => resolved.startsWith(dir + path.sep) || resolved === dir);
+}
+
+/**
+ * Upload a binary file as a Slack attachment.
+ */
+export async function uploadGifAttachment(web, channel, thread_ts, filePath, title) {
+  try {
+    if (!isMediaPathAllowed(filePath)) {
+      console.warn(`[uploadGifAttachment] Path not in allowed directories: ${filePath}`);
+      return false;
+    }
+
+    if (!fs.existsSync(filePath)) {
+      console.warn(`[bridge] Media file not found: ${filePath}`);
+      return false;
+    }
+
+    const stats = fs.statSync(filePath);
+    if (stats.size > 20 * 1024 * 1024) {
+      console.warn(`[bridge] Media too large (${(stats.size / 1024 / 1024).toFixed(1)}MB): ${filePath}`);
+      return false;
+    }
+
+    const fileBuffer = fs.readFileSync(filePath);
+    await web.filesUploadV2({
+      channel_id: channel,
+      thread_ts,
+      file: fileBuffer,
+      filename: path.basename(filePath),
+      title: title || path.basename(filePath),
+    });
+    return true;
+  } catch (err) {
+    console.error(`[bridge] Media upload failed for ${filePath}:`, err.message);
+    return false;
+  }
+}
+
+export async function uploadArtifact(web, channel, thread_ts, filePath, title) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    await web.filesUploadV2({
+      channel_id: channel,
+      thread_ts,
+      content,
+      filename: path.basename(filePath),
+      title,
+    });
+  } catch (err) {
+    console.error(`Error uploading artifact ${title}:`, err.message);
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const truncated =
+        content.length > 3000
+          ? content.slice(0, 3000) + "\n\n_(truncated -- full document in repo)_"
+          : content;
+      await postToThread(web, channel, thread_ts, `*${title}:*\n\n${truncated}`);
+    } catch (fallbackErr) {
+      console.error(`Fallback text post also failed for ${title}:`, fallbackErr.message);
+    }
+  }
+}
+
+/**
+ * Post a message to a Slack thread with mrkdwn conversion.
+ */
+export async function postToThread(web, channel, thread_ts, text) {
+  await web.chat.postMessage({ channel, thread_ts, text: markdownToMrkdwn(text), mrkdwn: true });
+}
+
+/**
+ * Build Slack Block Kit blocks for a decision with action buttons.
+ */
+export function buildDecisionBlocks(decisionId, title, context, options) {
+  const blocks = [];
+
+  blocks.push({
+    type: "section",
+    text: { type: "mrkdwn", text: `*${title}*${context ? `\n${context}` : ""}` },
+  });
+
+  blocks.push({
+    type: "actions",
+    block_id: `decision_${decisionId}`,
+    elements: options.map(opt => ({
+      type: "button",
+      text: { type: "plain_text", text: opt.label, emoji: true },
+      value: opt.id,
+      action_id: `decision_${decisionId}_${opt.id}`,
+      ...(opt.style === "primary" ? { style: "primary" } : {}),
+      ...(opt.style === "danger" ? { style: "danger" } : {}),
+    })),
+  });
+
+  return blocks;
+}
+
+/**
+ * Build resolved-state blocks to replace buttons after a decision is made.
+ */
+export function buildResolvedBlocks(title, selectedLabel, resolvedBy, feedback = "") {
+  const feedbackLine = feedback ? `\n> ${feedback.replace(/\n/g, "\n> ")}` : "";
+  return [{
+    type: "section",
+    text: {
+      type: "mrkdwn",
+      text: `*${title}*\n~Resolved~: *${selectedLabel}*${resolvedBy ? ` by <@${resolvedBy}>` : ""}${feedbackLine}`,
+    },
+  }];
+}
+
+export async function addReaction(web, channel, timestamp, reaction) {
+  try {
+    await web.reactions.add({ channel, name: reaction, timestamp });
+  } catch {
+    // Ignore -- reaction may already exist
+  }
+}
+
+export async function removeReaction(web, channel, timestamp, reaction) {
+  try {
+    await web.reactions.remove({ channel, name: reaction, timestamp });
+  } catch {
+    // Ignore
+  }
+}

package/v3/adapters/terminal-adapter.js

@@ -0,0 +1,249 @@
+// terminal-adapter.js — TerminalAdapter implementing InterfaceAdapter.
+// For terminal-based (iriai-build CLI) development workflows.
+//
+// postDecision() routes decisions through the Operator agent. The Operator
+// presents the decision conversationally and resolves it via [RESOLVE_DECISION].
+// This matches Slack's async model — no blocking prompts on stdin.
+
+import fs from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import * as queries from "../queries.js";
+import { InterfaceAdapter } from "./interface.js";
+import { ensureDir, parseGifMarkers } from "../helpers.js";
+
+export class TerminalAdapter extends InterfaceAdapter {
+  constructor({ logDir } = {}) {
+    super();
+    this.logDir = logDir || path.join(process.env.HOME, ".iriai", "bridge-logs");
+    ensureDir(this.logDir);
+    this._inputHandler = null;
+    this._events = new EventEmitter();
+    this._recentArtifacts = []; // tracks artifacts for inclusion in decision blocks
+  }
+
+  /**
+   * Set the input handler (TerminalInput instance) for interactive input.
+   */
+  setInputHandler(handler) {
+    this._inputHandler = handler;
+  }
+
+  /**
+   * Print a line, respecting active prompts (buffer if needed, stop spinner).
+   */
+  _print(text) {
+    if (this._inputHandler) {
+      this._inputHandler.printAboveLine(text);
+    } else {
+      console.log(text);
+    }
+  }
+
+  /**
+   * Subscribe to adapter lifecycle events.
+   * Events: "plan-approved", "plan-rejected", "feature-complete"
+   */
+  on(event, listener) {
+    this._events.on(event, listener);
+  }
+
+  removeListener(event, listener) {
+    this._events.removeListener(event, listener);
+  }
+
+  async createFeatureChannel(featureId, slug) {
+    const featureLogDir = path.join(this.logDir, slug);
+    ensureDir(featureLogDir);
+    return slug; // opaque ref = slug
+  }
+
+  async postMessage(featureId, text) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const C = { reset: "\x1b[0m", dim: "\x1b[2m" };
+    this._print(`${C.dim}[${slug}]${C.reset} ${text}`);
+    this._appendLog(slug, text);
+    return { ref: Date.now().toString() };
+  }
+
+  async postThreadMessage(featureId, text) {
+    await this.postMessage(featureId, text);
+  }
+
+  async postPipelineMessage(featureId, text) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const C = { reset: "\x1b[0m", dim: "\x1b[2m", bold: "\x1b[1m", blue: "\x1b[34m", white: "\x1b[37m", bgBlue: "\x1b[44m" };
+    const msg = `${C.dim}[${slug}]${C.reset} ${C.bgBlue}${C.white} Pipeline ${C.reset} ${text}`;
+    this._print(msg);
+    this._appendLog(slug, `[Pipeline] ${text}`);
+    queries.insertEvent(featureId, "system", "bridge", text);
+    return { ref: Date.now().toString() };
+  }
+
+  async postAgentResponse(featureId, agentLabel, rawContent) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const { text } = parseGifMarkers(rawContent);
+
+    const C = {
+      reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+      cyan: "\x1b[36m", yellow: "\x1b[33m", white: "\x1b[37m",
+      magenta: "\x1b[35m", blue: "\x1b[34m", green: "\x1b[32m",
+    };
+    const labelColor = agentLabel === "Operator" ? C.white : C.cyan;
+
+    // Colorize inline agent attribution tags like *[PM]* or [PM] in Operator relay text
+    const AGENT_TAG_COLORS = {
+      PM: C.cyan, Designer: C.magenta, Architect: C.blue,
+      "Plan Compiler": C.green, FL: C.yellow, "Feature Lead": C.yellow,
+    };
+    const colorized = text.replace(/\*?\[([^\]]+)\]\*?/g, (match, name) => {
+      const color = AGENT_TAG_COLORS[name];
+      if (color) return `${color}${C.bold}[${name}]${C.reset}`;
+      return match;
+    });
+
+    const msg = `${C.dim}[${slug}]${C.reset} ${labelColor}${C.bold}[${agentLabel}]${C.reset} ${colorized}`;
+    this._print(msg);
+    this._appendLog(slug, `[${agentLabel}] ${text}`);
+    queries.insertEvent(featureId, "agent-response", `agent:${agentLabel}`, rawContent);
+    return { ref: Date.now().toString() };
+  }
+
+  async uploadArtifact(featureId, filePath, title) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    // Track for inclusion in the next decision block
+    this._recentArtifacts.push({ title, filePath });
+    this._appendLog(slug, `Artifact: ${title} at ${filePath}`);
+  }
+
+  async postDecision(featureId, decision) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const C = {
+      reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+      yellow: "\x1b[33m", bgYellow: "\x1b[43m", black: "\x1b[30m",
+      white: "\x1b[37m", green: "\x1b[32m", red: "\x1b[31m",
+      cyan: "\x1b[36m",
+    };
+
+    const w = (this._inputHandler?._cols) || (process.stdout.columns || 80);
+    const rule = `${C.yellow}${"─".repeat(w)}${C.reset}`;
+
+    this._print("");
+    this._print(rule);
+    this._print("");
+
+    // Title with badge
+    const badge = `${C.bgYellow}${C.black}${C.bold} ACTION REQUIRED ${C.reset}`;
+    this._print(`  ${badge} ${C.bold}${decision.title}${C.reset}`);
+
+    // Context
+    if (decision.context) {
+      this._print(`  ${C.dim}${decision.context}${C.reset}`);
+    }
+
+    // Review URLs
+    if (decision.reviewUrl || decision.qaUrl) {
+      this._print("");
+      this._print(`  ${C.cyan}${C.bold}Review & Annotate:${C.reset}`);
+      if (decision.reviewUrl) {
+        this._print(`    ${C.cyan}📎 Doc Review${C.reset}  ${C.bold}${decision.reviewUrl}${C.reset}`);
+      }
+      if (decision.qaUrl) {
+        this._print(`    ${C.cyan}🧪 QA Test${C.reset}    ${C.bold}${decision.qaUrl}${C.reset}`);
+      }
+      this._print(`  ${C.dim}Open in browser to review with annotation tools.${C.reset}`);
+    }
+
+    // Artifacts
+    const artifacts = this._recentArtifacts;
+    if (artifacts.length > 0) {
+      this._print("");
+      this._print(`  ${C.cyan}${C.bold}Artifacts:${C.reset}`);
+      for (const a of artifacts) {
+        this._print(`    ${C.cyan}📎 ${a.title}${C.reset}  ${C.dim}${a.filePath}${C.reset}`);
+      }
+    }
+
+    this._print("");
+
+    // Options
+    for (const opt of decision.options) {
+      const color = opt.style === "primary" ? C.green : opt.style === "danger" ? C.red : C.white;
+      this._print(`    ${color}${C.bold}▸ ${opt.label}${C.reset}  ${C.dim}type: ${C.bold}${opt.id}${C.reset}`);
+    }
+
+    this._print("");
+    this._print(`  ${C.dim}Reply with an option id (e.g. "${decision.options[0]?.id}") or ask the Operator.${C.reset}`);
+    this._print("");
+    this._print(rule);
+    this._print("");
+
+    // Clear tracked artifacts after rendering
+    this._recentArtifacts = [];
+
+    this._appendLog(slug, `Decision: ${decision.title}`);
+    return { ref: decision.id };
+  }
+
+  async resolveDecisionMessage(featureId, messageRef, decisionId, selectedOption, selectedLabel, resolvedBy, feedback) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const C = { reset: "\x1b[0m", dim: "\x1b[2m", green: "\x1b[32m", bold: "\x1b[1m" };
+    this._print(`${C.dim}[${slug}]${C.reset} ${C.green}${C.bold}✓ Decision resolved:${C.reset} ${selectedLabel}${feedback ? ` ${C.dim}(${feedback})${C.reset}` : ""}`);
+    this._appendLog(slug, `Decision "${decisionId}" resolved: ${selectedLabel}`);
+
+    // Clean up pending decision file
+    const decisionFile = path.join(this.logDir, slug, `.pending-decision-${decisionId}`);
+    try { fs.unlinkSync(decisionFile); } catch { /* ok */ }
+
+    // Emit lifecycle events for plan-approval decisions
+    if (decisionId === "plan-approval") {
+      const updatedFeature = queries.getFeatureById(featureId);
+      if (updatedFeature?.phase === "impl" || updatedFeature?.phase === "plan-approval") {
+        this._events.emit("plan-approved", featureId);
+      } else if (updatedFeature?.phase === "planning") {
+        this._events.emit("plan-rejected", featureId);
+      }
+    }
+  }
+
+  async postPlanForApproval(featureId, planDir) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const C = { reset: "\x1b[0m", dim: "\x1b[2m", bold: "\x1b[1m", bgBlue: "\x1b[44m", white: "\x1b[37m" };
+    this._print(`${C.dim}[${slug}]${C.reset} ${C.bgBlue}${C.white} Pipeline ${C.reset} ${C.bold}Plan ready for approval.${C.reset} ${C.dim}Artifacts: ${planDir}${C.reset}`);
+    this._appendLog(slug, `Plan ready for approval. Artifacts in: ${planDir}`);
+
+    return await this.postDecision(featureId, {
+      id: "plan-approval",
+      title: "Plan ready for approval",
+      context: "All planning phases complete. Review the artifacts.",
+      options: [
+        { id: "approve", label: "Approve Plan", style: "primary" },
+        { id: "reject", label: "Reject Plan", style: "danger" },
+      ],
+    });
+  }
+
+  async postFeatureComplete(featureId) {
+    const feature = queries.getFeatureById(featureId);
+    const slug = feature?.slug || "unknown";
+    const C = { reset: "\x1b[0m", bold: "\x1b[1m", green: "\x1b[32m", bgGreen: "\x1b[42m", white: "\x1b[37m" };
+    this._print(`\n${C.bgGreen}${C.white}${C.bold} COMPLETE ${C.reset} ${C.green}${C.bold}Feature ${slug} — all gates passed!${C.reset}\n`);
+    this._appendLog(slug, "Feature complete! All gates passed.");
+    this._events.emit("feature-complete", featureId);
+  }
+
+  _appendLog(slug, text) {
+    const logFile = path.join(this.logDir, slug, "bridge.log");
+    const timestamp = new Date().toISOString();
+    try {
+      fs.appendFileSync(logFile, `[${timestamp}] ${text}\n`);
+    } catch { /* log dir may not exist yet */ }
+  }
+}