iriai-build 0.1.0

package/v3/adapters/slack-adapter.js

@@ -0,0 +1,608 @@
+// slack-adapter.js — SlackAdapter implementing InterfaceAdapter.
+// Socket Mode + WebClient. All Slack I/O routed through the contract.
+
+import { SocketModeClient } from "@slack/socket-mode";
+import { WebClient } from "@slack/web-api";
+import path from "node:path";
+import * as queries from "../queries.js";
+import { SIGNAL } from "../constants.js";
+import { InterfaceAdapter } from "./interface.js";
+import {
+  slugify, ensureDir, writeSignal, parseRole, parseGifMarkers, findArtifact,
+} from "../helpers.js";
+import {
+  markdownToMrkdwn, uploadGifAttachment, uploadArtifact as slackUploadArtifact,
+  postToThread, addReaction, removeReaction,
+  buildDecisionBlocks, buildResolvedBlocks,
+} from "./slack-helpers.js";
+
+export class SlackAdapter extends InterfaceAdapter {
+  constructor({ appToken, botToken, planningChannel }) {
+    super();
+    this.planningChannel = planningChannel;
+    this.web = new WebClient(botToken);
+    this.socket = new SocketModeClient({ appToken });
+    this.botUserId = null;
+    this._orchestrator = null;
+
+    // Track pending user messages for :eyes: cleanup
+    this._pendingUserMessages = {};
+  }
+
+  setOrchestrator(orchestrator) {
+    this._orchestrator = orchestrator;
+  }
+
+  async connect() {
+    const auth = await this.web.auth.test();
+    this.botUserId = auth.user_id;
+
+    this._setupMessageHandler();
+    this._setupReactionHandler();
+    this._setupInteractiveHandler();
+
+    this.socket.on("disconnect", () => {
+      console.warn("[slack] Socket Mode disconnected. Will attempt reconnect...");
+    });
+
+    this.socket.on("slack_event", ({ type }) => {
+      console.log(`[slack] Raw event: type=${type}`);
+    });
+
+    await this.socket.start();
+  }
+
+  // ─── InterfaceAdapter Implementation ──────────────────────────────────────
+
+  async createFeatureChannel(featureId, slug) {
+    try {
+      const result = await this.web.conversations.create({
+        name: `impl-${slug}`.slice(0, 80),
+      });
+      return result.channel.id;
+    } catch (err) {
+      if (err.data?.error === "name_taken") {
+        try {
+          const list = await this.web.conversations.list({ types: "public_channel", limit: 200 });
+          const existing = list.channels.find(c => c.name === `impl-${slug}`.slice(0, 80));
+          if (existing) return existing.id;
+        } catch { /* ok */ }
+      }
+      console.warn("[slack-adapter] Could not create feature channel:", err.message);
+      return null;
+    }
+  }
+
+  async postMessage(featureId, text) {
+    const channel = this._resolveChannel(featureId);
+    const result = await this.web.chat.postMessage({
+      channel,
+      text: markdownToMrkdwn(text),
+      mrkdwn: true,
+    });
+    return { ref: result.ts };
+  }
+
+  async postThreadMessage(featureId, text) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+    await postToThread(this.web, this.planningChannel, feature.thread_ts, text);
+  }
+
+  async postPipelineMessage(featureId, text) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+    const channel = this._resolveChannel(featureId);
+    const result = await this.web.chat.postMessage({
+      channel,
+      text: markdownToMrkdwn(`*[Pipeline]* ${text}`),
+      mrkdwn: true,
+    });
+    queries.insertEvent(featureId, "system", "bridge", text, {}, result.ts);
+    return { ref: result.ts };
+  }
+
+  async postAgentResponse(featureId, agentLabel, rawContent) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+    const channel = this._resolveChannel(featureId);
+
+    const { text: cleanedContent, gifPaths, evidencePaths } = parseGifMarkers(rawContent);
+
+    const result = await this.web.chat.postMessage({
+      channel,
+      text: markdownToMrkdwn(`*[${agentLabel}]* ${cleanedContent}`),
+      mrkdwn: true,
+    });
+
+    // Upload media (GIFs/screenshots)
+    for (const gifPath of gifPaths) {
+      const resolvedPath = path.isAbsolute(gifPath) ? gifPath : path.resolve(gifPath);
+      const ext = path.extname(gifPath);
+      const label = path.basename(gifPath, ext).replace(/[-_]/g, " ");
+      await uploadGifAttachment(this.web, channel, result.ts, resolvedPath, label);
+    }
+
+    // Upload evidence documents
+    for (const evidencePath of evidencePaths) {
+      const resolvedPath = path.isAbsolute(evidencePath) ? evidencePath : path.resolve(evidencePath);
+      await uploadGifAttachment(this.web, channel, result.ts, resolvedPath, "Gate Evidence Document");
+    }
+
+    // Record event + slack post for dedup
+    const eventId = queries.insertEvent(featureId, "agent-response", `agent:${agentLabel}`, rawContent, {}, result.ts);
+    queries.recordSlackPost(eventId, featureId, channel, result.ts);
+
+    // Clear pending eyes reaction
+    this._clearPendingReaction(feature.thread_ts, channel);
+
+    return { ref: result.ts };
+  }
+
+  async uploadArtifact(featureId, filePath, title) {
+    const channel = this._resolveChannel(featureId);
+    const feature = queries.getFeatureById(featureId);
+    const threadTs = feature?.thread_ts || null;
+    await slackUploadArtifact(this.web, channel, threadTs, filePath, title);
+  }
+
+  async postDecision(featureId, decision) {
+    const channel = this._resolveChannel(featureId);
+
+    const blocks = buildDecisionBlocks(
+      decision.id,
+      decision.title,
+      decision.context,
+      decision.options,
+    );
+
+    // Insert review URL block before the action buttons (last block)
+    if (decision.reviewUrl || decision.qaUrl) {
+      const links = [];
+      if (decision.reviewUrl) links.push(`📎 *<${decision.reviewUrl}|Doc Review — open to annotate>*`);
+      if (decision.qaUrl) links.push(`🧪 *<${decision.qaUrl}|QA Test — open to test live app>*`);
+      const reviewBlock = {
+        type: "section",
+        text: { type: "mrkdwn", text: links.join("\n") + "\n_Annotate in browser, then approve or reject below._" },
+      };
+      // Insert before the last block (action buttons)
+      blocks.splice(blocks.length - 1, 0, reviewBlock);
+    }
+
+    const result = await this.web.chat.postMessage({
+      channel,
+      text: decision.title,
+      blocks,
+    });
+
+    return { ref: result.ts };
+  }
+
+  async resolveDecisionMessage(featureId, messageRef, decisionId, selectedOption, selectedLabel, resolvedBy, feedback) {
+    const channel = this._resolveChannel(featureId);
+    try {
+      const result = await this.web.conversations.history({
+        channel, latest: messageRef, inclusive: true, limit: 1,
+      });
+      const msg = result.messages?.[0];
+      if (!msg) return;
+
+      // Get title from the first section block
+      const titleText = msg.blocks?.[0]?.text?.text || decisionId;
+
+      await this.web.chat.update({
+        channel,
+        ts: messageRef,
+        blocks: buildResolvedBlocks(titleText, selectedLabel, resolvedBy, feedback),
+        text: `Decision resolved: ${selectedLabel}`,
+      });
+    } catch (err) {
+      console.error("[slack-adapter] Failed to update decision message:", err.message);
+    }
+  }
+
+  async postPlanForApproval(featureId, planDir) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+
+    const channel = this._resolveChannel(featureId);
+
+    const prdPath = findArtifact("prd", planDir);
+    const designPath = findArtifact("design-decisions", planDir);
+    const planPath = findArtifact("implementation-plan", planDir);
+
+    // Upload artifacts FIRST
+    if (prdPath) await slackUploadArtifact(this.web, channel, feature.thread_ts, prdPath, "PRD");
+    if (designPath) await slackUploadArtifact(this.web, channel, feature.thread_ts, designPath, "Design Decisions");
+    if (planPath) await slackUploadArtifact(this.web, channel, feature.thread_ts, planPath, "Implementation Plan");
+
+    // Post approval with Block Kit buttons AFTER uploads
+    const blocks = buildDecisionBlocks(
+      "plan-approval",
+      "Plan ready for approval",
+      "All planning phases complete. Review the artifacts above.",
+      [
+        { id: "approve", label: "Approve Plan", style: "primary" },
+        { id: "reject", label: "Reject Plan", style: "danger" },
+      ]
+    );
+
+    const result = await this.web.chat.postMessage({
+      channel,
+      text: "Plan ready for approval.",
+      blocks,
+    });
+
+    queries.updateFeaturePlanSummaryTs(featureId, result.ts);
+
+    const branch = `feature/${feature.slug}`;
+    const artifactList = [prdPath, designPath, planPath]
+      .filter(Boolean)
+      .map((p) => path.basename(p))
+      .join(", ");
+
+    // Also post to planning thread
+    await this.web.chat.postMessage({
+      channel: this.planningChannel,
+      thread_ts: feature.thread_ts,
+      reply_broadcast: true,
+      text: `*Planning complete: ${feature.slug}*\n\nBranch: \`${branch}\`\nArtifacts: ${artifactList || "none"}\n\nApprove/reject in <#${feature.feature_channel || channel}>.`,
+      mrkdwn: true,
+    });
+
+    return { ref: result.ts };
+  }
+
+  async postFeatureComplete(featureId) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+
+    if (feature.feature_channel) {
+      await this.postMessage(featureId,
+        `*[Pipeline]* Feature *${feature.slug}* is complete! All gates passed. :tada:`);
+    }
+
+    await postToThread(this.web, this.planningChannel, feature.thread_ts,
+      `*[Pipeline]* Feature complete: *${feature.slug}* :tada:\nAll gates approved and merged.`);
+
+    await this.web.chat.postMessage({
+      channel: this.planningChannel,
+      thread_ts: feature.thread_ts,
+      reply_broadcast: true,
+      text: `*Feature complete: ${feature.slug}* :tada:`,
+      mrkdwn: true,
+    });
+  }
+
+  async markProcessing(featureId, messageRef) {
+    const channel = this._resolveChannel(featureId);
+    await addReaction(this.web, channel, messageRef, "eyes");
+  }
+
+  async clearProcessing(featureId, messageRef) {
+    const channel = this._resolveChannel(featureId);
+    await removeReaction(this.web, channel, messageRef, "eyes");
+  }
+
+  // ─── Internal Helpers ──────────────────────────────────────────────────
+
+  _resolveChannel(featureId) {
+    const feature = queries.getFeatureById(featureId);
+    return feature?.feature_channel || this.planningChannel;
+  }
+
+  _clearPendingReaction(threadTs, channel) {
+    const pendingTs = this._pendingUserMessages[threadTs];
+    if (pendingTs) {
+      removeReaction(this.web, channel, pendingTs, "eyes").catch(() => {});
+      delete this._pendingUserMessages[threadTs];
+    }
+  }
+
+  // ─── Inbound Message Handling ────────────────────────────────────────────
+
+  _setupMessageHandler() {
+    this.socket.on("message", async ({ event, ack }) => {
+      await ack();
+
+      if (event.bot_id || event.subtype === "bot_message") return;
+
+      const text = (event.text || "").trim();
+      const channel = event.channel;
+      const thread_ts = event.thread_ts || event.ts;
+      const isThreadReply = !!event.thread_ts;
+      const userId = event.user;
+
+      console.log(`[slack] Message: channel=${channel} thread=${isThreadReply} user=${userId} text="${text.slice(0, 60)}"`);
+
+      try {
+        // [FEATURE] detection in planning channel
+        if (channel === this.planningChannel && !isThreadReply && text.toUpperCase().startsWith("[FEATURE]")) {
+          await this._handleFeatureDetection(text, event.ts, userId);
+          return;
+        }
+
+        // Thread replies in planning channel
+        if (isThreadReply && channel === this.planningChannel) {
+          const feature = queries.getFeatureByThreadTs(thread_ts);
+          if (feature) {
+            await this._handlePlanningThreadReply(feature, text, event, userId);
+            return;
+          }
+        }
+
+        // Messages in impl channels
+        const features = queries.getActiveFeatures();
+        const implFeature = features.find(f => f.feature_channel === channel);
+        if (implFeature) {
+          await this._handleImplChannelMessage(implFeature, text, event, userId);
+        }
+      } catch (err) {
+        console.error("[slack] Message handler error:", err.message);
+      }
+    });
+  }
+
+  async _handleFeatureDetection(text, messageTs, userId) {
+    const featureDesc = text.replace(/^\[FEATURE\]\s*/i, "").trim();
+    const slug = slugify(featureDesc);
+
+    if (this._orchestrator) {
+      await this._orchestrator.initializeFeature(slug, messageTs, userId);
+    }
+  }
+
+  async _handlePlanningThreadReply(feature, text, event, userId) {
+    const lower = text.toLowerCase();
+
+    // Record user message
+    queries.insertEvent(feature.id, "user-message", `user:${userId}`, text);
+
+    // Phase review approval/rejection (text fallback for Block Kit buttons)
+    const meta = queries.getFeatureMetadata(feature.id);
+    if (meta.awaiting_phase_review) {
+      if (lower === "approved" || lower === "lgtm" || lower.startsWith("approve")) {
+        if (this._orchestrator) await this._orchestrator.handlePhaseReviewApproval(feature.id);
+        return;
+      }
+      if (lower.startsWith("reject") || lower === "no" || lower === "nope" ||
+          lower.startsWith("redo") || lower.startsWith("revise")) {
+        const reason = text.replace(/^(rejected?|no|nope|redo|revise):?\s*/i, "").trim();
+        if (this._orchestrator) await this._orchestrator.handlePhaseReviewRejection(feature.id, reason || "Revisions requested");
+        return;
+      }
+    }
+
+    // Plan approval/rejection
+    if (feature.plan_summary_ts && feature.phase === "plan-approval") {
+      if (lower === "approved" || lower === "lgtm" || lower.startsWith("approve")) {
+        if (this._orchestrator) await this._orchestrator.handlePlanApproval(feature.id);
+        return;
+      }
+      if (lower.startsWith("reject") || lower === "no" || lower === "nope" ||
+          lower.startsWith("redo") || lower.startsWith("revise")) {
+        const reason = text.replace(/^(rejected?|no|nope|redo|revise):?\s*/i, "").trim();
+        if (this._orchestrator) await this._orchestrator.handlePlanRejection(feature.id, reason || "Plan rejected");
+        return;
+      }
+    }
+
+    // Route to feature channel via operator (if channel exists and feature is in planning)
+    if (feature.feature_channel && this._orchestrator) {
+      this._orchestrator.routeUserMessage(feature.id, text);
+      await addReaction(this.web, event.channel, event.ts, "eyes");
+      this._pendingUserMessages[feature.thread_ts] = event.ts;
+      return;
+    }
+
+    // Fallback: route directly to active planning role signal dir
+    const mentionedRole = parseRole(text);
+    const targetRole = mentionedRole || feature.active_planning_role;
+
+    if (targetRole) {
+      const featureDir = feature.signal_dir;
+      const signalDir = path.join(featureDir, "planning", targetRole);
+      ensureDir(signalDir);
+      const cleanText = text.replace(/@(pm|designer|architect|plan-compiler|compiler|lead)\b/gi, "").trim();
+      writeSignal(path.join(signalDir, SIGNAL.USER_MESSAGE), cleanText);
+      await addReaction(this.web, event.channel, event.ts, "eyes");
+      this._pendingUserMessages[feature.thread_ts] = event.ts;
+    }
+  }
+
+  async _handleImplChannelMessage(feature, text, event, userId) {
+    const lower = text.toLowerCase();
+
+    // Record user message
+    queries.insertEvent(feature.id, "user-message", `user:${userId}`, text);
+
+    // Phase review approval/rejection (text fallback for Block Kit buttons)
+    const meta = queries.getFeatureMetadata(feature.id);
+    if (meta.awaiting_phase_review) {
+      if (lower === "approved" || lower === "lgtm" || lower.startsWith("approve")) {
+        if (this._orchestrator) await this._orchestrator.handlePhaseReviewApproval(feature.id);
+        return;
+      }
+      if (lower.startsWith("reject") || lower === "no" || lower === "nope" ||
+          lower.startsWith("redo") || lower.startsWith("revise")) {
+        const reason = text.replace(/^(rejected?|no|nope|redo|revise):?\s*/i, "").trim();
+        if (this._orchestrator) await this._orchestrator.handlePhaseReviewRejection(feature.id, reason || "Revisions requested");
+        return;
+      }
+    }
+
+    // Plan approval/rejection (feature channel now exists during planning)
+    if (feature.plan_summary_ts && feature.phase === "plan-approval") {
+      if (lower === "approved" || lower === "lgtm" || lower.startsWith("approve")) {
+        if (this._orchestrator) await this._orchestrator.handlePlanApproval(feature.id);
+        return;
+      }
+      if (lower.startsWith("reject") || lower === "no" || lower === "nope" ||
+          lower.startsWith("redo") || lower.startsWith("revise")) {
+        const reason = text.replace(/^(rejected?|no|nope|redo|revise):?\s*/i, "").trim();
+        if (this._orchestrator) await this._orchestrator.handlePlanRejection(feature.id, reason || "Plan rejected");
+        return;
+      }
+    }
+
+    // Gate approval/rejection
+    if (feature.gate_evidence_ts) {
+      if (lower === "approved" || lower === "lgtm" || lower.startsWith("approve")) {
+        if (this._orchestrator) await this._orchestrator.handleGateApproval(feature.id);
+        return;
+      }
+      if (lower.startsWith("reject")) {
+        const reason = text.replace(/^rejected?:?\s*/i, "");
+        if (this._orchestrator) await this._orchestrator.handleGateRejection(feature.id, reason);
+        return;
+      }
+    }
+
+    // Route to operator (or FL fallback)
+    if (this._orchestrator) {
+      this._orchestrator.routeUserMessage(feature.id, text);
+    }
+
+    await addReaction(this.web, event.channel, event.ts, "eyes");
+    this._pendingUserMessages[feature.thread_ts] = event.ts;
+  }
+
+  // ─── Interactive (Block Kit Button Clicks) ─────────────────────────────
+
+  _setupInteractiveHandler() {
+    this.socket.on("interactive", async ({ body, ack }) => {
+      await ack();
+
+      // Handle modal submissions (feedback for rejections)
+      if (body.type === "view_submission") {
+        const meta = JSON.parse(body.view?.private_metadata || "{}");
+        const feedback = body.view?.state?.values?.feedback_block?.feedback_input?.value || "";
+        const { decisionId, optionId, userId: origUser, channel, messageTs } = meta;
+
+        console.log(`[slack] Modal submit: decision=${decisionId} feedback="${feedback}"`);
+
+        if (!this._orchestrator) return;
+        try {
+          await this._orchestrator.handleDecisionClick(decisionId, optionId, origUser, channel, messageTs, feedback);
+        } catch (err) {
+          console.error("[slack] Modal submission error:", err.message);
+        }
+        return;
+      }
+
+      if (body.type !== "block_actions") return;
+      const action = body.actions?.[0];
+      if (!action) return;
+
+      const actionId = action.action_id;  // "decision_<decisionId>_<optionId>"
+      const userId = body.user?.id;
+      const messageTs = body.message?.ts;
+      const channel = body.channel?.id;
+      const triggerId = body.trigger_id;
+
+      // Parse action_id
+      const parts = actionId.split("_");
+      if (parts[0] !== "decision" || parts.length < 3) return;
+      const decisionId = parts.slice(1, -1).join("_");  // handles hyphens in ID
+      const optionId = parts[parts.length - 1];
+
+      console.log(`[slack] Button click: decision=${decisionId} option=${optionId} user=${userId}`);
+
+      if (!this._orchestrator) return;
+
+      try {
+        // For reject/revision actions, open a modal to collect feedback
+        if (optionId === "reject" && triggerId) {
+          await this._openFeedbackModal(triggerId, decisionId, optionId, userId, channel, messageTs);
+        } else {
+          await this._orchestrator.handleDecisionClick(decisionId, optionId, userId, channel, messageTs);
+        }
+      } catch (err) {
+        console.error("[slack] Interactive handler error:", err.message);
+      }
+    });
+  }
+
+  async _openFeedbackModal(triggerId, decisionId, optionId, userId, channel, messageTs) {
+    const titleMap = {
+      "plan-approval": "Reject Plan",
+    };
+    if (decisionId.startsWith("phase-review-")) {
+      const role = decisionId.replace("phase-review-", "");
+      titleMap[decisionId] = `Revise ${role.charAt(0).toUpperCase() + role.slice(1)}`;
+    }
+    if (decisionId.startsWith("gate-")) {
+      titleMap[decisionId] = "Reject Gate";
+    }
+
+    const title = titleMap[decisionId] || "Provide Feedback";
+
+    await this.web.views.open({
+      trigger_id: triggerId,
+      view: {
+        type: "modal",
+        callback_id: "decision_feedback",
+        private_metadata: JSON.stringify({ decisionId, optionId, userId, channel, messageTs }),
+        title: { type: "plain_text", text: title.slice(0, 24) },
+        submit: { type: "plain_text", text: "Submit" },
+        close: { type: "plain_text", text: "Cancel" },
+        blocks: [
+          {
+            type: "input",
+            block_id: "feedback_block",
+            label: { type: "plain_text", text: "What needs to change?" },
+            element: {
+              type: "plain_text_input",
+              action_id: "feedback_input",
+              multiline: true,
+              placeholder: { type: "plain_text", text: "Describe what you'd like revised..." },
+            },
+          },
+        ],
+      },
+    });
+  }
+
+  // ─── Reaction Handling ───────────────────────────────────────────────────
+
+  _setupReactionHandler() {
+    this.socket.on("reaction_added", async ({ event, ack }) => {
+      await ack();
+
+      const { reaction, item } = event;
+      if (event.user === this.botUserId) return;
+      if (item.type !== "message") return;
+
+      const messageTs = item.ts;
+
+      try {
+        // Plan approval via reaction
+        const features = queries.getActiveFeatures();
+        const planFeature = features.find(f =>
+          f.plan_summary_ts && f.phase === "plan-approval" &&
+          (f.plan_summary_ts === messageTs || f.thread_ts === messageTs)
+        );
+        if (planFeature && this._orchestrator) {
+          if (reaction === "white_check_mark" || reaction === "+1") {
+            await this._orchestrator.handlePlanApproval(planFeature.id);
+          } else if (reaction === "x" || reaction === "-1") {
+            await this._orchestrator.handlePlanRejection(planFeature.id, "Rejected via reaction");
+          }
+          return;
+        }
+
+        // Gate approval via reaction
+        const gateFeature = features.find(f => f.gate_evidence_ts === messageTs);
+        if (gateFeature && this._orchestrator) {
+          if (reaction === "white_check_mark" || reaction === "+1") {
+            await this._orchestrator.handleGateApproval(gateFeature.id);
+          } else if (reaction === "x" || reaction === "-1") {
+            await this._orchestrator.handleGateRejection(gateFeature.id, "Rejected via reaction");
+          }
+        }
+      } catch (err) {
+        console.error("[slack] Reaction handler error:", err.message);
+      }
+    });
+  }
+}