minimem 0.0.6 → 0.0.7

package/dist/cli/index.js

@@ -4,18 +4,28 @@
 import { program } from "commander";
 
 // src/cli/commands/init.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 import path3 from "path";
 
 // src/cli/config.ts
-import fs from "fs/promises";
+import fs2 from "fs/promises";
+import fsSync from "fs";
 import path2 from "path";
 import os2 from "os";
 import crypto from "crypto";
 
 // src/cli/shared.ts
+import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+function discoverMemoryDir(base) {
+  if (fs.existsSync(path.join(base, "MEMORY.md"))) return base;
+  const swarmDir = path.join(base, ".swarm", "minimem");
+  if (fs.existsSync(path.join(swarmDir, "config.json"))) return swarmDir;
+  const minimemDir = path.join(base, ".minimem");
+  if (fs.existsSync(path.join(minimemDir, "config.json"))) return minimemDir;
+  return base;
+}
 function resolveMemoryDir(options) {
   const dir = Array.isArray(options.dir) ? options.dir[0] : options.dir;
   if (dir) {
@@ -28,7 +38,7 @@ function resolveMemoryDir(options) {
   if (options.global) {
     return path.join(os.homedir(), ".minimem");
   }
-  return process.cwd();
+  return discoverMemoryDir(process.cwd());
 }
 function resolveMemoryDirs(options) {
   const dirs = [];
@@ -46,7 +56,7 @@ function resolveMemoryDirs(options) {
     }
   }
   if (dirs.length === 0) {
-    dirs.push(process.cwd());
+    dirs.push(discoverMemoryDir(process.cwd()));
   }
   return [...new Set(dirs)];
 }
@@ -90,8 +100,16 @@ function getGlobalDir() {
 function getGlobalConfigPath() {
   return path2.join(getGlobalDir(), CONFIG_DIR, CONFIG_FILENAME);
 }
+function resolveConfigSubdir(memoryDir) {
+  const envDir = process.env.MINIMEM_CONFIG_DIR;
+  if (envDir) return envDir;
+  if (fsSync.existsSync(path2.join(memoryDir, CONFIG_FILENAME))) return ".";
+  const swarmDir = path2.join(memoryDir, ".swarm", "minimem");
+  if (fsSync.existsSync(path2.join(swarmDir, CONFIG_FILENAME))) return path2.join(".swarm", "minimem");
+  return CONFIG_DIR;
+}
 function getConfigPath(memoryDir) {
-  return path2.join(memoryDir, CONFIG_DIR, CONFIG_FILENAME);
+  return path2.join(memoryDir, resolveConfigSubdir(memoryDir), CONFIG_FILENAME);
 }
 function getXdgConfigDir() {
   return path2.join(os2.homedir(), XDG_CONFIG_DIR);
@@ -110,7 +128,7 @@ function expandPath(filePath) {
 }
 async function loadXdgConfig() {
   try {
-    const content = await fs.readFile(getXdgConfigPath(), "utf-8");
+    const content = await fs2.readFile(getXdgConfigPath(), "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -119,8 +137,8 @@ async function loadXdgConfig() {
 async function saveXdgConfig(config2) {
   const configDir = getXdgConfigDir();
   const configPath = getXdgConfigPath();
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  await fs2.mkdir(configDir, { recursive: true });
+  await fs2.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
 }
 async function getMachineId() {
   const globalConfig = await loadXdgConfig();
@@ -135,7 +153,7 @@ async function getMachineId() {
 }
 async function loadConfigFile(configPath) {
   try {
-    const content = await fs.readFile(configPath, "utf-8");
+    const content = await fs2.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -189,10 +207,10 @@ function deepMergeConfig(target, source) {
   return result;
 }
 async function saveConfig(memoryDir, config2) {
-  const configDir = path2.join(memoryDir, CONFIG_DIR);
   const configPath = getConfigPath(memoryDir);
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  const configDir = path2.dirname(configPath);
+  await fs2.mkdir(configDir, { recursive: true });
+  await fs2.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
 }
 function getDefaultConfig() {
   return {
@@ -309,7 +327,7 @@ function buildMinimemConfig(memoryDir, cliConfig, options) {
 async function isInitialized(memoryDir) {
   const configPath = getConfigPath(memoryDir);
   try {
-    await fs.access(configPath);
+    await fs2.access(configPath);
     return true;
   } catch {
     return false;
@@ -346,23 +364,23 @@ async function init(dir, options) {
     return;
   }
   console.log(`Initializing minimem in ${displayPath}...`);
-  await fs2.mkdir(memoryDir, { recursive: true });
-  await fs2.mkdir(path3.join(memoryDir, "memory"), { recursive: true });
-  await fs2.mkdir(path3.join(memoryDir, ".minimem"), { recursive: true });
+  await fs3.mkdir(memoryDir, { recursive: true });
+  await fs3.mkdir(path3.join(memoryDir, "memory"), { recursive: true });
   const memoryFilePath = path3.join(memoryDir, "MEMORY.md");
   try {
-    await fs2.access(memoryFilePath);
+    await fs3.access(memoryFilePath);
     console.log("  MEMORY.md already exists, skipping");
   } catch {
-    await fs2.writeFile(memoryFilePath, MEMORY_TEMPLATE, "utf-8");
+    await fs3.writeFile(memoryFilePath, MEMORY_TEMPLATE, "utf-8");
     console.log("  Created MEMORY.md");
   }
   const config2 = getInitConfig();
-  await saveConfig(memoryDir, config2);
-  console.log("  Created .minimem/config.json");
-  const gitignorePath = path3.join(memoryDir, ".minimem", ".gitignore");
-  await fs2.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
-  console.log("  Created .minimem/.gitignore");
+  const configPath = path3.join(memoryDir, "config.json");
+  await fs3.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  console.log("  Created config.json");
+  const gitignorePath = path3.join(memoryDir, ".gitignore");
+  await fs3.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
+  console.log("  Created .gitignore");
   console.log();
   console.log("Done! Your memory directory is ready.");
   console.log();
@@ -379,15 +397,16 @@ async function init(dir, options) {
 
 // src/minimem.ts
 import { randomUUID } from "crypto";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
+import fsSync4 from "fs";
 import path6 from "path";
 import { DatabaseSync } from "node:sqlite";
 import chokidar from "chokidar";
 
 // src/internal.ts
 import crypto2 from "crypto";
-import fsSync from "fs";
-import fs3 from "fs/promises";
+import fsSync2 from "fs";
+import fs4 from "fs/promises";
 import path4 from "path";
 function logError2(context, error, debug) {
   if (!debug) return;
@@ -396,7 +415,7 @@ function logError2(context, error, debug) {
 }
 function ensureDir(dir, debug) {
   try {
-    fsSync.mkdirSync(dir, { recursive: true });
+    fsSync2.mkdirSync(dir, { recursive: true });
   } catch (error) {
     const nodeError = error;
     if (nodeError.code !== "EEXIST") {
@@ -407,14 +426,14 @@ function ensureDir(dir, debug) {
 }
 async function exists(filePath) {
   try {
-    await fs3.access(filePath);
+    await fs4.access(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function walkDir(dir, files) {
-  const entries = await fs3.readdir(dir, { withFileTypes: true });
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const full = path4.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -436,11 +455,11 @@ async function listMemoryFiles(memoryDir) {
     let upperReal = memoryFile;
     let lowerReal = altMemoryFile;
     try {
-      upperReal = await fs3.realpath(memoryFile);
+      upperReal = await fs4.realpath(memoryFile);
     } catch {
     }
     try {
-      lowerReal = await fs3.realpath(altMemoryFile);
+      lowerReal = await fs4.realpath(altMemoryFile);
     } catch {
     }
     if (upperReal !== lowerReal) {
@@ -464,7 +483,7 @@ async function listMemoryFiles(memoryDir) {
   for (const entry of result) {
     let key = entry;
     try {
-      key = await fs3.realpath(entry);
+      key = await fs4.realpath(entry);
     } catch {
     }
     if (seen.has(key)) continue;
@@ -477,8 +496,8 @@ function hashText(value) {
   return crypto2.createHash("sha256").update(value).digest("hex");
 }
 async function buildFileEntry(absPath, memoryDir) {
-  const stat = await fs3.stat(absPath);
-  const content = await fs3.readFile(absPath, "utf-8");
+  const stat = await fs4.stat(absPath);
+  const content = await fs4.readFile(absPath, "utf-8");
   const hash = hashText(content);
   return {
     path: path4.relative(memoryDir, absPath).replace(/\\/g, "/"),
@@ -1298,7 +1317,7 @@ async function loadSqliteVecExtension(params) {
 }
 
 // src/embeddings/embeddings.ts
-import fsSync2 from "fs";
+import fsSync3 from "fs";
 import path5 from "path";
 import os4 from "os";
 var DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
@@ -1326,7 +1345,7 @@ function canAutoSelectLocal(options) {
   if (/^(hf:|https?:)/i.test(modelPath)) return false;
   const resolved = resolveUserPath(modelPath);
   try {
-    return fsSync2.statSync(resolved).isFile();
+    return fsSync3.statSync(resolved).isFile();
   } catch {
     return false;
   }
@@ -2202,6 +2221,14 @@ async function runGeminiEmbeddingBatches(params) {
 }
 
 // src/minimem.ts
+function resolveMinimemSubdir(memoryDir) {
+  const envDir = process.env.MINIMEM_CONFIG_DIR;
+  if (envDir) return envDir;
+  if (fsSync4.existsSync(path6.join(memoryDir, "config.json"))) return ".";
+  const swarmDir = path6.join(memoryDir, ".swarm", "minimem");
+  if (fsSync4.existsSync(path6.join(swarmDir, "config.json"))) return path6.join(".swarm", "minimem");
+  return ".minimem";
+}
 var META_KEY = "memory_index_meta_v1";
 var SNIPPET_MAX_CHARS = 700;
 var VECTOR_TABLE = "chunks_vec";
@@ -2241,7 +2268,7 @@ var Minimem = class _Minimem {
   embeddingOptions;
   constructor(config2) {
     this.memoryDir = path6.resolve(config2.memoryDir);
-    this.dbPath = config2.dbPath ?? path6.join(this.memoryDir, ".minimem", "index.db");
+    this.dbPath = config2.dbPath ?? path6.join(this.memoryDir, resolveMinimemSubdir(this.memoryDir), "index.db");
     this.chunking = {
       tokens: config2.chunking?.tokens ?? 256,
       overlap: config2.chunking?.overlap ?? 32
@@ -2387,7 +2414,7 @@ var Minimem = class _Minimem {
           this.debug?.(`Stale: new file ${relPath}`);
           return true;
         }
-        const stat = await fs4.stat(absPath);
+        const stat = await fs5.stat(absPath);
         const currentMtime = Math.floor(stat.mtimeMs);
         if (currentMtime !== storedMtime) {
           this.debug?.(`Stale: mtime changed for ${relPath}`);
@@ -2555,7 +2582,7 @@ var Minimem = class _Minimem {
     this.debug?.(`memory sync complete`, { files: files.length });
   }
   async indexFile(entry) {
-    const content = await fs4.readFile(entry.absPath, "utf-8");
+    const content = await fs5.readFile(entry.absPath, "utf-8");
     const chunks = chunkMarkdown(content, this.chunking);
     const { frontmatter } = parseFrontmatter(content);
     const knowledgeType = frontmatter?.type ?? null;
@@ -2859,7 +2886,7 @@ var Minimem = class _Minimem {
   async readFile(relativePath) {
     const absPath = path6.join(this.memoryDir, relativePath);
     try {
-      return await fs4.readFile(absPath, "utf-8");
+      return await fs5.readFile(absPath, "utf-8");
     } catch {
       return null;
     }
@@ -2889,8 +2916,8 @@ var Minimem = class _Minimem {
     this.validateMemoryPath(relativePath);
     const absPath = path6.join(this.memoryDir, relativePath);
     const dir = path6.dirname(absPath);
-    await fs4.mkdir(dir, { recursive: true });
-    await fs4.writeFile(absPath, content, "utf-8");
+    await fs5.mkdir(dir, { recursive: true });
+    await fs5.writeFile(absPath, content, "utf-8");
     this.dirty = true;
     this.debug?.(`memory write: ${relativePath}`);
   }
@@ -2901,16 +2928,16 @@ var Minimem = class _Minimem {
     this.validateMemoryPath(relativePath);
     const absPath = path6.join(this.memoryDir, relativePath);
     const dir = path6.dirname(absPath);
-    await fs4.mkdir(dir, { recursive: true });
+    await fs5.mkdir(dir, { recursive: true });
     let toAppend = content;
     try {
-      const existing = await fs4.readFile(absPath, "utf-8");
+      const existing = await fs5.readFile(absPath, "utf-8");
       if (existing.length > 0 && !existing.endsWith("\n")) {
         toAppend = "\n" + content;
       }
     } catch {
     }
-    await fs4.appendFile(absPath, toAppend, "utf-8");
+    await fs5.appendFile(absPath, toAppend, "utf-8");
     this.dirty = true;
     this.debug?.(`memory append: ${relativePath}`);
   }
@@ -3277,7 +3304,7 @@ ${text}`;
 }
 
 // src/cli/commands/upsert.ts
-import * as fs5 from "fs/promises";
+import * as fs6 from "fs/promises";
 import * as path7 from "path";
 async function upsert(file, content, options) {
   const memoryDir = resolveMemoryDir({ dir: options.dir, global: options.global });
@@ -3312,13 +3339,13 @@ async function upsert(file, content, options) {
     );
   }
   const parentDir = path7.dirname(filePath);
-  await fs5.mkdir(parentDir, { recursive: true });
+  await fs6.mkdir(parentDir, { recursive: true });
   let isUpdate = false;
   let existingContent;
   try {
-    await fs5.access(filePath);
+    await fs6.access(filePath);
     isUpdate = true;
-    existingContent = await fs5.readFile(filePath, "utf-8");
+    existingContent = await fs6.readFile(filePath, "utf-8");
   } catch {
   }
   let contentToWrite = finalContent;
@@ -3346,7 +3373,7 @@ async function upsert(file, content, options) {
       });
     }
   }
-  await fs5.writeFile(filePath, contentToWrite, "utf-8");
+  await fs6.writeFile(filePath, contentToWrite, "utf-8");
   const relativePath = path7.relative(memoryDir, filePath);
   const action = isUpdate ? "Updated" : "Created";
   console.log(`${action}: ${relativePath}`);
@@ -3386,7 +3413,7 @@ async function readStdin() {
 }
 
 // src/cli/commands/mcp.ts
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import * as path8 from "path";
 
 // src/server/mcp.ts
@@ -4083,12 +4110,11 @@ async function mcp(options) {
 }
 async function ensureGlobalInitialized(globalDir) {
   console.error(`Auto-initializing global memory directory (~/.minimem)...`);
-  await fs6.mkdir(globalDir, { recursive: true });
-  await fs6.mkdir(path8.join(globalDir, "memory"), { recursive: true });
-  await fs6.mkdir(path8.join(globalDir, ".minimem"), { recursive: true });
+  await fs7.mkdir(globalDir, { recursive: true });
+  await fs7.mkdir(path8.join(globalDir, "memory"), { recursive: true });
   const memoryFilePath = path8.join(globalDir, "MEMORY.md");
   try {
-    await fs6.access(memoryFilePath);
+    await fs7.access(memoryFilePath);
   } catch {
     const template = `# Global Memory
 
@@ -4099,12 +4125,13 @@ Notes stored here are available across all projects.
 ## Notes
 
 `;
-    await fs6.writeFile(memoryFilePath, template, "utf-8");
+    await fs7.writeFile(memoryFilePath, template, "utf-8");
   }
   const config2 = getInitConfig();
-  await saveConfig(globalDir, config2);
-  const gitignorePath = path8.join(globalDir, ".minimem", ".gitignore");
-  await fs6.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
+  const configPath = path8.join(globalDir, "config.json");
+  await fs7.writeFile(configPath, JSON.stringify(config2, null, 2), "utf-8");
+  const gitignorePath = path8.join(globalDir, ".gitignore");
+  await fs7.writeFile(gitignorePath, "index.db\nindex.db-*\n", "utf-8");
   console.error(`  Created ~/.minimem with default configuration.`);
 }
 
@@ -4250,9 +4277,9 @@ async function handleXdgConfigEdit(options) {
   }
 }
 async function loadConfigFile2(configPath) {
-  const fs18 = await import("fs/promises");
+  const fs19 = await import("fs/promises");
   try {
-    const content = await fs18.readFile(configPath, "utf-8");
+    const content = await fs19.readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -4298,16 +4325,16 @@ function unsetConfigValue(config2, keyPath) {
 }
 
 // src/cli/commands/sync-init.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 import path12 from "path";
 
 // src/cli/sync/central.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 import path11 from "path";
 import { execSync } from "child_process";
 
 // src/cli/sync/registry.ts
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import path9 from "path";
 import os5 from "os";
 import crypto3 from "crypto";
@@ -4324,7 +4351,7 @@ function createEmptyRegistry() {
 async function readRegistry(centralRepo) {
   const registryPath = getRegistryPath(centralRepo);
   try {
-    const content = await fs7.readFile(registryPath, "utf-8");
+    const content = await fs8.readFile(registryPath, "utf-8");
     const registry = JSON.parse(content);
     if (!registry.mappings || !Array.isArray(registry.mappings)) {
       return createEmptyRegistry();
@@ -4338,8 +4365,8 @@ async function writeRegistry(centralRepo, registry) {
   const registryPath = getRegistryPath(centralRepo);
   const tempPath = `${registryPath}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
   registry.version = registry.version || 1;
-  await fs7.writeFile(tempPath, JSON.stringify(registry, null, 2), "utf-8");
-  await fs7.rename(tempPath, registryPath);
+  await fs8.writeFile(tempPath, JSON.stringify(registry, null, 2), "utf-8");
+  await fs8.rename(tempPath, registryPath);
 }
 function normalizePath(filePath) {
   if (filePath.startsWith("~/")) {
@@ -4417,7 +4444,7 @@ function updateLastSync(registry, centralPath, machineId) {
 }
 
 // src/cli/sync/detection.ts
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 import path10 from "path";
 async function isInsideGitRepo(dir) {
   let current = path10.resolve(dir);
@@ -4425,7 +4452,7 @@ async function isInsideGitRepo(dir) {
   while (current !== root) {
     try {
       const gitPath = path10.join(current, ".git");
-      const stat = await fs8.stat(gitPath);
+      const stat = await fs9.stat(gitPath);
       if (stat.isDirectory() || stat.isFile()) {
         return true;
       }
@@ -4438,7 +4465,7 @@ async function isInsideGitRepo(dir) {
 async function hasSyncConfig(dir) {
   const configPath = getConfigPath(dir);
   try {
-    const content = await fs8.readFile(configPath, "utf-8");
+    const content = await fs9.readFile(configPath, "utf-8");
     const config2 = JSON.parse(content);
     return config2.sync?.enabled === true || typeof config2.sync?.path === "string";
   } catch {
@@ -4508,8 +4535,8 @@ minimem sync init --path <directory-name>/
 async function isWritable(dirPath) {
   try {
     const testFile = path11.join(dirPath, `.minimem-write-test-${Date.now()}`);
-    await fs9.writeFile(testFile, "test");
-    await fs9.unlink(testFile);
+    await fs10.writeFile(testFile, "test");
+    await fs10.unlink(testFile);
     return true;
   } catch {
     return false;
@@ -4539,7 +4566,7 @@ async function initCentralRepo(repoPath) {
   }
   let dirExists = false;
   try {
-    const stat = await fs9.stat(resolvedPath);
+    const stat = await fs10.stat(resolvedPath);
     dirExists = stat.isDirectory();
   } catch {
     dirExists = false;
@@ -4547,7 +4574,7 @@ async function initCentralRepo(repoPath) {
   let created = false;
   if (!dirExists) {
     try {
-      await fs9.mkdir(resolvedPath, { recursive: true });
+      await fs10.mkdir(resolvedPath, { recursive: true });
       created = true;
     } catch (error) {
       return {
@@ -4581,21 +4608,21 @@ async function initCentralRepo(repoPath) {
   }
   const gitignorePath = path11.join(resolvedPath, ".gitignore");
   try {
-    await fs9.access(gitignorePath);
+    await fs10.access(gitignorePath);
   } catch {
-    await fs9.writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
+    await fs10.writeFile(gitignorePath, GITIGNORE_CONTENT, "utf-8");
   }
   const registryPath = getRegistryPath(resolvedPath);
   try {
-    await fs9.access(registryPath);
+    await fs10.access(registryPath);
   } catch {
     await writeRegistry(resolvedPath, createEmptyRegistry());
   }
   const readmePath = path11.join(resolvedPath, "README.md");
   try {
-    await fs9.access(readmePath);
+    await fs10.access(readmePath);
   } catch {
-    await fs9.writeFile(readmePath, README_CONTENT, "utf-8");
+    await fs10.writeFile(readmePath, README_CONTENT, "utf-8");
   }
   const globalConfig = await loadXdgConfig();
   globalConfig.centralRepo = repoPath;
@@ -4613,7 +4640,7 @@ async function validateCentralRepo(repoPath) {
   const warnings = [];
   const errors = [];
   try {
-    const stat = await fs9.stat(resolvedPath);
+    const stat = await fs10.stat(resolvedPath);
     if (!stat.isDirectory()) {
       errors.push("Path is not a directory");
       return { valid: false, warnings, errors };
@@ -4628,7 +4655,7 @@ async function validateCentralRepo(repoPath) {
   }
   const registryPath = getRegistryPath(resolvedPath);
   try {
-    await fs9.access(registryPath);
+    await fs10.access(registryPath);
     const registry = await readRegistry(resolvedPath);
     if (!registry.mappings) {
       warnings.push("Registry file is malformed");
@@ -4638,7 +4665,7 @@ async function validateCentralRepo(repoPath) {
   }
   const gitignorePath = path11.join(resolvedPath, ".gitignore");
   try {
-    const gitignore = await fs9.readFile(gitignorePath, "utf-8");
+    const gitignore = await fs10.readFile(gitignorePath, "utf-8");
     if (!gitignore.includes("*.db")) {
       warnings.push(".gitignore does not exclude database files");
     }
@@ -4765,7 +4792,7 @@ async function syncInit(options) {
   console.log("  Registered mapping in central repository");
   const centralDir = path12.join(centralRepo, centralPath);
   try {
-    await fs10.mkdir(centralDir, { recursive: true });
+    await fs11.mkdir(centralDir, { recursive: true });
   } catch {
   }
   console.log();
@@ -4842,19 +4869,19 @@ async function syncRemove(options) {
 }
 
 // src/cli/sync/operations.ts
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import path16 from "path";
 import crypto5 from "crypto";
 
 // src/cli/sync/state.ts
-import fs11 from "fs/promises";
+import fs12 from "fs/promises";
 import path13 from "path";
 import crypto4 from "crypto";
 import { minimatch } from "minimatch";
 var STATE_FILENAME = "sync-state.json";
-var STATE_DIR = ".minimem";
 function getSyncStatePath(dir) {
-  return path13.join(dir, STATE_DIR, STATE_FILENAME);
+  const subdir = resolveConfigSubdir(dir);
+  return path13.join(dir, subdir, STATE_FILENAME);
 }
 function createEmptySyncState(centralPath) {
   return {
@@ -4868,7 +4895,7 @@ function createEmptySyncState(centralPath) {
 async function loadSyncState(dir, centralPath) {
   const statePath = getSyncStatePath(dir);
   try {
-    const content = await fs11.readFile(statePath, "utf-8");
+    const content = await fs12.readFile(statePath, "utf-8");
     const state = JSON.parse(content);
     if (!state.files || typeof state.files !== "object") {
       return createEmptySyncState(centralPath);
@@ -4890,23 +4917,24 @@ async function saveSyncState(dir, state) {
   const statePath = getSyncStatePath(dir);
   const stateDir = path13.dirname(statePath);
   const tempPath = `${statePath}.${crypto4.randomBytes(4).toString("hex")}.tmp`;
-  await fs11.mkdir(stateDir, { recursive: true });
+  await fs12.mkdir(stateDir, { recursive: true });
   state.version = state.version || 2;
-  await fs11.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
-  await fs11.rename(tempPath, statePath);
+  await fs12.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
+  await fs12.rename(tempPath, statePath);
 }
 async function computeFileHash(filePath) {
-  const content = await fs11.readFile(filePath);
+  const content = await fs12.readFile(filePath);
   return crypto4.createHash("sha256").update(content).digest("hex");
 }
 async function listSyncableFiles(dir, include, exclude) {
   const files = [];
   async function walkDir2(currentDir, relativePath = "") {
-    const entries = await fs11.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs12.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const entryPath = path13.join(currentDir, entry.name);
       const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-      if (entry.name === ".minimem") continue;
+      if (entry.name === ".minimem" || entry.name === ".swarm") continue;
+      if (entry.name === "index.db" || entry.name.startsWith("index.db-")) continue;
       if (entry.isDirectory()) {
         await walkDir2(entryPath, relPath);
       } else if (entry.isFile()) {
@@ -4933,7 +4961,7 @@ async function listSyncableFiles(dir, include, exclude) {
 }
 async function getFileHashInfo(filePath) {
   try {
-    const stat = await fs11.stat(filePath);
+    const stat = await fs12.stat(filePath);
     const hash = await computeFileHash(filePath);
     return {
       exists: true,
@@ -4961,26 +4989,27 @@ function getFileSyncStatus(localHash, remoteHash) {
 }
 
 // src/cli/commands/conflicts.ts
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 import path15 from "path";
 import { spawn } from "child_process";
 
 // src/cli/sync/conflicts.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import path14 from "path";
 var CONFLICTS_DIR = "conflicts";
 function getConflictsDir(memoryDir) {
-  return path14.join(memoryDir, ".minimem", CONFLICTS_DIR);
+  const subdir = resolveConfigSubdir(memoryDir);
+  return path14.join(memoryDir, subdir, CONFLICTS_DIR);
 }
 async function listQuarantinedConflicts(memoryDir) {
   const conflictsDir = getConflictsDir(memoryDir);
   const conflicts = [];
   try {
-    const entries = await fs12.readdir(conflictsDir, { withFileTypes: true });
+    const entries = await fs13.readdir(conflictsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const dirPath = path14.join(conflictsDir, entry.name);
-        const files = await fs12.readdir(dirPath);
+        const files = await fs13.readdir(dirPath);
         const uniqueFiles = /* @__PURE__ */ new Set();
         for (const file of files) {
           const baseName = file.replace(/\.(local|remote|base)$/, "");
@@ -5103,7 +5132,7 @@ async function resolveCommand(timestamp, options) {
   }
   const conflictDir = path15.join(getConflictsDir(memoryDir), timestamp);
   try {
-    await fs13.access(conflictDir);
+    await fs14.access(conflictDir);
   } catch {
     exitWithError(
       `Conflict '${timestamp}' not found.`,
@@ -5111,7 +5140,7 @@ async function resolveCommand(timestamp, options) {
     );
   }
   try {
-    const files = await fs13.readdir(conflictDir);
+    const files = await fs14.readdir(conflictDir);
     const fileGroups = /* @__PURE__ */ new Map();
     for (const file of files) {
       const match = file.match(/^(.+)\.(local|remote|base)$/);
@@ -5194,7 +5223,7 @@ async function cleanupCommand(options) {
     const conflictsDir = getConflictsDir(memoryDir);
     let entries = [];
     try {
-      entries = await fs13.readdir(conflictsDir);
+      entries = await fs14.readdir(conflictsDir);
     } catch {
       console.log("No conflicts directory found.");
       return;
@@ -5213,7 +5242,7 @@ async function cleanupCommand(options) {
         if (options.dryRun) {
           console.log(`  Would remove: ${entry}`);
         } else {
-          await fs13.rm(entryPath, { recursive: true, force: true });
+          await fs14.rm(entryPath, { recursive: true, force: true });
           console.log(`  Removed: ${entry}`);
         }
         cleaned++;
@@ -5236,15 +5265,16 @@ Removed ${cleaned} conflict(s), kept ${kept}`);
 var SYNC_LOG_FILE = "sync.log";
 var MAX_LOG_ENTRIES = 1e3;
 function getSyncLogPath(memoryDir) {
-  return path15.join(memoryDir, ".minimem", SYNC_LOG_FILE);
+  const subdir = resolveConfigSubdir(memoryDir);
+  return path15.join(memoryDir, subdir, SYNC_LOG_FILE);
 }
 async function appendSyncLog(memoryDir, entry) {
   const logPath = getSyncLogPath(memoryDir);
   try {
-    await fs13.mkdir(path15.dirname(logPath), { recursive: true });
+    await fs14.mkdir(path15.dirname(logPath), { recursive: true });
     let entries = [];
     try {
-      const content2 = await fs13.readFile(logPath, "utf-8");
+      const content2 = await fs14.readFile(logPath, "utf-8");
       entries = content2.split("\n").filter(Boolean).map((line) => JSON.parse(line));
     } catch {
     }
@@ -5253,7 +5283,7 @@ async function appendSyncLog(memoryDir, entry) {
       entries = entries.slice(-MAX_LOG_ENTRIES);
     }
     const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    await fs13.writeFile(logPath, content);
+    await fs14.writeFile(logPath, content);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     warn(`Failed to write sync log: ${message}`);
@@ -5262,7 +5292,7 @@ async function appendSyncLog(memoryDir, entry) {
 async function readSyncLog(memoryDir) {
   const logPath = getSyncLogPath(memoryDir);
   try {
-    const content = await fs13.readFile(logPath, "utf-8");
+    const content = await fs14.readFile(logPath, "utf-8");
     return content.split("\n").filter(Boolean).map((line) => JSON.parse(line));
   } catch {
     return [];
@@ -5312,18 +5342,18 @@ async function logCommand(options) {
 
 // src/cli/sync/operations.ts
 async function ensureDir2(dirPath) {
-  await fs14.mkdir(dirPath, { recursive: true });
+  await fs15.mkdir(dirPath, { recursive: true });
 }
 async function copyFileAtomic(src, dest) {
   const destDir = path16.dirname(dest);
   await ensureDir2(destDir);
   const tempDest = `${dest}.${crypto5.randomBytes(4).toString("hex")}.tmp`;
   try {
-    await fs14.copyFile(src, tempDest);
-    await fs14.rename(tempDest, dest);
+    await fs15.copyFile(src, tempDest);
+    await fs15.rename(tempDest, dest);
   } catch (error) {
     try {
-      await fs14.unlink(tempDest);
+      await fs15.unlink(tempDest);
     } catch {
     }
     throw error;
@@ -5696,10 +5726,10 @@ async function syncStatusCommand(options) {
 }
 
 // src/cli/commands/daemon.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 
 // src/cli/sync/daemon.ts
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import path19 from "path";
 import os6 from "os";
 
@@ -5710,7 +5740,7 @@ import { EventEmitter } from "events";
 var DEFAULT_DEBOUNCE_MS = 2e3;
 var DEFAULT_POLL_INTERVAL = 1e3;
 var DEFAULT_INCLUDE = ["MEMORY.md", "memory/**/*.md"];
-var DEFAULT_EXCLUDE = [".minimem/**", "node_modules/**", ".git/**"];
+var DEFAULT_EXCLUDE = [".minimem/**", "index.db", "index.db-*", "node_modules/**", ".git/**"];
 function createFileWatcher(memoryDir, options = {}) {
   const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   const include = options.include ?? DEFAULT_INCLUDE;
@@ -5736,7 +5766,10 @@ function createFileWatcher(memoryDir, options = {}) {
   };
   const handleEvent = (event, filePath) => {
     const relativePath = path17.relative(memoryDir, filePath);
-    if (relativePath.startsWith(".minimem")) {
+    if (relativePath.startsWith(".minimem") || relativePath.startsWith(".swarm")) {
+      return;
+    }
+    if (relativePath === "index.db" || relativePath.startsWith("index.db-")) {
       return;
     }
     const isIncluded = include.some((pattern) => {
@@ -5808,7 +5841,7 @@ function createFileWatcher(memoryDir, options = {}) {
 }
 
 // src/cli/sync/validation.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import path18 from "path";
 var STALE_THRESHOLD_DAYS = 30;
 async function validateRegistry() {
@@ -5893,7 +5926,7 @@ async function validateRegistry() {
     if (mapping.machineId === currentMachineId) {
       const localPath = expandPath3(mapping.localPath);
       try {
-        await fs15.access(localPath);
+        await fs16.access(localPath);
       } catch {
         result.issues.push({
           type: "missing",
@@ -5962,7 +5995,7 @@ function getDaemonLogPath() {
 async function isDaemonRunning() {
   const pidFile = getPidFilePath();
   try {
-    const content = await fs16.readFile(pidFile, "utf-8");
+    const content = await fs17.readFile(pidFile, "utf-8");
     const pid = parseInt(content.trim(), 10);
     if (isNaN(pid)) {
       return false;
@@ -5971,7 +6004,7 @@ async function isDaemonRunning() {
       process.kill(pid, 0);
       return true;
     } catch {
-      await fs16.unlink(pidFile).catch(() => {
+      await fs17.unlink(pidFile).catch(() => {
       });
       return false;
     }
@@ -5985,7 +6018,7 @@ async function getDaemonStatus() {
     return { running: false };
   }
   const pidFile = getPidFilePath();
-  const content = await fs16.readFile(pidFile, "utf-8");
+  const content = await fs17.readFile(pidFile, "utf-8");
   const pid = parseInt(content.trim(), 10);
   return {
     running: true,
@@ -5998,15 +6031,15 @@ async function writeLog(message, level = "info") {
   const line = `[${timestamp}] [${level.toUpperCase()}] ${message}
 `;
   try {
-    await fs16.mkdir(path19.dirname(logPath), { recursive: true });
+    await fs17.mkdir(path19.dirname(logPath), { recursive: true });
     try {
-      const stats = await fs16.stat(logPath);
+      const stats = await fs17.stat(logPath);
       if (stats.size > MAX_LOG_SIZE) {
-        await fs16.rename(logPath, `${logPath}.old`);
+        await fs17.rename(logPath, `${logPath}.old`);
       }
     } catch {
     }
-    await fs16.appendFile(logPath, line);
+    await fs17.appendFile(logPath, line);
   } catch (error) {
     console.error(`Failed to write log: ${error}`);
   }
@@ -6041,8 +6074,8 @@ async function startDaemon(options = {}) {
     throw new Error("Daemon is already running");
   }
   const daemonDir = getDaemonDir();
-  await fs16.mkdir(daemonDir, { recursive: true });
-  await fs16.writeFile(getPidFilePath(), String(process.pid));
+  await fs17.mkdir(daemonDir, { recursive: true });
+  await fs17.writeFile(getPidFilePath(), String(process.pid));
   await writeLog("Daemon starting");
   const centralRepo = await getCentralRepoPath();
   if (!centralRepo) {
@@ -6133,7 +6166,7 @@ async function startDaemon(options = {}) {
     }
     watchedDirs.clear();
     try {
-      await fs16.unlink(getPidFilePath());
+      await fs17.unlink(getPidFilePath());
     } catch {
     }
     await writeLog("Daemon stopped");
@@ -6257,7 +6290,7 @@ async function daemonStatusCommand() {
 async function daemonLogsCommand(options) {
   const logPath = getDaemonLogPath();
   try {
-    const content = await fs17.readFile(logPath, "utf-8");
+    const content = await fs18.readFile(logPath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const numLines = options.lines ?? 50;
     const displayLines = lines.slice(-numLines);
@@ -6266,12 +6299,12 @@ async function daemonLogsCommand(options) {
     }
     if (options.follow) {
       console.log("\n--- Following log (Ctrl+C to stop) ---\n");
-      let lastSize = (await fs17.stat(logPath)).size;
+      let lastSize = (await fs18.stat(logPath)).size;
       const poll = async () => {
         try {
-          const stats = await fs17.stat(logPath);
+          const stats = await fs18.stat(logPath);
           if (stats.size > lastSize) {
-            const fd = await fs17.open(logPath, "r");
+            const fd = await fs18.open(logPath, "r");
             const buffer = Buffer.alloc(stats.size - lastSize);
             await fd.read(buffer, 0, buffer.length, lastSize);
             await fd.close();