@lotargo/memory_plugin 1.6.6 → 1.6.8

package/mcp-server/cli/direct_commands.js

@@ -12,6 +12,45 @@ import {
 import { factBody } from "../fact_format.js";
 
 export async function handleDirectCommands(cliArgs) {
+  if (cliArgs[0] === "uninstall" || cliArgs.includes("uninstall") || cliArgs.includes("--uninstall")) {
+    const { runUninstall } = await import("../uninstall.js");
+    await runUninstall();
+    return true;
+  }
+
+  if (cliArgs[0] === "dev-link" || cliArgs[0] === "dev_link") {
+    const { runDevLink } = await import("../dev_link.js");
+    await runDevLink();
+    return true;
+  }
+
+  if (cliArgs[0] === "sync-persona" || cliArgs[0] === "sync_persona") {
+    const { syncPersonaPrompts } = await import("../prompt_manager.js");
+    const results = await syncPersonaPrompts();
+    console.log("\nPersona overlay synchronization:\n");
+    for (const result of results) {
+      console.log(`  - ${result.name}: ${result.status}${result.error ? ` (${result.error})` : ""}`);
+    }
+    console.log("");
+    if (results.some((result) => result.status === "failed")) process.exitCode = 1;
+    return true;
+  }
+
+  if (cliArgs[0] === "migrate-persona" || cliArgs[0] === "migrate_persona") {
+    const { migrateLegacyPersonaDirectives } = await import("../persona_migration.js");
+    const dryRun = cliArgs.includes("--dry-run");
+    const result = await migrateLegacyPersonaDirectives({ dryRun });
+    console.log(`\nPersona metadata migration${dryRun ? " (dry run)" : ""}:\n`);
+    console.log(`  Legacy directives found: ${result.changed}`);
+    for (const item of result.migrated) {
+      console.log(`  - ${item.title}${item.id ? ` (${item.id})` : ""}`);
+    }
+    console.log(dryRun
+      ? "\nNo files were changed.\n"
+      : "\nGlobal directives and managed client prompts are synchronized.\n");
+    return true;
+  }
+
   if (cliArgs[0] === "doctor" && cliArgs.includes("--codex")) {
     const { runCodexDoctor } = await import("../codex_diagnostics.js");
     console.log("\nCodex memory-agent diagnostics\n");

package/mcp-server/cli.js

@@ -13,6 +13,12 @@ import { handleDiagnosticsAction } from "./cli/handlers/diagnostics_actions.js";
 export async function runCli() {
   const cliArgs = process.argv.slice(2);
 
+  if (cliArgs.includes("uninstall") || cliArgs.includes("--uninstall")) {
+    const { runUninstall } = await import("./uninstall.js");
+    await runUninstall();
+    return;
+  }
+
   if (cliArgs.includes("--help") || cliArgs.includes("-h") || cliArgs[0] === "help") {
     console.log(`memory-cli — interactive control panel for @lotargo/memory_plugin
 
@@ -23,13 +29,18 @@ Usage:
   memory-cli auth-status
   memory-cli link|unlink|relink|identity [--dir <path>] [--remote <url>]
   memory-cli migrate_titles [--key <key>]
-  memory-cli enable-prompt | disable-prompt
-  memory-cli doctor --codex
+  memory-cli dev-link                Link the working repository for local development
+  memory-cli sync-persona            Synchronize global directives into client prompts
+  memory-cli migrate-persona [--dry-run]
+                                     Mark legacy global persona entries as directives
+  memory-cli enable-prompt | disable-prompt
+  memory-cli uninstall [--purge] [--purge-cache] [--dry-run] [--yes] [--opencode|--claude|--codex|--gemini|--antigravity]
+  memory-cli doctor --codex
 
 Options:
   -h, --help                         Show this help text`);
     return;
-  }
+  }
 
   const handled = await handleDirectCommands(cliArgs);
   if (handled) return;
@@ -279,9 +290,9 @@ async function showCategorySubmenu(category, config, stats, initialIndex = 0) {
     case "prompt":
       items = [
         {
-          label: "[PROMPT ENABLE] Enable Global Prompt (Antigravity / Codex / Claude)",
+          label: "[PROMPT ENABLE] Enable Global Prompt (Gemini / Antigravity / Codex / Claude)",
           value: "enable_prompt",
-          info: "Inject memory instructions into ~/.gemini/config/AGENTS.md, ~/.codex/AGENTS.md, ~/.claude/CLAUDE.md",
+          info: "Inject managed memory instructions into each supported client's global prompt file",
         },
         {
           label: "[PROMPT DISABLE] Disable Global Prompt",

package/mcp-server/cli_boot.js

@@ -32,6 +32,9 @@ if (major < MIN_MAJOR || (major === MIN_MAJOR && minor < MIN_MINOR)) {
 // Version is OK — hand off to the real CLI.
 import("./cli.js").then(m => {
   if (process.argv[1] && process.argv[1].includes("cli_boot.js")) {
-    m.runCli().catch((err) => console.error("CLI error:", err));
+    m.runCli().catch((err) => {
+      console.error("CLI error:", err);
+      process.exitCode = 1;
+    });
   }
 });

package/mcp-server/client_cli.js

@@ -0,0 +1,73 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, extname, join } from "node:path";
+
+function envValue(env, name) {
+  if (Object.prototype.hasOwnProperty.call(env || {}, name)) return env[name];
+  const key = Object.keys(env || {}).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : undefined;
+}
+
+export function resolveClientExecutable(name, {
+  env = process.env,
+  platform = process.platform,
+} = {}) {
+  if (String(env.MEMORY_PLUGIN_DISABLE_NATIVE_CLI || "") === "1") return null;
+  const pathValue = envValue(env, "PATH") || "";
+  const directories = pathValue.split(delimiter).filter(Boolean);
+  const extensions = platform === "win32"
+    ? (envValue(env, "PATHEXT") || ".EXE;.COM;.CMD;.BAT").split(";").filter(Boolean)
+    : [""];
+
+  for (const directory of directories) {
+    const base = join(directory, name);
+    const candidates = platform === "win32" && extname(base)
+      ? [base]
+      : extensions.map((extension) => `${base}${extension.toLowerCase()}`)
+        .concat(extensions.map((extension) => `${base}${extension.toUpperCase()}`));
+    for (const candidate of candidates) {
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+export function runClientCli(name, args, {
+  cwd = process.cwd(),
+  env = process.env,
+  platform = process.platform,
+  timeout = 20_000,
+} = {}) {
+  const executable = resolveClientExecutable(name, { env, platform });
+  if (!executable) {
+    return { available: false, ok: false, status: null, executable: null, stdout: "", stderr: "" };
+  }
+
+  const isWindowsShim = platform === "win32" && /\.(?:cmd|bat)$/i.test(executable);
+  const command = isWindowsShim ? (envValue(env, "ComSpec") || "cmd.exe") : executable;
+  const commandArgs = isWindowsShim ? ["/d", "/s", "/c", executable, ...args] : args;
+  const result = spawnSync(command, commandArgs, {
+    cwd,
+    env,
+    encoding: "utf-8",
+    timeout,
+    windowsHide: true,
+    shell: false,
+  });
+  return {
+    available: true,
+    ok: result.status === 0 && !result.error,
+    status: result.status,
+    executable,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+    error: result.error || null,
+  };
+}
+
+export function cliFailureMessage(result) {
+  if (!result?.available) return "client CLI is not installed or not available on PATH";
+  if (result.error) return result.error.message;
+  const detail = String(result.stderr || result.stdout || "").trim().split(/\r?\n/).pop();
+  return detail || `client CLI exited with status ${result.status}`;
+}

package/mcp-server/client_paths.js

@@ -0,0 +1,44 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function resolveClientPaths({
+  home = homedir(),
+  cwd = process.cwd(),
+  env = process.env,
+} = {}) {
+  const configHome = env.XDG_CONFIG_HOME || join(home, ".config");
+  const cacheHome = env.XDG_CACHE_HOME || join(home, ".cache");
+  const opencodeDir = env.OPENCODE_CONFIG_DIR || join(configHome, "opencode");
+  const agentConfigDir = join(configHome, "memory-agent");
+  const geminiDir = join(home, ".gemini");
+  const antigravityConfigDir = join(geminiDir, "config");
+
+  return {
+    home,
+    cwd,
+    configHome,
+    cacheHome,
+    opencodeDir,
+    opencodeConfigPath: join(opencodeDir, "opencode.json"),
+    opencodeCachePackages: join(cacheHome, "opencode", "packages"),
+    claudeConfigPath: join(home, ".claude.json"),
+    geminiDir,
+    geminiSettingsPath: join(geminiDir, "settings.json"),
+    geminiPromptPath: join(geminiDir, "GEMINI.md"),
+    geminiSkillsDir: join(geminiDir, "skills"),
+    // Antigravity intentionally uses its own legacy layout. Keep these paths
+    // separate from the real Gemini CLI settings above.
+    antigravityConfigDir,
+    antigravityMcpConfigPath: join(antigravityConfigDir, "mcp_config.json"),
+    geminiConfigDir: antigravityConfigDir,
+    geminiMcpConfigPath: join(antigravityConfigDir, "mcp_config.json"),
+    localAgentsDir: join(cwd, ".agents"),
+    localAgentsMcpConfigPath: join(cwd, ".agents", "mcp_config.json"),
+    codexDir: join(home, ".codex"),
+    codexConfigPath: join(home, ".codex", "config.toml"),
+    agentConfigDir,
+    promptFile: join(agentConfigDir, "prompt.md"),
+    promptStateFile: join(agentConfigDir, "prompt-state.json"),
+    promptBackupDir: join(agentConfigDir, "backups"),
+  };
+}

package/mcp-server/client_registration.js

@@ -0,0 +1,38 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { isMemoryPluginSpec } from "./dev_link.js";
+
+export const MEMORY_MCP_ENTRY = Object.freeze({
+  command: "npx",
+  args: Object.freeze(["-y", "@lotargo/memory_plugin"]),
+});
+
+export function isMemoryPluginEntry(entry) {
+  const spec = Array.isArray(entry)
+    ? entry[0]
+    : entry && typeof entry === "object"
+      ? entry.package
+      : entry;
+  return isMemoryPluginSpec(spec);
+}
+
+export function isMemoryMcpServerEntry(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const command = String(entry.command || "").replace(/\\/g, "/").toLowerCase();
+  const args = Array.isArray(entry.args)
+    ? entry.args.map((value) => String(value).replace(/\\/g, "/").toLowerCase())
+    : [];
+  return args.some((arg) => /^@lotargo\/memory_plugin(?:@[^/]+)?$/i.test(arg) || /^opencode-memory-plugin(?:@[^/]+)?$/i.test(arg))
+    || args.some((arg) => arg.endsWith("/mcp-server/boot.js") && arg.includes("memory"))
+    || /(?:^|\/)(?:memory_plugin|memory-agent)(?:\.(?:cmd|exe|ps1|bat))?$/i.test(command);
+}
+
+export async function readJsonConfig(filePath) {
+  if (!existsSync(filePath)) return {};
+  const raw = (await readFile(filePath, "utf-8")).replace(/^\uFEFF/, "");
+  const value = JSON.parse(raw);
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Expected a JSON object in ${filePath}`);
+  }
+  return value;
+}

package/mcp-server/codex_config.js

@@ -102,6 +102,44 @@ function sectionRanges(lines) {
   }));
 }
 
+function validateOwnedMemoryAgentTargets(lines, ranges) {
+  const targets = ranges.filter((range) => isMemoryAgentHeader(range.name));
+  if (targets.length === 0) return { targets, exactTargets: [], conflict: null };
+
+  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 || exactTargets.length === 0) {
+    return {
+      targets,
+      exactTargets,
+      conflict: "Existing memory-agent TOML section is not recognized as owned by @lotargo/memory_plugin",
+    };
+  }
+
+  let activeOwnedRoot = false;
+  for (const range of ranges) {
+    if (isMemoryAgentHeader(range.name, { exact: true })) {
+      const text = lines.slice(range.start, range.end).join("\n");
+      activeOwnedRoot = isMemoryPluginOwnedSection(text);
+    } else if (isMemoryAgentHeader(range.name)) {
+      if (!activeOwnedRoot) {
+        return {
+          targets,
+          exactTargets,
+          conflict: "A memory-agent child TOML section is not attached to an owned plugin section",
+        };
+      }
+    } else {
+      activeOwnedRoot = false;
+    }
+  }
+
+  return { targets, exactTargets, conflict: null };
+}
+
 export function getCodexMemoryAgentSections(content) {
   const lines = String(content || "").split(/\r?\n/);
   return sectionRanges(lines)
@@ -113,25 +151,65 @@ export function getCodexMemoryAgentSections(content) {
     }));
 }
 
+export function removeCodexMemoryAgentConfig(content) {
+  const source = String(content || "");
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const lines = source.split(/\r?\n/);
+  const ranges = sectionRanges(lines);
+  const { targets, conflict } = validateOwnedMemoryAgentTargets(lines, ranges);
+
+  if (targets.length === 0) {
+    return { content: source, changed: false, status: "not_found", removed: 0 };
+  }
+
+  if (conflict) {
+    return {
+      content: source,
+      changed: false,
+      status: "conflict",
+      reason: conflict,
+      removed: 0,
+    };
+  }
+
+  const targetLineIndexes = new Set();
+  for (const target of targets) {
+    let contentEnd = target.end;
+    while (contentEnd > target.start + 1 && lines[contentEnd - 1] === "") contentEnd--;
+    for (let i = target.start; i < contentEnd; i++) targetLineIndexes.add(i);
+  }
+
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (targetLineIndexes.has(i)) continue;
+    result.push(lines[i]);
+  }
+
+  let updated = result.join(eol);
+  if (updated.trim() === "") updated = "";
+
+  return {
+    content: updated,
+    changed: updated !== source,
+    status: updated !== source ? "removed" : "unchanged",
+    removed: targets.length,
+  };
+}
+
 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 { targets, conflict } = validateOwnedMemoryAgentTargets(lines, ranges);
 
-  const unowned = exactTargets.filter((range) => {
-    const text = lines.slice(range.start, range.end).join("\n");
-    return !isMemoryPluginOwnedSection(text);
-  });
-  if (unowned.length > 0) {
+  if (conflict) {
     return {
       content: source,
       changed: false,
       status: "conflict",
-      reason: "Existing [mcp_servers.memory-agent] section is not recognized as owned by @lotargo/memory_plugin",
+      reason: conflict,
     };
   }
 

package/mcp-server/db/database.js

@@ -10,7 +10,7 @@ import { createClient } from "@libsql/client";
 let dbInstance = null;
 let dbInitPromise = null;
 let dbLastFailAt = 0;
-const DB_FAIL_COOLDOWN_MS = 5_000;  // don't retry cloud init within 5s of a failure
+const DB_FAIL_COOLDOWN_MS = 5_000;
 
 export const STORAGE_DIR = join(MEMORY_DIR, "storage");
 export const BLOBS_DIR = join(STORAGE_DIR, "blobs");
@@ -34,8 +34,6 @@ class DatabaseWrapper {
 
     while (attempts < maxAttempts) {
       attempts++;
-      // A plain timer is enough here; an AbortController per attempt leaked its
-      // "abort" listener because it was never removed.
       let timeoutId = null;
       const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(
@@ -48,7 +46,6 @@ class DatabaseWrapper {
         const client = (this.usingFailover && this.failoverClient) ? this.failoverClient : this.cloudClient;
         const result = await Promise.race([fn(client), timeoutPromise]);
         clearTimeout(timeoutId);
-        // Successful operation, reset consecutive failures
         this.consecutiveFailures = 0;
         return result;
       } catch (err) {
@@ -58,12 +55,10 @@ class DatabaseWrapper {
           if (this.consecutiveFailures >= 3 && this.failoverClient && !this.usingFailover) {
             console.warn("[WARN] Turso is temporarily unreachable. Switching to LiteFS failover replica...");
             this.usingFailover = true;
-            // Retry the operation on the failover client
             return this.runWithRetry(fn);
           }
           throw err;
         }
-        // Small delay before retrying (exponential backoff / fixed delay)
         await new Promise((resolve) => setTimeout(resolve, 200));
       }
     }
@@ -156,16 +151,12 @@ async function openDatabase(customPath, mode) {
     localDb = new DatabaseSync(dbPath);
     localDb.exec("PRAGMA foreign_keys = ON;");
     localDb.exec("PRAGMA journal_mode = WAL;");
-    // Default busy_timeout is 0 => an immediate SQLITE_BUSY ("database is
-    // locked") whenever background sync, ingestion and MCP calls overlap.
     localDb.exec("PRAGMA busy_timeout = 5000;");
   }
 
   let cloudClient = null;
   let failoverClient = null;
   if (mode === "only-cloud" || mode === "hybrid-sync") {
-    // Resolve working cloud credentials. An env TURSO_API_TOKEN (which can only
-    // call the Platform API) is lazily minted into a per-database JWT here.
     const secrets = await resolveCloudSecrets();
     const tursoUrl = customPath && customPath.startsWith("libsql:") ? customPath : (secrets?.dbUrl || config.tursoUrl);
     const failoverUrl = config.failoverUrl || "";
@@ -182,8 +173,6 @@ async function openDatabase(customPath, mode) {
           authToken: token || undefined,
         });
       }
-      // In hybrid-sync mode, ensure remote schema is also fully migrated and up to date.
-      // Use a dedicated short-lived client so closing it doesn't kill the shared one.
       if (mode === "hybrid-sync") {
         const remoteClient = createClient({
           url: tursoUrl,
@@ -199,13 +188,22 @@ async function openDatabase(customPath, mode) {
   }
 
   const wrappedDb = new DatabaseWrapper(localDb, cloudClient, mode, failoverClient);
-
-  // Initialize/run migrations
   await runMigrations(wrappedDb);
 
+  // Upgrade path for RAG content ingested before portable cloud blobs existed.
+  // The backfill is content-addressed and uploads only hashes absent in Turso.
+  // Missing local files are simply reported/skipped; database availability must
+  // never depend on a legacy raw blob still being present on this machine.
+  if ((mode === "only-cloud" || mode === "hybrid-sync") && cloudClient) {
+    try {
+      const { backfillCloudBlobsFromLocal } = await import("./rag_blob_transport.js");
+      await backfillCloudBlobsFromLocal(wrappedDb);
+    } catch (err) {
+      console.warn("[WARN] RAG cloud blob backfill skipped:", err.message);
+    }
+  }
+
   if (!customPath) {
-    // Closing the previous instance before replacing it: otherwise a mode switch
-    // leaked the old DatabaseSync handle and Turso client.
     if (dbInstance && dbInstance !== wrappedDb) {
       try {
         dbInstance.close();
@@ -225,15 +223,10 @@ export async function getDatabase(customPath = null, forceMode = null) {
     if (dbInstance && dbInstance.mode === mode) {
       return dbInstance;
     }
-    // After a failed init, wait before retrying to avoid hammering cloud auth.
-    // Only cloud modes are throttled — reopening a local SQLite file is cheap
-    // and must never be blocked by an unrelated cloud failure.
     const isCloudMode = mode === "only-cloud" || mode === "hybrid-sync";
     if (isCloudMode && !dbInitPromise && dbLastFailAt && (Date.now() - dbLastFailAt) < DB_FAIL_COOLDOWN_MS) {
       throw new Error("Database initialization failed recently. Retrying in a few seconds...");
     }
-    // Deduplicate concurrent default-DB initialization so migrations never run
-    // on multiple connections at once (avoids "database is locked" crashes).
     if (!dbInitPromise) {
       dbInitPromise = openDatabase(null, mode).then((result) => {
         dbLastFailAt = 0;