relay-os 0.1.0

package/backend/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "relay-backend",
+  "version": "1.0.0",
+  "description": "Relay Agent Memory Backend",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node server.js"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^4.18.2"
+  }
+}

package/backend/parsers/antigravity.js

@@ -0,0 +1,206 @@
+const fs = require('fs');
+const path = require('path');
+const { normalizeTs } = require('../lib/timeline');
+
+const SOURCE = 'Antigravity';
+
+function safeRead(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); }
+  catch (_) { return ''; }
+}
+
+function getBrainDir(transcriptPath) {
+  return path.resolve(path.dirname(transcriptPath), '../..');
+}
+
+function extractFileUriFromContent(content) {
+  if (!content) return null;
+  const patterns = [
+    /(?:Created|Modified|Deleted|Updated|Wrote)\s+(?:file\s+)?(file:\/\/\/[^\s\n]+)/i,
+    /File Path:\s*`?(file:\/\/\/[^\s`\n]+)`?/i,
+  ];
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) return match[1];
+  }
+  return null;
+}
+
+function uriToPath(uri) {
+  if (!uri || !uri.startsWith('file:///')) return null;
+  try {
+    return decodeURIComponent(uri.replace('file:///', '')).replace(/\//g, path.sep);
+  } catch (_) {
+    return null;
+  }
+}
+
+function parseCodeActionStep(step) {
+  const fileUri = extractFileUriFromContent(step.content);
+  const filePath = uriToPath(fileUri);
+  const summary = String(step.content || '')
+    .split('\n')
+    .find(line => /Created|Modified|Deleted|Updated|Wrote/i.test(line)) || 'Agent code action';
+
+  return {
+    ts: normalizeTs(step.created_at),
+    kind: 'code_edit',
+    role: 'assistant',
+    source: SOURCE,
+    file: filePath ? path.basename(filePath) : null,
+    path: filePath,
+    action: step.type === 'VIEW_FILE' ? 'view' : 'edit',
+    summary: summary.slice(0, 240),
+    stepIndex: step.step_index,
+  };
+}
+
+function collectMarkdownArtifacts(brainDir) {
+  const artifacts = [];
+  const seen = new Set();
+
+  function addMdFile(mdPath) {
+    if (seen.has(mdPath)) return;
+    seen.add(mdPath);
+
+    const name = path.basename(mdPath);
+    const metaPath = `${mdPath}.metadata.json`;
+    const metaRaw = safeRead(metaPath);
+    let metadata = metaRaw;
+    let artifactTs = null;
+
+    if (metaRaw) {
+      try {
+        const meta = JSON.parse(metaRaw);
+        metadata = metaRaw;
+        artifactTs = normalizeTs(meta.updatedAt || meta.createdAt || meta.timestamp);
+      } catch (_) { }
+    }
+
+    if (!artifactTs) {
+      try {
+        artifactTs = normalizeTs(fs.statSync(mdPath).mtimeMs);
+      } catch (_) { }
+    }
+
+    artifacts.push({
+      name,
+      path: mdPath,
+      content: safeRead(mdPath),
+      metadata,
+      ts: artifactTs,
+    });
+  }
+
+  if (!fs.existsSync(brainDir)) return artifacts;
+
+  for (const entry of fs.readdirSync(brainDir, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith('.md') && !entry.name.endsWith('.metadata.json')) {
+      addMdFile(path.join(brainDir, entry.name));
+    }
+  }
+
+  const nestedDirs = ['artifacts', 'browser'];
+  for (const sub of nestedDirs) {
+    const subDir = path.join(brainDir, sub);
+    if (!fs.existsSync(subDir)) continue;
+    for (const entry of fs.readdirSync(subDir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        addMdFile(path.join(subDir, entry.name));
+      }
+    }
+  }
+
+  return artifacts;
+}
+
+function artifactTimelineEvents(artifacts) {
+  return artifacts
+    .filter(a => a.ts)
+    .map(a => ({
+      ts: a.ts,
+      kind: 'artifact',
+      role: 'assistant',
+      source: SOURCE,
+      file: a.name,
+      path: a.path,
+      summary: `Artifact updated: ${a.name}`,
+      content: a.content.slice(0, 500),
+    }));
+}
+
+function parseAntigravity(transcriptPath, options = {}) {
+  const content = safeRead(transcriptPath);
+  const lines = content.trim().split('\n').filter(Boolean);
+  const events = [];
+
+  for (const line of lines) {
+    try {
+      const step = JSON.parse(line);
+
+      if (step.type === 'USER_INPUT' && step.content) {
+        const match = step.content.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
+        const text = match ? match[1].trim() : step.content;
+        events.push({
+          ts: normalizeTs(step.created_at),
+          kind: 'message',
+          role: 'user',
+          content: text,
+          source: SOURCE,
+          stepIndex: step.step_index,
+        });
+      } else if (step.type === 'PLANNER_RESPONSE' && step.content) {
+        events.push({
+          ts: normalizeTs(step.created_at),
+          kind: 'message',
+          role: 'assistant',
+          content: step.content,
+          source: SOURCE,
+          stepIndex: step.step_index,
+        });
+      } else if (step.type === 'CODE_ACTION' || step.type === 'VIEW_FILE') {
+        const edit = parseCodeActionStep(step);
+        if (edit.ts) events.push(edit);
+      }
+    } catch (_) { }
+  }
+
+  const brainDir = options.brainDir || getBrainDir(transcriptPath);
+
+  const artifacts = collectMarkdownArtifacts(brainDir);
+  events.push(...artifactTimelineEvents(artifacts));
+
+  const tasksDir = path.join(brainDir, '.system_generated', 'tasks');
+  const tasks = fs.existsSync(tasksDir)
+    ? fs.readdirSync(tasksDir)
+      .filter(f => f.endsWith('.log'))
+      .map(f => {
+        const raw = safeRead(path.join(tasksDir, f));
+        return {
+          id: path.basename(f, '.log'),
+          preview: raw.length > 500 ? raw.substring(raw.length - 500) : raw,
+        };
+      })
+    : [];
+
+  const msgsDir = path.join(brainDir, '.system_generated', 'messages');
+  const messages = fs.existsSync(msgsDir)
+    ? fs.readdirSync(msgsDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => {
+        try { return JSON.parse(safeRead(path.join(msgsDir, f))); }
+        catch (_) { return null; }
+      })
+      .filter(Boolean)
+    : [];
+
+  events.sort((a, b) => {
+    const ta = Date.parse(a.ts || '') || 0;
+    const tb = Date.parse(b.ts || '') || 0;
+    return ta - tb;
+  });
+
+  return { events, artifacts, tasks, messages, brainDir };
+}
+
+module.exports = { parseAntigravity, getBrainDir, collectMarkdownArtifacts };

package/backend/parsers/claude.js

@@ -0,0 +1,92 @@
+const fs = require('fs');
+const path = require('path');
+const { normalizeTs, makeUnifiedDiff } = require('../lib/timeline');
+
+const SOURCE = 'Claude Code';
+const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit']);
+
+function parseClaude(transcriptPath, options = {}) {
+  const content = fs.readFileSync(transcriptPath, 'utf-8');
+  const lines = content.trim().split('\n').filter(Boolean);
+  const events = [];
+
+  for (const line of lines) {
+    try {
+      const step = JSON.parse(line);
+      const ts = normalizeTs(step.timestamp);
+
+      if (step.type === 'user' && step.message?.role === 'user') {
+        const contentArr = step.message.content;
+        const text = Array.isArray(contentArr)
+          ? contentArr.filter(c => c.type === 'text').map(c => c.text).join(' ')
+          : String(contentArr);
+        if (text.trim()) {
+          events.push({
+            ts,
+            kind: 'message',
+            role: 'user',
+            content: text,
+            source: SOURCE,
+          });
+        }
+      } else if (step.type === 'assistant' && step.message?.role === 'assistant') {
+        const contentArr = step.message.content;
+        const parts = Array.isArray(contentArr) ? contentArr : [contentArr];
+        const textParts = [];
+        const toolUses = [];
+
+        for (const part of parts) {
+          if (!part || typeof part !== 'object') continue;
+          if (part.type === 'text' && part.text) textParts.push(part.text);
+          if (part.type === 'tool_use' && EDIT_TOOLS.has(part.name)) toolUses.push(part);
+        }
+
+        const text = textParts.join(' ').trim();
+        if (text) {
+          events.push({
+            ts,
+            kind: 'message',
+            role: 'assistant',
+            content: text,
+            source: SOURCE,
+          });
+        }
+
+        for (const tool of toolUses) {
+          const input = tool.input || {};
+          const filePath = input.file_path || input.path || null;
+          if (!filePath) continue;
+
+          let diff = null;
+          let summary = `${tool.name} ${path.basename(filePath)}`;
+
+          if (tool.name === 'Edit' && input.old_string != null && input.new_string != null) {
+            diff = makeUnifiedDiff(input.old_string, input.new_string, path.basename(filePath));
+            summary = `Edited ${path.basename(filePath)}`;
+          } else if (tool.name === 'Write' && input.contents != null) {
+            diff = makeUnifiedDiff('', input.contents, path.basename(filePath));
+            summary = `Wrote ${path.basename(filePath)}`;
+          }
+
+          events.push({
+            ts,
+            kind: 'code_edit',
+            role: 'assistant',
+            source: SOURCE,
+            file: path.basename(filePath),
+            path: filePath,
+            action: tool.name.toLowerCase(),
+            summary,
+            diff,
+            toolUseId: tool.id || null,
+          });
+        }
+      }
+    } catch (_) { }
+  }
+
+  events.sort((a, b) => Date.parse(a.ts || '') - Date.parse(b.ts || ''));
+  return events;
+}
+
+module.exports = { parseClaude };

package/backend/parsers/codex.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const path = require('path');
+const { normalizeTs } = require('../lib/timeline');
+
+const SOURCE = 'Codex';
+const EDIT_TOOL_NAMES = new Set([
+  'apply_patch',
+  'write',
+  'edit_file',
+  'create_file',
+  'patch_file',
+]);
+
+function parseCodex(transcriptPath) {
+  const content = fs.readFileSync(transcriptPath, 'utf-8');
+  const lines = content.trim().split('\n').filter(Boolean);
+  const events = [];
+
+  for (const line of lines) {
+    try {
+      const step = JSON.parse(line);
+      const ts = normalizeTs(step.timestamp);
+
+      if (step.type === 'event_msg') {
+        const p = step.payload;
+        if (p.type === 'user_message') {
+          events.push({
+            ts,
+            kind: 'message',
+            role: 'user',
+            content: (p.message || ''),
+            source: SOURCE,
+          });
+        } else if (p.type === 'agent_message') {
+          events.push({
+            ts,
+            kind: 'message',
+            role: 'assistant',
+            content: (p.message || ''),
+            source: SOURCE,
+          });
+        }
+      } else if (step.type === 'response_item' && step.payload?.type === 'function_call') {
+        const payload = step.payload;
+        const name = payload.name || '';
+        if (!EDIT_TOOL_NAMES.has(name)) continue;
+
+        let args = {};
+        try {
+          args = JSON.parse(payload.arguments || '{}');
+        } catch (_) { }
+
+        const filePath =
+          args.path ||
+          args.file_path ||
+          args.file ||
+          extractPathFromPatch(args.patch || args.input || '') ||
+          null;
+
+        events.push({
+          ts,
+          kind: 'code_edit',
+          role: 'assistant',
+          source: SOURCE,
+          file: filePath ? path.basename(filePath) : null,
+          path: filePath,
+          action: name,
+          summary: `${name}${filePath ? `: ${path.basename(filePath)}` : ''}`,
+          diff: typeof args.patch === 'string' ? args.patch : null,
+          callId: payload.call_id || null,
+        });
+      }
+    } catch (_) { }
+  }
+
+  events.sort((a, b) => Date.parse(a.ts || '') - Date.parse(b.ts || ''));
+  return events;
+}
+
+function extractPathFromPatch(patchText) {
+  if (!patchText || typeof patchText !== 'string') return null;
+  const match = patchText.match(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+
+module.exports = { parseCodex };