minimem 0.0.6 → 0.1.0

package/dist/index.js

@@ -24,6 +24,7 @@ import {
 // src/minimem.ts
 import { randomUUID } from "crypto";
 import fs from "fs/promises";
+import fsSync2 from "fs";
 import path2 from "path";
 import { DatabaseSync } from "sqlite";
 import chokidar from "chokidar";
@@ -444,15 +445,15 @@ function getPathBetween(db, fromId, toId, maxDepth = 3) {
   return [];
 }
 function reconstructPath(parentLink, fromId, toId) {
-  const path4 = [];
+  const path7 = [];
   let current = toId;
   while (current !== fromId) {
     const link = parentLink.get(current);
     if (!link) break;
-    path4.unshift(link);
+    path7.unshift(link);
     current = link.toId === current ? link.fromId : link.toId;
   }
-  return path4;
+  return path7;
 }
 function toGraphLink(row) {
   return {
@@ -1389,6 +1390,14 @@ async function runGeminiEmbeddingBatches(params) {
 }
 
 // src/minimem.ts
+function resolveMinimemSubdir(memoryDir) {
+  const envDir = process.env.MINIMEM_CONFIG_DIR;
+  if (envDir) return envDir;
+  if (fsSync2.existsSync(path2.join(memoryDir, "config.json"))) return ".";
+  const swarmDir = path2.join(memoryDir, ".swarm", "minimem");
+  if (fsSync2.existsSync(path2.join(swarmDir, "config.json"))) return path2.join(".swarm", "minimem");
+  return ".minimem";
+}
 var META_KEY = "memory_index_meta_v1";
 var SNIPPET_MAX_CHARS = 700;
 var VECTOR_TABLE = "chunks_vec";
@@ -1428,7 +1437,7 @@ var Minimem = class _Minimem {
   embeddingOptions;
   constructor(config) {
     this.memoryDir = path2.resolve(config.memoryDir);
-    this.dbPath = config.dbPath ?? path2.join(this.memoryDir, ".minimem", "index.db");
+    this.dbPath = config.dbPath ?? path2.join(this.memoryDir, resolveMinimemSubdir(this.memoryDir), "index.db");
     this.chunking = {
       tokens: config.chunking?.tokens ?? 256,
       overlap: config.chunking?.overlap ?? 32
@@ -2675,13 +2684,13 @@ ${formatted}` }]
     }
     const maxDepth = Math.min(params.maxDepth ?? 3, 5);
     for (const instance of instancesToSearch) {
-      const path4 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
-      if (path4.length > 0) {
-        const steps = path4.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
+      const path7 = instance.minimem.getGraphPath(params.fromId, params.toId, maxDepth);
+      if (path7.length > 0) {
+        const steps = path7.map((link) => `  ${link.fromId} \u2014(${link.relation})\u2192 ${link.toId}`).join("\n");
         return {
           content: [{
             type: "text",
-            text: `Path from "${params.fromId}" to "${params.toId}" (${path4.length} steps):
+            text: `Path from "${params.fromId}" to "${params.toId}" (${path7.length} steps):
 ${steps}`
           }]
         };
@@ -3414,6 +3423,354 @@ var MemorySearcher = class {
     return false;
   }
 };
+
+// src/store/store-graph.ts
+import path6 from "path";
+
+// src/store/manifest.ts
+import fs3 from "fs/promises";
+import fsSync3 from "fs";
+import path4 from "path";
+import os2 from "os";
+var GLOBAL_MANIFEST_PATH = path4.join(
+  os2.homedir(),
+  ".config",
+  "minimem",
+  "stores.json"
+);
+var LINKS_FILENAME = "links.json";
+async function loadManifest(manifestPath) {
+  const filePath = manifestPath ?? GLOBAL_MANIFEST_PATH;
+  try {
+    const content = await fs3.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 fs3.mkdir(path4.dirname(filePath), { recursive: true });
+  await fs3.writeFile(filePath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+async function loadStoreLinks(memoryDir) {
+  const candidates = [
+    path4.join(memoryDir, ".minimem", LINKS_FILENAME),
+    path4.join(memoryDir, ".swarm", "minimem", LINKS_FILENAME),
+    path4.join(memoryDir, LINKS_FILENAME)
+  ];
+  for (const candidate of candidates) {
+    try {
+      const content = await fs3.readFile(candidate, "utf-8");
+      const parsed = JSON.parse(content);
+      return { links: parsed.links ?? [] };
+    } catch {
+      continue;
+    }
+  }
+  return { links: [] };
+}
+async function saveStoreLinks(memoryDir, links) {
+  const candidates = [
+    path4.join(memoryDir, ".minimem"),
+    path4.join(memoryDir, ".swarm", "minimem"),
+    memoryDir
+    // contained layout
+  ];
+  let targetDir = candidates[0];
+  for (const candidate of candidates) {
+    if (fsSync3.existsSync(candidate)) {
+      targetDir = candidate;
+      break;
+    }
+  }
+  await fs3.mkdir(targetDir, { recursive: true });
+  await fs3.writeFile(
+    path4.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 = path4.resolve(dirPath);
+  for (const [name, def] of Object.entries(manifest.stores)) {
+    if (path4.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 path4.join(os2.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+// src/store/materialize.ts
+import fs4 from "fs/promises";
+import fsSync4 from "fs";
+import path5 from "path";
+import os3 from "os";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var CACHE_BASE = path5.join(os3.homedir(), ".cache", "minimem", "stores");
+async function materializeStore(storeName, storeDef, opts) {
+  if (fsSync4.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 fs4.mkdtemp(
+    path5.join(os3.tmpdir(), "minimem-stores-")
+  );
+  const symlinkDir = path5.join(tmpBase, storeName);
+  await fs4.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 fs4.unlink(symlinkDir);
+        await fs4.rmdir(tmpBase);
+      } catch {
+      }
+    }
+  };
+}
+async function materializeRemote(storeName, storeDef, refresh) {
+  const cacheDir = path5.join(CACHE_BASE, storeName);
+  try {
+    if (fsSync4.existsSync(path5.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 fs4.mkdir(path5.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 fs4.readdir(CACHE_BASE);
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function clearStoreCache(storeName) {
+  const cacheDir = path5.join(CACHE_BASE, storeName);
+  await fs4.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, path6.basename(dirPath));
+    const instance = await Minimem.create(config);
+    return [
+      {
+        minimem: instance,
+        memoryDir: dirPath,
+        name: path6.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 }
+  };
+}
 export {
   KNOWLEDGE_GRAPH_TOOL,
   KNOWLEDGE_PATH_TOOL,
@@ -3426,11 +3783,13 @@ export {
   MemorySearcher,
   MemoryToolExecutor,
   Minimem,
+  StoreGraph,
   addFrontmatter,
   addSessionToContent,
   buildFileEntry,
   buildKnowledgeFilterSql,
   chunkMarkdown,
+  clearStoreCache,
   cosineSimilarity,
   createEmbeddingProvider,
   createGeminiEmbeddingProvider,
@@ -3440,18 +3799,29 @@ export {
   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
 };