minimem 0.0.7 → 0.1.1

package/dist/cli/minimem-MQXSBGNG.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import {
+  Minimem
+} from "./chunk-BIYUNXYX.js";
+export {
+  Minimem
+};
+//# sourceMappingURL=minimem-MQXSBGNG.js.map

package/dist/cli/minimem-MQXSBGNG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.cjs

@@ -41,11 +41,13 @@ __export(index_exports, {
   MemorySearcher: () => MemorySearcher,
   MemoryToolExecutor: () => MemoryToolExecutor,
   Minimem: () => Minimem,
+  StoreGraph: () => StoreGraph,
   addFrontmatter: () => addFrontmatter,
   addSessionToContent: () => addSessionToContent,
   buildFileEntry: () => buildFileEntry,
   buildKnowledgeFilterSql: () => buildKnowledgeFilterSql,
   chunkMarkdown: () => chunkMarkdown,
+  clearStoreCache: () => clearStoreCache,
   cosineSimilarity: () => cosineSimilarity,
   createEmbeddingProvider: () => createEmbeddingProvider,
   createGeminiEmbeddingProvider: () => createGeminiEmbeddingProvider,
@@ -55,18 +57,29 @@ __export(index_exports, {
   extractChunkMetadata: () => extractChunkMetadata,
   extractSession: () => extractSession,
   generateMcpConfig: () => generateMcpConfig,
+  getLinkedStoreNames: () => getLinkedStoreNames,
   getLinksFrom: () => getLinksFrom,
   getLinksTo: () => getLinksTo,
+  getManifestPath: () => getManifestPath,
   getNeighbors: () => getNeighbors,
   getPathBetween: () => getPathBetween,
+  getRemoteCacheDir: () => getRemoteCacheDir,
   getToolDefinitions: () => getToolDefinitions,
   hashText: () => hashText,
   isMemoryPath: () => isMemoryPath,
+  listCachedStores: () => listCachedStores,
   listMemoryFiles: () => listMemoryFiles,
+  loadManifest: () => loadManifest,
+  loadStoreLinks: () => loadStoreLinks,
+  materializeStore: () => materializeStore,
   parseFrontmatter: () => parseFrontmatter,
+  resolveStore: () => resolveStore,
+  resolveStoreName: () => resolveStoreName,
   runGeminiEmbeddingBatches: () => runGeminiEmbeddingBatches,
   runMcpServer: () => runMcpServer,
   runOpenAiEmbeddingBatches: () => runOpenAiEmbeddingBatches,
+  saveManifest: () => saveManifest,
+  saveStoreLinks: () => saveStoreLinks,
   serializeFrontmatter: () => serializeFrontmatter,
   stripPrivateContent: () => stripPrivateContent
 });
@@ -970,15 +983,15 @@ function getPathBetween(db, fromId, toId, maxDepth = 3) {
   return [];
 }
 function reconstructPath(parentLink, fromId, toId) {
-  const path5 = [];
+  const path8 = [];
   let current = toId;
   while (current !== fromId) {
     const link = parentLink.get(current);
     if (!link) break;
-    path5.unshift(link);
+    path8.unshift(link);
     current = link.toId === current ? link.fromId : link.toId;
   }
-  return path5;
+  return path8;
 }
 function toGraphLink(row) {
   return {
@@ -3209,13 +3222,13 @@ ${formatted}` }]
     }
     const maxDepth = Math.min(params.maxDepth ?? 3, 5);
     for (const instance of instancesToSearch) {
-      const path5 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
-      if (path5.length > 0) {
-        const steps = path5.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
+      const path8 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
+      if (path8.length > 0) {
+        const steps = path8.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
         return {
           content: [{
             type: "text",
-            text: `Path from "${params.fromId}" to "${params.toId}" (${path5.length} steps):
+            text: `Path from "${params.fromId}" to "${params.toId}" (${path8.length} steps):
 ${steps}`
           }]
         };
@@ -3948,6 +3961,354 @@ var MemorySearcher = class {
     return false;
   }
 };
