relay-os 0.1.0

package/backend/lib/vscdb.js

@@ -0,0 +1,42 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+function queryVscdb(dbPath, sql) {
+  if (!fs.existsSync(dbPath)) return null;
+
+  try {
+    const out = execSync(`sqlite3 "${dbPath.replace(/"/g, '""')}" "${sql.replace(/"/g, '""')}"`, {
+      encoding: 'utf-8',
+      timeout: 5000,
+      windowsHide: true,
+    });
+    return out.trim();
+  } catch (_) {
+    return null;
+  }
+}
+
+function readVscdbJson(dbPath, key) {
+  const raw = queryVscdb(dbPath, `SELECT value FROM ItemTable WHERE key='${key.replace(/'/g, "''")}';`);
+  if (!raw) return null;
+
+  try {
+    return JSON.parse(raw);
+  } catch (_) {
+    return null;
+  }
+}
+
+function vscodeInternalTimeToIso(value) {
+  if (value == null) return null;
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  const date = new Date(n);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+module.exports = {
+  queryVscdb,
+  readVscdbJson,
+  vscodeInternalTimeToIso,
+};

package/backend/lib/vscodeHistory.js

@@ -0,0 +1,227 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { folderUriToPath, normalizeWorkspacePath } = require('./vscodeWorkspace');
+const { normalizeTs } = require('./timeline');
+
+const HOME = os.homedir();
+
+const HISTORY_ROOTS = [
+  {
+    root: path.join(HOME, 'AppData', 'Roaming', 'Code', 'User', 'History'),
+    source: 'GitHub Copilot',
+  },
+  {
+    root: path.join(HOME, 'AppData', 'Roaming', 'Cursor', 'User', 'History'),
+    source: 'Cursor',
+  },
+  {
+    root: path.join(HOME, 'AppData', 'Roaming', 'Antigravity IDE', 'User', 'History'),
+    source: 'Antigravity',
+  },
+  {
+    root: path.join(HOME, '.config', 'Code', 'User', 'History'),
+    source: 'GitHub Copilot',
+  },
+  {
+    root: path.join(HOME, '.config', 'Cursor', 'User', 'History'),
+    source: 'Cursor',
+  },
+];
+
+function getCodeHistoryRoots() {
+  return HISTORY_ROOTS.filter(({ root, source }) =>
+    source === 'GitHub Copilot' && fs.existsSync(root)
+  );
+}
+
+function getCursorHistoryRoots() {
+  return HISTORY_ROOTS.filter(({ root, source }) =>
+    source === 'Cursor' && fs.existsSync(root)
+  );
+}
+
+function editPathKey(event) {
+  const filePath = normalizeWorkspacePath(event.path || event.file || '');
+  const tsBucket = Math.floor((Date.parse(event.ts || '') || 0) / 1000);
+  return `${filePath}|${tsBucket}`;
+}
+
+function findClosestHistoryEdit(edit, historyEdits, maxDeltaMs = 120000) {
+  const editTs = Date.parse(edit.ts || '') || 0;
+  const editPath = normalizeWorkspacePath(edit.path || '');
+
+  let best = null;
+  let bestDelta = Infinity;
+
+  for (const candidate of historyEdits) {
+    const candidatePath = normalizeWorkspacePath(candidate.path || '');
+    if (candidatePath !== editPath) continue;
+
+    const delta = Math.abs((Date.parse(candidate.ts || '') || 0) - editTs);
+    if (delta <= maxDeltaMs && delta < bestDelta) {
+      best = candidate;
+      bestDelta = delta;
+    }
+  }
+
+  return best;
+}
+
+function enrichEditsWithHistory(sessionEdits, historyEdits) {
+  return sessionEdits.map(edit => {
+    if (edit.diff) return edit;
+
+    const match = findClosestHistoryEdit(edit, historyEdits);
+    if (!match) return edit;
+
+    return {
+      ...edit,
+      diff: match.diff || null,
+      summary: match.summary || edit.summary,
+      historyId: match.historyId || null,
+      editSource: match.editSource || 'localHistory',
+    };
+  });
+}
+
+function mergeCodeEditSources(historyEdits, sessionEdits) {
+  const merged = [];
+  const seen = new Set();
+  const historyPaths = new Set(
+    historyEdits.map(edit => normalizeWorkspacePath(edit.path || '')).filter(Boolean)
+  );
+
+  for (const edit of historyEdits) {
+    const key = editPathKey(edit);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push({
+      ...edit,
+      editSource: edit.editSource || 'localHistory',
+    });
+  }
+
+  for (const edit of sessionEdits) {
+    const editPath = normalizeWorkspacePath(edit.path || '');
+    if (editPath && historyPaths.has(editPath)) continue;
+
+    const nearHistory = historyEdits.some(h =>
+      normalizeWorkspacePath(h.path || '') === editPath &&
+      Math.abs((Date.parse(h.ts || '') || 0) - (Date.parse(edit.ts || '') || 0)) < 60000
+    );
+
+    if (nearHistory && !edit.diff) continue;
+
+    const key = editPathKey(edit);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push({
+      ...edit,
+      editSource: edit.editSource || 'chatEditingSession',
+    });
+  }
+
+  merged.sort((a, b) => Date.parse(a.ts || '') - Date.parse(b.ts || ''));
+  return merged;
+}
+
+function isUnderWorkspace(filePath, workspacePath) {
+  if (!filePath || !workspacePath) return false;
+  const fileNorm = normalizeWorkspacePath(filePath);
+  const wsNorm = normalizeWorkspacePath(workspacePath);
+  return fileNorm === wsNorm || fileNorm.startsWith(`${wsNorm}/`);
+}
+
+function readSnapshotContent(historyDir, entryId) {
+  const snapshotPath = path.join(historyDir, entryId);
+  if (!fs.existsSync(snapshotPath)) return null;
+  try {
+    return fs.readFileSync(snapshotPath, 'utf-8');
+  } catch (_) {
+    return null;
+  }
+}
+
+function scanHistoryRoot(historyRoot, workspacePath, source) {
+  const events = [];
+  if (!fs.existsSync(historyRoot)) return events;
+
+  for (const entry of fs.readdirSync(historyRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+
+    const historyDir = path.join(historyRoot, entry.name);
+    const entriesPath = path.join(historyDir, 'entries.json');
+    if (!fs.existsSync(entriesPath)) continue;
+
+    let meta;
+    try {
+      meta = JSON.parse(fs.readFileSync(entriesPath, 'utf-8'));
+    } catch (_) {
+      continue;
+    }
+
+    const resourcePath = folderUriToPath(meta.resource);
+    if (!isUnderWorkspace(resourcePath, workspacePath)) continue;
+
+    const historyEntries = Array.isArray(meta.entries) ? [...meta.entries] : [];
+    historyEntries.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+
+    for (let i = 0; i < historyEntries.length; i++) {
+      const item = historyEntries[i];
+      const ts = normalizeTs(item.timestamp);
+      if (!ts) continue;
+
+      const summary = item.source || 'Local History snapshot';
+      const snapshot = readSnapshotContent(historyDir, item.id);
+      let diff = null;
+
+      if (snapshot != null && i > 0) {
+        const prev = readSnapshotContent(historyDir, historyEntries[i - 1].id);
+        if (prev != null && prev !== snapshot) {
+          const { makeUnifiedDiff } = require('./timeline');
+          diff = makeUnifiedDiff(prev, snapshot, path.basename(resourcePath || ''));
+        }
+      }
+
+      events.push({
+        ts,
+        kind: 'code_edit',
+        role: 'assistant',
+        source,
+        file: path.basename(resourcePath || ''),
+        path: resourcePath,
+        action: 'localHistory',
+        editSource: 'localHistory',
+        summary,
+        diff,
+        historyId: item.id,
+      });
+    }
+  }
+
+  return events;
+}
+
+function scanHistoryForWorkspace(workspacePath, options = {}) {
+  const roots = options.roots || HISTORY_ROOTS;
+  const events = [];
+
+  for (const { root, source } of roots) {
+    events.push(...scanHistoryRoot(root, workspacePath, source));
+  }
+
+  events.sort((a, b) => Date.parse(a.ts || '') - Date.parse(b.ts || ''));
+  return events;
+}
+
+module.exports = {
+  HISTORY_ROOTS,
+  getCodeHistoryRoots,
+  getCursorHistoryRoots,
+  scanHistoryForWorkspace,
+  scanHistoryRoot,
+  isUnderWorkspace,
+  enrichEditsWithHistory,
+  mergeCodeEditSources,
+};

package/backend/lib/vscodeWorkspace.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+
+const WORKSPACE_STORAGE_ROOTS = [
+  path.join(HOME, 'AppData', 'Roaming', 'Code', 'User', 'workspaceStorage'),
+  path.join(HOME, 'AppData', 'Roaming', 'Cursor', 'User', 'workspaceStorage'),
+  path.join(HOME, 'AppData', 'Roaming', 'Antigravity IDE', 'User', 'workspaceStorage'),
+  path.join(HOME, '.config', 'Code', 'User', 'workspaceStorage'),
+  path.join(HOME, '.config', 'Cursor', 'User', 'workspaceStorage'),
+];
+
+function normalizeWorkspacePath(p) {
+  return String(p || '')
+    .toLowerCase()
+    .replace(/\\/g, '/')
+    .replace(/\/$/, '');
+}
+
+function folderUriToPath(folderUri) {
+  if (!folderUri || typeof folderUri !== 'string') return null;
+  if (!folderUri.startsWith('file:///')) return null;
+  try {
+    const decoded = decodeURIComponent(folderUri.replace('file:///', ''));
+    return decoded.replace(/\//g, path.sep);
+  } catch (_) {
+    return null;
+  }
+}
+
+function discoverWorkspaceStorageDir(workspacePath, roots = WORKSPACE_STORAGE_ROOTS) {
+  const target = normalizeWorkspacePath(workspacePath);
+
+  for (const root of roots) {
+    if (!fs.existsSync(root)) continue;
+
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+
+      const workspaceJsonPath = path.join(root, entry.name, 'workspace.json');
+      if (!fs.existsSync(workspaceJsonPath)) continue;
+
+      try {
+        const { folder } = JSON.parse(fs.readFileSync(workspaceJsonPath, 'utf-8'));
+        const folderPath = folderUriToPath(folder);
+        if (folderPath && normalizeWorkspacePath(folderPath) === target) {
+          return path.join(root, entry.name);
+        }
+      } catch (_) { }
+    }
+  }
+
+  return null;
+}
+
+function getWorkspacePathFromStorageDir(workspaceStorageDir) {
+  if (!workspaceStorageDir) return null;
+  const workspaceJsonPath = path.join(workspaceStorageDir, 'workspace.json');
+  if (!fs.existsSync(workspaceJsonPath)) return null;
+
+  try {
+    const { folder } = JSON.parse(fs.readFileSync(workspaceJsonPath, 'utf-8'));
+    return folderUriToPath(folder);
+  } catch (_) {
+    return null;
+  }
+}
+
+module.exports = {
+  normalizeWorkspacePath,
+  folderUriToPath,
+  discoverWorkspaceStorageDir,
+  getWorkspacePathFromStorageDir,
+  WORKSPACE_STORAGE_ROOTS,
+};

package/backend/mcp/server.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+/**
+ * Relay MCP server — agents explore .relay via tools (local files or remote API).
+ *
+ * Local:  RELAY_WORKSPACE_PATH=/path/to/project
+ * Remote: RELAY_API_URL=https://api.relay.dev  RELAY_API_KEY=...
+ */
+const readline = require('readline');
+const path = require('path');
+
+const BACKEND = path.join(__dirname, '..');
+const store = require(path.join(BACKEND, 'lib', 'relayStore'));
+const { syncWorkspace, getRelayContext } = require(path.join(BACKEND, 'relay'));
+
+const MODE = process.env.RELAY_API_URL ? 'remote' : 'local';
+const WORKSPACE = process.env.RELAY_WORKSPACE_PATH
+  ? path.resolve(process.env.RELAY_WORKSPACE_PATH)
+  : process.cwd();
+const API_URL = (process.env.RELAY_API_URL || '').replace(/\/$/, '');
+const API_KEY = process.env.RELAY_API_KEY || '';
+
+const TOOLS = [
+  {
+    name: 'relay_list_files',
+    description: 'List files and folders inside the project .relay directory. Use path="" for root.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Relative path within .relay (empty for root)' },
+      },
+    },
+  },
+  {
+    name: 'relay_read_file',
+    description: 'Read any file inside .relay (markdown, json, etc.).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Relative file path, e.g. relay_context.md' },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'relay_write_file',
+    description: 'Write or update a file inside .relay (IR markdown, etc.).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Relative file path' },
+        content: { type: 'string', description: 'Full file content' },
+      },
+      required: ['path', 'content'],
+    },
+  },
+  {
+    name: 'relay_get_context',
+    description: 'Regenerate and return relay_context.md handoff bundle.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'relay_sync',
+    description: 'Sync agent transcripts into memory.json and refresh compile brief.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+];
+
+async function apiFetch(method, urlPath, body) {
+  const headers = { 'Content-Type': 'application/json' };
+  if (API_KEY) headers.Authorization = `Bearer ${API_KEY}`;
+
+  const res = await fetch(`${API_URL}${urlPath}`, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || res.statusText);
+  return data;
+}
+
+async function listFiles(subPath) {
+  if (MODE === 'remote') {
+    const q = new URLSearchParams({
+      workspacePath: WORKSPACE,
+      path: subPath || '',
+    });
+    const data = await apiFetch('GET', `/api/relay/files?${q}`);
+    return data;
+  }
+  return store.listRelayFiles(WORKSPACE, subPath || '');
+}
+
+async function readFile(relPath) {
+  if (MODE === 'remote') {
+    const q = new URLSearchParams({ workspacePath: WORKSPACE, path: relPath });
+    const data = await apiFetch('GET', `/api/relay/file?${q}`);
+    return data.file;
+  }
+  return store.readRelayFile(WORKSPACE, relPath);
+}
+
+async function writeFile(relPath, content) {
+  if (MODE === 'remote') {
+    const data = await apiFetch('PUT', '/api/relay/file', {
+      workspacePath: WORKSPACE,
+      path: relPath,
+      content,
+    });
+    return data.file;
+  }
+  return store.writeRelayFile(WORKSPACE, relPath, content);
+}
+
+async function getContext() {
+  if (MODE === 'remote') {
+    const q = new URLSearchParams({ workspacePath: WORKSPACE });
+    const data = await apiFetch('GET', `/api/context?${q}`);
+    return { markdown: data.markdown, context: data.context };
+  }
+  return getRelayContext(WORKSPACE);
+}
+
+async function syncRelay() {
+  if (MODE === 'remote') {
+    return apiFetch('POST', '/api/sync', { workspacePath: WORKSPACE });
+  }
+  const result = syncWorkspace(WORKSPACE);
+  getRelayContext(WORKSPACE);
+  return result;
+}
+
+async function callTool(name, args) {
+  switch (name) {
+    case 'relay_list_files': {
+      const listing = await listFiles(args.path || '');
+      return {
+        content: [{ type: 'text', text: JSON.stringify(listing, null, 2) }],
+      };
+    }
+    case 'relay_read_file': {
+      const file = await readFile(args.path);
+      return {
+        content: [{ type: 'text', text: file.content }],
+      };
+    }
+    case 'relay_write_file': {
+      const file = await writeFile(args.path, args.content);
+      return {
+        content: [{ type: 'text', text: `Wrote ${file.path} (${file.size} bytes)` }],
+      };
+    }
+    case 'relay_get_context': {
+      const result = await getContext();
+      return {
+        content: [{ type: 'text', text: result.markdown || '' }],
+      };
+    }
+    case 'relay_sync': {
+      const result = await syncRelay();
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+      };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+function send(msg) {
+  process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+
+function handleRequest(req) {
+  const { id, method, params } = req;
+
+  if (method === 'initialize') {
+    send({
+      jsonrpc: '2.0',
+      id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'relay-os', version: '0.1.0' },
+      },
+    });
+    return;
+  }
+
+  if (method === 'notifications/initialized') return;
+
+  if (method === 'tools/list') {
+    send({ jsonrpc: '2.0', id, result: { tools: TOOLS } });
+    return;
+  }
+
+  if (method === 'tools/call') {
+    callTool(params.name, params.arguments || {})
+      .then((result) => send({ jsonrpc: '2.0', id, result }))
+      .catch((err) =>
+        send({
+          jsonrpc: '2.0',
+          id,
+          result: { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true },
+        })
+      );
+    return;
+  }
+
+  if (id !== undefined) {
+    send({ jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${method}` } });
+  }
+}
+
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+rl.on('line', (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  try {
+    handleRequest(JSON.parse(trimmed));
+  } catch (err) {
+    send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: err.message } });
+  }
+});
+
+process.stderr.write(
+  `relay-mcp started (${MODE} mode, workspace: ${WORKSPACE})\n`
+);

package/backend/node_modules/.bin/mime

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../mime/cli.js" "$@"
+else 
+  exec node  "$basedir/../mime/cli.js" "$@"
+fi

package/backend/node_modules/.bin/mime.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\mime\cli.js" %*

package/backend/node_modules/.bin/mime.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../mime/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../mime/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../mime/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../mime/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret