agentikit 0.0.13 → 0.0.14

package/dist/common.js

@@ -0,0 +1,192 @@
+import fs from "node:fs";
+import path from "node:path";
+import { TYPE_DIRS } from "./asset-spec";
+import { getConfigPath, getDefaultStashDir } from "./paths";
+// ── Constants ───────────────────────────────────────────────────────────────
+export const IS_WINDOWS = process.platform === "win32";
+export { SCRIPT_EXTENSIONS, TYPE_DIRS } from "./asset-spec";
+// ── Validators ──────────────────────────────────────────────────────────────
+export function isAssetType(type) {
+    return type in TYPE_DIRS;
+}
+// ── Utilities ───────────────────────────────────────────────────────────────
+/**
+ * Resolve the stash directory using a three-level fallback chain:
+ *   1. AKM_STASH_DIR environment variable (override for CI/scripts)
+ *   2. stashDir field in config.json
+ *   3. Platform default (~/agentikit or ~/Documents/agentikit on Windows)
+ *
+ * Throws if no valid stash directory is found.
+ */
+export function resolveStashDir(options) {
+    // 1. Env var override (for CI, scripts, testing)
+    const envDir = process.env.AKM_STASH_DIR?.trim();
+    if (envDir) {
+        const resolved = validateStashDir(envDir);
+        if (!options?.readOnly)
+            persistStashDirToConfig(resolved);
+        return resolved;
+    }
+    // 2. Config file stashDir field
+    const configStashDir = readStashDirFromConfig();
+    if (configStashDir)
+        return validateStashDir(configStashDir);
+    // 3. Platform default — use it if it exists
+    const defaultDir = getDefaultStashDir();
+    if (isValidDirectory(defaultDir)) {
+        return defaultDir;
+    }
+    throw new Error(`No stash directory found. Run "akm init" to create one at ${defaultDir}, ` +
+        `or set stashDir in ${getConfigPath()}.`);
+}
+function validateStashDir(raw) {
+    const stashDir = path.resolve(raw);
+    let stat;
+    try {
+        stat = fs.statSync(stashDir);
+    }
+    catch {
+        throw new Error(`Unable to read stash directory at "${stashDir}".`);
+    }
+    if (!stat.isDirectory()) {
+        throw new Error(`Stash path must point to a directory: "${stashDir}".`);
+    }
+    return stashDir;
+}
+function isValidDirectory(dir) {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read stashDir directly from config.json without pulling in the full config
+ * module, to avoid circular dependencies.
+ */
+function readStashDirFromConfig() {
+    try {
+        const configPath = getConfigPath();
+        const text = fs.readFileSync(configPath, "utf8");
+        const raw = JSON.parse(text);
+        if (typeof raw === "object" && raw !== null && typeof raw.stashDir === "string" && raw.stashDir.trim()) {
+            return raw.stashDir.trim();
+        }
+    }
+    catch {
+        // Config doesn't exist or is invalid — fall through
+    }
+    return undefined;
+}
+/**
+ * Persist stashDir to config.json if not already set, so users can
+ * transition away from relying on the AKM_STASH_DIR env var.
+ */
+function persistStashDirToConfig(stashDir) {
+    try {
+        const configPath = getConfigPath();
+        let raw = {};
+        try {
+            const text = fs.readFileSync(configPath, "utf8");
+            const parsed = JSON.parse(text);
+            if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+                raw = parsed;
+            }
+        }
+        catch {
+            // No existing config or invalid — start fresh
+        }
+        if (!raw.stashDir) {
+            raw.stashDir = stashDir;
+            const dir = path.dirname(configPath);
+            fs.mkdirSync(dir, { recursive: true });
+            const tmpPath = configPath + `.tmp.${process.pid}`;
+            fs.writeFileSync(tmpPath, JSON.stringify(raw, null, 2) + "\n", "utf8");
+            fs.renameSync(tmpPath, configPath);
+        }
+    }
+    catch {
+        // Non-fatal: best-effort persistence
+    }
+}
+export function toPosix(input) {
+    return input.replace(/\\/g, "/");
+}
+export function hasErrnoCode(error, code) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return false;
+    return error.code === code;
+}
+export function isWithin(candidate, root) {
+    const resolvedRoot = safeRealpath(root);
+    const resolvedCandidate = safeRealpath(candidate);
+    const normalizedRoot = normalizeFsPathForComparison(resolvedRoot);
+    const normalizedCandidate = normalizeFsPathForComparison(resolvedCandidate);
+    const rel = path.relative(normalizedRoot, normalizedCandidate);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+function safeRealpath(p) {
+    try {
+        return fs.realpathSync(path.resolve(p));
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+function normalizeFsPathForComparison(value) {
+    return process.platform === "win32" ? value.toLowerCase() : value;
+}
+/**
+ * Fetch with an AbortController timeout.
+ * Defaults to 30 seconds if no timeout is specified.
+ */
+export async function fetchWithTimeout(url, opts, timeoutMs = 30_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...opts, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Fetch with retry and exponential backoff.
+ * Retries on network errors, 429, and 5xx responses.
+ * Honors Retry-After header for 429 responses.
+ */
+export async function fetchWithRetry(url, init, options) {
+    const maxRetries = options?.retries ?? 3;
+    const baseDelay = options?.baseDelay ?? 500;
+    const timeout = options?.timeout ?? 30_000;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetchWithTimeout(url, init, timeout);
+            if (attempt < maxRetries && shouldRetry(response.status)) {
+                const retryAfter = parseRetryAfter(response);
+                const delay = retryAfter ?? baseDelay * Math.pow(2, attempt) * (0.5 + Math.random() * 0.5);
+                await new Promise((r) => setTimeout(r, delay));
+                continue;
+            }
+            return response;
+        }
+        catch (err) {
+            if (attempt >= maxRetries)
+                throw err;
+            const delay = baseDelay * Math.pow(2, attempt) * (0.5 + Math.random() * 0.5);
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    throw new Error("fetchWithRetry: unreachable");
+}
+function shouldRetry(status) {
+    return status === 429 || status >= 500;
+}
+function parseRetryAfter(response) {
+    const header = response.headers.get("retry-after");
+    if (!header)
+        return undefined;
+    const seconds = parseInt(header, 10);
+    return isNaN(seconds) ? undefined : seconds * 1000;
+}

package/dist/{src/config-cli.js → config-cli.js}

@@ -59,20 +59,22 @@ const LLM_PROVIDER_PRESETS = {
 };
 export function parseConfigValue(key, value) {
     switch (key) {
+        case "stashDir":
+            return { stashDir: requireNonEmptyString(value, key) };
         case "semanticSearch":
             if (value !== "true" && value !== "false") {
                 throw new Error(`Invalid value for semanticSearch: expected "true" or "false"`);
             }
             return { semanticSearch: value === "true" };
-        case "mountedStashDirs":
+        case "searchPaths":
             try {
                 const parsed = JSON.parse(value);
                 if (!Array.isArray(parsed))
                     throw new Error("expected JSON array");
-                return { mountedStashDirs: parsed.filter((d) => typeof d === "string") };
+                return { searchPaths: parsed.filter((d) => typeof d === "string") };
             }
             catch {
-                throw new Error(`Invalid value for mountedStashDirs: expected JSON array (e.g. '["/path/a","/path/b"]')`);
+                throw new Error(`Invalid value for searchPaths: expected JSON array (e.g. '["/path/a","/path/b"]')`);
             }
         case "embedding":
             return { embedding: parseEmbeddingConnectionValue(value) };
@@ -84,10 +86,12 @@ export function parseConfigValue(key, value) {
 }
 export function getConfigValue(config, key) {
     switch (key) {
+        case "stashDir":
+            return config.stashDir ?? null;
         case "semanticSearch":
             return config.semanticSearch;
-        case "mountedStashDirs":
-            return [...config.mountedStashDirs];
+        case "searchPaths":
+            return [...config.searchPaths];
         case "embedding":
             return maskSecrets(getEmbeddingDisplayConfig(config));
         case "embedding.provider":
@@ -120,8 +124,9 @@ export function getConfigValue(config, key) {
 }
 export function setConfigValue(config, key, rawValue) {
     switch (key) {
+        case "stashDir":
         case "semanticSearch":
-        case "mountedStashDirs":
+        case "searchPaths":
         case "embedding":
         case "llm":
             return { ...config, ...parseConfigValue(key, rawValue) };
@@ -207,6 +212,8 @@ export function setConfigValue(config, key, rawValue) {
 }
 export function unsetConfigValue(config, key) {
     switch (key) {
+        case "stashDir":
+            return { ...config, stashDir: undefined };
         case "embedding":
             return { ...config, embedding: undefined };
         case "embedding.apiKey":
@@ -247,6 +254,7 @@ export function listConfig(config) {
     return {
         ...DEFAULT_CONFIG,
         ...maskSecrets(config),
+        stashDir: config.stashDir ?? null,
         embedding: maskSecrets(getEmbeddingDisplayConfig(config)),
         llm: maskSecrets(getLlmDisplayConfig(config)),
     };

package/dist/{src/config.js → config.js}

@@ -1,37 +1,33 @@
 import fs from "node:fs";
 import path from "node:path";
+import { getConfigDir as _getConfigDir, getConfigPath as _getConfigPath } from "./paths";
 // ── Defaults ────────────────────────────────────────────────────────────────
 export const DEFAULT_CONFIG = {
     semanticSearch: true,
-    mountedStashDirs: [],
+    searchPaths: [],
 };
 // ── Paths ───────────────────────────────────────────────────────────────────
-export function getConfigDir(env = process.env, platform = process.platform) {
-    if (platform === "win32") {
-        const appData = env.APPDATA?.trim();
-        if (appData)
-            return path.join(appData, "agentikit");
-        const userProfile = env.USERPROFILE?.trim();
-        if (!userProfile) {
-            throw new Error("Unable to determine config directory. Set APPDATA or USERPROFILE.");
-        }
-        return path.join(userProfile, "AppData", "Roaming", "agentikit");
-    }
-    const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
-    if (xdgConfigHome)
-        return path.join(xdgConfigHome, "agentikit");
-    const home = env.HOME?.trim();
-    if (!home) {
-        throw new Error("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.");
-    }
-    return path.join(home, ".config", "agentikit");
+export function getConfigDir(env, platform) {
+    return _getConfigDir(env, platform);
 }
 export function getConfigPath() {
-    return path.join(getConfigDir(), "config.json");
+    return _getConfigPath();
 }
 // ── Load / Save / Update ────────────────────────────────────────────────────
+let cachedConfig;
 export function loadConfig() {
     const configPath = getConfigPath();
+    try {
+        const stat = fs.statSync(configPath);
+        if (cachedConfig && cachedConfig.path === configPath && cachedConfig.mtime === stat.mtimeMs) {
+            return cachedConfig.config;
+        }
+    }
+    catch {
+        // File doesn't exist — return defaults below
+        cachedConfig = undefined;
+        return { ...DEFAULT_CONFIG };
+    }
     const raw = readConfigObject(configPath);
     const config = raw ? pickKnownKeys(raw) : { ...DEFAULT_CONFIG };
     // Inject API keys from environment variables.
@@ -47,9 +43,18 @@ export function loadConfig() {
         if (envKey)
             config.llm.apiKey = envKey;
     }
+    // Cache the parsed config with its path and mtime for subsequent calls
+    try {
+        const stat = fs.statSync(configPath);
+        cachedConfig = { config, path: configPath, mtime: stat.mtimeMs };
+    }
+    catch {
+        // If we can't stat (unlikely since we just read it), skip caching
+    }
     return config;
 }
 export function saveConfig(config) {
+    cachedConfig = undefined;
     const configPath = getConfigPath();
     const dir = path.dirname(configPath);
     fs.mkdirSync(dir, { recursive: true });
@@ -93,11 +98,23 @@ export function updateConfig(partial) {
 // ── Helpers ─────────────────────────────────────────────────────────────────
 function pickKnownKeys(raw) {
     const config = { ...DEFAULT_CONFIG };
+    if (typeof raw.stashDir === "string" && raw.stashDir.trim()) {
+        config.stashDir = raw.stashDir.trim();
+    }
     if (typeof raw.semanticSearch === "boolean") {
         config.semanticSearch = raw.semanticSearch;
     }
+    if (Array.isArray(raw.searchPaths)) {
+        config.searchPaths = raw.searchPaths.filter((d) => typeof d === "string");
+    }
+    // Backward compat: merge legacy mountedStashDirs into searchPaths
     if (Array.isArray(raw.mountedStashDirs)) {
-        config.mountedStashDirs = raw.mountedStashDirs.filter((d) => typeof d === "string");
+        const legacy = raw.mountedStashDirs.filter((d) => typeof d === "string");
+        const existing = new Set(config.searchPaths);
+        for (const d of legacy) {
+            if (!existing.has(d))
+                config.searchPaths.push(d);
+        }
     }
     const embedding = parseEmbeddingConfig(raw.embedding);
     if (embedding)
@@ -115,7 +132,8 @@ function pickKnownKeys(raw) {
 }
 function readConfigObject(configPath) {
     try {
-        const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        const text = fs.readFileSync(configPath, "utf8");
+        const raw = JSON.parse(stripJsonComments(text));
         if (typeof raw !== "object" || raw === null || Array.isArray(raw))
             return undefined;
         return raw;
@@ -124,6 +142,54 @@ function readConfigObject(configPath) {
         return undefined;
     }
 }
+/**
+ * Strip JavaScript-style comments from a JSON string (JSONC support).
+ * Handles // line comments and /* block comments while preserving
+ * comment-like sequences inside quoted strings.
+ */
+export function stripJsonComments(text) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    let stringChar = "";
+    while (i < text.length) {
+        if (inString) {
+            if (text[i] === "\\") {
+                result += text[i] + (text[i + 1] ?? "");
+                i += 2;
+                continue;
+            }
+            if (text[i] === stringChar) {
+                inString = false;
+            }
+            result += text[i];
+            i++;
+            continue;
+        }
+        if (text[i] === '"' || text[i] === "'") {
+            inString = true;
+            stringChar = text[i];
+            result += text[i];
+            i++;
+            continue;
+        }
+        if (text[i] === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            continue;
+        }
+        if (text[i] === "/" && text[i + 1] === "*") {
+            i += 2;
+            while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
+                i++;
+            i += 2;
+            continue;
+        }
+        result += text[i];
+        i++;
+    }
+    return result;
+}
 function parseEmbeddingConfig(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
@@ -230,5 +296,7 @@ function asNonEmptyString(value) {
     return typeof value === "string" && value ? value : undefined;
 }
 function asRegistrySource(value) {
-    return value === "npm" || value === "github" || value === "git" ? value : undefined;
+    if (value === "npm" || value === "github" || value === "git" || value === "local")
+        return value;
+    return undefined;
 }

package/dist/{src/db.js → db.js}

@@ -1,14 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
+import { createRequire } from "node:module";
 import { Database } from "bun:sqlite";
+import { cosineSimilarity } from "./embedder";
+import { getDbPath as _getDbPath } from "./paths";
 // ── Constants ───────────────────────────────────────────────────────────────
-export const DB_VERSION = 5;
+export const DB_VERSION = 6;
 export const EMBEDDING_DIM = 384;
 // ── Path ────────────────────────────────────────────────────────────────────
 export function getDbPath() {
-    const cacheDir = process.env.XDG_CACHE_HOME ||
-        path.join(process.env.HOME || process.env.USERPROFILE || "", ".cache");
-    return path.join(cacheDir, "agentikit", "index.db");
+    return _getDbPath();
 }
 // ── Database lifecycle ──────────────────────────────────────────────────────
 export function openDatabase(dbPath, options) {
@@ -23,26 +24,51 @@ export function openDatabase(dbPath, options) {
     // Try to load sqlite-vec extension
     loadVecExtension(db);
     ensureSchema(db, options?.embeddingDim ?? EMBEDDING_DIM);
+    // Warn once at init if using JS fallback with many entries
+    warnIfVecMissing(db, { once: true });
     return db;
 }
 export function closeDatabase(db) {
     db.close();
 }
 // ── sqlite-vec extension ────────────────────────────────────────────────────
-let vecAvailable = false;
+const vecStatus = new WeakMap();
 function loadVecExtension(db) {
     try {
-        const sqliteVec = require("sqlite-vec");
+        const esmRequire = createRequire(import.meta.url);
+        const sqliteVec = esmRequire("sqlite-vec");
         sqliteVec.load(db);
-        vecAvailable = true;
+        vecStatus.set(db, true);
     }
     catch {
-        console.warn("sqlite-vec extension not available, embeddings will be skipped");
-        vecAvailable = false;
+        vecStatus.set(db, false);
     }
 }
-export function isVecAvailable() {
-    return vecAvailable;
+export function isVecAvailable(db) {
+    return vecStatus.get(db) ?? false;
+}
+const VEC_DOCS_URL = "https://github.com/itlackey/agentikit/blob/main/docs/configuration.md#sqlite-vec-extension";
+const VEC_FALLBACK_THRESHOLD = 10_000;
+let vecInitWarned = false;
+/**
+ * Warn if sqlite-vec is unavailable and embedding count exceeds threshold.
+ * Called from openDatabase (once at init) and from indexer (each run).
+ */
+export function warnIfVecMissing(db, { once } = { once: false }) {
+    if (isVecAvailable(db))
+        return;
+    if (once && vecInitWarned)
+        return;
+    try {
+        const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
+        const count = row?.cnt ?? 0;
+        if (count >= VEC_FALLBACK_THRESHOLD) {
+            console.warn("Semantic search is using JS fallback for %d entries. Install sqlite-vec for faster performance.\n  See: %s", count, VEC_DOCS_URL);
+            if (once)
+                vecInitWarned = true;
+        }
+    }
+    catch { /* embeddings table may not exist yet during init */ }
 }
 // ── Schema ──────────────────────────────────────────────────────────────────
 function ensureSchema(db, embeddingDim) {
@@ -56,6 +82,7 @@ function ensureSchema(db, embeddingDim) {
     // Check stored version — if it differs from DB_VERSION, drop and recreate all tables
     const storedVersion = getMeta(db, "version");
     if (storedVersion && storedVersion !== String(DB_VERSION)) {
+        db.exec("DROP TABLE IF EXISTS embeddings");
         db.exec("DROP TABLE IF EXISTS entries_vec");
         db.exec("DROP TABLE IF EXISTS entries_fts");
         db.exec("DROP INDEX IF EXISTS idx_entries_dir");
@@ -77,6 +104,14 @@ function ensureSchema(db, embeddingDim) {
 
     CREATE INDEX IF NOT EXISTS idx_entries_dir ON entries(dir_path);
     CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type);
+  `);
+    // BLOB-based embedding storage (always available, no sqlite-vec needed)
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS embeddings (
+      id        INTEGER PRIMARY KEY,
+      embedding BLOB NOT NULL,
+      FOREIGN KEY (id) REFERENCES entries(id)
+    );
   `);
     // FTS5 table — standalone with explicit entry_id for joining
     const ftsExists = db
@@ -92,7 +127,7 @@ function ensureSchema(db, embeddingDim) {
     `);
     }
     // sqlite-vec table
-    if (vecAvailable) {
+    if (isVecAvailable(db)) {
         // Check if stored embedding dimension differs from configured one
         const storedDim = getMeta(db, "embeddingDim");
         if (storedDim && storedDim !== String(embeddingDim)) {
@@ -147,15 +182,19 @@ export function upsertEntry(db, entryKey, dirPath, filePath, stashDir, entry, se
     return row.id;
 }
 export function deleteEntriesByDir(db, dirPath) {
-    if (vecAvailable) {
-        const ids = db
-            .prepare("SELECT id FROM entries WHERE dir_path = ?")
-            .all(dirPath);
-        for (const { id } of ids) {
+    const ids = db
+        .prepare("SELECT id FROM entries WHERE dir_path = ?")
+        .all(dirPath);
+    for (const { id } of ids) {
+        try {
+            db.prepare("DELETE FROM embeddings WHERE id = ?").run(id);
+        }
+        catch { /* ignore */ }
+        if (isVecAvailable(db)) {
             try {
                 db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
             }
-            catch { /* ignore if vec table missing */ }
+            catch { /* ignore */ }
         }
     }
     db.prepare("DELETE FROM entries WHERE dir_path = ?").run(dirPath);
@@ -166,32 +205,67 @@ export function rebuildFts(db) {
 }
 // ── Vector operations ───────────────────────────────────────────────────────
 export function upsertEmbedding(db, entryId, embedding) {
-    if (!vecAvailable)
-        return;
     const buf = float32Buffer(embedding);
-    try {
-        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
+    // Always write to BLOB table (works without sqlite-vec)
+    db.prepare("INSERT OR REPLACE INTO embeddings (id, embedding) VALUES (?, ?)").run(entryId, buf);
+    // Also write to sqlite-vec table when available (fast path)
+    if (isVecAvailable(db)) {
+        try {
+            db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
+        }
+        catch { /* ignore */ }
+        db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
     }
-    catch { /* ignore */ }
-    db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
 }
 export function searchVec(db, queryEmbedding, k) {
-    if (!vecAvailable)
-        return [];
-    const buf = float32Buffer(queryEmbedding);
-    try {
-        return db
-            .prepare("SELECT id, distance FROM entries_vec WHERE embedding MATCH ? AND k = ?")
-            .all(buf, k);
-    }
-    catch {
-        return [];
+    // Fast path: use sqlite-vec when available
+    if (isVecAvailable(db)) {
+        const buf = float32Buffer(queryEmbedding);
+        try {
+            return db
+                .prepare("SELECT id, distance FROM entries_vec WHERE embedding MATCH ? AND k = ?")
+                .all(buf, k);
+        }
+        catch {
+            return [];
+        }
     }
+    // Fallback: JS-based cosine similarity over BLOB table
+    return searchBlobVec(db, queryEmbedding, k);
 }
 function float32Buffer(vec) {
     const f32 = new Float32Array(vec);
     return Buffer.from(f32.buffer);
 }
+function bufferToFloat32(buf) {
+    const f32 = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+    return Array.from(f32);
+}
+function searchBlobVec(db, queryEmbedding, k) {
+    try {
+        const rows = db
+            .prepare("SELECT id, embedding FROM embeddings")
+            .all();
+        if (rows.length === 0)
+            return [];
+        const scored = [];
+        for (const row of rows) {
+            const embedding = bufferToFloat32(row.embedding);
+            const similarity = cosineSimilarity(queryEmbedding, embedding);
+            scored.push({ id: row.id, similarity });
+        }
+        scored.sort((a, b) => b.similarity - a.similarity);
+        // Convert cosine similarity to L2 distance for compatibility with sqlite-vec interface
+        // For normalized vectors: L2² = 2(1 - cos_sim)
+        return scored.slice(0, k).map(({ id, similarity }) => ({
+            id,
+            distance: Math.sqrt(2 * Math.max(0, 1 - similarity)),
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 // ── FTS5 search ─────────────────────────────────────────────────────────────
 export function searchFts(db, query, limit, entryType) {
     const ftsQuery = sanitizeFtsQuery(query);
@@ -246,7 +320,7 @@ function sanitizeFtsQuery(query) {
     if (tokens.length === 0)
         return "";
     // Use unquoted tokens so the porter stemmer can normalize word forms
-    return tokens.join(" OR ");
+    return tokens.join(" ");
 }
 // ── All entries ─────────────────────────────────────────────────────────────
 export function getAllEntries(db, entryType) {