relaybrain 0.0.0-stage → 0.2.0

package/backend/lib/transcripts/sync.js

@@ -0,0 +1,291 @@
+const fs = require("fs");
+const path = require("path");
+const { loadMemory, saveMemory, id } = require("../store");
+const { discoverAll, AGENTS } = require("./discover");
+const { parseFile } = require("./parse");
+const { eventId, normalizeWorkspaceRoot } = require("./util");
+
+const HISTORY_CAP = 2000;
+const MESSAGES_PER_THREAD = 300;
+const inflight = new Map();
+
+function unifyEvent(raw, agent, ownerLogin) {
+  const sessionId = raw.sessionId || "session";
+  return {
+    id: eventId([agent, ownerLogin, raw.transcriptPath, sessionId, raw.index, raw.role, raw.kind, raw.text]),
+    ts: raw.ts,
+    tsIso: new Date(raw.ts).toISOString(),
+    agent,
+    ownerLogin,
+    sessionId,
+    role: raw.role,
+    kind: raw.kind,
+    text: raw.text || "",
+    file: raw.file || null,
+    path: raw.path || null,
+    diff: raw.diff || "",
+    transcriptPath: raw.transcriptPath || null,
+    tsSynthetic: raw.tsSynthetic === true,
+  };
+}
+
+function compareEvents(a, b) {
+  if (a.ts !== b.ts) return a.ts - b.ts;
+  if (a.kind !== b.kind) return a.kind === "message" ? -1 : 1;
+  if (a.role === "user" && b.role !== "user") return -1;
+  if (a.role !== "user" && b.role === "user") return 1;
+  return String(a.agent).localeCompare(String(b.agent));
+}
+
+function threadKey(event) {
+  return `${event.ownerLogin}::${event.agent}::${event.sessionId}`;
+}
+
+// Edits carry the absolute path the agent used. Returns the workspace-relative
+// path, or null when the edit landed outside this workspace entirely — an agent
+// touching a temp file or a sibling repo is not this workspace's activity, and
+// showing it as such is what makes one project's feed look like another's.
+function relativeEditPath(event, workspacePath) {
+  const abs = event.path || event.file || "";
+  if (!abs) return null;
+  if (!workspacePath || !path.isAbsolute(abs)) return abs.replace(/\\/g, "/");
+  const rel = path.relative(workspacePath, abs).replace(/\\/g, "/");
+  if (!rel || rel.startsWith("../") || rel === ".." || path.isAbsolute(rel)) return null;
+  return rel;
+}
+
+function buildViews(history, ownerLogin, workspacePath) {
+  const threads = new Map();
+  const edits = [];
+  const activity = [];
+  const timeline = [];
+
+  for (const event of history) {
+    const editPath = event.kind === "code_edit" ? relativeEditPath(event, workspacePath) : null;
+    if (event.kind === "code_edit" && !editPath) continue;
+    const key = threadKey(event);
+    if (!threads.has(key)) {
+      threads.set(key, {
+        id: `chat_${event.agent.replace(/\s+/g, "-").toLowerCase()}_${event.sessionId}`.slice(0, 80),
+        agent: event.agent,
+        ownerLogin: event.ownerLogin,
+        mine: event.ownerLogin === ownerLogin,
+        sessionId: event.sessionId,
+        updatedAt: event.ts,
+        messages: [],
+      });
+    }
+    const thread = threads.get(key);
+    thread.updatedAt = Math.max(thread.updatedAt, event.ts);
+    if (event.kind === "message" || event.kind === "code_edit") {
+      thread.messages.push({
+        role: event.role,
+        text: event.text,
+        ts: event.ts,
+        kind: event.kind,
+        file: event.file || undefined,
+      });
+    }
+    if (event.kind === "code_edit") {
+      edits.push({
+        id: `e_${event.id}`,
+        agent: event.agent,
+        ownerLogin: event.ownerLogin,
+        mine: event.ownerLogin === ownerLogin,
+        file: editPath,
+        ts: event.ts,
+        diff: event.diff || "",
+      });
+      activity.push({
+        id: `a_${event.id}`,
+        kind: "edit",
+        agent: event.agent,
+        ownerLogin: event.ownerLogin,
+        mine: event.ownerLogin === ownerLogin,
+        text: event.text || `Edited ${event.file}`,
+        ts: event.ts,
+      });
+    }
+  }
+
+  const chats = [...threads.values()]
+    .map((thread) => ({
+      ...thread,
+      messages: thread.messages.slice(-MESSAGES_PER_THREAD),
+    }))
+    .sort((a, b) => b.updatedAt - a.updatedAt);
+
+  for (const thread of chats) {
+    timeline.push({
+      id: `seg_${thread.id}`,
+      agent: thread.agent,
+      ownerLogin: thread.ownerLogin,
+      mine: thread.mine,
+      ts: thread.updatedAt,
+      title: `${thread.agent} · ${thread.messages.length} events`,
+      events: thread.messages.map((m) => ({
+        type: m.kind === "code_edit" ? "edit" : m.role,
+        text: m.text,
+        file: m.file,
+      })),
+    });
+  }
+  timeline.sort((a, b) => b.ts - a.ts);
+
+  edits.sort((a, b) => b.ts - a.ts);
+  activity.sort((a, b) => b.ts - a.ts);
+
+  return { chats, timeline, edits: edits.slice(0, 400), activity: activity.slice(0, 80) };
+}
+
+function markAgents(memory, history, ownerLogin) {
+  const latest = new Map();
+  for (const event of history) {
+    const prev = latest.get(event.agent);
+    if (!prev || event.ts > prev) latest.set(event.agent, event.ts);
+  }
+  const agents = (memory.agents || []).map((row) => {
+    const ts = latest.get(row.label);
+    const stamped = ownerLogin && !row.ownerLogin ? { ...row, ownerLogin } : row;
+    if (!ts) return stamped;
+    return { ...stamped, status: "connected", lastActiveAt: ts };
+  });
+  for (const label of AGENTS) {
+    if (!agents.some((a) => a.label === label && (!a.ownerLogin || a.ownerLogin === ownerLogin)) && latest.has(label)) {
+      agents.push({
+        id: label.toLowerCase().replace(/\s+/g, "-"),
+        label,
+        status: "connected",
+        lastActiveAt: latest.get(label),
+        ownerLogin: ownerLogin || undefined,
+      });
+    }
+  }
+  return agents;
+}
+
+function syncTranscripts(project, opts = {}) {
+  const ownerLogin = opts.ownerLogin || "local";
+  const workspacePath = normalizeWorkspaceRoot(project.path) || project.path;
+  const found = discoverAll(workspacePath, opts.hint || {});
+  const existing = loadMemory(project.id);
+  if (!found.length && ((existing.history || []).length || (existing.chats || []).length)) {
+    return existing;
+  }
+  const history = [];
+  const seen = new Set();
+  // Which agents actually produced readable transcripts this pass. An agent
+  // missing from this set was not refreshed — that is very different from
+  // "this agent has nothing to say", and the two must not be conflated below.
+  const refreshed = new Set();
+  let failed = 0;
+
+  for (const { agent, file } of found) {
+    let parsed = [];
+    try {
+      parsed = parseFile(agent, file);
+    } catch (err) {
+      // Swallowing this silently is how a parser crash turns into an empty
+      // Activity/Chats panel with no way to tell that from "nothing happened".
+      failed += 1;
+      console.warn(`[relay-transcripts] ${agent} parse failed for ${file}: ${err.message || err}`);
+      continue;
+    }
+    refreshed.add(agent);
+    for (const raw of parsed) {
+      const event = unifyEvent(raw, agent, ownerLogin);
+      if (seen.has(event.id)) continue;
+      seen.add(event.id);
+      history.push(event);
+    }
+  }
+
+  // Every discovered transcript blew up: keep whatever was ingested before and
+  // leave lastTranscriptSyncAt alone so the next poll retries instead of
+  // treating the empty result as the current truth.
+  if (failed && failed === found.length) {
+    console.warn(`[relay-transcripts] ${project.id}: all ${failed} transcript(s) failed to parse — keeping previous history`);
+    return existing;
+  }
+
+  // History used to be rebuilt from scratch on every pass, so an agent that was
+  // momentarily undiscoverable — its session directory not created yet, a
+  // rotated transcript, a hint that narrowed discovery to one other agent's
+  // file, a parse error — was erased from the dashboard even though nothing had
+  // happened to its conversation. That is what made a finished Claude session
+  // disappear the moment Cursor's transcript was re-read. Carry forward every
+  // event belonging to an agent we did not successfully re-read this pass.
+  let carried = 0;
+  for (const event of existing.history || []) {
+    if (refreshed.has(event.agent)) continue;
+    if (seen.has(event.id)) continue;
+    seen.add(event.id);
+    history.push(event);
+    carried += 1;
+  }
+  if (carried) {
+    const kept = [...new Set((existing.history || []).filter((e) => !refreshed.has(e.agent)).map((e) => e.agent))];
+    console.log(`[relay-transcripts] ${project.id}: kept ${carried} event(s) from ${kept.join(", ")} (not re-read this pass)`);
+  }
+
+  history.sort(compareEvents);
+  const capped = history.slice(-HISTORY_CAP);
+  const views = buildViews(capped, ownerLogin, workspacePath);
+  const memory = existing;
+  memory.history = capped;
+  memory.chats = views.chats;
+  memory.timeline = views.timeline;
+  memory.edits = views.edits;
+  memory.activity = views.activity;
+  memory.agents = markAgents(memory, capped, ownerLogin);
+  memory.stats = memory.stats || {};
+  memory.stats.events = capped.length;
+  memory.stats.patches = views.edits.length;
+  memory.stats.agents = new Set(capped.map((e) => e.agent)).size;
+  memory.lastTranscriptSyncAt = Date.now();
+  if (memory.ir) delete memory.ir;
+  saveMemory(project.id, memory);
+  require("../falkor/bus").emit("history", { project, workspacePath, memory });
+  return memory;
+}
+
+function syncTranscriptsQueued(project, opts = {}) {
+  const key = project.id;
+  if (inflight.has(key)) return inflight.get(key);
+  const pending = Promise.resolve()
+    .then(() => syncTranscripts(project, opts))
+    .finally(() => inflight.delete(key));
+  inflight.set(key, pending);
+  return pending;
+}
+
+function latestTranscriptMtime(workspacePath) {
+  let max = 0;
+  for (const { file } of discoverAll(workspacePath)) {
+    try {
+      max = Math.max(max, fs.statSync(file).mtimeMs);
+    } catch {
+      /* skip */
+    }
+  }
+  return max;
+}
+
+function syncIfStale(project, opts = {}) {
+  const workspacePath = normalizeWorkspaceRoot(project.path) || project.path;
+  const existing = loadMemory(project.id);
+  const mtime = latestTranscriptMtime(workspacePath);
+  if (!mtime || mtime <= (existing.lastTranscriptSyncAt || 0)) return Promise.resolve(existing);
+  return syncTranscriptsQueued(project, opts);
+}
+
+module.exports = {
+  syncTranscripts,
+  syncTranscriptsQueued,
+  syncIfStale,
+  latestTranscriptMtime,
+  unifyEvent,
+  compareEvents,
+  relativeEditPath,
+  id,
+};

