@neuroverseos/governance 0.7.0 → 0.8.0

package/dist/radiant/index.js

@@ -13,17 +13,21 @@ import {
   emergent,
   extractSignals,
   fetchGitHubActivity,
+  fetchGitHubOrgActivity,
   formatExocortexForPrompt,
   formatPriorReadsForPrompt,
   formatScope,
+  formatTeamExocorticesForPrompt,
   interpretPatterns,
   isPresent,
   isScored,
   isSentinel,
   loadPriorReads,
   parseRepoScope,
+  parseScope,
   presenceAverage,
   readExocortex,
+  readTeamExocortices,
   render,
   scoreComposite,
   scoreCyber,
@@ -33,7 +37,7 @@ import {
   think,
   updateKnowledge,
   writeRead
-} from "../chunk-T6EQ7ZBG.js";
+} from "../chunk-MC6O5GV5.js";
 import {
   LENSES,
   aukiBuilderLens,
@@ -45,6 +49,400 @@ import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
 import "../chunk-QWGCMQQD.js";
 
+// src/radiant/adapters/discord.ts
+async function fetchDiscordActivity(guildId, token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const perChannel = options.perChannel ?? 100;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const headers = {
+    Authorization: `Bot ${token}`,
+    "Content-Type": "application/json"
+  };
+  const channels = await fetchJSON(
+    `https://discord.com/api/v10/guilds/${guildId}/channels`,
+    headers
+  );
+  const textChannels = channels.filter((c) => {
+    if (c.type !== 0) return false;
+    if (options.channelIds && options.channelIds.length > 0) {
+      return options.channelIds.includes(c.id);
+    }
+    if (options.visibility === "public") {
+      return !c.name.startsWith("private-") && !c.nsfw;
+    }
+    return true;
+  });
+  const events = [];
+  let totalMessages = 0;
+  let helpRequests = 0;
+  let unresolvedThreads = 0;
+  let newcomerMessages = 0;
+  const responseTimes = [];
+  const participants = /* @__PURE__ */ new Set();
+  const knownParticipants = /* @__PURE__ */ new Set();
+  const topicCounts = /* @__PURE__ */ new Map();
+  for (const channel of textChannels.slice(0, 15)) {
+    try {
+      const messages = await fetchJSON(
+        `https://discord.com/api/v10/channels/${channel.id}/messages?limit=${perChannel}`,
+        headers
+      );
+      const inWindow = messages.filter(
+        (m) => new Date(m.timestamp) >= since
+      );
+      totalMessages += inWindow.length;
+      const topic = channel.name.replace(/-/g, " ");
+      topicCounts.set(topic, (topicCounts.get(topic) ?? 0) + inWindow.length);
+      for (const msg of inWindow) {
+        const actor = mapDiscordUser(msg.author);
+        participants.add(actor.id);
+        const lowerContent = msg.content.toLowerCase();
+        if (lowerContent.includes("help") || lowerContent.includes("stuck") || lowerContent.includes("how do i") || lowerContent.includes("anyone know")) {
+          helpRequests++;
+        }
+        if (msg.referenced_message) {
+          const refTime = new Date(msg.referenced_message.timestamp).getTime();
+          const msgTime = new Date(msg.timestamp).getTime();
+          const diffMinutes = (msgTime - refTime) / 6e4;
+          if (diffMinutes > 0 && diffMinutes < 10080) {
+            responseTimes.push(diffMinutes);
+          }
+        }
+        events.push({
+          id: `discord-${msg.id}`,
+          timestamp: msg.timestamp,
+          actor,
+          kind: "discord_message",
+          content: msg.content.slice(0, 500),
+          respondsTo: msg.referenced_message ? {
+            eventId: `discord-${msg.referenced_message.id}`,
+            actor: mapDiscordUser(msg.referenced_message.author)
+          } : void 0,
+          metadata: {
+            channel: channel.name,
+            guildId
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  const avgResponseMinutes = responseTimes.length > 0 ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length : null;
+  const topTopics = [...topicCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t]) => t);
+  const signals = {
+    totalMessages,
+    activeChannels: textChannels.length,
+    uniqueParticipants: participants.size,
+    avgResponseMinutes: avgResponseMinutes ? Math.round(avgResponseMinutes) : null,
+    helpRequests,
+    unresolvedThreads,
+    topTopics,
+    newcomerMessages
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatDiscordSignalsForPrompt(signals) {
+  if (signals.totalMessages === 0) return "";
+  const lines = [
+    "## Discord Activity (conversational behavior)",
+    "",
+    `${signals.totalMessages} messages across ${signals.activeChannels} channels.`,
+    `${signals.uniqueParticipants} unique participants.`
+  ];
+  if (signals.avgResponseMinutes !== null) {
+    lines.push(`Average response time: ${signals.avgResponseMinutes} minutes.`);
+  }
+  if (signals.helpRequests > 0) {
+    lines.push(`${signals.helpRequests} help requests detected.`);
+  }
+  if (signals.unresolvedThreads > 0) {
+    lines.push(`${signals.unresolvedThreads} unresolved threads.`);
+  }
+  if (signals.topTopics.length > 0) {
+    lines.push(`Top discussion topics: ${signals.topTopics.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Compare conversational activity against GitHub shipping activity.");
+  lines.push("Where debates happen in Discord but nothing ships in GitHub, name the gap.");
+  lines.push("Where work ships in GitHub but nobody discusses it in Discord, name the visibility gap.");
+  return lines.join("\n");
+}
+function mapDiscordUser(user) {
+  return {
+    id: user.username,
+    kind: user.bot ? "bot" : "human",
+    name: user.username
+  };
+}
+async function fetchJSON(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    if (res.status === 404 || res.status === 403) return [];
+    throw new Error(`Discord API error ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  }
+  return await res.json();
+}
+
+// src/radiant/adapters/slack.ts
+async function fetchSlackActivity(token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const perChannel = options.perChannel ?? 100;
+  const oldest = String(
+    Math.floor((Date.now() - windowDays * 24 * 60 * 60 * 1e3) / 1e3)
+  );
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const channelsResponse = await fetchSlackAPI("https://slack.com/api/conversations.list?types=public_channel&limit=200", headers);
+  let channels = channelsResponse.channels ?? [];
+  if (options.channelIds && options.channelIds.length > 0) {
+    const ids = new Set(options.channelIds);
+    channels = channels.filter((c) => ids.has(c.id));
+  }
+  if (options.visibility === "public") {
+    channels = channels.filter((c) => !c.is_private && !c.is_archived);
+  }
+  const events = [];
+  let totalMessages = 0;
+  let reactionCount = 0;
+  let unresolvedThreads = 0;
+  const responseTimes = [];
+  const participants = /* @__PURE__ */ new Set();
+  const externalParticipants = /* @__PURE__ */ new Set();
+  const channelMessageCounts = /* @__PURE__ */ new Map();
+  for (const channel of channels.slice(0, 15)) {
+    try {
+      const historyResponse = await fetchSlackAPI(
+        `https://slack.com/api/conversations.history?channel=${channel.id}&limit=${perChannel}&oldest=${oldest}`,
+        headers
+      );
+      const messages = historyResponse.messages ?? [];
+      totalMessages += messages.length;
+      channelMessageCounts.set(channel.name, messages.length);
+      for (const msg of messages) {
+        if (msg.subtype === "channel_join" || msg.subtype === "channel_leave") continue;
+        const actor = mapSlackUser(msg.user ?? "unknown");
+        participants.add(actor.id);
+        if (msg.reactions) {
+          reactionCount += msg.reactions.reduce(
+            (sum, r) => sum + (r.count ?? 0),
+            0
+          );
+        }
+        if (msg.thread_ts && msg.thread_ts !== msg.ts) {
+          const parentTs = parseFloat(msg.thread_ts) * 1e3;
+          const msgTs = parseFloat(msg.ts) * 1e3;
+          const diffMinutes = (msgTs - parentTs) / 6e4;
+          if (diffMinutes > 0 && diffMinutes < 10080) {
+            responseTimes.push(diffMinutes);
+          }
+        }
+        if (msg.thread_ts === msg.ts && (!msg.reply_count || msg.reply_count === 0)) {
+          if (msg.text && (msg.text.includes("?") || msg.text.toLowerCase().includes("help"))) {
+            unresolvedThreads++;
+          }
+        }
+        const timestamp = new Date(parseFloat(msg.ts) * 1e3).toISOString();
+        events.push({
+          id: `slack-${msg.ts}`,
+          timestamp,
+          actor,
+          kind: "slack_message",
+          content: (msg.text ?? "").slice(0, 500),
+          respondsTo: msg.thread_ts && msg.thread_ts !== msg.ts ? {
+            eventId: `slack-${msg.thread_ts}`,
+            actor: { id: "thread-parent", kind: "unknown" }
+          } : void 0,
+          metadata: {
+            channel: channel.name,
+            isPrivate: channel.is_private,
+            hasReactions: (msg.reactions?.length ?? 0) > 0
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  const avgResponseMinutes = responseTimes.length > 0 ? Math.round(responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length) : null;
+  const topChannels = [...channelMessageCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name]) => name);
+  const signals = {
+    totalMessages,
+    activeChannels: channelMessageCounts.size,
+    uniqueParticipants: participants.size,
+    avgResponseMinutes,
+    externalParticipants: externalParticipants.size,
+    unresolvedThreads,
+    topChannels,
+    reactionCount
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatSlackSignalsForPrompt(signals) {
+  if (signals.totalMessages === 0) return "";
+  const lines = [
+    "## Slack Activity (external coordination)",
+    "",
+    `${signals.totalMessages} messages across ${signals.activeChannels} channels.`,
+    `${signals.uniqueParticipants} unique participants.`
+  ];
+  if (signals.avgResponseMinutes !== null) {
+    lines.push(`Average thread response time: ${signals.avgResponseMinutes} minutes.`);
+  }
+  if (signals.unresolvedThreads > 0) {
+    lines.push(`${signals.unresolvedThreads} questions/threads with no reply.`);
+  }
+  if (signals.reactionCount > 0) {
+    lines.push(`${signals.reactionCount} reactions (engagement signal).`);
+  }
+  if (signals.topChannels.length > 0) {
+    lines.push(`Most active channels: ${signals.topChannels.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Slack carries external coordination \u2014 partner and client communication.");
+  lines.push("Compare partner engagement against internal activity. Where partners are");
+  lines.push("active but internal follow-through is low, name the gap.");
+  return lines.join("\n");
+}
+function mapSlackUser(userId) {
+  return {
+    id: userId,
+    kind: "human",
+    name: userId
+  };
+}
+async function fetchSlackAPI(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    throw new Error(`Slack API error ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error ?? "unknown"}`);
+  }
+  return data;
+}
+
+// src/radiant/adapters/notion.ts
+async function fetchNotionActivity(token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const maxPages = options.maxPages ?? 100;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Notion-Version": "2022-06-28",
+    "Content-Type": "application/json"
+  };
+  const searchResponse = await fetchNotionAPI("https://api.notion.com/v1/search", headers, {
+    method: "POST",
+    body: JSON.stringify({
+      filter: { property: "object", value: "page" },
+      sort: { direction: "descending", timestamp: "last_edited_time" },
+      page_size: maxPages
+    })
+  });
+  const pages = searchResponse.results ?? [];
+  const events = [];
+  const editors = /* @__PURE__ */ new Set();
+  let pagesCreated = 0;
+  let pagesUpdated = 0;
+  let stalePages = 0;
+  const editAges = [];
+  const topPages = [];
+  const now = Date.now();
+  for (const page of pages) {
+    const lastEdited = new Date(page.last_edited_time);
+    const created = new Date(page.created_time);
+    const daysSinceEdit = (now - lastEdited.getTime()) / (24 * 60 * 60 * 1e3);
+    editAges.push(daysSinceEdit);
+    if (daysSinceEdit > 30) stalePages++;
+    const title = extractTitle(page);
+    const editorId = page.last_edited_by?.id ?? "unknown";
+    editors.add(editorId);
+    if (lastEdited >= since) {
+      const isNew = created >= since;
+      if (isNew) pagesCreated++;
+      else pagesUpdated++;
+      topPages.push({ title, editedAt: page.last_edited_time });
+      events.push({
+        id: `notion-${page.id}`,
+        timestamp: page.last_edited_time,
+        actor: {
+          id: editorId,
+          kind: "human",
+          name: editorId
+        },
+        kind: isNew ? "doc_created" : "doc_updated",
+        content: `${isNew ? "Created" : "Updated"}: ${title}`,
+        metadata: {
+          pageId: page.id,
+          url: page.url,
+          createdAt: page.created_time
+        }
+      });
+    }
+  }
+  const avgDaysSinceEdit = editAges.length > 0 ? Math.round(editAges.reduce((a, b) => a + b, 0) / editAges.length) : null;
+  const signals = {
+    pagesActive: pagesCreated + pagesUpdated,
+    pagesCreated,
+    pagesUpdated,
+    uniqueEditors: editors.size,
+    stalePages,
+    avgDaysSinceEdit,
+    topPages: topPages.slice(0, 5).map((p) => p.title)
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatNotionSignalsForPrompt(signals) {
+  if (signals.pagesActive === 0 && signals.stalePages === 0) return "";
+  const lines = [
+    "## Notion Activity (documentation behavior)",
+    "",
+    `${signals.pagesActive} pages active in window (${signals.pagesCreated} created, ${signals.pagesUpdated} updated).`,
+    `${signals.uniqueEditors} unique editors.`
+  ];
+  if (signals.stalePages > 0) {
+    lines.push(`${signals.stalePages} pages haven't been touched in 30+ days.`);
+  }
+  if (signals.avgDaysSinceEdit !== null) {
+    lines.push(`Average page age since last edit: ${signals.avgDaysSinceEdit} days.`);
+  }
+  if (signals.topPages.length > 0) {
+    lines.push(`Recently active pages: ${signals.topPages.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Documentation is how the team crystallizes and shares knowledge.");
+  lines.push("High code velocity + low documentation = building without recording.");
+  lines.push("High documentation + low code = planning without shipping.");
+  lines.push("Compare Notion activity against GitHub and Discord to find the balance.");
+  return lines.join("\n");
+}
+function extractTitle(page) {
+  for (const prop of Object.values(page.properties)) {
+    if (prop.type === "title" && prop.title) {
+      return prop.title.map((t) => t.plain_text).join("") || "Untitled";
+    }
+  }
+  return "Untitled";
+}
+async function fetchNotionAPI(url, headers, init) {
+  const res = await fetch(url, {
+    method: init?.method ?? "GET",
+    headers,
+    body: init?.body
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Notion API error ${res.status}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  return await res.json();
+}
+
 // src/radiant/index.ts
 var RADIANT_PACKAGE_VERSION = "0.0.0";
 export {
@@ -64,10 +462,18 @@ export {
   createMockGitHubAdapter,
   emergent,
   extractSignals,
+  fetchDiscordActivity,
   fetchGitHubActivity,
+  fetchGitHubOrgActivity,
+  fetchNotionActivity,
+  fetchSlackActivity,
+  formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
+  formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt,
   formatScope,
+  formatSlackSignalsForPrompt,
+  formatTeamExocorticesForPrompt,
   getLens,
   interpretPatterns,
   isPresent,
@@ -76,8 +482,10 @@ export {
   listLenses,
   loadPriorReads,
   parseRepoScope,
+  parseScope,
   presenceAverage,
   readExocortex,
+  readTeamExocortices,
   render,
   scoreComposite,
   scoreCyber,

package/dist/{server-BXMC5NOE.js → server-DFNY5N5A.js}

@@ -3,7 +3,7 @@ import {
   emergent,
   parseRepoScope,
   think
-} from "./chunk-T6EQ7ZBG.js";
+} from "./chunk-MC6O5GV5.js";
 import "./chunk-VGFDMPVB.js";
 import "./chunk-I4RTIMLX.js";
 import "./chunk-ZAF6JH23.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Deterministic governance engine for AI agents — enforce worlds (permanent rules) and plans (mission constraints) with full audit trace",
   "license": "Apache-2.0",
   "type": "module",