@lotargo/memory_plugin 1.6.2 → 1.6.4

package/mcp-server/codex_config.js

@@ -0,0 +1,171 @@
+import { existsSync } from "node:fs";
+
+export const MIN_NODE_VERSION = Object.freeze({ major: 22, minor: 5, patch: 0 });
+export const DEFAULT_CODEX_STARTUP_TIMEOUT_SEC = 60;
+
+function parseVersion(version) {
+  const match = String(version || "").trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)(?:\.(\d+))?/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3] || 0),
+  };
+}
+
+export function isSupportedNodeVersion(version) {
+  const parsed = parseVersion(version);
+  if (!parsed) return false;
+  if (parsed.major !== MIN_NODE_VERSION.major) return parsed.major > MIN_NODE_VERSION.major;
+  if (parsed.minor !== MIN_NODE_VERSION.minor) return parsed.minor > MIN_NODE_VERSION.minor;
+  return parsed.patch >= MIN_NODE_VERSION.patch;
+}
+
+export function validateCodexRuntime({
+  nodePath,
+  nodeVersion = process.versions.node,
+  bootPath,
+  pathExists = existsSync,
+} = {}) {
+  const errors = [];
+  if (!nodePath || !pathExists(nodePath)) {
+    errors.push(`Node executable not found: ${nodePath || "<empty>"}`);
+  }
+  if (!isSupportedNodeVersion(nodeVersion)) {
+    errors.push(
+      `@lotargo/memory_plugin requires Node.js >= ${MIN_NODE_VERSION.major}.${MIN_NODE_VERSION.minor}.0; detected ${nodeVersion || "unknown"}`
+    );
+  }
+  if (!bootPath || !pathExists(bootPath)) {
+    errors.push(`MCP boot entry point not found: ${bootPath || "<empty>"}`);
+  }
+  return { ok: errors.length === 0, errors, nodePath, nodeVersion, bootPath };
+}
+
+export function escapeTomlBasicString(value) {
+  return String(value)
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\u0008/g, "\\b")
+    .replace(/\t/g, "\\t")
+    .replace(/\n/g, "\\n")
+    .replace(/\f/g, "\\f")
+    .replace(/\r/g, "\\r");
+}
+
+export function buildCodexMemoryAgentSection({
+  nodePath,
+  bootPath,
+  startupTimeoutSec = DEFAULT_CODEX_STARTUP_TIMEOUT_SEC,
+} = {}) {
+  if (!nodePath || !bootPath) throw new Error("nodePath and bootPath are required");
+  if (!Number.isInteger(startupTimeoutSec) || startupTimeoutSec <= 0) {
+    throw new Error("startupTimeoutSec must be a positive integer");
+  }
+  return [
+    "[mcp_servers.memory-agent]",
+    `command = "${escapeTomlBasicString(nodePath)}"`,
+    `args = ["${escapeTomlBasicString(bootPath)}"]`,
+    `startup_timeout_sec = ${startupTimeoutSec}`,
+  ].join("\n");
+}
+
+function tableHeaderName(line) {
+  const match = String(line).match(/^\s*\[\s*([^\[\]]+?)\s*\]\s*(?:#.*)?$/);
+  return match ? match[1] : null;
+}
+
+function isMemoryAgentHeader(name, { exact = false } = {}) {
+  if (!name) return false;
+  const suffix = exact ? "$" : "(?:\\s*\\.|$)";
+  return new RegExp(
+    `^mcp_servers\\s*\\.\\s*(?:memory-agent|"memory-agent"|'memory-agent')${suffix}`,
+    "i"
+  ).test(name);
+}
+
+export function isMemoryPluginOwnedSection(sectionText) {
+  return /@lotargo[\\/]memory_plugin|opencode-memory-plugin|(?:^|[\\/])memory_plugin(?:[\\/]|\b)|mcp-server[\\/]+boot\.js/i.test(
+    String(sectionText || "")
+  );
+}
+
+function sectionRanges(lines) {
+  const headers = [];
+  for (let i = 0; i < lines.length; i++) {
+    const name = tableHeaderName(lines[i]);
+    if (name) headers.push({ start: i, name });
+  }
+  return headers.map((header, index) => ({
+    ...header,
+    end: index + 1 < headers.length ? headers[index + 1].start : lines.length,
+  }));
+}
+
+export function getCodexMemoryAgentSections(content) {
+  const lines = String(content || "").split(/\r?\n/);
+  return sectionRanges(lines)
+    .filter((range) => isMemoryAgentHeader(range.name))
+    .map((range) => ({
+      ...range,
+      exact: isMemoryAgentHeader(range.name, { exact: true }),
+      text: lines.slice(range.start, range.end).join("\n").trimEnd(),
+    }));
+}
+
+export function updateCodexMemoryAgentConfig(content, options) {
+  const source = String(content || "");
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const lines = source.split(/\r?\n/);
+  const desired = buildCodexMemoryAgentSection(options).split("\n");
+  const ranges = sectionRanges(lines);
+  const targets = ranges.filter((range) => isMemoryAgentHeader(range.name));
+  const exactTargets = targets.filter((range) => isMemoryAgentHeader(range.name, { exact: true }));
+
+  const unowned = exactTargets.filter((range) => {
+    const text = lines.slice(range.start, range.end).join("\n");
+    return !isMemoryPluginOwnedSection(text);
+  });
+  if (unowned.length > 0) {
+    return {
+      content: source,
+      changed: false,
+      status: "conflict",
+      reason: "Existing [mcp_servers.memory-agent] section is not recognized as owned by @lotargo/memory_plugin",
+    };
+  }
+
+  if (targets.length === 0) {
+    const prefix = source.length === 0 ? "" : source.replace(/[\r\n]+$/, "") + eol + eol;
+    return { content: prefix + desired.join(eol) + eol, changed: true, status: "added" };
+  }
+
+  const targetStarts = new Map(targets.map((target) => [target.start, target]));
+  const targetLineIndexes = new Set();
+  for (const target of targets) {
+    for (let i = target.start; i < target.end; i++) targetLineIndexes.add(i);
+  }
+
+  const firstStart = Math.min(...targets.map((target) => target.start));
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (i === firstStart) {
+      while (result.length > 0 && result[result.length - 1] === "") result.pop();
+      if (result.length > 0) result.push("");
+      result.push(...desired, "");
+    }
+    if (targetLineIndexes.has(i)) continue;
+    if (targetStarts.has(i)) continue;
+    result.push(lines[i]);
+  }
+
+  while (result.length > 1 && result[result.length - 1] === "" && result[result.length - 2] === "") {
+    result.pop();
+  }
+  const updated = result.join(eol);
+  return {
+    content: updated,
+    changed: updated !== source,
+    status: updated === source ? "unchanged" : "migrated",
+  };
+}

package/mcp-server/codex_diagnostics.js

@@ -0,0 +1,263 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getCodexMemoryAgentSections, isSupportedNodeVersion } from "./codex_config.js";
+
+function decodeTomlString(raw) {
+  const value = String(raw || "").trim();
+  if (value.startsWith('"')) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1).replace(/''/g, "'");
+  return null;
+}
+
+export function parseCodexMemoryAgentConfig(content) {
+  const exact = getCodexMemoryAgentSections(content).filter((section) => section.exact);
+  if (exact.length !== 1) {
+    return {
+      ok: false,
+      error: exact.length === 0
+        ? "[mcp_servers.memory-agent] section not found"
+        : `Found ${exact.length} memory-agent sections`,
+      sectionCount: exact.length,
+    };
+  }
+
+  const text = exact[0].text;
+  const commandMatch = text.match(/^\s*command\s*=\s*(.+?)\s*$/m);
+  const argsMatch = text.match(/^\s*args\s*=\s*\[([\s\S]*?)\]\s*$/m);
+  const timeoutMatch = text.match(/^\s*startup_timeout_sec\s*=\s*(\d+)\s*$/m);
+  const command = decodeTomlString(commandMatch?.[1]);
+  const args = [];
+  if (argsMatch) {
+    const stringPattern = /"(?:\\.|[^"\\])*"|'(?:''|[^'])*'/g;
+    for (const match of argsMatch[1].matchAll(stringPattern)) {
+      const decoded = decodeTomlString(match[0]);
+      if (decoded === null) return { ok: false, error: "Unable to parse memory-agent args", sectionCount: 1 };
+      args.push(decoded);
+    }
+  }
+
+  if (!command) return { ok: false, error: "Unable to parse memory-agent command", sectionCount: 1 };
+  if (!argsMatch) return { ok: false, error: "Unable to parse memory-agent args", sectionCount: 1 };
+  return {
+    ok: true,
+    command,
+    args,
+    startupTimeoutSec: timeoutMatch ? Number(timeoutMatch[1]) : null,
+    sectionCount: 1,
+    text,
+  };
+}
+
+function toolText(result) {
+  return (result?.content || [])
+    .filter((item) => item.type === "text")
+    .map((item) => item.text)
+    .join("\n");
+}
+
+export async function runDirectMcpSmoke({
+  command,
+  args = [],
+  cwd = process.cwd(),
+  env = process.env,
+  timeoutMs = 30_000,
+} = {}) {
+  if (!command) throw new Error("MCP command is required");
+  const child = spawn(command, args, { cwd, env: { ...env }, stdio: ["pipe", "pipe", "pipe"] });
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+
+  let nextId = 0;
+  let stdoutBuffer = "";
+  let stderr = "";
+  let settled = false;
+  const pending = new Map();
+
+  const rejectAll = (error) => {
+    for (const { reject } of pending.values()) reject(error);
+    pending.clear();
+  };
+  child.stderr.on("data", (chunk) => { stderr += chunk; });
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk;
+    let newline;
+    while ((newline = stdoutBuffer.indexOf("\n")) >= 0) {
+      const line = stdoutBuffer.slice(0, newline).trim();
+      stdoutBuffer = stdoutBuffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (error) {
+        rejectAll(new Error(`Invalid JSON-RPC output: ${error.message}; line=${line.slice(0, 200)}`));
+        continue;
+      }
+      const waiter = pending.get(message.id);
+      if (!waiter) continue;
+      pending.delete(message.id);
+      if (message.error) waiter.reject(new Error(message.error.message || JSON.stringify(message.error)));
+      else waiter.resolve(message.result);
+    }
+  });
+  child.on("error", (error) => rejectAll(error));
+  child.on("exit", (code, signal) => {
+    if (!settled && pending.size > 0) {
+      rejectAll(new Error(`MCP server exited before completing diagnostics (code=${code}, signal=${signal}): ${stderr.trim()}`));
+    }
+  });
+
+  const request = (method, params = {}) => {
+    const id = ++nextId;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    });
+  };
+  const withTimeout = (promise, label) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Timed out waiting for ${label} after ${timeoutMs}ms`)), timeoutMs);
+    promise.then(
+      (value) => { clearTimeout(timer); resolve(value); },
+      (error) => { clearTimeout(timer); reject(error); }
+    );
+  });
+
+  try {
+    await withTimeout(request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "memory-plugin-codex-doctor", version: "1.0.0" },
+    }), "initialize");
+    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }) + "\n");
+
+    const toolsResult = await withTimeout(request("tools/list"), "tools/list");
+    const toolNames = (toolsResult?.tools || []).map((tool) => tool.name);
+    for (const required of ["memory_info", "recall"]) {
+      if (!toolNames.includes(required)) throw new Error(`Required MCP tool is missing: ${required}`);
+    }
+    const infoResult = await withTimeout(
+      request("tools/call", { name: "memory_info", arguments: {} }),
+      "memory_info"
+    );
+    const recallResult = await withTimeout(
+      request("tools/call", { name: "recall", arguments: { scope: "all" } }),
+      "recall(scope=all)"
+    );
+    settled = true;
+    return {
+      ok: true,
+      toolNames,
+      memoryInfo: toolText(infoResult),
+      recall: toolText(recallResult),
+      stderr: stderr.trim(),
+    };
+  } finally {
+    settled = true;
+    rejectAll(new Error("MCP diagnostics finished"));
+    if (child.exitCode === null) child.kill();
+  }
+}
+
+function countOccurrences(text, needle) {
+  let count = 0;
+  let offset = 0;
+  while ((offset = text.indexOf(needle, offset)) !== -1) {
+    count++;
+    offset += needle.length;
+  }
+  return count;
+}
+
+export async function runCodexDoctor({
+  home = homedir(),
+  cwd = process.cwd(),
+  env = process.env,
+  output = console,
+} = {}) {
+  const checks = [];
+  const record = (level, label, detail = "") => {
+    checks.push({ level, label, detail });
+    output.log(`[${level}] ${label}${detail ? `: ${detail}` : ""}`);
+  };
+
+  const configPath = join(home, ".codex", "config.toml");
+  if (!existsSync(configPath)) {
+    record("FAIL", "Codex config found", configPath);
+    return { ok: false, checks, configPath };
+  }
+  record("OK", "Codex config found", configPath);
+  const config = readFileSync(configPath, "utf8");
+  const parsed = parseCodexMemoryAgentConfig(config);
+  if (!parsed.ok) {
+    record("FAIL", "memory-agent configuration", parsed.error);
+    return { ok: false, checks, configPath };
+  }
+  record("OK", "Single memory-agent section found");
+  record(parsed.command.toLowerCase().includes("npx") ? "FAIL" : "OK", "Direct executable launcher", parsed.command);
+  record(existsSync(parsed.command) ? "OK" : "FAIL", "Command executable exists", parsed.command);
+
+  const bootPath = parsed.args[0];
+  record(bootPath && existsSync(bootPath) ? "OK" : "FAIL", "boot.js exists", bootPath || "missing first arg");
+  record(parsed.args.length === 1 ? "OK" : "FAIL", "boot.js is the only launcher argument", JSON.stringify(parsed.args));
+
+  let detectedVersion = null;
+  try {
+    detectedVersion = await new Promise((resolve, reject) => {
+      const child = spawn(parsed.command, ["--version"], { cwd, env: { ...env }, stdio: ["ignore", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.setEncoding("utf8");
+      child.stderr.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => { stdout += chunk; });
+      child.stderr.on("data", (chunk) => { stderr += chunk; });
+      child.on("error", reject);
+      child.on("exit", (code) => code === 0 ? resolve(stdout.trim()) : reject(new Error(stderr.trim() || `exit ${code}`)));
+    });
+    record(isSupportedNodeVersion(detectedVersion) ? "OK" : "FAIL", "Node.js version >= 22.5.0", detectedVersion);
+  } catch (error) {
+    record("FAIL", "Node.js version check", error.message);
+  }
+
+  try {
+    const smoke = await runDirectMcpSmoke({ command: parsed.command, args: parsed.args, cwd, env });
+    record("OK", "MCP initialize");
+    record("OK", "MCP tools/list", `${smoke.toolNames.length} tools`);
+    record("OK", "memory_info tool call");
+    record("OK", "recall(scope=all) tool call");
+  } catch (error) {
+    record("FAIL", "Direct MCP protocol smoke test", error.message);
+  }
+
+  try {
+    const { resolveProjectIdentity } = await import("./identity.js");
+    const identity = await resolveProjectIdentity(cwd);
+    record("INFO", "Current project identity", identity?.key || "none (global memory only)");
+  } catch (error) {
+    record("WARN", "Current project identity", error.message);
+  }
+
+  const agentsPath = join(home, ".codex", "AGENTS.md");
+  if (existsSync(agentsPath)) {
+    const agents = readFileSync(agentsPath, "utf8");
+    const starts = countOccurrences(agents, "<!-- START MEMORY AGENT PROMPT -->");
+    const ends = countOccurrences(agents, "<!-- END MEMORY AGENT PROMPT -->");
+    record(starts === 1 && ends === 1 ? "OK" : "WARN", "Codex memory prompt block count", `start=${starts}, end=${ends}`);
+  } else {
+    record("WARN", "Codex memory prompt", `${agentsPath} not found`);
+  }
+
+  record(
+    "INFO",
+    "Codex Desktop exposure",
+    "Cannot be proven by the MCP server; start a new task after setup and verify that memory-agent tools are listed"
+  );
+  const ok = !checks.some((check) => check.level === "FAIL");
+  return { ok, checks, configPath, parsed, detectedVersion };
+}

package/mcp-server/config/config_manager.js

@@ -17,7 +17,6 @@ export const DEFAULT_CONFIG = {
   onnxThreads: 0,          // ONNX WASM threads: 0 = auto-detect CPU cores, or 1-16
   executionDevice: "cpu",  // "cpu" | "webgpu"
   mode: "only-local",     // "only-local" | "only-cloud" | "hybrid-sync"
-  injectLimit: 10,
   conflictStrategy: "merge", // "merge" | "cloud-wins" | "local-wins"
   tursoUrl: "",           // Connection endpoint URL for Turso DB
   failoverUrl: "",        // Failover connection endpoint URL (Fly.io + LiteFS)

package/mcp-server/db/migrations.js

@@ -138,8 +138,8 @@ const MIGRATIONS = [
       `);
     },
   },
-  {
-    version: 5,
+  {
+    version: 5,
     name: "005_retrieval_policy",
     up: async (db) => {
       try {
@@ -151,9 +151,30 @@ const MIGRATIONS = [
       await db.exec(`
         CREATE INDEX IF NOT EXISTS idx_micro_chunks_retrieval_policy ON micro_chunks(retrieval_policy);
       `);
-    },
-  },
-];
+    },
+  },
+  {
+    version: 6,
+    name: "006_project_scoped_rag",
+    up: async (db) => {
+      await db.exec(`
+        CREATE TABLE IF NOT EXISTS document_scopes (
+          doc_id     TEXT NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+          scope_key  TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          PRIMARY KEY (doc_id, scope_key)
+        );
+      `);
+      await db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_document_scopes_scope ON document_scopes(scope_key, doc_id);
+      `);
+      await db.exec(`
+        INSERT OR IGNORE INTO document_scopes (doc_id, scope_key, created_at)
+        SELECT id, 'global', created_at FROM documents;
+      `);
+    },
+  },
+];
 
 export async function runMigrations(db) {
   let currentVersion = 0;