iriai-build 0.1.0

package/v3/slack-adapter.js

@@ -0,0 +1,510 @@
+// slack-adapter.js — Socket Mode + WebClient wrapper. All Slack I/O.
+
+import { SocketModeClient } from "@slack/socket-mode";
+import { WebClient } from "@slack/web-api";
+import path from "node:path";
+import * as queries from "./queries.js";
+import * as db from "./db.js";
+import {
+  SIGNAL,
+} from "./constants.js";
+import {
+  slugify, ensureDir, writeSignal, parseRole,
+  markdownToMrkdwn, parseGifMarkers, uploadGifAttachment,
+  postToThread, addReaction, removeReaction,
+  findArtifact, uploadArtifact,
+  buildDecisionBlocks, buildResolvedBlocks,
+} from "./slack-helpers.js";
+
+export class SlackAdapter {
+  constructor({ appToken, botToken, planningChannel }) {
+    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();
+  }
+
+  // ─── Outbound Messaging ──────────────────────────────────────────────────
+
+  async postToChannel(channel, text, opts = {}) {
+    return this.web.chat.postMessage({
+      channel,
+      text: markdownToMrkdwn(text),
+      mrkdwn: true,
+      ...opts,
+    });
+  }
+
+  async postToThread(channel, threadTs, text) {
+    return postToThread(this.web, channel, threadTs, text);
+  }
+
+  async addReaction(channel, ts, reaction) {
+    return addReaction(this.web, channel, ts, reaction);
+  }
+
+  async removeReaction(channel, ts, reaction) {
+    return removeReaction(this.web, channel, ts, reaction);
+  }
+
+  /**
+   * Post an agent response to Slack. Handles media markers, dedup.
+   * Gate evidence detection is now handled by the Operator via [SLACK:decision] blocks
+   * and processed in orchestrator.js impl:operatorResponse handler.
+   */
+  async postAgentResponse(featureId, agentLabel, rawContent) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+    const channel = feature.feature_channel || this.planningChannel;
+
+    const { text: cleanedContent, gifPaths, evidencePaths } = parseGifMarkers(rawContent);
+
+    const result = await this.postToChannel(channel, `*[${agentLabel}]* ${cleanedContent}`);
+
+    // 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 (HTML with base64 images — binary mode)
+    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 result;
+  }
+
+  async postPipelineMessage(featureId, text) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+    const channel = feature.feature_channel || this.planningChannel;
+    const result = await this.postToChannel(channel, `*[Pipeline]* ${text}`);
+    queries.insertEvent(featureId, "system", "bridge", text, {}, result.ts);
+    return result;
+  }
+
+  async postPlanForApproval(featureId, planDir) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+
+    const channel = feature.feature_channel || this.planningChannel;
+
+    const prdPath = findArtifact("prd", planDir);
+    const designPath = findArtifact("design-decisions", planDir);
+    const planPath = findArtifact("implementation-plan", planDir);
+
+    // Upload artifacts FIRST
+    if (prdPath) await uploadArtifact(this.web, channel, feature.thread_ts, prdPath, "PRD");
+    if (designPath) await uploadArtifact(this.web, channel, feature.thread_ts, designPath, "Design Decisions");
+    if (planPath) await uploadArtifact(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,
+    });
+  }
+
+  async postFeatureComplete(featureId) {
+    const feature = queries.getFeatureById(featureId);
+    if (!feature) return;
+
+    if (feature.feature_channel) {
+      await this.postToChannel(feature.feature_channel,
+        `*[Pipeline]* Feature *${feature.slug}* is complete! All gates passed. :tada:`);
+    }
+
+    await this.postToThread(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,
+    });
+  }
+
+  _clearPendingReaction(threadTs, channel) {
+    const pendingTs = this._pendingUserMessages[threadTs];
+    if (pendingTs) {
+      this.removeReaction(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 this.addReaction(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 this.addReaction(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 this.addReaction(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",
+    };
+    // Phase reviews: "phase-review-pm", "phase-review-designer", etc.
+    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);
+      }
+    });
+  }
+}