@strvmarv/total-recall 0.6.8-beta.4 → 0.6.8-beta.7

package/dist/index.js

@@ -6803,7 +6803,8 @@ import { randomUUID as randomUUID8 } from "crypto";
 
 // src/config.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
+import { join, isAbsolute } from "path";
+import { homedir } from "os";
 import { createHash, randomUUID } from "crypto";
 
 // node_modules/smol-toml/dist/error.js
@@ -7640,7 +7641,40 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 // src/config.ts
 var DEFAULTS_PATH = new URL("./defaults.toml", import.meta.url);
 function getDataDir() {
-  return process.env.TOTAL_RECALL_HOME ?? join(process.env.HOME ?? "~", ".total-recall");
+  return process.env.TOTAL_RECALL_HOME ?? join(homedir(), ".total-recall");
+}
+var SqliteDbPathError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SqliteDbPathError";
+  }
+};
+function getDbPath() {
+  const raw = process.env.TOTAL_RECALL_DB_PATH;
+  if (raw === void 0 || raw.trim() === "") {
+    return join(getDataDir(), "total-recall.db");
+  }
+  const trimmed = raw.trim();
+  if (trimmed.endsWith("/") || trimmed.endsWith("\\")) {
+    throw new SqliteDbPathError(
+      `TOTAL_RECALL_DB_PATH must be a file path, not a directory. Got: "${trimmed}"`
+    );
+  }
+  if (trimmed === "~") {
+    throw new SqliteDbPathError(
+      `TOTAL_RECALL_DB_PATH must be a file path, not a directory. Got: "~"`
+    );
+  }
+  let expanded = trimmed;
+  if (trimmed.startsWith("~/")) {
+    expanded = join(homedir(), trimmed.slice(2));
+  }
+  if (!isAbsolute(expanded)) {
+    throw new SqliteDbPathError(
+      `TOTAL_RECALL_DB_PATH must be absolute or start with ~/. Got: "${trimmed}"`
+    );
+  }
+  return expanded;
 }
 function loadConfig() {
   const defaultsText = readFileSync(DEFAULTS_PATH, "utf-8");
@@ -7734,9 +7768,9 @@ function deepMerge(target, source) {
 }
 
 // src/db/connection.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { Database as Database2 } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
 
 // node_modules/sqlite-vec/index.mjs
 import { fileURLToPath } from "url";
@@ -7988,16 +8022,55 @@ function initSchema(db) {
   migrate();
 }
 
+// src/db/sqlite-bootstrap.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync2 } from "fs";
+var DARWIN_SQLITE_CANDIDATES = [
+  "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib",
+  // Apple Silicon brew
+  "/usr/local/opt/sqlite/lib/libsqlite3.dylib"
+  // Intel brew
+];
+var SqliteExtensionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SqliteExtensionError";
+  }
+};
+var _bootstrapped = false;
+function bootstrapSqlite() {
+  if (_bootstrapped) return;
+  _bootstrapped = true;
+  if (process.platform !== "darwin") return;
+  for (const candidate of DARWIN_SQLITE_CANDIDATES) {
+    if (existsSync2(candidate)) {
+      Database.setCustomSQLite(candidate);
+      return;
+    }
+  }
+  throw new SqliteExtensionError(
+    [
+      "total-recall: no extension-capable libsqlite3 found on this Mac.",
+      "",
+      "macOS ships /usr/lib/libsqlite3.dylib without SQLITE_ENABLE_LOAD_EXTENSION,",
+      "so sqlite-vec cannot be loaded. Install Homebrew sqlite to fix:",
+      "",
+      "  brew install sqlite",
+      "",
+      "total-recall will automatically pick it up from:",
+      ...DARWIN_SQLITE_CANDIDATES.map((p) => `  - ${p}`)
+    ].join("\n")
+  );
+}
+
 // src/db/connection.ts
 var _db = null;
 function getDb() {
   if (_db) return _db;
-  const dataDir = getDataDir();
-  if (!existsSync2(dataDir)) {
-    mkdirSync2(dataDir, { recursive: true });
-  }
-  const dbPath = join2(dataDir, "total-recall.db");
-  _db = new Database(dbPath);
+  bootstrapSqlite();
+  const dbPath = getDbPath();
+  mkdirSync2(dirname(dbPath), { recursive: true });
+  _db = new Database2(dbPath);
   load(_db);
   initSchema(_db);
   return _db;
@@ -8011,30 +8084,30 @@ function closeDb() {
 
 // src/embedding/embedder.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 import * as ort from "onnxruntime-node";
 
 // src/embedding/bootstrap.ts
 import { mkdirSync as mkdirSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 
 // src/embedding/registry.ts
 import { readFileSync as readFileSync2 } from "fs";
 
 // src/pkg-root.ts
 import { existsSync as existsSync3 } from "fs";
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cached = null;
 function getPackageRoot() {
   if (cached) return cached;
-  let dir = dirname(fileURLToPath2(import.meta.url));
+  let dir = dirname2(fileURLToPath2(import.meta.url));
   for (let i = 0; i < 10; i++) {
-    if (existsSync3(join3(dir, "package.json"))) {
+    if (existsSync3(join2(dir, "package.json"))) {
       cached = dir;
       return dir;
     }
-    const parent = dirname(dir);
+    const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -8043,7 +8116,7 @@ function getPackageRoot() {
   );
 }
 function pkgPath(...segments) {
-  return join3(getPackageRoot(), ...segments);
+  return join2(getPackageRoot(), ...segments);
 }
 
 // src/embedding/registry.ts
@@ -8096,14 +8169,14 @@ import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { createWriteStream } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { join as join4, dirname as dirname2 } from "path";
+import { join as join3, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getBundledModelPath(modelName) {
-  const distDir = dirname2(fileURLToPath3(import.meta.url));
-  return join4(distDir, "..", "models", modelName);
+  const distDir = dirname3(fileURLToPath3(import.meta.url));
+  return join3(distDir, "..", "models", modelName);
 }
 function getUserModelPath(modelName) {
-  return join4(getDataDir(), "models", modelName);
+  return join3(getDataDir(), "models", modelName);
 }
 function getModelPath(modelName) {
   const bundled = getBundledModelPath(modelName);
@@ -8206,10 +8279,10 @@ async function downloadModel(modelName, options = {}) {
   const fileCount = fileEntries.length;
   for (let i = 0; i < fileEntries.length; i++) {
     const { file: file2, url: url2 } = fileEntries[i];
-    const finalPath = join4(target, file2);
+    const finalPath = join3(target, file2);
     await downloadFile(url2, finalPath, file2, i, fileCount, options, maxRetries);
   }
-  const onnxPath = join4(target, "model.onnx");
+  const onnxPath = join3(target, "model.onnx");
   const actualHash = await sha256File(onnxPath);
   if (actualHash !== spec.sha256) {
     try {
@@ -8220,7 +8293,7 @@ async function downloadModel(modelName, options = {}) {
       `sha256 mismatch for model.onnx: expected ${spec.sha256}, actual ${actualHash}`
     );
   }
-  const sidecarPath = join4(target, ".verified");
+  const sidecarPath = join3(target, ".verified");
   await writeFileAtomic(sidecarPath, spec.sha256);
   return target;
 }
@@ -8255,11 +8328,11 @@ async function writeFileAtomic(dest, data) {
 function isModelStructurallyValid(modelPath, spec) {
   if (!existsSync4(modelPath)) return false;
   for (const file2 of Object.keys(spec.files)) {
-    const p = join4(modelPath, file2);
+    const p = join3(modelPath, file2);
     if (!existsSync4(p)) return false;
   }
   try {
-    const onnx = join4(modelPath, "model.onnx");
+    const onnx = join3(modelPath, "model.onnx");
     const size = statSync(onnx).size;
     return size === spec.sizeBytes;
   } catch {
@@ -8267,7 +8340,7 @@ function isModelStructurallyValid(modelPath, spec) {
   }
 }
 async function isModelChecksumValid(modelPath, spec) {
-  const sidecarPath = join4(modelPath, ".verified");
+  const sidecarPath = join3(modelPath, ".verified");
   if (existsSync4(sidecarPath)) {
     try {
       const cached4 = (await readFile(sidecarPath, "utf8")).trim();
@@ -8275,7 +8348,7 @@ async function isModelChecksumValid(modelPath, spec) {
     } catch {
     }
   }
-  const onnxPath = join4(modelPath, "model.onnx");
+  const onnxPath = join3(modelPath, "model.onnx");
   if (!existsSync4(onnxPath)) return false;
   let computed;
   try {
@@ -8316,7 +8389,7 @@ import * as lockfile from "proper-lockfile";
 var defaultAcquireLock = async (targetDir) => {
   mkdirSync4(targetDir, { recursive: true });
   const release = await lockfile.lock(targetDir, {
-    lockfilePath: join5(targetDir, ".bootstrap.lock"),
+    lockfilePath: join4(targetDir, ".bootstrap.lock"),
     retries: { retries: 60, minTimeout: 1e3, maxTimeout: 1e3 }
   });
   return { release: async () => {
@@ -8579,9 +8652,9 @@ var Embedder = class {
       }
     }
     const modelPath = await this.bootstrap.ensureReady();
-    const onnxPath = join6(modelPath, "model.onnx");
+    const onnxPath = join5(modelPath, "model.onnx");
     this.session = await ort.InferenceSession.create(onnxPath);
-    const tokenizerPath = join6(modelPath, "tokenizer.json");
+    const tokenizerPath = join5(modelPath, "tokenizer.json");
     const tokenizerText = await readFile2(tokenizerPath, "utf-8");
     const tokenizerJson = JSON.parse(tokenizerText);
     this.tokenizer = new WordPieceTokenizer(tokenizerJson.model.vocab);
@@ -23515,7 +23588,6 @@ async function handleMemoryTool(name, args, ctx) {
 
 // src/tools/system-tools.ts
 import { statSync as statSync2 } from "fs";
-import { join as join7 } from "path";
 
 // src/ingestion/hierarchical-index.ts
 function rowToEntry2(row) {
@@ -23644,8 +23716,7 @@ function handleSystemTool(name, args, ctx) {
       const key = `${tier}_${type === "memory" ? "memories" : "knowledge"}`;
       tierSizes[key] = countEntries(ctx.db, tier, type);
     }
-    const dataDir = getDataDir();
-    const dbPath = join7(dataDir, "total-recall.db");
+    const dbPath = getDbPath();
     let dbSizeBytes = null;
     try {
       dbSizeBytes = statSync2(dbPath).size;
@@ -23742,7 +23813,7 @@ import { statSync as statSync4 } from "fs";
 
 // src/ingestion/ingest.ts
 import { readFileSync as readFileSync3, readdirSync, statSync as statSync3 } from "fs";
-import { join as join8, dirname as dirname3, basename, extname } from "path";
+import { join as join6, dirname as dirname4, basename, extname } from "path";
 
 // src/ingestion/markdown-parser.ts
 function estimateTokens(text) {
@@ -24215,7 +24286,7 @@ async function ingestFile(db, embed, filePath, collectionId) {
   const chunks = chunkFile(content, filePath, { maxTokens: 512, overlapTokens: 50 });
   let resolvedCollectionId = collectionId;
   if (!resolvedCollectionId) {
-    const dirPath = dirname3(filePath);
+    const dirPath = dirname4(filePath);
     const dirName = basename(dirPath);
     resolvedCollectionId = await createCollection(db, embed, {
       name: dirName,
@@ -24262,7 +24333,7 @@ function walkDirectory(dirPath) {
   }
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules") continue;
-    const fullPath = join8(dirPath, entry);
+    const fullPath = join6(dirPath, entry);
     let stat;
     try {
       stat = statSync3(fullPath);
@@ -24581,7 +24652,7 @@ function registerKbTools() {
 }
 
 // src/tools/eval-tools.ts
-import { resolve as resolve3, dirname as dirname5, basename as basename3 } from "path";
+import { resolve as resolve3, dirname as dirname6, basename as basename3 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/eval/benchmark-runner.ts
@@ -24662,9 +24733,9 @@ async function runBenchmark(db, embed, opts) {
 // src/eval/benchmark-candidates.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve2, dirname as dirname4, basename as basename2 } from "path";
+import { resolve as resolve2, dirname as dirname5, basename as basename2 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-var __dirname = dirname4(fileURLToPath4(import.meta.url));
+var __dirname = dirname5(fileURLToPath4(import.meta.url));
 var PACKAGE_ROOT = basename2(__dirname) === "dist" ? resolve2(__dirname, "..") : resolve2(__dirname, "..", "..");
 function writeCandidates(db, misses, contexts) {
   const contextMap = new Map(contexts.map((c) => [c.query, c]));
@@ -24911,7 +24982,7 @@ function computeCompactionHealth(rows) {
 }
 
 // src/tools/eval-tools.ts
-var __dirname2 = dirname5(fileURLToPath5(import.meta.url));
+var __dirname2 = dirname6(fileURLToPath5(import.meta.url));
 var PACKAGE_ROOT2 = basename3(__dirname2) === "dist" ? resolve3(__dirname2, "..") : resolve3(__dirname2, "..", "..");
 var EVAL_TOOLS = [
   {
@@ -25099,8 +25170,8 @@ function registerEvalTools() {
 
 // src/importers/claude-code.ts
 import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
-import { join as join9 } from "path";
-import { homedir } from "os";
+import { join as join7 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/importers/import-utils.ts
 import { createHash as createHash3 } from "crypto";
@@ -25142,29 +25213,29 @@ var ClaudeCodeImporter = class {
   name = "claude-code";
   basePath;
   constructor(basePath) {
-    this.basePath = basePath ?? join9(homedir(), ".claude");
+    this.basePath = basePath ?? join7(homedir2(), ".claude");
   }
   detect() {
-    return existsSync5(this.basePath) && existsSync5(join9(this.basePath, "projects"));
+    return existsSync5(this.basePath) && existsSync5(join7(this.basePath, "projects"));
   }
   scan() {
     let memoryFiles = 0;
     let knowledgeFiles = 0;
     let sessionFiles = 0;
-    const projectsDir = join9(this.basePath, "projects");
+    const projectsDir = join7(this.basePath, "projects");
     if (!existsSync5(projectsDir)) {
       return { memoryFiles, knowledgeFiles, sessionFiles };
     }
     for (const projectEntry of readdirSync2(projectsDir, { withFileTypes: true })) {
       if (!projectEntry.isDirectory()) continue;
-      const projectDir = join9(projectsDir, projectEntry.name);
-      const memoryDir = join9(projectDir, "memory");
+      const projectDir = join7(projectsDir, projectEntry.name);
+      const memoryDir = join7(projectDir, "memory");
       if (existsSync5(memoryDir)) {
         for (const f of readdirSync2(memoryDir)) {
           if (f.endsWith(".md") && f !== "MEMORY.md") memoryFiles++;
         }
       }
-      if (existsSync5(join9(projectDir, "CLAUDE.md"))) knowledgeFiles++;
+      if (existsSync5(join7(projectDir, "CLAUDE.md"))) knowledgeFiles++;
       for (const f of readdirSync2(projectDir)) {
         if (f.endsWith(".jsonl")) sessionFiles++;
       }
@@ -25173,16 +25244,16 @@ var ClaudeCodeImporter = class {
   }
   async importMemories(db, embed, project) {
     const result = { imported: 0, skipped: 0, errors: [] };
-    const projectsDir = join9(this.basePath, "projects");
+    const projectsDir = join7(this.basePath, "projects");
     if (!existsSync5(projectsDir)) return result;
     for (const projectEntry of readdirSync2(projectsDir, { withFileTypes: true })) {
       if (!projectEntry.isDirectory()) continue;
-      const projectDir = join9(projectsDir, projectEntry.name);
-      const memoryDir = join9(projectDir, "memory");
+      const projectDir = join7(projectsDir, projectEntry.name);
+      const memoryDir = join7(projectDir, "memory");
       if (!existsSync5(memoryDir)) continue;
       for (const filename of readdirSync2(memoryDir)) {
         if (!filename.endsWith(".md") || filename === "MEMORY.md") continue;
-        const filePath = join9(memoryDir, filename);
+        const filePath = join7(memoryDir, filename);
         try {
           const raw = readFileSync6(filePath, "utf8");
           const hash2 = contentHash(raw);
@@ -25217,7 +25288,7 @@ var ClaudeCodeImporter = class {
   }
   async importKnowledge(db, embed) {
     const result = { imported: 0, skipped: 0, errors: [] };
-    const claudeMdPath = join9(this.basePath, "CLAUDE.md");
+    const claudeMdPath = join7(this.basePath, "CLAUDE.md");
     if (!existsSync5(claudeMdPath)) return result;
     try {
       const raw = readFileSync6(claudeMdPath, "utf8");
@@ -25247,28 +25318,28 @@ var ClaudeCodeImporter = class {
 
 // src/importers/copilot-cli.ts
 import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
 var CopilotCliImporter = class {
   name = "copilot-cli";
   basePath;
   constructor(basePath) {
-    this.basePath = basePath ?? join10(homedir2(), ".copilot");
+    this.basePath = basePath ?? join8(homedir3(), ".copilot");
   }
   detect() {
-    return existsSync6(this.basePath) && existsSync6(join10(this.basePath, "session-state"));
+    return existsSync6(this.basePath) && existsSync6(join8(this.basePath, "session-state"));
   }
   scan() {
     let knowledgeFiles = 0;
     let sessionFiles = 0;
-    const sessionStateDir = join10(this.basePath, "session-state");
+    const sessionStateDir = join8(this.basePath, "session-state");
     if (!existsSync6(sessionStateDir)) {
       return { memoryFiles: 0, knowledgeFiles, sessionFiles };
     }
     for (const entry of readdirSync3(sessionStateDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const sessionDir = join10(sessionStateDir, entry.name);
-      if (existsSync6(join10(sessionDir, "plan.md"))) knowledgeFiles++;
+      const sessionDir = join8(sessionStateDir, entry.name);
+      if (existsSync6(join8(sessionDir, "plan.md"))) knowledgeFiles++;
       for (const f of readdirSync3(sessionDir)) {
         if (f.endsWith(".jsonl")) sessionFiles++;
       }
@@ -25280,11 +25351,11 @@ var CopilotCliImporter = class {
   }
   async importKnowledge(db, embed) {
     const result = { imported: 0, skipped: 0, errors: [] };
-    const sessionStateDir = join10(this.basePath, "session-state");
+    const sessionStateDir = join8(this.basePath, "session-state");
     if (!existsSync6(sessionStateDir)) return result;
     for (const entry of readdirSync3(sessionStateDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const planPath = join10(sessionStateDir, entry.name, "plan.md");
+      const planPath = join8(sessionStateDir, entry.name, "plan.md");
       if (!existsSync6(planPath)) continue;
       try {
         const raw = readFileSync7(planPath, "utf8");
@@ -25311,36 +25382,44 @@ var CopilotCliImporter = class {
 
 // src/importers/cursor.ts
 import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir3 } from "os";
-import { Database as Database2 } from "bun:sqlite";
+import { join as join9 } from "path";
+import { homedir as homedir4 } from "os";
+import { fileURLToPath as fileURLToPath6 } from "url";
+import { Database as Database3 } from "bun:sqlite";
+function safeFileURLToPath(url2) {
+  try {
+    return fileURLToPath6(url2);
+  } catch {
+    return null;
+  }
+}
 var CursorImporter = class {
   name = "cursor";
   configPath;
   extensionPath;
   constructor(configPath, extensionPath) {
-    this.configPath = configPath ?? join11(homedir3(), ".config", "Cursor");
-    this.extensionPath = extensionPath ?? join11(homedir3(), ".cursor");
+    this.configPath = configPath ?? join9(homedir4(), ".config", "Cursor");
+    this.extensionPath = extensionPath ?? join9(homedir4(), ".cursor");
   }
   detect() {
     return existsSync7(this.configPath) || existsSync7(this.extensionPath);
   }
   scan() {
     let knowledgeFiles = 0;
-    const globalDb = join11(this.configPath, "User", "globalStorage", "state.vscdb");
+    const globalDb = join9(this.configPath, "User", "globalStorage", "state.vscdb");
     if (existsSync7(globalDb)) knowledgeFiles++;
-    const workspaceDir = join11(this.configPath, "User", "workspaceStorage");
+    const workspaceDir = join9(this.configPath, "User", "workspaceStorage");
     if (existsSync7(workspaceDir)) {
       for (const entry of readdirSync4(workspaceDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const wsJson = join11(workspaceDir, entry.name, "workspace.json");
+        const wsJson = join9(workspaceDir, entry.name, "workspace.json");
         if (!existsSync7(wsJson)) continue;
         try {
           const ws = JSON.parse(readFileSync8(wsJson, "utf8"));
-          const projectPath = ws.folder ? decodeURIComponent(new URL(ws.folder).pathname) : ws.workspace ? decodeURIComponent(new URL(ws.workspace).pathname) : null;
+          const projectPath = ws.folder ? safeFileURLToPath(ws.folder) : ws.workspace ? safeFileURLToPath(ws.workspace) : null;
           if (!projectPath) continue;
-          if (existsSync7(join11(projectPath, ".cursorrules"))) knowledgeFiles++;
-          const rulesDir = join11(projectPath, ".cursor", "rules");
+          if (existsSync7(join9(projectPath, ".cursorrules"))) knowledgeFiles++;
+          const rulesDir = join9(projectPath, ".cursor", "rules");
           if (existsSync7(rulesDir)) {
             for (const f of readdirSync4(rulesDir)) {
               if (f.endsWith(".mdc")) knowledgeFiles++;
@@ -25362,11 +25441,11 @@ var CursorImporter = class {
     return result;
   }
   async importGlobalRules(db, embed, result) {
-    const dbPath = join11(this.configPath, "User", "globalStorage", "state.vscdb");
+    const dbPath = join9(this.configPath, "User", "globalStorage", "state.vscdb");
     if (!existsSync7(dbPath)) return;
     let cursorDb = null;
     try {
-      cursorDb = new Database2(dbPath, { readonly: true });
+      cursorDb = new Database3(dbPath, { readonly: true });
       const row = cursorDb.query("SELECT value FROM ItemTable WHERE key = 'aicontext.personalContext'").get();
       if (!row?.value) return;
       const content = row.value;
@@ -25391,30 +25470,30 @@ var CursorImporter = class {
     }
   }
   async importProjectRules(db, embed, result) {
-    const workspaceDir = join11(this.configPath, "User", "workspaceStorage");
+    const workspaceDir = join9(this.configPath, "User", "workspaceStorage");
     if (!existsSync7(workspaceDir)) return;
     const projectPaths = /* @__PURE__ */ new Set();
     for (const entry of readdirSync4(workspaceDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const wsJson = join11(workspaceDir, entry.name, "workspace.json");
+      const wsJson = join9(workspaceDir, entry.name, "workspace.json");
       if (!existsSync7(wsJson)) continue;
       try {
         const ws = JSON.parse(readFileSync8(wsJson, "utf8"));
-        const projectPath = ws.folder ? new URL(ws.folder).pathname : ws.workspace ? new URL(ws.workspace).pathname : null;
+        const projectPath = ws.folder ? safeFileURLToPath(ws.folder) : ws.workspace ? safeFileURLToPath(ws.workspace) : null;
         if (projectPath) projectPaths.add(projectPath);
       } catch {
       }
     }
     for (const projectPath of projectPaths) {
-      const legacyPath = join11(projectPath, ".cursorrules");
+      const legacyPath = join9(projectPath, ".cursorrules");
       if (existsSync7(legacyPath)) {
         await this.importRuleFile(db, embed, result, legacyPath, ["cursorrules", "legacy"]);
       }
-      const rulesDir = join11(projectPath, ".cursor", "rules");
+      const rulesDir = join9(projectPath, ".cursor", "rules");
       if (existsSync7(rulesDir)) {
         for (const filename of readdirSync4(rulesDir)) {
           if (!filename.endsWith(".mdc")) continue;
-          await this.importRuleFile(db, embed, result, join11(rulesDir, filename), ["cursor-rule"]);
+          await this.importRuleFile(db, embed, result, join9(rulesDir, filename), ["cursor-rule"]);
         }
       }
     }
@@ -25446,24 +25525,24 @@ var CursorImporter = class {
 
 // src/importers/cline.ts
 import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync9 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir4 } from "os";
+import { join as join10 } from "path";
+import { homedir as homedir5 } from "os";
 var ClineImporter = class {
   name = "cline";
   dataPath;
   legacyPath;
   globalRulesPath;
   constructor(dataPath, legacyPath) {
-    this.dataPath = dataPath ?? join12(homedir4(), ".cline", "data");
-    this.legacyPath = legacyPath ?? join12(
-      homedir4(),
+    this.dataPath = dataPath ?? join10(homedir5(), ".cline", "data");
+    this.legacyPath = legacyPath ?? join10(
+      homedir5(),
       ".config",
       "Code",
       "User",
       "globalStorage",
       "saoudrizwan.claude-dev"
     );
-    this.globalRulesPath = join12(homedir4(), "Documents", "Cline", "Rules");
+    this.globalRulesPath = join10(homedir5(), "Documents", "Cline", "Rules");
   }
   detect() {
     return existsSync8(this.dataPath) || existsSync8(this.legacyPath);
@@ -25471,13 +25550,13 @@ var ClineImporter = class {
   scan() {
     let knowledgeFiles = 0;
     let sessionFiles = 0;
-    const ruleDirs = [this.globalRulesPath, join12(homedir4(), "Cline", "Rules")];
+    const ruleDirs = [this.globalRulesPath, join10(homedir5(), "Cline", "Rules")];
     for (const dir of ruleDirs) {
       if (existsSync8(dir)) knowledgeFiles += countFiles(dir, [".md", ".txt"]);
     }
     const stateDir = this.resolveStateDir();
     if (stateDir) {
-      const historyPath = join12(stateDir, "taskHistory.json");
+      const historyPath = join10(stateDir, "taskHistory.json");
       if (existsSync8(historyPath)) {
         try {
           const items = JSON.parse(readFileSync9(historyPath, "utf8"));
@@ -25486,7 +25565,7 @@ var ClineImporter = class {
         }
       }
     }
-    const mcpSettings = join12(this.resolveDataDir() ?? "", "settings", "cline_mcp_settings.json");
+    const mcpSettings = join10(this.resolveDataDir() ?? "", "settings", "cline_mcp_settings.json");
     if (existsSync8(mcpSettings)) knowledgeFiles++;
     return { memoryFiles: 0, knowledgeFiles, sessionFiles };
   }
@@ -25507,20 +25586,20 @@ var ClineImporter = class {
   resolveStateDir() {
     const dataDir = this.resolveDataDir();
     if (!dataDir) return null;
-    const newState = join12(dataDir, "state");
+    const newState = join10(dataDir, "state");
     if (existsSync8(newState)) return newState;
     return dataDir;
   }
   async importGlobalRules(db, embed, result) {
     const ruleDirs = [
       this.globalRulesPath,
-      join12(homedir4(), "Cline", "Rules")
+      join10(homedir5(), "Cline", "Rules")
     ];
     for (const dir of ruleDirs) {
       if (!existsSync8(dir)) continue;
       for (const filename of readdirSync5(dir)) {
         if (!filename.endsWith(".md") && !filename.endsWith(".txt")) continue;
-        const filePath = join12(dir, filename);
+        const filePath = join10(dir, filename);
         try {
           const raw = readFileSync9(filePath, "utf8");
           const hash2 = contentHash(raw);
@@ -25546,7 +25625,7 @@ var ClineImporter = class {
   async importTaskSummaries(db, embed, result) {
     const stateDir = this.resolveStateDir();
     if (!stateDir) return;
-    const historyPath = join12(stateDir, "taskHistory.json");
+    const historyPath = join10(stateDir, "taskHistory.json");
     if (!existsSync8(historyPath)) return;
     let items;
     try {
@@ -25595,20 +25674,20 @@ function countFiles(dir, extensions) {
 
 // src/importers/opencode.ts
 import { existsSync as existsSync9, readdirSync as readdirSync6, readFileSync as readFileSync10 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir5 } from "os";
-import { Database as Database3 } from "bun:sqlite";
+import { join as join11 } from "path";
+import { homedir as homedir6 } from "os";
+import { Database as Database4 } from "bun:sqlite";
 var OpenCodeImporter = class {
   name = "opencode";
   dataPath;
   configPath;
   constructor(dataPath, configPath) {
-    this.dataPath = dataPath ?? join13(
-      process.env["XDG_DATA_HOME"] ?? join13(homedir5(), ".local", "share"),
+    this.dataPath = dataPath ?? join11(
+      process.env["XDG_DATA_HOME"] ?? join11(homedir6(), ".local", "share"),
       "opencode"
     );
-    this.configPath = configPath ?? join13(
-      process.env["XDG_CONFIG_HOME"] ?? join13(homedir5(), ".config"),
+    this.configPath = configPath ?? join11(
+      process.env["XDG_CONFIG_HOME"] ?? join11(homedir6(), ".config"),
       "opencode"
     );
   }
@@ -25618,8 +25697,8 @@ var OpenCodeImporter = class {
   scan() {
     let knowledgeFiles = 0;
     let sessionFiles = 0;
-    if (existsSync9(join13(this.configPath, "AGENTS.md"))) knowledgeFiles++;
-    const dbPath = join13(this.dataPath, "opencode.db");
+    if (existsSync9(join11(this.configPath, "AGENTS.md"))) knowledgeFiles++;
+    const dbPath = join11(this.dataPath, "opencode.db");
     if (existsSync9(dbPath)) sessionFiles = 1;
     return { memoryFiles: 0, knowledgeFiles, sessionFiles };
   }
@@ -25633,7 +25712,7 @@ var OpenCodeImporter = class {
     return result;
   }
   async importAgentsMd(db, embed, result) {
-    const agentsMdPath = join13(this.configPath, "AGENTS.md");
+    const agentsMdPath = join11(this.configPath, "AGENTS.md");
     if (!existsSync9(agentsMdPath)) return;
     try {
       const raw = readFileSync10(agentsMdPath, "utf8");
@@ -25659,28 +25738,28 @@ var OpenCodeImporter = class {
   async importProjectContent(db, embed, result) {
     const projectPaths = await this.discoverProjects();
     for (const projectPath of projectPaths) {
-      const openCodeDir = join13(projectPath, ".opencode");
+      const openCodeDir = join11(projectPath, ".opencode");
       if (!existsSync9(openCodeDir)) continue;
-      const agentDir = join13(openCodeDir, "agent");
+      const agentDir = join11(openCodeDir, "agent");
       if (existsSync9(agentDir)) {
         await this.importMdDir(db, embed, result, agentDir, ["opencode-agent"]);
       }
-      const commandDir = join13(openCodeDir, "command");
+      const commandDir = join11(openCodeDir, "command");
       if (existsSync9(commandDir)) {
         await this.importMdDir(db, embed, result, commandDir, ["opencode-command"]);
       }
-      const projectAgentsMd = join13(projectPath, "AGENTS.md");
+      const projectAgentsMd = join11(projectPath, "AGENTS.md");
       if (existsSync9(projectAgentsMd)) {
         await this.importSingleFile(db, embed, result, projectAgentsMd, ["agents-md", "project"]);
       }
     }
   }
   async discoverProjects() {
-    const dbPath = join13(this.dataPath, "opencode.db");
+    const dbPath = join11(this.dataPath, "opencode.db");
     if (!existsSync9(dbPath)) return [];
     let ocDb = null;
     try {
-      ocDb = new Database3(dbPath, { readonly: true });
+      ocDb = new Database4(dbPath, { readonly: true });
       const rows = ocDb.query("SELECT worktree FROM project").all();
       return rows.map((r) => r.worktree).filter((p) => existsSync9(p));
     } catch {
@@ -25692,7 +25771,7 @@ var OpenCodeImporter = class {
   async importMdDir(db, embed, result, dir, tags) {
     for (const filename of readdirSync6(dir)) {
       if (!filename.endsWith(".md")) continue;
-      await this.importSingleFile(db, embed, result, join13(dir, filename), tags);
+      await this.importSingleFile(db, embed, result, join11(dir, filename), tags);
     }
   }
   async importSingleFile(db, embed, result, filePath, tags) {
@@ -25722,36 +25801,36 @@ var OpenCodeImporter = class {
 
 // src/importers/hermes.ts
 import { existsSync as existsSync10, readdirSync as readdirSync7, readFileSync as readFileSync11 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join12 } from "path";
+import { homedir as homedir7 } from "os";
 var HermesImporter = class {
   name = "hermes";
   basePath;
   constructor(basePath) {
-    this.basePath = basePath ?? (process.env["HERMES_HOME"] || join14(homedir6(), ".hermes"));
+    this.basePath = basePath ?? (process.env["HERMES_HOME"] || join12(homedir7(), ".hermes"));
   }
   detect() {
-    return existsSync10(this.basePath) && (existsSync10(join14(this.basePath, "state.db")) || existsSync10(join14(this.basePath, "memories")) || existsSync10(join14(this.basePath, "config.yaml")));
+    return existsSync10(this.basePath) && (existsSync10(join12(this.basePath, "state.db")) || existsSync10(join12(this.basePath, "memories")) || existsSync10(join12(this.basePath, "config.yaml")));
   }
   scan() {
     let memoryFiles = 0;
     let knowledgeFiles = 0;
     let sessionFiles = 0;
-    const memoriesDir = join14(this.basePath, "memories");
+    const memoriesDir = join12(this.basePath, "memories");
     if (existsSync10(memoriesDir)) {
-      if (existsSync10(join14(memoriesDir, "MEMORY.md"))) memoryFiles++;
-      if (existsSync10(join14(memoriesDir, "USER.md"))) memoryFiles++;
+      if (existsSync10(join12(memoriesDir, "MEMORY.md"))) memoryFiles++;
+      if (existsSync10(join12(memoriesDir, "USER.md"))) memoryFiles++;
     }
-    const skillsDir = join14(this.basePath, "skills");
+    const skillsDir = join12(this.basePath, "skills");
     if (existsSync10(skillsDir)) {
       for (const entry of readdirSync7(skillsDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && existsSync10(join14(skillsDir, entry.name, "SKILL.md"))) {
+        if (entry.isDirectory() && existsSync10(join12(skillsDir, entry.name, "SKILL.md"))) {
           knowledgeFiles++;
         }
       }
     }
-    if (existsSync10(join14(this.basePath, "SOUL.md"))) knowledgeFiles++;
-    if (existsSync10(join14(this.basePath, "state.db"))) sessionFiles = 1;
+    if (existsSync10(join12(this.basePath, "SOUL.md"))) knowledgeFiles++;
+    if (existsSync10(join12(this.basePath, "state.db"))) sessionFiles = 1;
     return { memoryFiles, knowledgeFiles, sessionFiles };
   }
   async importMemories(db, embed, _project) {
@@ -25760,21 +25839,21 @@ var HermesImporter = class {
       db,
       embed,
       result,
-      join14(this.basePath, "memories", "MEMORY.md"),
+      join12(this.basePath, "memories", "MEMORY.md"),
       ["hermes-memory"]
     );
     await this.importMemoryFile(
       db,
       embed,
       result,
-      join14(this.basePath, "memories", "USER.md"),
+      join12(this.basePath, "memories", "USER.md"),
       ["hermes-user", "user-profile"]
     );
     return result;
   }
   async importKnowledge(db, embed) {
     const result = { imported: 0, skipped: 0, errors: [] };
-    const soulPath = join14(this.basePath, "SOUL.md");
+    const soulPath = join12(this.basePath, "SOUL.md");
     if (existsSync10(soulPath)) {
       await this.importSingleFile(db, embed, result, soulPath, "warm", ["hermes-soul"]);
     }
@@ -25808,11 +25887,11 @@ var HermesImporter = class {
     }
   }
   async importSkills(db, embed, result) {
-    const skillsDir = join14(this.basePath, "skills");
+    const skillsDir = join12(this.basePath, "skills");
     if (!existsSync10(skillsDir)) return;
     for (const entry of readdirSync7(skillsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const skillPath = join14(skillsDir, entry.name, "SKILL.md");
+      const skillPath = join12(skillsDir, entry.name, "SKILL.md");
       if (!existsSync10(skillPath)) continue;
       await this.importSingleFile(db, embed, result, skillPath, "cold", ["hermes-skill", entry.name]);
     }
@@ -26040,7 +26119,7 @@ async function sweepWarmTier(db, embed, config2, sessionId) {
 
 // src/importers/project-docs.ts
 import { existsSync as existsSync11, readFileSync as readFileSync12, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
-import { join as join15, basename as basename4 } from "path";
+import { join as join13, basename as basename4 } from "path";
 import { createHash as createHash4 } from "crypto";
 var DOC_FILES = ["README.md", "CONTRIBUTING.md", "CLAUDE.md", "AGENTS.md"];
 var DOC_DIRS = ["docs", "doc"];
@@ -26065,11 +26144,11 @@ async function ingestProjectDocs(db, embed, cwd) {
   let collectionId = null;
   const filesToIngest = [];
   for (const file2 of DOC_FILES) {
-    const path = join15(cwd, file2);
+    const path = join13(cwd, file2);
     if (existsSync11(path)) filesToIngest.push(path);
   }
   for (const dir of DOC_DIRS) {
-    const dirPath = join15(cwd, dir);
+    const dirPath = join13(cwd, dir);
     if (existsSync11(dirPath) && statSync5(dirPath).isDirectory()) {
       collectMarkdownFiles(dirPath, filesToIngest);
     }
@@ -26097,7 +26176,7 @@ async function ingestProjectDocs(db, embed, cwd) {
 }
 function collectMarkdownFiles(dirPath, files) {
   for (const entry of readdirSync8(dirPath, { withFileTypes: true })) {
-    const full = join15(dirPath, entry.name);
+    const full = join13(dirPath, entry.name);
     if (entry.isDirectory()) {
       collectMarkdownFiles(full, files);
     } else if (entry.name.endsWith(".md")) {
@@ -26108,10 +26187,11 @@ function collectMarkdownFiles(dirPath, files) {
 
 // src/utils/project-detect.ts
 import { execFileSync } from "child_process";
-import { basename as basename5 } from "path";
+import { basename as basename5, parse as parsePath } from "path";
+import { homedir as homedir8 } from "os";
 function detectProject(cwd) {
-  const home = process.env.HOME ?? "";
-  if (cwd === home || cwd === "/") return null;
+  if (cwd === homedir8()) return null;
+  if (cwd === parsePath(cwd).root) return null;
   try {
     const remote = execFileSync("git", ["remote", "get-url", "origin"], {
       cwd,
@@ -26128,10 +26208,10 @@ function detectProject(cwd) {
 }
 
 // src/eval/smoke-test.ts
-import { resolve as resolve4, dirname as dirname6, basename as basename6 } from "path";
+import { resolve as resolve4, dirname as dirname7, basename as basename6 } from "path";
 import { readFileSync as readFileSync13 } from "fs";
-import { fileURLToPath as fileURLToPath6 } from "url";
-var __dirname3 = dirname6(fileURLToPath6(import.meta.url));
+import { fileURLToPath as fileURLToPath7 } from "url";
+var __dirname3 = dirname7(fileURLToPath7(import.meta.url));
 var PACKAGE_ROOT3 = basename6(__dirname3) === "dist" ? resolve4(__dirname3, "..") : resolve4(__dirname3, "..", "..");
 var SMOKE_PASS_THRESHOLD = 0.8;
 function getMetaValue(db, key) {
@@ -26529,7 +26609,7 @@ function registerSessionTools() {
 
 // src/tools/extra-tools.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3, readFileSync as readFileSync14 } from "fs";
-import { join as join16 } from "path";
+import { join as join14 } from "path";
 function registerExtraTools() {
   return [
     {
@@ -26762,10 +26842,10 @@ async function handleExtraTool(name, args, ctx) {
         });
       }
     }
-    const exportsDir = join16(getDataDir(), "exports");
+    const exportsDir = join14(getDataDir(), "exports");
     mkdirSync5(exportsDir, { recursive: true });
     const timestamp = Date.now();
-    const exportPath = join16(exportsDir, `${timestamp}.json`);
+    const exportPath = join14(exportsDir, `${timestamp}.json`);
     const exportData = { version: 1, exported_at: timestamp, entries: allEntries };
     const jsonStr = JSON.stringify(exportData, null, 2);
     writeFileSync3(exportPath, jsonStr, "utf-8");
@@ -26954,6 +27034,17 @@ async function startServer(ctx) {
 
 // src/index.ts
 async function main() {
+  let dbPath;
+  try {
+    dbPath = getDbPath();
+  } catch (e) {
+    if (e instanceof SqliteDbPathError) {
+      process.stderr.write(`total-recall: ${e.message}
+`);
+      process.exit(1);
+    }
+    throw e;
+  }
   const config2 = loadConfig();
   const db = getDb();
   const embedder = new Embedder({
@@ -26961,7 +27052,7 @@ async function main() {
     dimensions: config2.embedding.dimensions
   });
   const sessionId = randomUUID8();
-  process.stderr.write(`total-recall: MCP server starting (db: ${getDataDir()}/total-recall.db)
+  process.stderr.write(`total-recall: MCP server starting (db: ${dbPath})
 `);
   await startServer({ db, config: config2, embedder, sessionId, configSnapshotId: "default", sessionInitialized: false, sessionInitResult: null, sessionInitPromise: null });
   const cleanup = () => {