iriai-build 0.1.0

package/v3/slack-helpers.js

@@ -0,0 +1,346 @@
+// slack-helpers.js — Ported pure helper functions from lib/slack-helpers.js.
+// Slugify, mrkdwn conversion, media upload, signal file I/O.
+
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { IRIAI_TEAM_DIR, KNOWN_REPOS, TEMPLATES_DIR, AVAILABLE_TEMPLATES } 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 });
+}
+
+/**
+ * Read a signal file, return content, and optionally delete it.
+ */
+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.
+ */
+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;
+}
+
+/**
+ * Extract media markers from message text.
+ */
+export function parseGifMarkers(text) {
+  const gifPaths = [];
+  const evidencePaths = [];
+  const cleaned = text.replace(/\[(gif|img|image|video|screenshot|evidence):([^\]]+)\]/gi, (match, type, filePath) => {
+    if (type.toLowerCase() === "evidence") {
+      evidencePaths.push(filePath.trim());
+    } else {
+      gifPaths.push(filePath.trim());
+    }
+    return "";
+  });
+  return { text: cleaned.trim(), gifPaths, evidencePaths };
+}
+
+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 function findArtifact(filename, planDir) {
+  const dir = planDir || path.join(IRIAI_TEAM_DIR, "implementation-plans", "current");
+  try {
+    const files = fs.readdirSync(dir);
+    const match = files.find((f) => f.includes(filename) && f.endsWith(".md"));
+    if (match) return path.join(dir, match);
+  } catch {
+    // Directory 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(planDir, featureSlug) {
+  const planPath = findArtifact("implementation-plan", planDir);
+  const detected = [];
+
+  // 1. Text-scan plan artifact against KNOWN_REPOS
+  if (planPath) {
+    const content = fs.readFileSync(planPath, "utf-8");
+    for (const repo of KNOWN_REPOS) {
+      if (content.includes(repo)) detected.push(repo);
+    }
+  }
+
+  // 2. Scan worktree dir for repos already pulled in (catches new repos)
+  if (featureSlug) {
+    const reposDir = path.join(process.env.HOME, "src/iriai/.features", featureSlug, "repos");
+    if (fs.existsSync(reposDir)) {
+      try {
+        const entries = fs.readdirSync(reposDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          const wtPath = path.join(reposDir, entry.name);
+          if (!fs.existsSync(path.join(wtPath, ".git"))) continue;
+          // Try to resolve the source repo path from the worktree's remote
+          try {
+            const remote = execSync(`git -C "${wtPath}" remote get-url origin`, { stdio: "pipe" }).toString().trim();
+            // Remote is a local path like /Users/.../src/iriai/first-party-apps/test/test-backend
+            const projectRoot = path.join(process.env.HOME, "src/iriai");
+            if (remote.startsWith(projectRoot)) {
+              const relPath = remote.slice(projectRoot.length + 1);
+              if (!detected.includes(relPath)) detected.push(relPath);
+            }
+          } catch {
+            // No remote — might be a locally-scaffolded new repo; skip
+          }
+        }
+      } catch { /* reposDir read failed */ }
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * Scaffold a new repo locally: create directory, apply template or bare scaffold,
+ * initialize git. Does NOT create GitHub repo (that happens post-approval).
+ * Returns true on success, false on failure.
+ */
+export function scaffoldNewRepo(localPath, githubName, template) {
+  const projectRoot = path.join(process.env.HOME, "src/iriai");
+  const repoAbsPath = path.join(projectRoot, localPath);
+  const repoBasename = path.basename(localPath);
+
+  // Idempotent: if already exists with .git, skip
+  if (fs.existsSync(path.join(repoAbsPath, ".git"))) {
+    console.log(`[scaffoldNewRepo] ${localPath} already exists with .git, skipping`);
+    return true;
+  }
+
+  try {
+    fs.mkdirSync(repoAbsPath, { recursive: true });
+
+    if (template && AVAILABLE_TEMPLATES.includes(template)) {
+      const templateDir = path.join(TEMPLATES_DIR, template);
+      if (fs.existsSync(templateDir)) {
+        execSync(`rsync -a --exclude '.git' "${templateDir}/" "${repoAbsPath}/"`, { stdio: "pipe" });
+        console.log(`[scaffoldNewRepo] Applied template '${template}' to ${localPath}`);
+      } else {
+        console.warn(`[scaffoldNewRepo] Template dir not found: ${templateDir}, using bare scaffold`);
+        _writeBareScaffold(repoAbsPath, repoBasename);
+      }
+    } else {
+      _writeBareScaffold(repoAbsPath, repoBasename);
+    }
+
+    // Initialize git
+    execSync(`git -C "${repoAbsPath}" init -b main`, { stdio: "pipe" });
+    execSync(`git -C "${repoAbsPath}" add -A`, { stdio: "pipe" });
+    execSync(`git -C "${repoAbsPath}" commit -m "chore: scaffold ${repoBasename}"`, { stdio: "pipe" });
+
+    console.log(`[scaffoldNewRepo] Scaffolded ${localPath} (template: ${template || "bare"})`);
+    return true;
+  } catch (err) {
+    console.error(`[scaffoldNewRepo] Failed to scaffold ${localPath}:`, err.message);
+    return false;
+  }
+}
+
+function _writeBareScaffold(dir, name) {
+  fs.writeFileSync(path.join(dir, "README.md"), `# ${name}\n\nPart of the iriai platform.\n`);
+  fs.writeFileSync(path.join(dir, ".gitignore"), [
+    "node_modules/", "__pycache__/", "*.pyc", ".venv/", "venv/",
+    ".env", ".env.local", ".idea/", ".vscode/", "*.swp",
+    ".DS_Store", "dist/", "build/", "*.egg-info/",
+  ].join("\n") + "\n");
+}
+
+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;
+}
+
+/**
+ * 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
+  }
+}