+
+// src/store/store-graph.ts
+var import_node_path7 = __toESM(require("path"), 1);
+
+// src/store/manifest.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var GLOBAL_MANIFEST_PATH = import_node_path5.default.join(
+  import_node_os2.default.homedir(),
+  ".config",
+  "minimem",
+  "stores.json"
+);
+var LINKS_FILENAME = "links.json";
+async function loadManifest(manifestPath) {
+  const filePath = manifestPath ?? GLOBAL_MANIFEST_PATH;
+  try {
+    const content = await import_promises4.default.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    for (const [name, def] of Object.entries(parsed.stores ?? {})) {
+      parsed.stores[name] = {
+        ...def,
+        path: expandHome(def.path)
+      };
+    }
+    return { stores: parsed.stores ?? {} };
+  } catch {
+    return { stores: {} };
+  }
+}
+async function saveManifest(manifest, manifestPath) {
+  const filePath = manifestPath ?? GLOBAL_MANIFEST_PATH;
+  await import_promises4.default.mkdir(import_node_path5.default.dirname(filePath), { recursive: true });
+  await import_promises4.default.writeFile(filePath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+async function loadStoreLinks(memoryDir) {
+  const candidates = [
+    import_node_path5.default.join(memoryDir, ".minimem", LINKS_FILENAME),
+    import_node_path5.default.join(memoryDir, ".swarm", "minimem", LINKS_FILENAME),
+    import_node_path5.default.join(memoryDir, LINKS_FILENAME)
+  ];
+  for (const candidate of candidates) {
+    try {
+      const content = await import_promises4.default.readFile(candidate, "utf-8");
+      const parsed = JSON.parse(content);
+      return { links: parsed.links ?? [] };
+    } catch {
+      continue;
+    }
+  }
+  return { links: [] };
+}
+async function saveStoreLinks(memoryDir, links) {
+  const candidates = [
+    import_node_path5.default.join(memoryDir, ".minimem"),
+    import_node_path5.default.join(memoryDir, ".swarm", "minimem"),
+    memoryDir
+    // contained layout
+  ];
+  let targetDir = candidates[0];
+  for (const candidate of candidates) {
+    if (import_node_fs4.default.existsSync(candidate)) {
+      targetDir = candidate;
+      break;
+    }
+  }
+  await import_promises4.default.mkdir(targetDir, { recursive: true });
+  await import_promises4.default.writeFile(
+    import_node_path5.default.join(targetDir, LINKS_FILENAME),
+    JSON.stringify(links, null, 2),
+    "utf-8"
+  );
+}
+function resolveStore(manifest, storeName) {
+  return manifest.stores[storeName] ?? null;
+}
+function resolveStoreName(manifest, dirPath) {
+  const resolved = import_node_path5.default.resolve(dirPath);
+  for (const [name, def] of Object.entries(manifest.stores)) {
+    if (import_node_path5.default.resolve(def.path) === resolved) {
+      return name;
+    }
+  }
+  return null;
+}
+async function getLinkedStoreNames(manifest, storeName) {
+  const storeDef = manifest.stores[storeName];
+  if (!storeDef) return [];
+  const storeLinks = await loadStoreLinks(storeDef.path);
+  return [...new Set(storeLinks.links)];
+}
+function getManifestPath() {
+  return GLOBAL_MANIFEST_PATH;
+}
+function expandHome(filePath) {
+  if (filePath.startsWith("~/")) {
+    return import_node_path5.default.join(import_node_os2.default.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+// src/store/materialize.ts
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var CACHE_BASE = import_node_path6.default.join(import_node_os3.default.homedir(), ".cache", "minimem", "stores");
+async function materializeStore(storeName, storeDef, opts) {
+  if (import_node_fs5.default.existsSync(storeDef.path)) {
+    return materializeLocal(storeName, storeDef.path);
+  }
+  if (storeDef.remote) {
+    return materializeRemote(storeName, storeDef, opts?.refresh ?? false);
+  }
+  return null;
+}
+async function materializeLocal(storeName, storePath) {
+  const tmpBase = await import_promises5.default.mkdtemp(
+    import_node_path6.default.join(import_node_os3.default.tmpdir(), "minimem-stores-")
+  );
+  const symlinkDir = import_node_path6.default.join(tmpBase, storeName);
+  await import_promises5.default.symlink(storePath, symlinkDir, "dir");
+  return {
+    // The Minimem instance should use the original path for its DB,
+    // but the symlink path can be used for discovery/resolution.
+    // We return the original path since Minimem works directly with it.
+    path: storePath,
+    strategy: "symlink",
+    cleanup: async () => {
+      try {
+        await import_promises5.default.unlink(symlinkDir);
+        await import_promises5.default.rmdir(tmpBase);
+      } catch {
+      }
+    }
+  };
+}
+async function materializeRemote(storeName, storeDef, refresh) {
+  const cacheDir = import_node_path6.default.join(CACHE_BASE, storeName);
+  try {
+    if (import_node_fs5.default.existsSync(import_node_path6.default.join(cacheDir, ".git"))) {
+      if (refresh) {
+        await gitFetch(cacheDir);
+      }
+    } else {
+      await gitClone(storeDef.remote, cacheDir);
+    }
+    return {
+      path: cacheDir,
+      strategy: "remote",
+      cleanup: async () => {
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+async function gitClone(remote, targetDir) {
+  await import_promises5.default.mkdir(import_node_path6.default.dirname(targetDir), { recursive: true });
+  await execFileAsync("git", ["clone", "--depth", "1", remote, targetDir], {
+    timeout: 6e4
+  });
+}
+async function gitFetch(cacheDir) {
+  await execFileAsync("git", ["fetch", "--depth", "1", "origin"], {
+    cwd: cacheDir,
+    timeout: 6e4
+  });
+  await execFileAsync("git", ["reset", "--hard", "origin/HEAD"], {
+    cwd: cacheDir,
+    timeout: 3e4
+  });
+}
+function getRemoteCacheDir() {
+  return CACHE_BASE;
+}
+async function listCachedStores() {
+  try {
+    const entries = await import_promises5.default.readdir(CACHE_BASE);
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function clearStoreCache(storeName) {
+  const cacheDir = import_node_path6.default.join(CACHE_BASE, storeName);
+  await import_promises5.default.rm(cacheDir, { recursive: true, force: true });
+}
+
+// src/store/store-graph.ts
+var StoreGraph = class _StoreGraph {
+  manifest;
+  resolved = /* @__PURE__ */ new Map();
+  configFactory;
+  debug;
+  constructor(manifest, opts) {
+    this.manifest = manifest;
+    this.debug = opts?.debug;
+    this.configFactory = opts?.configFactory ?? defaultConfigFactory;
+  }
+  /**
+   * Create a StoreGraph from the global manifest.
+   */
+  static async create(opts) {
+    const manifest = await loadManifest(opts?.manifestPath);
+    return new _StoreGraph(manifest, opts);
+  }
+  /**
+   * Create a StoreGraph from an explicit manifest object (useful for testing).
+   */
+  static fromManifest(manifest, opts) {
+    return new _StoreGraph(manifest, opts);
+  }
+  /**
+   * Get the loaded manifest.
+   */
+  getManifest() {
+    return this.manifest;
+  }
+  /**
+   * Resolve a store by name: materialize it and all its linked stores (depth 1).
+   * Returns an array of MemoryInstance objects ready for search.
+   *
+   * Linked stores that fail to materialize are skipped with a warning.
+   */
+  async resolve(storeName) {
+    const instances = [];
+    const primary = await this.resolveOne(storeName);
+    if (!primary) {
+      throw new Error(`Store "${storeName}" not found or unavailable`);
+    }
+    instances.push({
+      minimem: primary.instance,
+      memoryDir: primary.materialization.path,
+      name: storeName
+    });
+    const linkedNames = await getLinkedStoreNames(this.manifest, storeName);
+    for (const linkedName of linkedNames) {
+      if (linkedName === storeName) continue;
+      try {
+        const linked = await this.resolveOne(linkedName);
+        if (linked) {
+          instances.push({
+            minimem: linked.instance,
+            memoryDir: linked.materialization.path,
+            name: linkedName
+          });
+        } else {
+          this.debug?.(`Linked store "${linkedName}" unavailable, skipping`);
+        }
+      } catch (err) {
+        this.debug?.(
+          `Failed to resolve linked store "${linkedName}": ${String(err)}`
+        );
+      }
+    }
+    return instances;
+  }
+  /**
+   * Resolve a store by directory path (looks up the store name in the manifest).
+   * Falls back to creating a standalone instance if the directory isn't in the manifest.
+   */
+  async resolveByPath(dirPath) {
+    const storeName = resolveStoreName(this.manifest, dirPath);
+    if (storeName) {
+      return this.resolve(storeName);
+    }
+    this.debug?.(`Directory "${dirPath}" not in manifest, using standalone`);
+    const config = await this.configFactory(dirPath, import_node_path7.default.basename(dirPath));
+    const instance = await Minimem.create(config);
+    return [
+      {
+        minimem: instance,
+        memoryDir: dirPath,
+        name: import_node_path7.default.basename(dirPath)
+      }
+    ];
+  }
+  /**
+   * List all known stores from the manifest with their link info.
+   */
+  async listStores() {
+    const result = [];
+    for (const [name, def] of Object.entries(this.manifest.stores)) {
+      const links = await getLinkedStoreNames(this.manifest, name);
+      const { existsSync } = await import("fs");
+      const available = existsSync(def.path) || !!def.remote;
+      result.push({
+        name,
+        path: def.path,
+        remote: def.remote,
+        links,
+        available
+      });
+    }
+    return result;
+  }
+  /**
+   * Close all resolved Minimem instances and clean up materializations.
+   */
+  async close() {
+    for (const [, store] of this.resolved) {
+      try {
+        store.instance.close();
+      } catch {
+      }
+      try {
+        await store.materialization.cleanup();
+      } catch {
+      }
+    }
+    this.resolved.clear();
+  }
+  /**
+   * Resolve a single store by name.
+   * Returns cached instance if already resolved.
+   */
+  async resolveOne(storeName) {
+    const cached = this.resolved.get(storeName);
+    if (cached) return cached;
+    const def = resolveStore(this.manifest, storeName);
+    if (!def) return null;
+    const materialization = await materializeStore(storeName, def);
+    if (!materialization) return null;
+    const config = await this.configFactory(materialization.path, storeName);
+    const instance = await Minimem.create(config);
+    const resolved = {
+      name: storeName,
+      definition: def,
+      materialization,
+      instance
+    };
+    this.resolved.set(storeName, resolved);
+    return resolved;
+  }
+};
+async function defaultConfigFactory(memoryDir, _storeName) {
+  return {
+    memoryDir,
+    embedding: { provider: "auto" },
+    watch: { enabled: false }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KNOWLEDGE_GRAPH_TOOL,
@@ -3961,11 +4322,13 @@ var MemorySearcher = class {
   MemorySearcher,
   MemoryToolExecutor,
   Minimem,
+  StoreGraph,
   addFrontmatter,
   addSessionToContent,
   buildFileEntry,
   buildKnowledgeFilterSql,
   chunkMarkdown,
+  clearStoreCache,
   cosineSimilarity,
   createEmbeddingProvider,
   createGeminiEmbeddingProvider,
@@ -3975,18 +4338,29 @@ var MemorySearcher = class {
   extractChunkMetadata,
   extractSession,
   generateMcpConfig,
+  getLinkedStoreNames,
   getLinksFrom,
   getLinksTo,
+  getManifestPath,
   getNeighbors,
   getPathBetween,
+  getRemoteCacheDir,
   getToolDefinitions,
   hashText,
   isMemoryPath,
+  listCachedStores,
   listMemoryFiles,
+  loadManifest,
+  loadStoreLinks,
+  materializeStore,
   parseFrontmatter,
+  resolveStore,
+  resolveStoreName,
   runGeminiEmbeddingBatches,
   runMcpServer,
   runOpenAiEmbeddingBatches,
+  saveManifest,
+  saveStoreLinks,
   serializeFrontmatter,
   stripPrivateContent
 });