@lotargo/memory_plugin 1.6.6 → 1.6.8

package/mcp-server/dev_link.js

@@ -0,0 +1,142 @@
+import { copyFile, cp, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolveClientPaths } from "./client_paths.js";
+
+export const PACKAGE_NAME = "@lotargo/memory_plugin";
+export const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+export const DEV_PLUGIN_FILE = join(REPO_ROOT, "opencode-plugin", "main.js");
+
+const LEGACY_PACKAGE_NAMES = new Set([
+  PACKAGE_NAME,
+  "opencode-memory-plugin",
+  "memory_plugin",
+  "memory-plugin",
+]);
+
+function pluginSpec(entry) {
+  return Array.isArray(entry) ? entry[0] : entry;
+}
+
+export function isMemoryPluginSpec(spec, devPluginUrl = pathToFileURL(DEV_PLUGIN_FILE).href) {
+  if (typeof spec !== "string") return false;
+  if (LEGACY_PACKAGE_NAMES.has(spec)) return true;
+  if (/^@lotargo\/memory_plugin(?:@[^/]+)?$/i.test(spec)) return true;
+  if (/^(?:opencode-memory-plugin|memory_plugin|memory-plugin)(?:@[^/]+)?$/i.test(spec)) return true;
+  if (spec === devPluginUrl) return true;
+  return false;
+}
+
+export function rewriteOpenCodePluginList(pluginList, devPluginUrl) {
+  const input = Array.isArray(pluginList) ? pluginList : [];
+  const output = [];
+  let inserted = false;
+
+  for (const entry of input) {
+    const spec = pluginSpec(entry);
+    if (!isMemoryPluginSpec(spec, devPluginUrl)) {
+      output.push(entry);
+      continue;
+    }
+    if (inserted) continue;
+    output.push(Array.isArray(entry) ? [devPluginUrl, entry[1]] : devPluginUrl);
+    inserted = true;
+  }
+
+  if (!inserted) output.push(devPluginUrl);
+  return output;
+}
+
+export async function linkOpenCodeToRepository({
+  configDir = resolveClientPaths().opencodeDir,
+  pluginFile = DEV_PLUGIN_FILE,
+} = {}) {
+  if (!existsSync(pluginFile)) throw new Error(`OpenCode plugin entry not found: ${pluginFile}`);
+  const configPath = join(configDir, "opencode.json");
+  const backupPath = `${configPath}.memory-dev-backup`;
+  await mkdir(configDir, { recursive: true });
+
+  let config = {};
+  if (existsSync(configPath)) {
+    const raw = await readFile(configPath, "utf-8");
+    config = raw.trim() ? JSON.parse(raw) : {};
+    if (!existsSync(backupPath)) await copyFile(configPath, backupPath);
+  }
+
+  const devPluginUrl = pathToFileURL(pluginFile).href;
+  config.plugin = rewriteOpenCodePluginList(config.plugin, devPluginUrl);
+  const content = `${JSON.stringify(config, null, 2)}\n`;
+  const tmpPath = `${configPath}.memory-dev-tmp-${process.pid}`;
+  await writeFile(tmpPath, content, "utf-8");
+  await rename(tmpPath, configPath);
+
+  return { configPath, backupPath, devPluginUrl };
+}
+
+export function linkGlobalNpmPackage({ repoRoot = REPO_ROOT } = {}) {
+  const npmExecPath = process.env.npm_execpath;
+  const command = npmExecPath && existsSync(npmExecPath) ? process.execPath : "npm";
+  const args = npmExecPath && existsSync(npmExecPath) ? [npmExecPath, "link"] : ["link"];
+  const result = spawnSync(command, args, {
+    cwd: repoRoot,
+    stdio: "inherit",
+    // A direct npm-cli.js invocation is preferred. The shell fallback is only
+    // needed when dev-link is launched outside npm and no npm_execpath exists;
+    // the command and arguments are fixed, not user-provided.
+    shell: process.platform === "win32" && !npmExecPath,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`npm link failed with exit code ${result.status}`);
+}
+
+export async function syncDevelopmentSkills({
+  skillsSource = join(REPO_ROOT, "skills"),
+  targets = null,
+} = {}) {
+  if (!existsSync(skillsSource)) return [];
+  const { home, opencodeDir } = resolveClientPaths();
+  const destinations = targets || [
+    join(opencodeDir, "skills"),
+    join(home, ".codex", "skills"),
+    join(home, ".agents", "skills"),
+    join(home, ".claude", "skills"),
+    join(home, ".gemini", "config", "skills"),
+  ];
+  const entries = await readdir(skillsSource, { withFileTypes: true });
+  for (const destination of destinations) {
+    await mkdir(destination, { recursive: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      await cp(join(skillsSource, entry.name), join(destination, entry.name), {
+        recursive: true,
+        force: true,
+      });
+    }
+  }
+  return destinations;
+}
+
+export async function runDevLink({ skipNpmLink = false } = {}) {
+  console.log(`\nLinking ${PACKAGE_NAME} to the working repository...\n`);
+  if (!skipNpmLink) {
+    linkGlobalNpmPackage();
+    console.log(`  [OK] System CLI linked to ${REPO_ROOT}`);
+  }
+  const linked = await linkOpenCodeToRepository();
+  console.log(`  [OK] OpenCode plugin source: ${linked.devPluginUrl}`);
+  console.log(`  [OK] OpenCode config: ${linked.configPath}`);
+  console.log(`  [OK] Original config backup: ${linked.backupPath}`);
+  const { enableGlobalPrompt } = await import("./prompt_manager.js");
+  const promptResults = await enableGlobalPrompt();
+  const promptFailures = promptResults.filter((result) => result.status === "failed");
+  if (promptFailures.length) {
+    throw new Error(`Failed to synchronize client prompts: ${promptFailures.map((item) => item.name).join(", ")}`);
+  }
+  console.log("  [OK] Codex, Claude Code, Gemini CLI, and Antigravity prompts synchronized");
+  const skillTargets = await syncDevelopmentSkills();
+  console.log(`  [OK] Development skills synchronized to ${skillTargets.length} client location(s)`);
+  console.log("\nDevelopment link is active. After source edits, restart OpenCode; publishing and reinstalling are not required.\n");
+  return linked;
+}

package/mcp-server/fact_format.js

@@ -12,9 +12,25 @@
 //   keep         "1" = protected fact: forget refuses to delete without force
 //   supersedes   id (or number/text) this fact replaces
 //   supersededBy id of the fact that replaced this one
-//   tags         comma-separated free-form tags for recall filtering
+//   tags         comma-separated free-form tags for recall filtering
+//   kind         "fact" = descriptive context, "directive" = active personalization/working instruction
 
-const META_KEYS = ["id", "ttl", "keep", "supersededBy", "supersedes", "tags", "inject"];
+const META_KEYS = ["id", "ttl", "keep", "supersededBy", "supersedes", "tags", "inject", "kind"];
+
+const LEGACY_DIRECTIVE_TAGS = new Set([
+  "persona",
+  "behavior",
+  "behaviour",
+  "speech",
+  "style",
+  "tone",
+  "preference",
+  "preferences",
+  "pref",
+  "instruction",
+  "instructions",
+  "directive",
+]);
 
 const ENTRY_RE = /^- \[(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})\]\s+(.*)$/;
 
@@ -125,9 +141,24 @@ export function isKeepFact(line) {
 }
 
 // True if the fact has been superseded by another fact.
-export function isSuperseded(line) {
-  return Boolean(factMeta(line).supersededBy);
-}
+export function isSuperseded(line) {
+  return Boolean(factMeta(line).supersededBy);
+}
+
+// Explicit kind metadata is authoritative. Legacy stores predate `kind`, so
+// well-known personalization tags and inject:1 remain a compatibility bridge.
+// kind:fact can explicitly opt a tagged item out of directive semantics.
+export function isDirectiveFact(line) {
+  const meta = factMeta(line);
+  if (meta.kind === "directive") return true;
+  if (meta.kind === "fact") return false;
+  if (meta.inject === "1") return true;
+  const tags = String(meta.tags || "")
+    .split(",")
+    .map((tag) => tag.trim().toLowerCase())
+    .filter(Boolean);
+  return tags.some((tag) => LEGACY_DIRECTIVE_TAGS.has(tag));
+}
 
 // Keyword match: space-separated terms, all must be present (case-insensitive).
 // Also matches against the fact's id and tags.
@@ -161,13 +192,14 @@ export function inDateRange(factLine, since, until) {
 }
 
 // Human-readable badges for a fact line, e.g. ["EXPIRED", "KEEP", "SUPERSEDED"].
-export function metaBadges(factLine, now = Date.now()) {
-  const badges = [];
-  if (isExpiredLine(factLine, now)) badges.push("EXPIRED");
-  if (isKeepFact(factLine)) badges.push("KEEP");
-  if (isSuperseded(factLine)) badges.push("SUPERSEDED");
-  return badges;
-}
+export function metaBadges(factLine, now = Date.now()) {
+  const badges = [];
+  if (isExpiredLine(factLine, now)) badges.push("EXPIRED");
+  if (isKeepFact(factLine)) badges.push("KEEP");
+  if (isSuperseded(factLine)) badges.push("SUPERSEDED");
+  if (isDirectiveFact(factLine)) badges.push("DIRECTIVE");
+  return badges;
+}
 
 // Display text of a fact line with badges appended, e.g.
 //   "user prefers TS  [EXPIRED] [KEEP]"

package/mcp-server/index.js

@@ -45,15 +45,17 @@ function printUsage() {
 
 Usage:
   memory_plugin                      Start the MCP server on stdio (default)
-  memory_plugin setup [--opencode|--claude|--codex|--antigravity] [--mode <MODE>]
+  memory_plugin setup [--opencode|--claude|--codex|--gemini|--antigravity] [--mode <MODE>]
+  memory_plugin setup --uninstall [--purge] [--purge-cache] [--dry-run] [--yes]
+  memory_plugin uninstall [--purge] [--purge-cache] [--dry-run] [--yes] [--opencode|--claude|--codex|--gemini|--antigravity]
   memory_plugin cli                  Interactive terminal UI
   memory_plugin login [--from-env|--api-token|--db-url <URL>]
   memory_plugin logout [--api-key]
   memory_plugin auth-status
   memory_plugin link|unlink|relink|identity [--dir <path>] [--remote <url>]
   memory_plugin migrate_titles [--key <key>]
-  memory_plugin enable-prompt | disable-prompt
-  memory_plugin doctor --codex
+  memory_plugin enable-prompt | disable-prompt
+  memory_plugin doctor --codex
 
 Options:
   -h, --help                         Show this help text
@@ -62,9 +64,11 @@ Options:
 Secrets: prefer TURSO_API_TOKEN / TURSO_DB_URL / TURSO_DB_TOKEN environment
 variables over command-line flags — argv is visible to other local processes.
 Data directory: ${MEMORY_DIR}`);
-}
+}
 
-if (cliArgs.includes("--help") || cliArgs.includes("-h") || cliArgs[0] === "help") {
+const isUninstallCommand = cliArgs.includes("uninstall") || cliArgs.includes("--uninstall");
+
+if (!isUninstallCommand && (cliArgs.includes("--help") || cliArgs.includes("-h") || cliArgs[0] === "help")) {
   printUsage();
   process.exit(0);
 }
@@ -74,8 +78,14 @@ if (cliArgs.includes("--version") || cliArgs.includes("-v")) {
   process.exit(0);
 }
 
-if (cliArgs.includes("setup") || cliArgs.includes("install") || cliArgs.includes("--setup") || cliArgs.includes("-s")) {
-  const { runSetup } = await import("./setup.js");
+if (isUninstallCommand) {
+  const { runUninstall } = await import("./uninstall.js");
+  await runUninstall();
+  process.exit(process.exitCode || 0);
+}
+
+if (cliArgs.includes("setup") || cliArgs.includes("install") || cliArgs.includes("--setup") || cliArgs.includes("-s")) {
+  const { runSetup } = await import("./setup.js");
   await runSetup();
   process.exit(0);
 }

package/mcp-server/ingest/exporter.js

@@ -1,8 +1,8 @@
 import { getDatabase } from "../db/database.js";
 import { writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { MEMORY_DIR } from "../memory.js";
-import { toVectorBytes } from "../retrieval/retriever.js";
+import { MEMORY_DIR } from "../memory.js";
+import { toVectorBytes } from "../retrieval/retriever.js";
 
 export const EXPORTS_DIR = join(MEMORY_DIR, "exports");
 
@@ -36,32 +36,38 @@ export async function exportDocumentData(docIdOrPath, customDb = null) {
 
   const sections = await db.prepare("SELECT id, heading, breadcrumbs, content, token_count FROM sections WHERE doc_id = ?").all(doc.id);
   const mediumChunks = await db.prepare("SELECT id, section_id, content, block_type, token_count, created_at FROM medium_chunks WHERE doc_id = ?").all(doc.id);
-  const rawMicroChunks = await db.prepare("SELECT id, medium_id, section_id, content, vector, token_count, retrieval_policy, policy_source_id FROM micro_chunks WHERE doc_id = ?").all(doc.id);
-  const microChunks = rawMicroChunks.map((chunk) => {
-    const bytes = toVectorBytes(chunk.vector);
-    return {
-      ...chunk,
-      vector: bytes && bytes.byteLength
-        ? Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64")
-        : "",
-    };
-  });
-  const ownedRows = await db.prepare(`
-    SELECT id FROM sections WHERE doc_id = ?
-    UNION SELECT id FROM medium_chunks WHERE doc_id = ?
-    UNION SELECT id FROM micro_chunks WHERE doc_id = ?;
-  `).all(doc.id, doc.id, doc.id);
-  const ownedIds = [doc.id, ...ownedRows.map((row) => row.id)];
-  const placeholders = ownedIds.map(() => "?").join(",");
-  const graphEdges = await db.prepare(`
-    SELECT source_id, target_id, relation_type, metadata_json, created_at
-    FROM graph_edges
-    WHERE source_id IN (${placeholders})
-       OR target_id IN (${placeholders})
-       OR target_id GLOB ?;
-  `).all(...ownedIds, ...ownedIds, `${doc.id}:L*`);
-  const knowledgeLinks = await db.prepare("SELECT * FROM knowledge_links WHERE doc_id = ?").all(doc.id);
-  const documentScopes = await db.prepare("SELECT scope_key, created_at FROM document_scopes WHERE doc_id = ?").all(doc.id);
+  const rawMicroChunks = await db.prepare(`
+    SELECT m.id, m.medium_id, m.section_id, m.content, m.vector, m.token_count,
+           m.retrieval_policy, m.policy_source_id, s.breadcrumbs
+    FROM micro_chunks m
+    LEFT JOIN sections s ON s.id = m.section_id
+    WHERE m.doc_id = ?;
+  `).all(doc.id);
+  const microChunks = rawMicroChunks.map((chunk) => {
+    const bytes = toVectorBytes(chunk.vector);
+    return {
+      ...chunk,
+      vector: bytes && bytes.byteLength
+        ? Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64")
+        : "",
+    };
+  });
+  const ownedRows = await db.prepare(`
+    SELECT id FROM sections WHERE doc_id = ?
+    UNION SELECT id FROM medium_chunks WHERE doc_id = ?
+    UNION SELECT id FROM micro_chunks WHERE doc_id = ?;
+  `).all(doc.id, doc.id, doc.id);
+  const ownedIds = [doc.id, ...ownedRows.map((row) => row.id)];
+  const placeholders = ownedIds.map(() => "?").join(",");
+  const graphEdges = await db.prepare(`
+    SELECT source_id, target_id, relation_type, metadata_json, created_at
+    FROM graph_edges
+    WHERE source_id IN (${placeholders})
+       OR target_id IN (${placeholders})
+       OR target_id GLOB ?;
+  `).all(...ownedIds, ...ownedIds, `${doc.id}:L*`);
+  const knowledgeLinks = await db.prepare("SELECT * FROM knowledge_links WHERE doc_id = ?").all(doc.id);
+  const documentScopes = await db.prepare("SELECT scope_key, created_at FROM document_scopes WHERE doc_id = ?").all(doc.id);
 
   return {
     document: {
@@ -69,11 +75,11 @@ export async function exportDocumentData(docIdOrPath, customDb = null) {
       path: doc.path,
       title: doc.title,
       blob_hash: doc.blob_hash,
-      checksum: doc.checksum,
-      toc_json: doc.toc_json,
-      metadata_json: doc.metadata_json,
-      toc,
-      metadata,
+      checksum: doc.checksum,
+      toc_json: doc.toc_json,
+      metadata_json: doc.metadata_json,
+      toc,
+      metadata,
       created_at: doc.created_at,
       updated_at: doc.updated_at,
     },
@@ -86,11 +92,11 @@ export async function exportDocumentData(docIdOrPath, customDb = null) {
     sections,
     medium_chunks: mediumChunks,
     micro_chunks: microChunks,
-    graph_edges: graphEdges,
-    knowledge_links: knowledgeLinks,
-    document_scopes: documentScopes,
-  };
-}
+    graph_edges: graphEdges,
+    knowledge_links: knowledgeLinks,
+    document_scopes: documentScopes,
+  };
+}
 
 export async function exportDocumentToJsonString(docIdOrPath, customDb = null) {
   const data = await exportDocumentData(docIdOrPath, customDb);

package/mcp-server/ingest/normalizer.js

@@ -3,7 +3,7 @@ import { isIP } from "node:net";
 import { lookup } from "node:dns/promises";
 import { PDFParse } from "pdf-parse";
 import mammoth from "mammoth";
-import xlsx from "xlsx";
+import * as xlsx from "xlsx";
 
 export function cleanHtml(html) {
   if (!html) return "";