iriai-build 0.1.0

package/lib/signal-watcher.js

@@ -0,0 +1,215 @@
+// signal-watcher.js — Centralized chokidar-based signal file watcher.
+// Replaces the 5+ fragmented watchers in index.js.
+// Single chokidar instance per signal domain, emits typed events.
+
+import { EventEmitter } from "node:events";
+import path from "node:path";
+import fs from "node:fs";
+import chokidar from "chokidar";
+import { ROLE_DIRS, SIGNAL } from "./constants.js";
+import { ensureDir } from "./slack-helpers.js";
+
+const WATCHER_OPTS = {
+  ignoreInitial: true,
+  awaitWriteFinish: { stabilityThreshold: 500 },
+};
+
+export default class SignalWatcher extends EventEmitter {
+  constructor() {
+    super();
+    this._watchers = [];
+    this._featureWatchers = new Map(); // slug -> watcher[]
+  }
+
+  // ─── Planning Signals ────────────────────────────────────────────────────
+
+  watchPlanningSignals() {
+    const dirs = Object.values(ROLE_DIRS);
+    for (const d of dirs) ensureDir(d);
+
+    // Watch .agent-response
+    this._watch(
+      dirs.map((d) => path.join(d, SIGNAL.AGENT_RESPONSE)),
+      (fp) => {
+        const role = this._roleFromDir(path.dirname(fp));
+        if (role) this.emit("planning:response", { role, filePath: fp });
+      }
+    );
+
+    // NOTE: .done is intentionally NOT watched by chokidar here.
+    // PlanningRole state machine emits "done" on exit, and dispatchPlanningRole
+    // re-emits it as signalWatcher.emit("planning:done"). Watching it here too
+    // would cause double-posting. processExistingSignals() handles stale .done
+    // files on startup.
+
+    // Watch .question
+    this._watch(
+      dirs.map((d) => path.join(d, SIGNAL.QUESTION)),
+      (fp) => {
+        const role = this._roleFromDir(path.dirname(fp));
+        if (role) this.emit("planning:question", { role, filePath: fp });
+      }
+    );
+
+    console.log("[signal-watcher] Watching planning signals");
+  }
+
+  // ─── Implementation Feature Signals ──────────────────────────────────────
+
+  watchFeatureSignals(slug, tree) {
+    const featureWatchers = [];
+    const watch = (patterns, handler) => {
+      const w = this._createWatcher(patterns, handler);
+      featureWatchers.push(w);
+    };
+
+    // Feature Lead .agent-response
+    if (tree.featureLead) {
+      watch(
+        [path.join(tree.featureLead, SIGNAL.AGENT_RESPONSE)],
+        (fp) => this.emit("impl:response", { slug, agent: "feature-lead", filePath: fp })
+      );
+
+      // .feature-complete
+      watch(
+        [path.join(tree.featureLead, SIGNAL.FEATURE_COMPLETE)],
+        (fp) => this.emit("impl:featureComplete", { slug, filePath: fp })
+      );
+
+      // .phase-done
+      watch(
+        [path.join(tree.featureLead, SIGNAL.PHASE_DONE)],
+        (fp) => this.emit("impl:phaseDone", { slug, filePath: fp })
+      );
+
+      // .context-refresh
+      watch(
+        [path.join(tree.featureLead, SIGNAL.CONTEXT_REFRESH)],
+        (fp) => this.emit("impl:contextRefresh", { slug, filePath: fp })
+      );
+    }
+
+    // Operator .agent-response
+    if (tree.operator) {
+      watch(
+        [path.join(tree.operator, SIGNAL.AGENT_RESPONSE)],
+        (fp) => this.emit("impl:operatorResponse", { slug, filePath: fp })
+      );
+
+      // Operator .user-message (for triggering operator agent)
+      watch(
+        [path.join(tree.operator, SIGNAL.USER_MESSAGE)],
+        (fp) => this.emit("impl:userMessage", { slug, agent: "operator", filePath: fp })
+      );
+    }
+
+    // Collect all agent dirs for .needs-restart watching
+    const allDirs = [];
+    if (tree.featureLead) allDirs.push(tree.featureLead);
+    if (tree.operator) allDirs.push(tree.operator);
+
+    for (const [teamNum, team] of Object.entries(tree.teams)) {
+      if (team.orchestrator) {
+        allDirs.push(team.orchestrator);
+
+        // Watch .gate-ready per team
+        watch(
+          [path.join(team.orchestrator, SIGNAL.GATE_READY)],
+          (fp) => this.emit("impl:gateReady", { slug, teamNum, filePath: fp })
+        );
+
+        // Watch .crashed per team orchestrator
+        watch(
+          [path.join(team.orchestrator, SIGNAL.CRASHED)],
+          (fp) => this.emit("impl:crashed", { slug, agent: `team-${teamNum}-orch`, teamNum, filePath: fp })
+        );
+
+        // Watch .question per team orchestrator
+        watch(
+          [path.join(team.orchestrator, SIGNAL.QUESTION)],
+          (fp) => this.emit("impl:question", { slug, teamNum, filePath: fp })
+        );
+
+        // Watch .task for team orchestrator (dispatched by Feature Lead)
+        watch(
+          [path.join(team.orchestrator, SIGNAL.TASK)],
+          (fp) => this.emit("impl:orchTask", { slug, teamNum, filePath: fp })
+        );
+      }
+
+      for (const [role, roleDir] of Object.entries(team.roles)) {
+        allDirs.push(roleDir);
+
+        // Watch .task for role agents
+        watch(
+          [path.join(roleDir, SIGNAL.TASK)],
+          (fp) => this.emit("impl:task", { slug, teamNum, role, filePath: fp })
+        );
+
+        // Watch .done for role agents
+        watch(
+          [path.join(roleDir, SIGNAL.DONE)],
+          (fp) => this.emit("impl:done", { slug, teamNum, role, filePath: fp })
+        );
+      }
+    }
+
+    // Feature review roles
+    for (const [role, reviewDir] of Object.entries(tree.featureReview)) {
+      allDirs.push(reviewDir);
+
+      watch(
+        [path.join(reviewDir, SIGNAL.DONE)],
+        (fp) => this.emit("impl:done", { slug, agent: `review-${role}`, role, filePath: fp })
+      );
+    }
+
+    // Watch .needs-restart across ALL agent dirs
+    watch(
+      allDirs.map((d) => path.join(d, SIGNAL.NEEDS_RESTART)),
+      (fp) => this.emit("impl:needsRestart", { slug, dir: path.dirname(fp), filePath: fp })
+    );
+
+    this._featureWatchers.set(slug, featureWatchers);
+    console.log(`[signal-watcher] Watching impl signals for ${slug}: ${allDirs.length} dirs`);
+  }
+
+  unwatchFeature(slug) {
+    const watchers = this._featureWatchers.get(slug);
+    if (watchers) {
+      for (const w of watchers) w.close();
+      this._featureWatchers.delete(slug);
+      console.log(`[signal-watcher] Unwatched feature ${slug}`);
+    }
+  }
+
+  // ─── Cleanup ─────────────────────────────────────────────────────────────
+
+  async closeAll() {
+    for (const w of this._watchers) await w.close();
+    for (const [, watchers] of this._featureWatchers) {
+      for (const w of watchers) await w.close();
+    }
+    this._watchers = [];
+    this._featureWatchers.clear();
+  }
+
+  // ─── Internals ───────────────────────────────────────────────────────────
+
+  _watch(patterns, handler) {
+    const w = this._createWatcher(patterns, handler);
+    this._watchers.push(w);
+    return w;
+  }
+
+  _createWatcher(patterns, handler) {
+    const w = chokidar.watch(patterns, WATCHER_OPTS);
+    w.on("add", handler);
+    w.on("change", handler);
+    return w;
+  }
+
+  _roleFromDir(dir) {
+    return Object.entries(ROLE_DIRS).find(([, d]) => d === dir)?.[0] || null;
+  }
+}

