memoryrouter-codex 1.0.0

package/runtime/memory.cjs

@@ -0,0 +1,207 @@
+'use strict';
+
+const crypto = require('crypto');
+const api = require('./api.cjs');
+const { ENVELOPE_HEADER } = require('./constants.cjs');
+const { loadConfig, getApiKey, forgetHandle, recordAudit } = require('./config.cjs');
+const { resolveProject } = require('./project.cjs');
+
+function normalizeContent(content) {
+  return String(content || '').replace(/\r\n/g, '\n').replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+function memoryHandle(projectHandle, kind, content) {
+  const digest = crypto.createHash('sha256')
+    .update(`memoryrouter-codex-memory-v1\0${projectHandle}\0${kind}\0${normalizeContent(content)}`)
+    .digest('hex');
+  return `mrh_${digest.slice(0, 24)}`;
+}
+
+function scopeStamp(projectHandle, handle) {
+  return `[MR_SCOPE project=${projectHandle} handle=${handle}]`;
+}
+
+function stampBody(content, projectHandle, handle, interval = 800) {
+  const text = normalizeContent(content);
+  if (!text) return text;
+  const stamp = scopeStamp(projectHandle, handle);
+  const parts = [];
+  for (let offset = 0; offset < text.length; offset += interval) {
+    parts.push(`${stamp}\n${text.slice(offset, offset + interval)}`);
+  }
+  return parts.join('\n');
+}
+
+function envelope({ projectHandle, handle, kind = 'note', content, capturedAt = new Date().toISOString(), tags = [] }) {
+  const safeTags = tags.map(value => String(value).replace(/[\n,]/g, '-')).filter(Boolean).slice(0, 20);
+  return [
+    ENVELOPE_HEADER,
+    `project: ${projectHandle}`,
+    'scope: project',
+    `handle: ${handle}`,
+    `kind: ${kind}`,
+    `captured_at: ${capturedAt}`,
+    safeTags.length ? `tags: ${safeTags.join(',')}` : null,
+    '---',
+    stampBody(content, projectHandle, handle),
+  ].filter(Boolean).join('\n');
+}
+
+function parseEnvelope(content) {
+  const text = String(content || '');
+  const headerProject = text.match(/^project:\s*(proj_[a-f0-9]+)\s*$/m)?.[1];
+  const headerHandle = text.match(/^handle:\s*(mrh_[a-f0-9]+)\s*$/m)?.[1];
+  const stamp = text.match(/\[MR_SCOPE project=(proj_[a-f0-9]+) handle=(mrh_[a-f0-9]+)\]/);
+  const project = headerProject || stamp?.[1];
+  const handle = headerHandle || stamp?.[2];
+  if (!project || !handle) return null;
+  const kind = text.match(/^kind:\s*([^\n]+)$/m)?.[1]?.trim();
+  const separator = text.indexOf('\n---\n');
+  const rawBody = separator >= 0 ? text.slice(separator + 5) : text;
+  const body = rawBody.replace(/^\[MR_SCOPE project=proj_[a-f0-9]+ handle=mrh_[a-f0-9]+\]\n?/gm, '');
+  return { project, handle, kind, body };
+}
+
+function filterMemories(memories, projectHandle, config) {
+  const scope = config.retrievalScope || 'project';
+  const forgotten = new Set(config.forgottenHandles || []);
+  return (Array.isArray(memories) ? memories : []).filter(memory => {
+    const parsed = parseEnvelope(memory.content);
+    if (parsed && forgotten.has(parsed.handle)) return false;
+    if (scope === 'vault') return true;
+    return parsed?.project === projectHandle;
+  });
+}
+
+function formatContext(memories, projectHandle, maxChars) {
+  const prefix = [
+    'MemoryRouter recalled the following project-scoped context from prior work.',
+    `Project handle: ${projectHandle}. Memory handles are stable references.`,
+    'Use this as recollection; current repository state and explicit user directions take precedence.',
+  ].join('\n');
+  let output = prefix;
+  for (const memory of memories) {
+    const parsed = parseEnvelope(memory.content);
+    const body = parsed ? parsed.body : String(memory.content || '');
+    const handle = parsed?.handle || memory.id || 'unhandled';
+    const timestamp = memory.timestampHuman || (memory.timestamp ? new Date(memory.timestamp).toISOString() : 'unknown time');
+    const chunk = `\n\n[${handle} | ${timestamp}]\n${body.slice(0, 5000)}`;
+    if (output.length + chunk.length > maxChars) break;
+    output += chunk;
+  }
+  return output === prefix ? '' : output;
+}
+
+async function searchScoped(query, options = {}) {
+  const config = options.config || loadConfig(options.env);
+  const key = options.key || getApiKey(options.env, config);
+  if (!key) {
+    recordAudit('search', { ok: false, reason: 'no-api-key' }, options.env);
+    return { ok: false, reason: 'no-api-key', memories: [], context: '' };
+  }
+  const project = options.project || resolveProject(options.cwd);
+  const limit = Math.max(1, Math.min(50, Number(options.limit || config.maxSearchResults || 12)));
+  const response = await api.search(
+    key,
+    `${normalizeContent(query)}\nMemoryRouter project handle ${project.handle}`,
+    limit,
+    {
+      apiBase: config.apiBase,
+      sessionId: options.sessionId,
+      timeoutMs: options.timeoutMs || 5500,
+      retries: options.retries,
+    },
+  );
+  if (!response.ok) {
+    recordAudit('search', { ok: false, status: response.status, project: project.handle }, options.env);
+    return { ok: false, status: response.status, memories: [], context: '' };
+  }
+  const memories = filterMemories(response.data?.memories, project.handle, config);
+  recordAudit('search', { ok: true, project: project.handle, candidates: response.data?.memories?.length || 0, returned: memories.length }, options.env);
+  return {
+    ok: true,
+    project,
+    memories,
+    context: formatContext(memories, project.handle, Number(config.contextChars || 12000)),
+  };
+}
+
+async function storeScoped(content, options = {}) {
+  const config = options.config || loadConfig(options.env);
+  const key = options.key || getApiKey(options.env, config);
+  if (!key) {
+    recordAudit('store', { ok: false, reason: 'no-api-key' }, options.env);
+    return { ok: false, reason: 'no-api-key' };
+  }
+  const project = options.project || resolveProject(options.cwd);
+  const normalized = normalizeContent(content);
+  if (!normalized) return { ok: false, reason: 'empty-content' };
+  const kind = options.kind || 'note';
+  const handle = options.handle || memoryHandle(project.handle, kind, normalized);
+
+  if (!options.skipRemoteDedupe) {
+    try {
+      const duplicate = await api.search(key, handle, 5, {
+        apiBase: config.apiBase,
+        timeoutMs: options.searchTimeoutMs || 3500,
+        retries: 1,
+      });
+      const found = duplicate.data?.memories?.find(memory => parseEnvelope(memory.content)?.handle === handle);
+      if (found) {
+        recordAudit('store', { ok: true, stored: false, deduplicated: true, project: project.handle, handle, kind }, options.env);
+        return { ok: true, stored: false, deduplicated: true, handle, project };
+      }
+    } catch { /* write can proceed when dedupe lookup is offline */ }
+  }
+
+  const wrapped = envelope({
+    projectHandle: project.handle,
+    handle,
+    kind,
+    content: normalized,
+    tags: options.tags || [],
+  });
+  const sessionId = options.sessionId || `mrcodex:${project.handle}:manual`;
+  const response = await api.ingest(key, [{ role: 'user', content: wrapped }], sessionId, {
+    apiBase: config.apiBase,
+    timeoutMs: options.timeoutMs || 12000,
+  });
+  const stored = Boolean(response.ok && response.data?.accepted !== false);
+  recordAudit('store', { ok: response.ok, status: response.status, stored, deduplicated: false, project: project.handle, handle, kind }, options.env);
+  return {
+    ok: response.ok,
+    status: response.status,
+    stored,
+    deduplicated: false,
+    handle,
+    project,
+  };
+}
+
+function forgetLocally(handle, options = {}) {
+  if (!/^mrh_[a-f0-9]{8,64}$/.test(String(handle || ''))) {
+    return { ok: false, reason: 'invalid-handle' };
+  }
+  forgetHandle(handle, options.env);
+  recordAudit('forget-local', { ok: true, handle, deleted: false }, options.env);
+  return {
+    ok: true,
+    handle,
+    deleted: false,
+    message: 'Suppressed from MemoryRouter Codex retrieval on this machine. The server record was not deleted because the current MemoryRouter API has no per-memory delete endpoint.',
+  };
+}
+
+module.exports = {
+  normalizeContent,
+  memoryHandle,
+  scopeStamp,
+  stampBody,
+  envelope,
+  parseEnvelope,
+  filterMemories,
+  formatContext,
+  searchScoped,
+  storeScoped,
+  forgetLocally,
+};

package/runtime/project.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync } = require('child_process');
+
+function git(cwd, args) {
+  try {
+    return execFileSync('git', ['-C', cwd, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 2000,
+    }).trim();
+  } catch { return ''; }
+}
+
+function normalizeRemote(remote) {
+  let value = String(remote || '').trim();
+  value = value.replace(/^([^@/]+)@([^:]+):/, 'ssh://$2/');
+  try {
+    const url = new URL(value);
+    url.username = '';
+    url.password = '';
+    value = `${url.protocol}//${url.host}${url.pathname}`;
+  } catch { /* local/file-like remote */ }
+  return value.replace(/\\/g, '/').replace(/\.git\/?$/i, '').replace(/\/+$/, '').toLowerCase();
+}
+
+function resolveProject(cwd = process.cwd()) {
+  const absoluteCwd = path.resolve(cwd);
+  const root = git(absoluteCwd, ['rev-parse', '--show-toplevel']) || absoluteCwd;
+  const remote = normalizeRemote(git(root, ['remote', 'get-url', 'origin']));
+  const commonDir = git(root, ['rev-parse', '--git-common-dir']);
+  const canonical = remote
+    ? `remote:${remote}`
+    : commonDir
+      ? `git:${path.resolve(root, commonDir)}`
+      : `path:${root}`;
+  const digest = crypto.createHash('sha256')
+    .update(`memoryrouter-codex-project-v1\0${canonical}`)
+    .digest('hex');
+  return {
+    handle: `proj_${digest.slice(0, 20)}`,
+    root,
+    source: remote ? 'git-remote' : commonDir ? 'git-common-dir' : 'path',
+    portable: Boolean(remote),
+  };
+}
+
+module.exports = { git, normalizeRemote, resolveProject };