@hasna/conversations 0.1.33 → 0.2.1

package/bin/mcp.js

@@ -6302,7 +6302,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str) {
+    return function time3(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -27310,6 +27310,62 @@ class ExperimentalServerTasks {
   requestStream(request, resultSchema, options) {
     return this._server.requestStream(request, resultSchema, options);
   }
+  createMessageStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+      throw new Error("Client does not support sampling tools capability.");
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    return this.requestStream({
+      method: "sampling/createMessage",
+      params
+    }, CreateMessageResultSchema, options);
+  }
+  elicitInputStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        break;
+      }
+      case "form": {
+        if (!clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        break;
+      }
+    }
+    const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
+    return this.requestStream({
+      method: "elicitation/create",
+      params: normalizedParams
+    }, ElicitResultSchema, options);
+  }
   async getTask(taskId, options) {
     return this._server.getTask({ taskId }, options);
   }
@@ -28947,12 +29003,18 @@ function getThreadReplies(messageId) {
 function searchMessages(opts) {
   const db2 = getDb();
   const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? Math.floor(opts.limit) : 20;
+  const sortByRelevance = opts.sort !== "recent";
+  const priorityWeights = { urgent: 10, high: 5, normal: 1, low: 0.5 };
   try {
-    const ftsConditions = [];
     const ftsParams = [];
-    const words = opts.query.trim().split(/\s+/).filter(Boolean);
-    const ftsQuery = words.map((w) => `"${w.replace(/"/g, '""')}"`).join(" ");
-    ftsConditions.push("messages_fts MATCH ?");
+    const query = opts.query.trim();
+    let ftsQuery;
+    if (query.startsWith('"') && query.endsWith('"')) {
+      ftsQuery = query;
+    } else {
+      const words = query.split(/\s+/).filter(Boolean);
+      ftsQuery = words.map((w) => `"${w.replace(/"/g, '""')}"`).join(" ");
+    }
     ftsParams.push(ftsQuery);
     let extraWhere = "";
     if (opts.space) {
@@ -28967,11 +29029,23 @@ function searchMessages(opts) {
       extraWhere += " AND m.to_agent = ?";
       ftsParams.push(opts.to);
     }
-    const rows2 = db2.prepare(`SELECT m.* FROM messages m
+    const orderClause = sortByRelevance ? "ORDER BY rank" : "ORDER BY m.created_at DESC, m.id DESC";
+    const rows2 = db2.prepare(`SELECT m.*, rank,
+        snippet(messages_fts, 0, '**', '**', '...', 20) as snippet
+       FROM messages m
        JOIN messages_fts ON messages_fts.rowid = m.id
-       WHERE ${ftsConditions.join(" AND ")}${extraWhere}
-       ORDER BY m.created_at DESC, m.id DESC LIMIT ${limit}`).all(...ftsParams);
-    return rows2.map(parseMessage);
+       WHERE messages_fts MATCH ?${extraWhere}
+       ${orderClause} LIMIT ${limit}`).all(...ftsParams);
+    const maxRank = rows2.reduce((max, r) => Math.max(max, Math.abs(r.rank || 0)), 0) || 1;
+    return rows2.map((row) => {
+      const msg = parseMessage(row);
+      const ftsScore = maxRank > 0 ? Math.abs(row.rank || 0) / maxRank * 100 : 50;
+      const priorityBoost = priorityWeights[msg.priority] || 1;
+      const pinnedBoost = msg.pinned_at ? 20 : 0;
+      const blockingBoost = msg.blocking ? 15 : 0;
+      const relevance_score = Math.round((ftsScore * priorityBoost + pinnedBoost + blockingBoost) * 100) / 100;
+      return { ...msg, snippet: row.snippet || null, relevance_score };
+    });
   } catch {}
   const conditions = ["content LIKE ?"];
   const params = [`%${opts.query}%`];
@@ -28989,7 +29063,10 @@ function searchMessages(opts) {
   }
   const where = `WHERE ${conditions.join(" AND ")}`;
   const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY created_at DESC, id DESC LIMIT ${limit}`).all(...params);
-  return rows.map(parseMessage);
+  return rows.map((row) => {
+    const msg = parseMessage(row);
+    return { ...msg, snippet: null, relevance_score: 0 };
+  });
 }
 
 // src/lib/sessions.ts
@@ -29022,6 +29099,32 @@ function listSessions(agent) {
     };
   });
 }
+function getSessionActivity(sessionId) {
+  const db2 = getDb();
+  const exists = db2.prepare("SELECT 1 FROM messages WHERE session_id = ? LIMIT 1").get(sessionId);
+  if (!exists)
+    return null;
+  const msgsLast1h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-1 hour')").get(sessionId).c;
+  const msgsLast24h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-24 hours')").get(sessionId).c;
+  const uniqueAgents = db2.prepare("SELECT COUNT(DISTINCT from_agent) as c FROM messages WHERE session_id = ?").get(sessionId).c;
+  const totalMsgs = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ?").get(sessionId).c;
+  const replyCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND reply_to IS NOT NULL").get(sessionId).c;
+  const replyRatio = totalMsgs > 0 ? Math.round(replyCount / totalMsgs * 100) / 100 : 0;
+  const priorityRow = db2.prepare("SELECT priority, COUNT(*) as c FROM messages WHERE session_id = ? GROUP BY priority ORDER BY c DESC LIMIT 1").get(sessionId);
+  const reactionCount = db2.prepare("SELECT COUNT(*) as c FROM reactions r JOIN messages m ON r.message_id = m.id WHERE m.session_id = ?").get(sessionId).c;
+  const agentsLast1h = db2.prepare("SELECT COUNT(DISTINCT from_agent) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-1 hour')").get(sessionId).c;
+  const isTrending = msgsLast1h >= 5 || agentsLast1h >= 3;
+  return {
+    session_id: sessionId,
+    msgs_last_1h: msgsLast1h,
+    msgs_last_24h: msgsLast24h,
+    unique_agents: uniqueAgents,
+    reply_ratio: replyRatio,
+    avg_priority: priorityRow?.priority ?? "normal",
+    reaction_count: reactionCount,
+    is_trending: isTrending
+  };
+}
 
 // src/lib/spaces.ts
 init_db();
@@ -30018,10 +30121,491 @@ function listLocks(opts) {
   query += " ORDER BY locked_at ASC";
   return db2.prepare(query).all(...params);
 }
+
+// src/lib/hot.ts
+init_db();
+function computeHotness(sessionId) {
+  const db2 = getDb();
+  const base = db2.prepare(`
+    SELECT session_id,
+      GROUP_CONCAT(DISTINCT from_agent) as agents,
+      MAX(space) as space,
+      MAX(created_at) as last_message_at,
+      COUNT(*) as message_count
+    FROM messages WHERE session_id = ?
+    GROUP BY session_id
+  `).get(sessionId);
+  if (!base)
+    return null;
+  const msgsLast1h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-1 hour')").get(sessionId).c;
+  const msgsLast24h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-24 hours')").get(sessionId).c;
+  const uniqueAgents = db2.prepare("SELECT COUNT(DISTINCT from_agent) as c FROM messages WHERE session_id = ?").get(sessionId).c;
+  const reactionCount = db2.prepare("SELECT COUNT(*) as c FROM reactions r JOIN messages m ON r.message_id = m.id WHERE m.session_id = ?").get(sessionId).c;
+  const replyCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND reply_to IS NOT NULL").get(sessionId).c;
+  const highPriorityCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND priority IN ('high', 'urgent')").get(sessionId).c;
+  const blockerCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND blocking = 1").get(sessionId).c;
+  const lastMsgMs = new Date(base.last_message_at + "Z").getTime();
+  const hoursSinceLast = Math.max(0, (Date.now() - lastMsgMs) / 3600000);
+  const hotness_score = Math.round(msgsLast1h * 3 + uniqueAgents * 5 + reactionCount * 2 + replyCount * 4 + highPriorityCount * 10 + blockerCount * 20 - hoursSinceLast * 2);
+  return {
+    session_id: base.session_id,
+    participants: base.agents.split(","),
+    space: base.space,
+    last_message_at: base.last_message_at,
+    message_count: base.message_count,
+    hotness_score,
+    metrics: {
+      msgs_last_1h: msgsLast1h,
+      msgs_last_24h: msgsLast24h,
+      unique_agents: uniqueAgents,
+      reaction_count: reactionCount,
+      reply_count: replyCount,
+      high_priority_count: highPriorityCount,
+      blocker_count: blockerCount,
+      hours_since_last: Math.round(hoursSinceLast * 10) / 10
+    }
+  };
+}
+function listHotSessions(opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 20;
+  const minScore = opts?.min_score ?? 0;
+  let where = "";
+  const params = [];
+  if (opts?.space) {
+    where = " WHERE space = ?";
+    params.push(opts.space);
+  } else if (opts?.project_id) {
+    where = " WHERE project_id = ?";
+    params.push(opts.project_id);
+  }
+  const sessions = db2.prepare(`SELECT session_id, MAX(created_at) as last_at FROM messages${where} GROUP BY session_id ORDER BY last_at DESC LIMIT 100`).all(...params);
+  const hotSessions = [];
+  for (const { session_id } of sessions) {
+    const hot = computeHotness(session_id);
+    if (hot && hot.hotness_score >= minScore) {
+      hotSessions.push(hot);
+    }
+  }
+  hotSessions.sort((a, b) => b.hotness_score - a.hotness_score);
+  return hotSessions.slice(0, limit);
+}
+
+// src/lib/topics.ts
+init_db();
+var STOPWORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "this",
+  "that",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "not",
+  "no",
+  "so",
+  "if",
+  "then",
+  "than",
+  "too",
+  "very",
+  "just",
+  "about",
+  "up",
+  "out",
+  "all",
+  "also",
+  "as",
+  "into",
+  "only",
+  "other",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "some",
+  "such",
+  "any",
+  "over",
+  "after",
+  "before",
+  "between",
+  "under",
+  "above",
+  "here",
+  "there",
+  "when",
+  "where",
+  "how",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "why",
+  "its",
+  "my",
+  "your",
+  "his",
+  "her",
+  "our",
+  "their",
+  "we",
+  "you",
+  "he",
+  "she",
+  "they",
+  "i",
+  "me",
+  "him",
+  "us",
+  "them",
+  "now",
+  "new",
+  "get",
+  "got",
+  "go",
+  "going",
+  "done",
+  "make",
+  "made",
+  "see",
+  "know",
+  "think",
+  "want",
+  "one",
+  "two",
+  "like",
+  "still",
+  "back",
+  "even"
+]);
+function extractTopics(text, topN = 10) {
+  const cleaned = text.replace(/```[\s\S]*?```/g, " ").replace(/`[^`]+`/g, " ").replace(/https?:\/\/\S+/g, " ").replace(/[#*_~|>\[\](){}]/g, " ").replace(/\d+/g, " ").toLowerCase();
+  const words = cleaned.split(/\s+/).filter((w) => w.length >= 3 && !STOPWORDS.has(w) && /^[a-z]/.test(w));
+  const freq = new Map;
+  for (const w of words) {
+    freq.set(w, (freq.get(w) || 0) + 1);
+  }
+  const totalWords = words.length || 1;
+  return [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, topN).map(([topic, count]) => ({
+    topic,
+    weight: Math.round(count / totalWords * 1000) / 1000,
+    count
+  }));
+}
+function getSpaceTopics(spaceName, opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 100;
+  const sinceClause = opts?.since ? "AND created_at > ?" : "";
+  const params = [spaceName];
+  if (opts?.since)
+    params.push(opts.since);
+  const rows = db2.prepare(`SELECT content FROM messages WHERE space = ? ${sinceClause} ORDER BY created_at DESC LIMIT ${limit}`).all(...params);
+  const combined = rows.map((r) => r.content).join(`
+`);
+  return extractTopics(combined, 15);
+}
+function getSessionTopics(sessionId, opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 100;
+  const rows = db2.prepare(`SELECT content FROM messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ${limit}`).all(sessionId);
+  const combined = rows.map((r) => r.content).join(`
+`);
+  return extractTopics(combined, 15);
+}
+function getTrendingTopics(opts) {
+  const db2 = getDb();
+  const hours = opts?.hours ?? 24;
+  const topN = opts?.top_n ?? 20;
+  let where = `WHERE created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-${hours} hours')`;
+  const params = [];
+  if (opts?.project_id) {
+    where += " AND project_id = ?";
+    params.push(opts.project_id);
+  }
+  const rows = db2.prepare(`SELECT content FROM messages ${where} ORDER BY created_at DESC LIMIT 500`).all(...params);
+  const combined = rows.map((r) => r.content).join(`
+`);
+  return extractTopics(combined, topN);
+}
+
+// src/lib/summary.ts
+init_db();
+function getConversationSummary(sessionOrSpace, opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 50;
+  const isSpace = sessionOrSpace.startsWith("space:") || db2.prepare("SELECT 1 FROM spaces WHERE name = ?").get(sessionOrSpace);
+  const filterCol = isSpace ? "space" : "session_id";
+  const filterVal = isSpace && !sessionOrSpace.startsWith("space:") ? sessionOrSpace : sessionOrSpace;
+  const messages = db2.prepare(`SELECT * FROM messages WHERE ${filterCol} = ? ORDER BY created_at DESC LIMIT ${limit}`).all(filterVal);
+  if (messages.length === 0)
+    return null;
+  const agents = new Set;
+  for (const m of messages) {
+    agents.add(m.from_agent);
+    if (m.to_agent)
+      agents.add(m.to_agent);
+  }
+  const dates = messages.map((m) => m.created_at).sort();
+  const dateRange = { first: dates[0], last: dates[dates.length - 1] };
+  const allContent = messages.map((m) => m.content).join(`
+`);
+  const topics = extractTopics(allContent, 10);
+  const keyMessages = [];
+  for (const m of messages) {
+    const priority = m.priority;
+    if (priority === "high" || priority === "urgent") {
+      keyMessages.push({
+        id: m.id,
+        from: m.from_agent,
+        content: m.content.slice(0, 200),
+        reason: `${priority} priority`
+      });
+    }
+    if (m.blocking) {
+      keyMessages.push({
+        id: m.id,
+        from: m.from_agent,
+        content: m.content.slice(0, 200),
+        reason: "blocking message"
+      });
+    }
+  }
+  for (const m of messages) {
+    if (m.pinned_at) {
+      keyMessages.push({
+        id: m.id,
+        from: m.from_agent,
+        content: m.content.slice(0, 200),
+        reason: "pinned"
+      });
+    }
+  }
+  const msgIds = messages.map((m) => m.id);
+  if (msgIds.length > 0) {
+    const placeholders = msgIds.map(() => "?").join(",");
+    const reacted = db2.prepare(`SELECT message_id, COUNT(*) as c FROM reactions WHERE message_id IN (${placeholders}) GROUP BY message_id ORDER BY c DESC LIMIT 3`).all(...msgIds);
+    for (const r of reacted) {
+      const m = messages.find((msg) => msg.id === r.message_id);
+      if (m) {
+        keyMessages.push({
+          id: r.message_id,
+          from: m.from_agent,
+          content: m.content.slice(0, 200),
+          reason: `${r.c} reaction(s)`
+        });
+      }
+    }
+  }
+  const seen = new Set;
+  const uniqueKey = keyMessages.filter((k) => {
+    if (seen.has(k.id))
+      return false;
+    seen.add(k.id);
+    return true;
+  }).slice(0, 10);
+  const blockers = messages.filter((m) => m.blocking && !m.read_at).map((m) => ({
+    id: m.id,
+    from: m.from_agent,
+    content: m.content.slice(0, 200),
+    created_at: m.created_at
+  }));
+  const replyCount = messages.filter((m) => m.reply_to).length;
+  const reactionCount = msgIds.length > 0 ? db2.prepare(`SELECT COUNT(*) as c FROM reactions WHERE message_id IN (${msgIds.map(() => "?").join(",")})`).get(...msgIds).c : 0;
+  const priorityCounts = {};
+  for (const m of messages) {
+    const p = m.priority;
+    priorityCounts[p] = (priorityCounts[p] || 0) + 1;
+  }
+  const avgPriority = Object.entries(priorityCounts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "normal";
+  return {
+    session_id: sessionOrSpace,
+    participants: [...agents].filter((a) => a !== sessionOrSpace),
+    message_count: messages.length,
+    date_range: dateRange,
+    topics,
+    key_messages: uniqueKey,
+    unresolved_blockers: blockers,
+    activity: {
+      reply_count: replyCount,
+      reaction_count: reactionCount,
+      avg_priority: avgPriority
+    }
+  };
+}
+
+// src/lib/graph.ts
+init_db();
+function ensureGraphTable() {
+  const db2 = getDb();
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS graph_edges (
+      from_type TEXT NOT NULL,
+      from_id TEXT NOT NULL,
+      to_type TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 1,
+      metadata TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      UNIQUE(from_type, from_id, to_type, to_id, relation)
+    )
+  `);
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_graph_from ON graph_edges(from_type, from_id)");
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_graph_to ON graph_edges(to_type, to_id)");
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_graph_relation ON graph_edges(relation)");
+}
+function buildGraph() {
+  const db2 = getDb();
+  ensureGraphTable();
+  let created = 0;
+  let updated = 0;
+  const upsert = db2.prepare(`
+    INSERT INTO graph_edges (from_type, from_id, to_type, to_id, relation, weight, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%f', 'now'))
+    ON CONFLICT(from_type, from_id, to_type, to_id, relation) DO UPDATE SET
+      weight = excluded.weight,
+      updated_at = excluded.updated_at
+  `);
+  const insertOrUpdate = db2.transaction(() => {
+    const dmPairs = db2.prepare(`
+      SELECT from_agent, to_agent, COUNT(*) as cnt, MAX(created_at) as last_at
+      FROM messages WHERE space IS NULL AND from_agent != to_agent
+      GROUP BY from_agent, to_agent
+    `).all();
+    for (const pair of dmPairs) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='agent' AND from_id=? AND to_type='agent' AND to_id=? AND relation='communicates_with'").get(pair.from_agent, pair.to_agent);
+      upsert.run("agent", pair.from_agent, "agent", pair.to_agent, "communicates_with", pair.cnt);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+    const spacePosts = db2.prepare(`
+      SELECT from_agent, space, COUNT(*) as cnt
+      FROM messages WHERE space IS NOT NULL
+      GROUP BY from_agent, space
+    `).all();
+    for (const sp of spacePosts) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='agent' AND from_id=? AND to_type='space' AND to_id=? AND relation='posts_in'").get(sp.from_agent, sp.space);
+      upsert.run("agent", sp.from_agent, "space", sp.space, "posts_in", sp.cnt);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+    const members = db2.prepare("SELECT agent, space FROM space_members").all();
+    for (const m of members) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='agent' AND from_id=? AND to_type='space' AND to_id=? AND relation='member_of'").get(m.agent, m.space);
+      upsert.run("agent", m.agent, "space", m.space, "member_of", 1);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+    const spaceProjects = db2.prepare("SELECT name, project_id FROM spaces WHERE project_id IS NOT NULL").all();
+    for (const sp of spaceProjects) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='space' AND from_id=? AND to_type='project' AND to_id=? AND relation='belongs_to'").get(sp.name, sp.project_id);
+      upsert.run("space", sp.name, "project", sp.project_id, "belongs_to", 1);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+  });
+  insertOrUpdate();
+  return { edges_created: created, edges_updated: updated };
+}
+function getRelated(entityType, entityId) {
+  const db2 = getDb();
+  ensureGraphTable();
+  const outgoing = db2.prepare(`
+    SELECT to_type as type, to_id as id, relation, weight FROM graph_edges
+    WHERE from_type = ? AND from_id = ? ORDER BY weight DESC
+  `).all(entityType, entityId);
+  const incoming = db2.prepare(`
+    SELECT from_type as type, from_id as id, relation, weight FROM graph_edges
+    WHERE to_type = ? AND to_id = ? ORDER BY weight DESC
+  `).all(entityType, entityId);
+  return [...outgoing, ...incoming];
+}
+function getAgentNetwork(agent) {
+  const db2 = getDb();
+  ensureGraphTable();
+  const comms = db2.prepare(`
+    SELECT to_id as agent, weight as message_count,
+      (SELECT MAX(created_at) FROM messages WHERE from_agent = ? AND to_agent = ge.to_id AND space IS NULL) as last_at
+    FROM graph_edges ge
+    WHERE from_type = 'agent' AND from_id = ? AND relation = 'communicates_with'
+    ORDER BY weight DESC LIMIT 20
+  `).all(agent, agent);
+  const spaces = db2.prepare(`
+    SELECT to_id as space, weight as message_count FROM graph_edges
+    WHERE from_type = 'agent' AND from_id = ? AND relation = 'posts_in'
+    ORDER BY weight DESC LIMIT 20
+  `).all(agent);
+  const projects = db2.prepare(`
+    SELECT DISTINCT g2.to_id FROM graph_edges g1
+    JOIN graph_edges g2 ON g1.to_type = 'space' AND g1.to_id = g2.from_id AND g2.relation = 'belongs_to'
+    WHERE g1.from_type = 'agent' AND g1.from_id = ? AND g1.relation IN ('member_of', 'posts_in')
+  `).all(agent);
+  return {
+    agent,
+    communicates_with: comms,
+    spaces,
+    projects: projects.map((p) => p.to_id)
+  };
+}
+function getGraphStats() {
+  const db2 = getDb();
+  ensureGraphTable();
+  const total = db2.prepare("SELECT COUNT(*) as c FROM graph_edges").get().c;
+  const byRelation = db2.prepare("SELECT relation, COUNT(*) as c FROM graph_edges GROUP BY relation ORDER BY c DESC").all();
+  const map3 = {};
+  for (const r of byRelation)
+    map3[r.relation] = r.c;
+  return { total_edges: total, by_relation: map3 };
+}
 // package.json
 var package_default = {
   name: "@hasna/conversations",
-  version: "0.1.33",
+  version: "0.2.1",
   description: "Real-time CLI messaging for AI agents",
   type: "module",
   bin: {
@@ -30750,6 +31334,106 @@ server.registerTool("get_pinned_messages", {
     content: [{ type: "text", text: JSON.stringify(messages) }]
   };
 });
+server.registerTool("build_graph", {
+  description: "Build/rebuild the knowledge graph from messages, spaces, and projects. Creates relationship edges between agents, spaces, and projects.",
+  inputSchema: {}
+}, async () => {
+  const result = buildGraph();
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+});
+server.registerTool("get_related", {
+  description: "Find all entities related to a given entity in the knowledge graph.",
+  inputSchema: {
+    entity_type: exports_external.string(),
+    entity_id: exports_external.string()
+  }
+}, async (args) => {
+  const related = getRelated(args.entity_type, args.entity_id);
+  return { content: [{ type: "text", text: JSON.stringify(related) }] };
+});
+server.registerTool("get_agent_network", {
+  description: "Get an agent's communication network: who they talk to, spaces, projects.",
+  inputSchema: {
+    agent: exports_external.string()
+  }
+}, async (args) => {
+  const network = getAgentNetwork(args.agent);
+  return { content: [{ type: "text", text: JSON.stringify(network) }] };
+});
+server.registerTool("graph_stats", {
+  description: "Get knowledge graph statistics: total edges and counts by relation type.",
+  inputSchema: {}
+}, async () => {
+  const stats = getGraphStats();
+  return { content: [{ type: "text", text: JSON.stringify(stats) }] };
+});
+server.registerTool("get_summary", {
+  description: "Get a structured summary of a conversation (session or space): participants, topics, key messages, blockers, activity.",
+  inputSchema: {
+    session_id: exports_external.string().optional(),
+    space: exports_external.string().optional(),
+    limit: exports_external.coerce.number().optional()
+  }
+}, async (args) => {
+  const target = args.space || args.session_id;
+  if (!target)
+    return { content: [{ type: "text", text: "session_id or space required" }], isError: true };
+  const summary = getConversationSummary(target, { limit: args.limit });
+  if (!summary)
+    return { content: [{ type: "text", text: `No messages found for "${target}"` }], isError: true };
+  return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+});
+server.registerTool("get_topics", {
+  description: "Extract topics from a space or session. Returns weighted keyword list.",
+  inputSchema: {
+    space: exports_external.string().optional(),
+    session_id: exports_external.string().optional(),
+    limit: exports_external.coerce.number().optional()
+  }
+}, async (args) => {
+  const topics = args.space ? getSpaceTopics(args.space, { limit: args.limit }) : args.session_id ? getSessionTopics(args.session_id, { limit: args.limit }) : getTrendingTopics({ top_n: args.limit });
+  return { content: [{ type: "text", text: JSON.stringify(topics) }] };
+});
+server.registerTool("trending_topics", {
+  description: "Get trending topics across all messages in the last N hours.",
+  inputSchema: {
+    hours: exports_external.coerce.number().optional(),
+    project_id: exports_external.string().optional(),
+    top_n: exports_external.coerce.number().optional()
+  }
+}, async (args) => {
+  const topics = getTrendingTopics({ hours: args.hours, project_id: args.project_id, top_n: args.top_n });
+  return { content: [{ type: "text", text: JSON.stringify(topics) }] };
+});
+server.registerTool("get_session_activity", {
+  description: "Get activity metrics for a session: message velocity, unique agents, reply ratio, reaction count, trending status.",
+  inputSchema: {
+    session_id: exports_external.string()
+  }
+}, async (args) => {
+  const activity = getSessionActivity(args.session_id);
+  if (!activity) {
+    return { content: [{ type: "text", text: `session "${args.session_id}" not found` }], isError: true };
+  }
+  return { content: [{ type: "text", text: JSON.stringify(activity) }] };
+});
+server.registerTool("hot_sessions", {
+  description: "List conversations ranked by activity hotness (message velocity, reactions, replies, priority, blockers).",
+  inputSchema: {
+    limit: exports_external.coerce.number().optional(),
+    min_score: exports_external.coerce.number().optional(),
+    space: exports_external.string().optional(),
+    project_id: exports_external.string().optional()
+  }
+}, async (args) => {
+  const sessions = listHotSessions({
+    limit: args.limit,
+    min_score: args.min_score,
+    space: args.space,
+    project_id: args.project_id
+  });
+  return { content: [{ type: "text", text: JSON.stringify(sessions) }] };
+});
 server.registerTool("add_reaction", {
   description: "Add an emoji reaction to a message.",
   inputSchema: {
@@ -31049,6 +31733,15 @@ server.registerTool("search_tools", {
     "pin_message",
     "unpin_message",
     "get_pinned_messages",
+    "build_graph",
+    "get_related",
+    "get_agent_network",
+    "graph_stats",
+    "get_summary",
+    "get_topics",
+    "trending_topics",
+    "get_session_activity",
+    "hot_sessions",
     "add_reaction",
     "remove_reaction",
     "get_reactions",
@@ -31107,6 +31800,15 @@ server.registerTool("describe_tools", {
     pin_message: "Pin a message. Required: id",
     unpin_message: "Unpin a message. Required: id",
     get_pinned_messages: "Get pinned messages. Optional: space?, session_id?, limit?",
+    build_graph: "Build/rebuild knowledge graph from messages, spaces, projects. Returns edge counts.",
+    get_related: "Find entities related to a given entity. Required: entity_type, entity_id",
+    get_agent_network: "Agent's communication network: contacts, spaces, projects. Required: agent",
+    graph_stats: "Knowledge graph stats: total edges, by relation type",
+    get_summary: "Structured conversation summary: participants, topics, key messages, blockers. Required: session_id? or space?. Optional: limit?",
+    get_topics: "Extract topics from space or session. Optional: space?, session_id?, limit?",
+    trending_topics: "Trending topics across all messages. Optional: hours?, project_id?, top_n?",
+    get_session_activity: "Get activity metrics for a session: velocity, agents, reply ratio, reactions, trending. Required: session_id",
+    hot_sessions: "List conversations by hotness score (velocity, reactions, replies, priority, blockers). Optional: limit?, min_score?, space?, project_id?",
     add_reaction: "Add emoji reaction to a message. Required: message_id, emoji. Optional: from?",
     remove_reaction: "Remove emoji reaction from a message. Required: message_id, emoji. Optional: from?",
     get_reactions: "Get all reactions for a message. Required: message_id",