package/lib/slack-helpers.js

@@ -0,0 +1,224 @@
+// slack-helpers.js — Pure helper functions for Slack API and file operations.
+// Extracted from index.js lines 82-210.
+
+import fs from "node:fs";
+import path from "node:path";
+import { IRIAI_TEAM_DIR, KNOWN_REPOS } 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 });
+}
+
+export async function postToThread(web, channel, thread_ts, text) {
+  await web.chat.postMessage({ channel, thread_ts, text: markdownToMrkdwn(text), mrkdwn: true });
+}
+
+export async function addReaction(web, channel, timestamp, reaction) {
+  try {
+    await web.reactions.add({ channel, name: reaction, timestamp });
+  } catch {
+    // Ignore — reaction may already exist or message may be gone
+  }
+}
+
+export async function removeReaction(web, channel, timestamp, reaction) {
+  try {
+    await web.reactions.remove({ channel, name: reaction, timestamp });
+  } catch {
+    // Ignore — reaction may not exist
+  }
+}
+
+export function findArtifact(filename) {
+  const planDir = path.join(IRIAI_TEAM_DIR, "implementation-plans", "current");
+  try {
+    const files = fs.readdirSync(planDir);
+    const match = files.find((f) => f.includes(filename) && f.endsWith(".md"));
+    if (match) return path.join(planDir, match);
+  } catch {
+    // Directory or file doesn't exist yet
+  }
+  return null;
+}
+
+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);
+    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}`);
+  }
+}
+
+export function detectReposFromPlan() {
+  const planPath = findArtifact("implementation-plan");
+  if (!planPath) return [];
+  const content = fs.readFileSync(planPath, "utf-8");
+  return KNOWN_REPOS.filter((repo) => content.includes(repo));
+}
+
+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;
+}
+
+/**
+ * Read a signal file, return content, and optionally delete it.
+ * Returns empty string if file doesn't exist.
+ */
+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);
+}
+
+/**
+ * Convert standard Markdown to Slack mrkdwn format.
+ * Handles: **bold**→*bold*, ## headers→*Header*, [text](url)→<url|text>,
+ * *italic*→_italic_, ![alt](path)→[img:path]. Preserves code blocks.
+ */
+export function markdownToMrkdwn(text) {
+  if (!text) return text;
+
+  // Extract code blocks to protect them from conversion
+  const codeBlocks = [];
+  let result = text.replace(/```[\s\S]*?```/g, (match) => {
+    codeBlocks.push(match);
+    return `\x00CODE${codeBlocks.length - 1}\x00`;
+  });
+
+  // Extract inline code
+  const inlineCode = [];
+  result = result.replace(/`[^`]+`/g, (match) => {
+    inlineCode.push(match);
+    return `\x00INLINE${inlineCode.length - 1}\x00`;
+  });
+
+  // Headers → bold (Slack has no headers)
+  result = result.replace(/^#{1,6}\s+(.+)$/gm, "*$1*");
+
+  // Bold: **text** → *text*
+  result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+
+  // Italic: _text_ stays as-is (works in both)
+  // Standalone *text* (not **) that isn't already converted → _text_
+  // This is tricky — after bold conversion, single * pairs are already bold in Slack.
+  // Skip this to avoid double-converting.
+
+  // 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;
+}
+
+/**
+ * Extract media markers from message text: [gif:<path>], [img:<path>], [video:<path>].
+ * Returns the cleaned text (markers removed) and an array of file paths.
+ */
+export function parseGifMarkers(text) {
+  const gifPaths = [];
+  const cleaned = text.replace(/\[(gif|img|image|video|screenshot):([^\]]+)\]/gi, (match, type, filePath) => {
+    gifPaths.push(filePath.trim());
+    return "";
+  });
+  return { text: cleaned.trim(), gifPaths };
+}
+
+/**
+ * Check whether a file path is within the allowed directories for media uploads.
+ * Prevents path-traversal attacks that could exfiltrate arbitrary files.
+ */
+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 (GIF, PNG, JPG, WebM, MP4) as a Slack attachment.
+ * Reads the file as a Buffer and uses filesUploadV2.
+ * Silently skips if file doesn't exist or exceeds 20MB.
+ */
+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;
+  }
+}