@mukulaggarwal/pacman 0.1.0

package/dist/slack-listener.js

@@ -0,0 +1,888 @@
+import {
+  createContextManager
+} from "./chunk-UWT6AFJB.js";
+import {
+  generateDraft
+} from "./chunk-O6T35A4O.js";
+import {
+  resolveConfiguredStorage
+} from "./chunk-FH6ZHWGR.js";
+import {
+  WORKSPACE_PATHS
+} from "./chunk-TRQIZP6Z.js";
+import {
+  createSlackConnector,
+  openSocketModeConnection
+} from "./chunk-ZKKMIDRK.js";
+import "./chunk-7D4SUZUM.js";
+
+// src/slack-listener.ts
+import { google } from "googleapis";
+var RECONNECT_DELAY_MS = 5e3;
+var RECENT_EVENT_TTL_MS = 5 * 60 * 1e3;
+var PROJECT_RESOLUTION_MIN_SCORE = 0.45;
+var PROJECT_RESOLUTION_MIN_MARGIN = 0.08;
+var recentEventKeys = /* @__PURE__ */ new Map();
+var RESOLUTION_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "after",
+  "again",
+  "all",
+  "also",
+  "an",
+  "and",
+  "any",
+  "are",
+  "as",
+  "at",
+  "back",
+  "be",
+  "been",
+  "before",
+  "being",
+  "between",
+  "both",
+  "but",
+  "by",
+  "can",
+  "could",
+  "date",
+  "did",
+  "do",
+  "does",
+  "effective",
+  "for",
+  "from",
+  "had",
+  "has",
+  "have",
+  "help",
+  "here",
+  "how",
+  "i",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "just",
+  "latest",
+  "me",
+  "more",
+  "most",
+  "my",
+  "need",
+  "of",
+  "on",
+  "only",
+  "or",
+  "other",
+  "our",
+  "out",
+  "over",
+  "same",
+  "share",
+  "should",
+  "show",
+  "tell",
+  "than",
+  "that",
+  "the",
+  "their",
+  "them",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "to",
+  "under",
+  "update",
+  "us",
+  "using",
+  "want",
+  "was",
+  "we",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "who",
+  "why",
+  "with",
+  "would",
+  "you",
+  "your"
+]);
+async function startSlackListener(workspacePath) {
+  const { config, storage } = await resolveConfiguredStorage(workspacePath);
+  const slackRuntime = config.slackRuntime;
+  if (!slackRuntime?.enabled) {
+    throw new Error("Slack runtime is not enabled in the saved configuration");
+  }
+  if (slackRuntime.transport !== "socket_mode") {
+    throw new Error(`Slack transport "${slackRuntime.transport}" is not supported yet. Use Socket Mode for v1.`);
+  }
+  const slackIntegration = config.integrations.find((integration) => integration.type === "slack" && integration.enabled);
+  if (!slackIntegration?.credentials?.botToken) {
+    throw new Error("Slack integration is enabled but the bot token is missing");
+  }
+  if (!slackRuntime.appToken) {
+    throw new Error("Slack runtime app token is missing");
+  }
+  const deps = {
+    config,
+    storage,
+    slackIntegration,
+    slackRuntime
+  };
+  const connector = createSlackConnector();
+  await connector.authenticate(slackIntegration);
+  console.log("Starting real-time Slack listener...");
+  console.log(`Transport: ${slackRuntime.transport}`);
+  console.log(`Review mode: ${slackRuntime.reviewMode}`);
+  console.log(`Generation enabled: ${slackRuntime.generationEnabled ? "yes" : "no"}`);
+  if (slackRuntime.channelMappings.length > 0) {
+    console.log(`Mapped channels: ${slackRuntime.channelMappings.map((mapping) => mapping.channelName ?? mapping.channelId).join(", ")}`);
+  } else {
+    console.log("Monitored channels: all Slack channels/private groups where the bot is present");
+  }
+  console.log(`Escalation owner: ${config.user.name}`);
+  while (true) {
+    try {
+      const session = await openSocketModeConnection(slackRuntime.appToken, {
+        onEvent: (event) => {
+          void handleSlackEvent(event, deps).catch((err) => {
+            console.error("Slack event handling failed:", err);
+          });
+        },
+        onError: (err) => {
+          console.error("Slack Socket Mode error:", err.message);
+        }
+      });
+      await session.closed;
+      console.warn(`Slack Socket Mode disconnected. Reconnecting in ${RECONNECT_DELAY_MS}ms...`);
+    } catch (err) {
+      console.error("Slack listener connection failed:", err);
+    }
+    await sleep(RECONNECT_DELAY_MS);
+  }
+}
+async function handleSlackEvent(event, deps) {
+  if (!shouldHandleSlackEvent(event) || !event.channel || !event.ts) {
+    console.log(`[slack] Ignored unsupported event type=${event.type} subtype=${event.subtype ?? "none"}`);
+    return;
+  }
+  const eventKey = `${event.channel}:${event.ts}`;
+  if (hasSeenRecentEvent(eventKey)) {
+    console.log(`[slack] Ignored duplicate event ${eventKey}`);
+    return;
+  }
+  markRecentEvent(eventKey);
+  const mapping = createRuntimeChannelMapping(event.channel, deps.slackRuntime.channelMappings, deps.config.user.name);
+  if (!isReplyCandidate(event, deps.config.user.assistantName)) {
+    console.log(`[slack] Ignored non-request in #${mapping.channelName ?? event.channel}: ${summarizeText(event.text)}`);
+    return;
+  }
+  console.log(`[slack] Processing candidate in #${mapping.channelName ?? event.channel}: ${summarizeText(event.text)}`);
+  const connector = createSlackConnector();
+  await connector.authenticate(deps.slackIntegration);
+  const threadTs = event.thread_ts ?? event.ts;
+  const thread = await connector.fetchThread(event.channel, threadTs, mapping.channelName);
+  const threadMapping = {
+    ...mapping,
+    channelName: thread.channelName ?? mapping.channelName
+  };
+  const resolution = await resolveProjectName(deps.storage, thread);
+  logProjectResolution(resolution);
+  const projectName = resolution.selectedProject;
+  if (!projectName) {
+    console.log("[slack] Could not resolve a project from the thread; falling back to abstain");
+  } else {
+    console.log(`[slack] Resolved project: ${projectName}`);
+    logSelectedProjectSummary(resolution, projectName);
+  }
+  await writeArtifact(
+    deps.storage,
+    `${WORKSPACE_PATHS.context.raw.slack}/${artifactKey(event.channel, threadTs)}.json`,
+    {
+      receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      event,
+      thread
+    }
+  );
+  const replyInput = await buildReplyInput(deps.config, deps.storage, threadMapping, thread, projectName);
+  logEvidenceSummary(replyInput.evidence);
+  await writeArtifact(
+    deps.storage,
+    `${WORKSPACE_PATHS.context.derived.slack.replyInputs}/${artifactKey(event.channel, threadTs)}.json`,
+    replyInput
+  );
+  const draft = await buildDraftOutput(deps.config, replyInput, threadMapping);
+  console.log(`[slack] Draft outcome for ${artifactKey(event.channel, threadTs)}: ${draft.outcome}`);
+  logDraftPreview(draft);
+  if (draft.citations.length > 0) {
+    console.log(`[slack] Draft citations: ${draft.citations.join(" | ")}`);
+  }
+  if (draft.missingFacts.length > 0) {
+    console.log(`[slack] Draft missing facts: ${draft.missingFacts.join(" | ")}`);
+  }
+  await writeArtifact(
+    deps.storage,
+    `${WORKSPACE_PATHS.context.derived.slack.drafts}/${artifactKey(event.channel, threadTs)}.json`,
+    draft
+  );
+  let delivery;
+  try {
+    delivery = await deliverDraft(connector, deps.slackRuntime, threadMapping, thread, draft, replyInput.projectName);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[slack] Delivery failed for ${artifactKey(event.channel, threadTs)}: ${message}`);
+    delivery = {
+      mode: deps.slackRuntime.reviewMode,
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      channelId: thread.channelId,
+      threadTs: thread.threadTs,
+      reviewerUserId: threadMapping.reviewerUserId,
+      outcome: "delivery_error",
+      error: message
+    };
+  }
+  await writeArtifact(
+    deps.storage,
+    `${WORKSPACE_PATHS.context.derived.slack.deliveries}/${artifactKey(event.channel, threadTs)}.json`,
+    delivery
+  );
+  if (delivery.mode === "human_review") {
+    console.log(`[slack] Delivery mode: human_review (ephemeral draft only, visible to reviewer ${threadMapping.reviewerDisplayName ?? threadMapping.reviewerUserId})`);
+    console.log(`[slack] Reviewer target: ${threadMapping.reviewerDisplayName ?? "unknown"} (${threadMapping.reviewerUserId})`);
+  } else if (delivery.mode === "auto_send") {
+    console.log("[slack] Delivery mode: auto_send (public thread reply posted)");
+    console.log(`[slack] Public reply channel: #${threadMapping.channelName ?? thread.channelId} thread=${thread.threadTs}`);
+  }
+  console.log(`[slack] Delivery recorded for ${artifactKey(event.channel, threadTs)} (${String(delivery.outcome ?? "unknown")})`);
+}
+function shouldHandleSlackEvent(event) {
+  if (event.type !== "message" && event.type !== "app_mention") return false;
+  if (!event.channel || !event.ts) return false;
+  if (event.bot_id) return false;
+  if (event.type === "message" && event.subtype && event.subtype !== "thread_broadcast") return false;
+  return true;
+}
+function isReplyCandidate(event, assistantName) {
+  if (!shouldHandleSlackEvent(event)) return false;
+  if (event.type === "app_mention") return true;
+  const text = event.text?.trim();
+  if (!text) return false;
+  if (assistantName?.trim()) {
+    const assistantPattern = new RegExp(`\\b${escapeRegExp(assistantName.trim())}\\b`, "i");
+    if (assistantPattern.test(text)) return true;
+  }
+  return /[?]$/.test(text) || /\b(status|owner|blocked|blocker|eta|when|who|what|where|which|why|how|help|update|decision)\b/i.test(text) || /\b(tell|show|give)\s+me\b/i.test(text) || /\b(can|could|would|should)\s+you\b/i.test(text);
+}
+function resolveChannelMapping(channelId, mappings) {
+  return mappings.find((mapping) => mapping.channelId === channelId);
+}
+function createRuntimeChannelMapping(channelId, mappings, ownerName) {
+  return resolveChannelMapping(channelId, mappings) ?? {
+    channelId,
+    channelName: channelId,
+    reviewerUserId: "config-owner",
+    reviewerDisplayName: ownerName || "Configured user"
+  };
+}
+function extractGitHubResources(text) {
+  const matches = [...text.matchAll(/github\.com\/([^/\s]+\/[^/\s]+)\/(issues|pull)\/(\d+)/g)];
+  return matches.map((match) => ({
+    repo: match[1],
+    kind: match[2],
+    number: match[3]
+  }));
+}
+function extractGoogleDocIds(text) {
+  return [...text.matchAll(/docs\.google\.com\/document\/d\/([A-Za-z0-9_-]+)/g)].map((match) => match[1]);
+}
+async function buildReplyInput(config, storage, mapping, thread, projectName) {
+  const contextManager = createContextManager(storage);
+  const projectContext = await contextManager.getProjectContext(projectName ?? "");
+  const evidence = [];
+  for (const file of projectContext.canonicalFiles) {
+    evidence.push({
+      source: "project",
+      reference: file.path,
+      content: truncate(file.content, 2e3)
+    });
+  }
+  for (const file of projectContext.derivedFiles) {
+    evidence.push({
+      source: "project",
+      reference: file.path,
+      content: truncate(file.content, 1500)
+    });
+  }
+  for (const file of projectContext.rawFiles) {
+    evidence.push({
+      source: "raw",
+      reference: file.path,
+      content: truncate(file.content, 1500)
+    });
+  }
+  evidence.push(...await collectGitHubEvidence(config, mapping, thread));
+  evidence.push(...await collectGoogleDriveEvidence(config, mapping, thread));
+  return {
+    projectName: projectName ?? "",
+    thread,
+    evidence,
+    reviewMode: config.slackRuntime?.reviewMode ?? "auto_send",
+    provider: config.slackRuntime?.defaultProvider,
+    model: config.slackRuntime?.defaultModel
+  };
+}
+async function buildDraftOutput(config, replyInput, mapping) {
+  if (!replyInput.projectName) {
+    return {
+      outcome: "abstain",
+      draftText: "",
+      citations: [],
+      missingFacts: ["Could not determine which project the Slack thread is asking about."],
+      escalationOwner: mapping.reviewerDisplayName ?? mapping.reviewerUserId,
+      confidence: "low"
+    };
+  }
+  const provider = config.slackRuntime?.defaultProvider;
+  const model = config.slackRuntime?.defaultModel;
+  if (!config.slackRuntime?.generationEnabled || !provider || !model) {
+    return {
+      outcome: "abstain",
+      draftText: "",
+      citations: replyInput.evidence.map((item) => item.reference).slice(0, 5),
+      missingFacts: ["Generation is disabled or provider/model is not configured."],
+      escalationOwner: mapping.reviewerDisplayName ?? mapping.reviewerUserId,
+      confidence: "low"
+    };
+  }
+  try {
+    return await generateDraft(provider, model, config.providers, replyInput);
+  } catch (err) {
+    return {
+      outcome: "abstain",
+      draftText: "",
+      citations: replyInput.evidence.map((item) => item.reference).slice(0, 5),
+      missingFacts: [err instanceof Error ? err.message : String(err)],
+      escalationOwner: mapping.reviewerDisplayName ?? mapping.reviewerUserId,
+      confidence: "low"
+    };
+  }
+}
+async function deliverDraft(connector, slackRuntime, mapping, thread, draft, projectName) {
+  if (slackRuntime.reviewMode === "auto_send") {
+    const threadReply = renderAutoSendMessage(draft, projectName);
+    const ts = await connector.postThreadReply(thread.channelId, thread.threadTs, threadReply);
+    return {
+      mode: "auto_send",
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      channelId: thread.channelId,
+      threadTs: thread.threadTs,
+      messageTs: ts,
+      outcome: draft.outcome,
+      postedText: threadReply
+    };
+  }
+  const reviewText = renderReviewMessage(mapping, draft, projectName);
+  await connector.postEphemeral(thread.channelId, mapping.reviewerUserId, reviewText, thread.threadTs);
+  return {
+    mode: "human_review",
+    deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    channelId: thread.channelId,
+    threadTs: thread.threadTs,
+    reviewerUserId: mapping.reviewerUserId,
+    outcome: draft.outcome
+  };
+}
+async function collectGitHubEvidence(config, _mapping, thread) {
+  const githubIntegration = config.integrations.find((integration) => integration.type === "github" && integration.enabled);
+  const token = githubIntegration?.credentials?.token;
+  if (!token) {
+    return [];
+  }
+  const linkedResources = extractGitHubResources(thread.messages.map((message) => message.text).join("\n")).slice(0, 3);
+  if (linkedResources.length === 0) {
+    return [];
+  }
+  const evidence = [];
+  for (const resource of linkedResources) {
+    const endpoint = resource.kind === "pull" ? `https://api.github.com/repos/${resource.repo}/pulls/${resource.number}` : `https://api.github.com/repos/${resource.repo}/issues/${resource.number}`;
+    const response = await fetch(endpoint, {
+      headers: {
+        Authorization: `token ${token}`,
+        Accept: "application/vnd.github+json",
+        "User-Agent": "personal-assistant"
+      }
+    });
+    if (!response.ok) continue;
+    const data = await response.json();
+    evidence.push({
+      source: "github",
+      reference: data.html_url ?? `${resource.repo}#${resource.number}`,
+      content: truncate(`${data.title ?? "Untitled"}
+State: ${data.state ?? "unknown"}
+${data.body ?? ""}`, 1500)
+    });
+  }
+  return evidence;
+}
+async function collectGoogleDriveEvidence(config, _mapping, thread) {
+  const gdriveIntegration = config.integrations.find((integration) => integration.type === "gdrive" && integration.enabled);
+  const credentials = gdriveIntegration?.credentials;
+  if (!credentials?.clientId || !credentials?.clientSecret || !credentials?.refreshToken) {
+    return [];
+  }
+  const linkedDocIds = extractGoogleDocIds(thread.messages.map((message) => message.text).join("\n")).slice(0, 3);
+  if (linkedDocIds.length === 0) {
+    return [];
+  }
+  const oauth2Client = new google.auth.OAuth2(credentials.clientId, credentials.clientSecret);
+  oauth2Client.setCredentials({ refresh_token: credentials.refreshToken });
+  const drive = google.drive({ version: "v3", auth: oauth2Client });
+  const evidence = [];
+  for (const docId of linkedDocIds) {
+    try {
+      const meta = await drive.files.get({
+        fileId: docId,
+        fields: "name,webViewLink"
+      });
+      const exported = await drive.files.export({
+        fileId: docId,
+        mimeType: "text/plain"
+      });
+      evidence.push({
+        source: "gdrive",
+        reference: meta.data.webViewLink ?? docId,
+        content: truncate(`${meta.data.name ?? docId}
+${String(exported.data)}`, 1500)
+      });
+    } catch {
+    }
+  }
+  return evidence;
+}
+function renderReviewMessage(mapping, draft, projectName) {
+  const lines = [
+    `*Atlas draft for ${projectName || "unknown project"}*`,
+    draft.outcome === "draft" ? draft.draftText || "_No draft text was returned._" : "_Atlas abstained because the available context was insufficient._"
+  ];
+  if (draft.citations.length > 0) {
+    lines.push(`*Citations*
+\u2022 ${draft.citations.join("\n\u2022 ")}`);
+  }
+  if (draft.missingFacts.length > 0) {
+    lines.push(`*Missing facts*
+\u2022 ${draft.missingFacts.join("\n\u2022 ")}`);
+  }
+  if (draft.escalationOwner) {
+    lines.push(`*Escalation owner*
+${draft.escalationOwner}`);
+  }
+  return truncate(lines.join("\n\n"), 3500);
+}
+function renderAutoSendMessage(draft, projectName) {
+  if (draft.outcome === "draft" && draft.draftText.trim()) {
+    return truncate(draft.draftText.trim(), 3500);
+  }
+  const lines = [
+    `I can't answer confidently from the current context${projectName ? ` for ${projectName}` : ""}.`
+  ];
+  if (draft.missingFacts.length > 0) {
+    lines.push(`Missing context: ${draft.missingFacts.join("; ")}`);
+  }
+  if (draft.escalationOwner) {
+    lines.push(`Best escalation path: ${draft.escalationOwner}.`);
+  }
+  return truncate(lines.join("\n\n"), 3500);
+}
+function artifactKey(channelId, threadTs) {
+  return `${channelId}-${threadTs.replace(/[^\dA-Za-z_-]/g, "_")}`;
+}
+async function writeArtifact(storage, filePath, data) {
+  await storage.write(filePath, JSON.stringify(data, null, 2));
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 3)}...`;
+}
+function summarizeText(text, maxLength = 100) {
+  if (!text?.trim()) return "<no text>";
+  return truncate(text.replace(/\s+/g, " ").trim(), maxLength);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function resolveProjectName(storage, thread) {
+  const contextManager = createContextManager(storage);
+  const projectNames = await contextManager.listProjects().catch(() => []);
+  const threadText = thread.messages.map((message) => message.text).join(" ");
+  const sources = await loadProjectResolutionSources(storage, projectNames);
+  return inspectProjectResolution(sources, threadText);
+}
+function resolveProjectFromText(projectNames, text) {
+  const sources = projectNames.map((projectName) => ({
+    projectName,
+    latestSummary: "",
+    contextText: ""
+  }));
+  return inspectProjectResolution(sources, text).selectedProject;
+}
+function inspectProjectResolution(sources, text) {
+  const normalizedText = normalizeForMatching(text);
+  const queryTokens = uniqueTokens(tokenizeResolutionText(text));
+  if (sources.length === 0) {
+    return {
+      threadText: text,
+      normalizedText,
+      queryTokens,
+      candidates: [],
+      selectedProject: void 0
+    };
+  }
+  if (!normalizedText) {
+    return {
+      threadText: text,
+      normalizedText,
+      queryTokens,
+      candidates: sources.map((source) => ({
+        projectName: source.projectName,
+        normalizedProject: normalizeForMatching(source.projectName),
+        latestSummary: source.latestSummary,
+        matchedNameTokens: [],
+        matchedContextTokens: [],
+        matchedAliasTokens: [],
+        cosineSimilarity: 0,
+        coverageScore: 0,
+        aliasScore: 0,
+        phraseScore: 0,
+        score: 0
+      })),
+      selectedProject: void 0
+    };
+  }
+  const profiles = sources.map((source) => createProjectResolutionProfile(source));
+  const idf = buildInverseDocumentFrequencies(profiles);
+  const candidates = profiles.map((profile) => scoreProjectMatch(profile, normalizedText, queryTokens, idf));
+  candidates.sort((a, b) => b.score - a.score || a.projectName.localeCompare(b.projectName));
+  if (sources.length === 1) {
+    return {
+      threadText: text,
+      normalizedText,
+      queryTokens,
+      candidates,
+      selectedProject: candidates[0]?.projectName
+    };
+  }
+  const [best, second] = candidates;
+  const selectedProject = best && best.score >= PROJECT_RESOLUTION_MIN_SCORE && best.score - (second?.score ?? 0) >= PROJECT_RESOLUTION_MIN_MARGIN ? best.projectName : void 0;
+  return {
+    threadText: text,
+    normalizedText,
+    queryTokens,
+    candidates,
+    selectedProject
+  };
+}
+function scoreProjectMatch(profile, haystack, queryTokens, idf) {
+  const { source, normalizedProject } = profile;
+  if (!normalizedProject) {
+    return {
+      projectName: source.projectName,
+      normalizedProject,
+      latestSummary: source.latestSummary,
+      matchedNameTokens: [],
+      matchedContextTokens: [],
+      matchedAliasTokens: [],
+      cosineSimilarity: 0,
+      coverageScore: 0,
+      aliasScore: 0,
+      phraseScore: 0,
+      score: 0
+    };
+  }
+  const nameTokenSet = new Set(profile.nameTokens);
+  const contextTokenSet = /* @__PURE__ */ new Set([...profile.summaryTokens, ...profile.contextTokens]);
+  const aliasTokenSet = new Set(profile.aliasTokens);
+  const documentTokenSet = new Set(profile.documentTokens);
+  const queryTokenSet = new Set(queryTokens);
+  const fallbackIdf = Math.log((idf.size + 2) / 0.5) + 1;
+  const matchedNameTokens = queryTokens.filter((token) => nameTokenSet.has(token));
+  const matchedAliasTokens = queryTokens.filter((token) => aliasTokenSet.has(token));
+  const matchedContextTokens = queryTokens.filter((token) => contextTokenSet.has(token) && !nameTokenSet.has(token) && !aliasTokenSet.has(token));
+  const queryVector = buildWeightedTokenMap(queryTokens, idf, fallbackIdf, 1);
+  const documentVector = /* @__PURE__ */ new Map();
+  accumulateTokenWeights(documentVector, profile.nameTokens, idf, fallbackIdf, 3.5);
+  accumulateTokenWeights(documentVector, profile.summaryTokens, idf, fallbackIdf, 2.5);
+  accumulateTokenWeights(documentVector, profile.contextTokens, idf, fallbackIdf, 1.2);
+  accumulateTokenWeights(documentVector, profile.aliasTokens, idf, fallbackIdf, 3);
+  const totalQueryWeight = sumWeights(queryVector) || 1;
+  const matchedQueryWeight = [...queryTokenSet].filter((token) => documentTokenSet.has(token)).reduce((sum, token) => sum + (queryVector.get(token) ?? 0), 0);
+  const matchedAliasWeight = [...queryTokenSet].filter((token) => aliasTokenSet.has(token)).reduce((sum, token) => sum + (queryVector.get(token) ?? 0), 0);
+  const coverageScore = matchedQueryWeight / totalQueryWeight;
+  const aliasScore = matchedAliasWeight / totalQueryWeight;
+  const cosineSimilarity = computeCosineSimilarity(queryVector, documentVector);
+  const phraseScore = haystack.includes(normalizedProject) ? 1 : 0;
+  const score = phraseScore * 1.5 + cosineSimilarity * 1.2 + coverageScore * 1 + aliasScore * 0.8;
+  return {
+    projectName: source.projectName,
+    normalizedProject,
+    latestSummary: source.latestSummary,
+    matchedNameTokens,
+    matchedContextTokens,
+    matchedAliasTokens,
+    cosineSimilarity,
+    coverageScore,
+    aliasScore,
+    phraseScore,
+    score
+  };
+}
+function logProjectResolution(debug) {
+  console.log("[slack] Project resolution strategy: weighted TF-IDF similarity over project name, latest project summary, and recent project context, with stemming, stopword removal, and acronym alias extraction; require unique best score >= 0.45 with margin >= 0.08 or abstain");
+  console.log(`[slack] Registered projects: ${debug.candidates.length > 0 ? debug.candidates.map((candidate) => candidate.projectName).join(", ") : "none"}`);
+  console.log(`[slack] Resolution text: ${summarizeText(debug.threadText, 180)}`);
+  console.log(`[slack] Normalized text: ${debug.normalizedText || "<empty>"}`);
+  console.log(`[slack] Query tokens: ${debug.queryTokens.length > 0 ? debug.queryTokens.join(", ") : "none"}`);
+  if (debug.candidates.length === 0) {
+    return;
+  }
+  console.log(
+    `[slack] Project candidate scores: ${debug.candidates.map((candidate) => `${candidate.projectName}=total:${formatScore(candidate.score)},cosine:${formatScore(candidate.cosineSimilarity)},coverage:${formatScore(candidate.coverageScore)},alias:${formatScore(candidate.aliasScore)},phrase:${formatScore(candidate.phraseScore)}${candidate.matchedNameTokens.length > 0 ? `,name:[${candidate.matchedNameTokens.join(", ")}]` : ""}${candidate.matchedContextTokens.length > 0 ? `,context:[${candidate.matchedContextTokens.join(", ")}]` : ""}${candidate.matchedAliasTokens.length > 0 ? `,aliases:[${candidate.matchedAliasTokens.join(", ")}]` : ""},summary:${JSON.stringify(summarizeText(candidate.latestSummary, 100))}`).join(" | ")}`
+  );
+}
+function logSelectedProjectSummary(debug, projectName) {
+  const selected = debug.candidates.find((candidate) => candidate.projectName === projectName);
+  if (!selected?.latestSummary) {
+    console.log("[slack] Selected project summary: <empty>");
+    return;
+  }
+  console.log("[slack] Selected project summary begin");
+  for (const line of selected.latestSummary.split("\n")) {
+    console.log(`[slack] > ${line}`);
+  }
+  console.log("[slack] Selected project summary end");
+}
+function logEvidenceSummary(evidence) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    counts.set(item.source, (counts.get(item.source) ?? 0) + 1);
+  }
+  console.log(`[slack] Evidence counts: ${[...counts.entries()].map(([source, count]) => `${source}=${count}`).join(" | ") || "none"}`);
+  const rawRefs = evidence.filter((item) => item.source === "raw").map((item) => item.reference);
+  if (rawRefs.length > 0) {
+    console.log(`[slack] Raw context references: ${rawRefs.join(" | ")}`);
+  }
+}
+function logDraftPreview(draft) {
+  if (!draft.draftText?.trim()) {
+    console.log("[slack] Draft text: <empty>");
+    return;
+  }
+  console.log("[slack] Draft text begin");
+  for (const line of draft.draftText.trim().split("\n")) {
+    console.log(`[slack] | ${line}`);
+  }
+  console.log("[slack] Draft text end");
+}
+function normalizeForMatching(value) {
+  return value.replace(/<@[A-Z0-9]+>/gi, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase().replace(/[^a-z0-9\s]+/g, " ").replace(/\s+/g, " ").trim();
+}
+async function loadProjectResolutionSources(storage, projectNames) {
+  return Promise.all(projectNames.map(async (projectName) => {
+    const filePath = `${WORKSPACE_PATHS.context.canonical.projects}/${projectName}.md`;
+    let content = "";
+    try {
+      content = await storage.read(filePath);
+    } catch {
+    }
+    return {
+      projectName,
+      latestSummary: extractLatestProjectSummary(content),
+      contextText: extractRecentProjectContext(content)
+    };
+  }));
+}
+function extractLatestProjectSummary(content) {
+  const normalized = content.trim();
+  if (!normalized) return "";
+  const noteSections = normalized.split(/\n## Note - [^\n]+\n+/).map((section) => section.trim()).filter(Boolean);
+  if (noteSections.length > 0) {
+    return truncate(noteSections[noteSections.length - 1], 800);
+  }
+  return truncate(normalized, 800);
+}
+function extractRecentProjectContext(content) {
+  const normalized = content.trim();
+  if (!normalized) return "";
+  return truncate(normalized.slice(-2500), 2500);
+}
+function tokenizeResolutionText(value) {
+  if (!value) return [];
+  return normalizeForMatching(value).split(" ").map((token) => stemResolutionToken(token.trim())).filter((token) => token.length > 2 && !RESOLUTION_STOPWORDS.has(token));
+}
+function stemResolutionToken(token) {
+  if (!token) return "";
+  let stemmed = token.toLowerCase();
+  if (stemmed.endsWith("'s")) {
+    stemmed = stemmed.slice(0, -2);
+  }
+  if (stemmed.length > 4 && stemmed.endsWith("ies")) {
+    return `${stemmed.slice(0, -3)}y`;
+  }
+  if (stemmed.length > 5 && stemmed.endsWith("ing")) {
+    stemmed = stemmed.slice(0, -3);
+  } else if (stemmed.length > 4 && stemmed.endsWith("ed")) {
+    stemmed = stemmed.slice(0, -2);
+  }
+  if (stemmed.length > 4 && stemmed.endsWith("es")) {
+    stemmed = stemmed.slice(0, -2);
+  } else if (stemmed.length > 3 && stemmed.endsWith("s") && !stemmed.endsWith("ss")) {
+    stemmed = stemmed.slice(0, -1);
+  }
+  return stemmed;
+}
+function createProjectResolutionProfile(source) {
+  const nameTokens = tokenizeResolutionText(source.projectName);
+  const summaryTokens = tokenizeResolutionText(source.latestSummary);
+  const contextTokens = tokenizeResolutionText(source.contextText);
+  const aliasTokens = uniqueTokens([
+    ...extractAcronymTokens(source.projectName),
+    ...extractAcronymTokens(source.latestSummary),
+    ...extractAcronymTokens(source.contextText)
+  ]);
+  return {
+    source,
+    normalizedProject: normalizeForMatching(source.projectName),
+    nameTokens,
+    summaryTokens,
+    contextTokens,
+    aliasTokens,
+    documentTokens: uniqueTokens([...nameTokens, ...summaryTokens, ...contextTokens, ...aliasTokens])
+  };
+}
+function extractAcronymTokens(value) {
+  if (!value) return [];
+  const aliases = /* @__PURE__ */ new Set();
+  for (const match of value.matchAll(/\b(?:[A-Z][a-z0-9]+){2,}\b/g)) {
+    const acronym = (match[0].match(/[A-Z]/g) ?? []).join("").toLowerCase();
+    if (acronym.length >= 2) {
+      aliases.add(acronym);
+    }
+  }
+  for (const match of value.matchAll(/\b[A-Z][A-Za-z0-9]+(?:[\s_-]+[A-Z][A-Za-z0-9]+){1,4}\b/g)) {
+    const words = match[0].split(/[\s_-]+/).filter(Boolean);
+    const acronym = words.map((word) => word[0]?.toLowerCase() ?? "").join("");
+    if (acronym.length >= 2) {
+      aliases.add(acronym);
+    }
+  }
+  const separatorParts = value.split(/[\s_-]+/).map((part) => part.replace(/[^A-Za-z0-9]/g, "")).filter(Boolean);
+  if (separatorParts.length >= 2 && separatorParts.length <= 5) {
+    const acronym = separatorParts.map((part) => part[0]?.toLowerCase() ?? "").join("");
+    if (acronym.length >= 2) {
+      aliases.add(acronym);
+    }
+  }
+  return [...aliases].map((token) => stemResolutionToken(token)).filter((token) => token.length > 1);
+}
+function uniqueTokens(tokens) {
+  return [...new Set(tokens.filter(Boolean))];
+}
+function buildInverseDocumentFrequencies(profiles) {
+  const frequencies = /* @__PURE__ */ new Map();
+  for (const profile of profiles) {
+    for (const token of new Set(profile.documentTokens)) {
+      frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+    }
+  }
+  const totalDocuments = Math.max(profiles.length, 1);
+  const idf = /* @__PURE__ */ new Map();
+  for (const [token, frequency] of frequencies.entries()) {
+    idf.set(token, Math.log((totalDocuments + 1) / (frequency + 0.5)) + 1);
+  }
+  return idf;
+}
+function buildWeightedTokenMap(tokens, idf, fallbackIdf, multiplier) {
+  const weights = /* @__PURE__ */ new Map();
+  accumulateTokenWeights(weights, tokens, idf, fallbackIdf, multiplier);
+  return weights;
+}
+function accumulateTokenWeights(weights, tokens, idf, fallbackIdf, multiplier) {
+  for (const token of tokens) {
+    const idfWeight = idf.get(token) ?? fallbackIdf;
+    weights.set(token, (weights.get(token) ?? 0) + idfWeight * multiplier);
+  }
+}
+function sumWeights(weights) {
+  let total = 0;
+  for (const value of weights.values()) {
+    total += value;
+  }
+  return total;
+}
+function computeCosineSimilarity(left, right) {
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (const value of left.values()) {
+    leftNorm += value * value;
+  }
+  for (const value of right.values()) {
+    rightNorm += value * value;
+  }
+  for (const [token, leftValue] of left.entries()) {
+    dot += leftValue * (right.get(token) ?? 0);
+  }
+  if (leftNorm === 0 || rightNorm === 0) {
+    return 0;
+  }
+  return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+function formatScore(value) {
+  return value.toFixed(3);
+}
+function hasSeenRecentEvent(eventKey) {
+  const seenAt = recentEventKeys.get(eventKey);
+  if (!seenAt) return false;
+  if (Date.now() - seenAt > RECENT_EVENT_TTL_MS) {
+    recentEventKeys.delete(eventKey);
+    return false;
+  }
+  return true;
+}
+function markRecentEvent(eventKey) {
+  pruneRecentEvents();
+  recentEventKeys.set(eventKey, Date.now());
+}
+function pruneRecentEvents() {
+  const now = Date.now();
+  for (const [eventKey, seenAt] of recentEventKeys.entries()) {
+    if (now - seenAt > RECENT_EVENT_TTL_MS) {
+      recentEventKeys.delete(eventKey);
+    }
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  extractGitHubResources,
+  extractGoogleDocIds,
+  handleSlackEvent,
+  inspectProjectResolution,
+  isReplyCandidate,
+  resolveChannelMapping,
+  resolveProjectFromText,
+  shouldHandleSlackEvent,
+  startSlackListener
+};
+//# sourceMappingURL=slack-listener.js.map