package/backend/lib/transcripts/util.js

@@ -0,0 +1,299 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const crypto = require("crypto");
+
+const HOME = os.homedir();
+
+function normalizeWorkspaceRoot(root) {
+  if (!root || typeof root !== "string") return null;
+  let trimmed = root.trim();
+  if (!trimmed) return null;
+  // file:///C:/Users/... and Git Bash /C:/Users or /C:\Users become a real
+  // Windows path. path.resolve("/C:/Users") on win32 is C:\C:\Users, which
+  // then fails mkdir with ENOENT.
+  trimmed = trimmed.replace(/^file:\/+/i, "/");
+  const drive = trimmed.match(/^\/?([a-zA-Z]):([\\/].*)$/);
+  if (drive) trimmed = `${drive[1]}:${drive[2]}`;
+  const doubled = trimmed.match(/^([a-zA-Z]):[\\/]+\1:[\\/]+(.*)$/i);
+  if (doubled) trimmed = `${doubled[1]}:\\${doubled[2]}`;
+  try {
+    return path.resolve(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+
+function normalizeCompare(p) {
+  return String(p || "")
+    .toLowerCase()
+    .replace(/\\/g, "/")
+    .replace(/\/$/, "");
+}
+
+// A transcript embeds the same workspace path in three encodings, often within
+// one file: JSON-escaped (`c:\\Users\\me`), URL form (`file:///c:/Users/me%20x`),
+// and plain. normalizeCompare handles only the last — it turns `\\` into `//`
+// and never decodes `%20` — so a substring search for the workspace root misses
+// every Antigravity transcript and the agent looks like it has no history at all.
+function pathHaystack(text) {
+  let s = String(text || "");
+  if (s.includes("%")) {
+    s = s.replace(/%[0-9a-fA-F]{2}/g, (m) => {
+      try {
+        return decodeURIComponent(m);
+      } catch {
+        return m;
+      }
+    });
+  }
+  return s.toLowerCase().replace(/\\/g, "/").replace(/\/{2,}/g, "/");
+}
+
+function pathNeedle(p) {
+  return pathHaystack(p).replace(/\/+$/, "");
+}
+
+const WIN_PATH_RE = /(?:file:\/\/\/)?[a-zA-Z]:(?:\\{1,2}|\/)[^\s"'`,;)\]}<>|*?]*/g;
+const POSIX_PATH_RE = /(?:file:\/\/)?\/(?:users|home|workspace|repos|projects|var|opt|srv)\/[^\s"'`,;)\]}<>|*?]*/gi;
+
+// Collects every absolute path the text mentions, normalized. Matching on these
+// rather than a raw `includes(root)` keeps `.../relay/test` from claiming the
+// transcripts of `.../relay/test-harness`.
+function pathsMentionedIn(text) {
+  const out = new Set();
+  const source = String(text || "");
+  for (const re of [WIN_PATH_RE, POSIX_PATH_RE]) {
+    re.lastIndex = 0;
+    let match;
+    while ((match = re.exec(source))) {
+      const norm = pathNeedle(match[0].replace(/^file:\/+/i, "/").replace(/^\/([a-zA-Z]:)/, "$1"));
+      if (norm.length > 3) out.add(norm);
+    }
+  }
+  return out;
+}
+
+function pathsCoverWorkspace(paths, needle) {
+  if (!needle) return false;
+  for (const candidate of paths) {
+    if (candidate === needle || candidate.startsWith(`${needle}/`)) return true;
+  }
+  return false;
+}
+
+function cursorSlug(workspacePath) {
+  const norm = String(workspacePath || "")
+    .replace(/\\/g, "/")
+    .replace(/\/$/, "");
+  const driveMatch = norm.match(/^([a-zA-Z]):\/?(.*)$/);
+  if (driveMatch) {
+    const tail = driveMatch[2]
+      .replace(/[^a-zA-Z0-9]/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-|-$/g, "");
+    return `${driveMatch[1].toLowerCase()}-${tail}`;
+  }
+  let slug = norm.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (slug.charAt(1) === "-") slug = slug.charAt(0).toLowerCase() + slug.slice(1);
+  return slug;
+}
+
+function claudeSlug(workspacePath) {
+  let slug = String(workspacePath || "").replace(/[^a-zA-Z0-9]/g, "-");
+  if (slug.charAt(1) === "-") slug = slug.charAt(0).toLowerCase() + slug.slice(1);
+  return slug;
+}
+
+function readJsonl(file) {
+  if (!file || !fs.existsSync(file)) return [];
+  return fs
+    .readFileSync(file, "utf8")
+    .replace(/^\uFEFF/, "")
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function findJsonlFiles(dir, results = [], depth = 0) {
+  if (!dir || depth > 8 || !fs.existsSync(dir)) return results;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) findJsonlFiles(full, results, depth + 1);
+    else if (entry.name.endsWith(".jsonl")) results.push(full);
+  }
+  return results;
+}
+
+function mostRecentFile(files) {
+  if (!files.length) return null;
+  return [...files].sort((a, b) => {
+    try {
+      return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+    } catch {
+      return 0;
+    }
+  })[0];
+}
+
+function fileMtime(file) {
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return Date.now();
+  }
+}
+
+/** A timestamp the transcript actually recorded, or null (so callers can say theirs is a guess). */
+function realTs(value) {
+  if (value == null || value === "") return null;
+  if (typeof value === "number") return Number.isFinite(value) ? (value < 1e12 ? value * 1000 : value) : null;
+  const parsed = Date.parse(String(value));
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+/**
+ * Cursor rows carry no timestamps, but newer Cursor builds prefix each user message with
+ * <timestamp>Saturday, Aug 22, 2026, 3:41 PM (UTC+5:30)</timestamp>. Minute precision.
+ */
+function cursorStampTs(text) {
+  const m = String(text || "").match(/<timestamp>\s*([^<]+?)\s*<\/timestamp>/i);
+  if (!m) return null;
+  const cleaned = m[1]
+    .replace(/^[A-Za-z]+,\s*/, "")
+    .replace(/\s*\(UTC\s*([+-])?(\d{1,2})(?::?(\d{2}))?\)\s*$/i, (_, sign, h, mm) => ` GMT${sign || "+"}${h.padStart(2, "0")}${mm || "00"}`)
+    .replace(/\s*\(UTC\)\s*$/i, " GMT");
+  const parsed = Date.parse(cleaned);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+
+function toTs(value, fallback = Date.now()) {
+  if (value == null || value === "") return fallback;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e12 ? value * 1000 : value;
+  }
+  const parsed = Date.parse(String(value));
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+
+function eventId(parts) {
+  return crypto.createHash("sha1").update(parts.filter(Boolean).join("|")).digest("hex").slice(0, 16);
+}
+
+function clip(text, max = 8000) {
+  const s = String(text || "");
+  return s.length > max ? `${s.slice(0, max)}\n…` : s;
+}
+
+function isRedacted(text) {
+  const s = String(text || "").trim();
+  if (!s) return true;
+  if (s === "[REDACTED]") return true;
+  return !s.replace(/\[REDACTED\]/gi, "").trim() && /\[REDACTED\]/i.test(s);
+}
+
+function extractText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value.trim();
+  if (Array.isArray(value)) {
+    return value
+      .map((part) => {
+        if (typeof part === "string") return part;
+        // tool_result / tool_use blocks carry a `content` field holding raw tool
+        // output. Reading it as message text makes stdout show up in the chat
+        // attributed to whoever sent the enclosing turn.
+        if (part?.type === "tool_result" || part?.type === "tool_use") return "";
+        if (part?.type === "text" && typeof part.text === "string") return part.text;
+        if (typeof part?.text === "string") return part.text;
+        if (typeof part?.content === "string") return part.content;
+        return "";
+      })
+      .filter(Boolean)
+      .join("\n")
+      .trim();
+  }
+  if (typeof value === "object") {
+    if (typeof value.text === "string") return value.text.trim();
+    if (typeof value.content === "string") return value.content.trim();
+  }
+  return String(value).trim();
+}
+
+function makeUnifiedDiff(oldStr, newStr, filePath) {
+  const oldLines = String(oldStr ?? "").split("\n");
+  const newLines = String(newStr ?? "").split("\n");
+  const name = filePath || "file";
+  return [
+    `--- a/${name}`,
+    `+++ b/${name}`,
+    `@@ -1,${oldLines.length} +1,${newLines.length} @@`,
+    ...oldLines.map((line) => `-${line}`),
+    ...newLines.map((line) => `+${line}`),
+  ].join("\n");
+}
+
+function discoverWorkspaceStorageDir(workspacePath, roots) {
+  const target = normalizeCompare(workspacePath);
+  for (const root of roots) {
+    if (!fs.existsSync(root)) continue;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const workspaceJson = path.join(root, entry.name, "workspace.json");
+      if (!fs.existsSync(workspaceJson)) continue;
+      try {
+        const { folder } = JSON.parse(fs.readFileSync(workspaceJson, "utf8"));
+        if (!folder || !String(folder).startsWith("file:///")) continue;
+        const decoded = decodeURIComponent(String(folder).replace("file:///", "")).replace(/\//g, path.sep);
+        if (normalizeCompare(decoded) === target) return path.join(root, entry.name);
+      } catch {
+        /* skip */
+      }
+    }
+  }
+  return null;
+}
+
+module.exports = {
+  HOME,
+  normalizeWorkspaceRoot,
+  normalizeCompare,
+  pathHaystack,
+  pathNeedle,
+  pathsMentionedIn,
+  pathsCoverWorkspace,
+  cursorSlug,
+  claudeSlug,
+  readJsonl,
+  findJsonlFiles,
+  mostRecentFile,
+  fileMtime,
+  toTs,
+  realTs,
+  cursorStampTs,
+  eventId,
+  clip,
+  isRedacted,
+  extractText,
+  makeUnifiedDiff,
+  discoverWorkspaceStorageDir,
+};