akm-cli 0.7.3 → 0.7.5

package/dist/indexer/db-search.js

@@ -11,20 +11,17 @@
  * implementation, not a "local vs. remote" distinction.
  */
 import fs from "node:fs";
-import path from "node:path";
 import { makeAssetRef } from "../core/asset-ref";
 import { defaultRendererRegistry } from "../core/asset-registry";
-import { deriveCanonicalAssetNameFromStashRoot } from "../core/asset-spec";
 import { getDbPath } from "../core/paths";
 import { warn } from "../core/warn";
 import { closeDatabase, getAllEntries, getEntryById, getEntryCount, getMeta, getUtilityScoresByIds, openExistingDatabase, sanitizeFtsQuery, searchFts, searchVec, } from "./db";
+import { ensureIndex } from "./ensure-index";
 import { getRenderer } from "./file-context";
 import { computeGraphBoost, loadGraphBoostContext } from "./graph-boost";
-import { generateMetadataFlat, isProposedQuality, loadStashFile, shouldIndexStashFile, } from "./metadata";
-import { buildSearchText } from "./search-fields";
+import { isProposedQuality } from "./metadata";
 import { buildEditHint, findSourceForPath, isEditable } from "./search-source";
 import { deriveSemanticProviderFingerprint, getEffectiveSemanticStatus, isSemanticRuntimeReady, readSemanticStatus, } from "./semantic-status";
-import { walkStashFlat } from "./walker";
 export async function rendererForType(type, registry = defaultRendererRegistry) {
     const name = registry.rendererNameFor(type);
     return name ? getRenderer(name) : undefined;
@@ -53,7 +50,6 @@ export async function searchLocal(input) {
     const semanticStatus = getEffectiveSemanticStatus(config, rawStatus);
     const warnings = [];
     if (config.semanticSearchMode === "auto" && semanticStatus === "pending") {
-        // Distinguish between fingerprint mismatch (config changed) and never-set-up.
         const currentFingerprint = deriveSemanticProviderFingerprint(config.embedding);
         if (rawStatus && rawStatus.providerFingerprint !== currentFingerprint) {
             warnings.push("Embedding config changed. Run 'akm index --full' to rebuild the semantic index with the new provider.");
@@ -65,55 +61,40 @@ export async function searchLocal(input) {
     if (config.semanticSearchMode === "auto" && semanticStatus === "blocked") {
         warnings.push("Semantic search is currently blocked. Using keyword search until the semantic backend is healthy again.");
     }
-    // Try to open the database
+    // Auto-index when stale so the DB is always current before querying.
+    await ensureIndex(stashDir);
     const dbPath = getDbPath();
+    if (!fs.existsSync(dbPath)) {
+        return {
+            hits: [],
+            tip: "No search index available. Run 'akm index' to build one.",
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    const db = openExistingDatabase(dbPath);
     try {
-        if (fs.existsSync(dbPath)) {
-            const db = openExistingDatabase(dbPath);
-            try {
-                const entryCount = getEntryCount(db);
-                const storedStashDir = getMeta(db, "stashDir");
-                // Accept the index if the incoming stashDir matches the primary OR
-                // appears anywhere in the stored stashDirs array. This prevents
-                // unnecessary substring fallback when only the primary dir changes.
-                let stashDirMatch = storedStashDir === stashDir;
-                if (!stashDirMatch) {
-                    try {
-                        const storedDirs = JSON.parse(getMeta(db, "stashDirs") ?? "[]");
-                        stashDirMatch = storedDirs.includes(stashDir);
-                    }
-                    catch {
-                        /* ignore malformed stashDirs */
-                    }
-                }
-                if (entryCount > 0 && stashDirMatch) {
-                    const { hits, embedMs, rankMs } = await searchDatabase(db, query, searchType, limit, stashDir, allSourceDirs, config, sources, rendererRegistry, filters, includeProposed);
-                    return {
-                        hits,
-                        tip: hits.length === 0
-                            ? "No matching stash assets were found. Try running 'akm index' to rebuild."
-                            : undefined,
-                        warnings: warnings.length > 0 ? warnings : undefined,
-                        embedMs,
-                        rankMs,
-                    };
-                }
-            }
-            finally {
-                closeDatabase(db);
-            }
+        const entryCount = getEntryCount(db);
+        if (entryCount === 0) {
+            return {
+                hits: [],
+                tip: "Index is empty. Run 'akm index' to populate it.",
+                warnings: warnings.length > 0 ? warnings : undefined,
+            };
         }
+        const { hits, embedMs, rankMs } = await searchDatabase(db, query, searchType, limit, stashDir, allSourceDirs, config, sources, rendererRegistry, filters, includeProposed);
+        return {
+            hits,
+            tip: hits.length === 0
+                ? "No matching stash assets were found. Try a different query or run 'akm index' to rebuild."
+                : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            embedMs,
+            rankMs,
+        };
     }
-    catch (error) {
-        warn("Search index unavailable, falling back to substring search:", error instanceof Error ? error.message : String(error));
+    finally {
+        closeDatabase(db);
     }
-    const hitArrays = await Promise.all(allSourceDirs.map((dir) => substringSearch(query, searchType, limit, dir, sources, config, rendererRegistry, filters, includeProposed)));
-    const hits = hitArrays.flat().slice(0, limit);
-    return {
-        hits,
-        tip: hits.length === 0 ? "No matching stash assets were found. Try running 'akm index' to rebuild." : undefined,
-        warnings: warnings.length > 0 ? warnings : undefined,
-    };
 }
 // ── Database search ─────────────────────────────────────────────────────────
 async function searchDatabase(db, query, searchType, limit, stashDir, allSourceDirs, config, sources, rendererRegistry = defaultRendererRegistry, filters, includeProposed = false) {
@@ -494,62 +475,10 @@ async function tryVecScores(db, query, k, config) {
         return null;
     }
 }
-// ── Substring fallback (no index) ───────────────────────────────────────────
-async function substringSearch(query, searchType, limit, stashDir, sources, config, rendererRegistry = defaultRendererRegistry, filters, includeProposed = false) {
-    const assets = await indexAssets(stashDir, searchType, sources);
-    const scopeMatched = filters ? assets.filter((asset) => entryMatchesScope(asset.entry.scope, filters)) : assets;
-    const qualityMatched = includeProposed
-        ? scopeMatched
-        : scopeMatched.filter((asset) => !isProposedQuality(asset.entry.quality));
-    const matched = qualityMatched.filter((asset) => !query || buildSearchText(asset.entry).includes(query));
-    if (!query) {
-        const sorted = matched.sort(compareAssets);
-        const unique = deduplicateAssetsByPath(sorted);
-        return Promise.all(unique
-            .slice(0, limit)
-            .map((asset) => assetToSearchHit(asset, stashDir, sources, config, undefined, rendererRegistry)));
-    }
-    // Score and sort by relevance
-    const scored = matched.map((asset) => ({ asset, score: scoreSubstringMatch(asset.entry, query) }));
-    scored.sort((a, b) => b.score - a.score || compareAssets(a.asset, b.asset));
-    // Deduplicate by path — keep highest-scored entry per file
-    const dedupedScored = deduplicateByPath(scored.map((s) => ({ ...s, filePath: s.asset.path })));
-    return Promise.all(dedupedScored
-        .slice(0, limit)
-        .map(({ asset, score }) => assetToSearchHit(asset, stashDir, sources, config, score, rendererRegistry)));
-}
-function scoreSubstringMatch(entry, query) {
-    const tokens = query.split(/\s+/).filter(Boolean);
-    if (tokens.length === 0)
-        return 0.5;
-    let score = 0.3;
-    const nameLower = entry.name.toLowerCase().replace(/[-_]/g, " ");
-    const descLower = (entry.description ?? "").toLowerCase();
-    const tagsLower = (entry.tags ?? []).join(" ").toLowerCase();
-    if (nameLower === query) {
-        score += 0.5;
-    }
-    else if (nameLower.includes(query)) {
-        score += 0.35;
-    }
-    else if (tokens.some((t) => nameLower.includes(t))) {
-        score += 0.2;
-    }
-    if (tokens.some((t) => tagsLower.includes(t))) {
-        score += 0.1;
-    }
-    if (tokens.some((t) => descLower.includes(t))) {
-        score += 0.05;
-    }
-    // Issue #8: round to 4 decimal places instead of 2
-    return Math.round(Math.min(1, score) * 10000) / 10000;
-}
 // ── Hit building ────────────────────────────────────────────────────────────
 export async function buildDbHit(input) {
     const rendererRegistry = input.rendererRegistry ?? defaultRendererRegistry;
     const entryStashDir = findSourceForPath(input.path, input.sources)?.path ?? input.defaultStashDir;
-    const canonical = deriveCanonicalAssetNameFromStashRoot(input.entry.type, entryStashDir, input.path);
-    const refName = canonical && !canonical.startsWith("../") && !canonical.startsWith("..\\") ? canonical : input.entry.name;
     // Quality and confidence boosts are now applied in the main scoring
     // phase (searchDatabase). buildDbHit receives the already-final score and
     // passes it through without further multiplication. We still compute the
@@ -562,7 +491,7 @@ export async function buildDbHit(input) {
     const score = Math.round(input.score * 10000) / 10000;
     const whyMatched = buildWhyMatched(input.entry, input.query, input.rankingMode, qualityBoost, confidenceBoost, input.utilityBoosted);
     const source = findSourceForPath(input.path, input.sources);
-    const ref = resolveSearchHitRef(input.entry, refName, source);
+    const ref = resolveSearchHitRef(input.entry, input.entry.name, source);
     const editable = isEditable(input.path, input.config);
     const estimatedTokens = typeof input.entry.fileSize === "number" ? Math.round(input.entry.fileSize / 4) : undefined;
     const hit = {
@@ -572,7 +501,9 @@ export async function buildDbHit(input) {
         ref,
         origin: resolveSearchHitOrigin(source),
         editable,
-        ...(!editable ? { editHint: buildEditHint(input.path, input.entry.type, refName, source?.registryId) } : {}),
+        ...(!editable
+            ? { editHint: buildEditHint(input.path, input.entry.type, input.entry.name, source?.registryId) }
+            : {}),
         description: input.entry.description,
         tags: input.entry.tags,
         size: deriveSize(input.entry.fileSize),
@@ -638,37 +569,6 @@ rankingMode, qualityBoost, confidenceBoost, utilityBoosted) {
         reasons.push("usage history boost");
     return reasons;
 }
-async function assetToSearchHit(asset, stashDir, sources, config, score, rendererRegistry = defaultRendererRegistry) {
-    const source = findSourceForPath(asset.path, sources);
-    const editable = isEditable(asset.path, config);
-    const ref = resolveSearchHitRef(asset.entry, asset.entry.name, source);
-    const fileSize = readFileSize(asset.path);
-    const size = deriveSize(fileSize);
-    const estimatedTokens = typeof fileSize === "number" ? Math.round(fileSize / 4) : undefined;
-    const hit = {
-        type: asset.entry.type,
-        name: asset.entry.name,
-        path: asset.path,
-        ref,
-        origin: resolveSearchHitOrigin(source),
-        editable,
-        ...(!editable
-            ? { editHint: buildEditHint(asset.path, asset.entry.type, asset.entry.name, source?.registryId) }
-            : {}),
-        description: asset.entry.description,
-        tags: asset.entry.tags,
-        ...(size ? { size } : {}),
-        action: buildLocalAction(asset.entry.type, ref, rendererRegistry),
-        ...(score !== undefined ? { score } : {}),
-        ...(estimatedTokens !== undefined ? { estimatedTokens } : {}),
-        ...(asset.entry.quality ? { quality: asset.entry.quality } : {}),
-    };
-    const renderer = await rendererForType(asset.entry.type, rendererRegistry);
-    if (renderer?.enrichSearchHit) {
-        renderer.enrichSearchHit(hit, stashDir);
-    }
-    return hit;
-}
 // ── Utilities ────────────────────────────────────────────────────────────────
 export function deriveSize(bytes) {
     if (bytes === undefined)
@@ -679,92 +579,12 @@ export function deriveSize(bytes) {
         return "medium";
     return "large";
 }
-function readFileSize(filePath) {
-    try {
-        return fs.statSync(filePath).size;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function indexAssets(stashDir, type, sources) {
-    const resolvedStashDir = realpathOrResolve(stashDir);
-    const source = sources?.find((entry) => realpathOrResolve(entry.path) === resolvedStashDir);
-    if (source?.wikiName) {
-        return indexWikiRootAssets(stashDir, source.wikiName, type);
-    }
-    const assets = [];
-    const filterType = type === "any" ? undefined : type;
-    const fileContexts = walkStashFlat(stashDir);
-    const dirGroups = new Map();
-    for (const ctx of fileContexts) {
-        const group = dirGroups.get(ctx.parentDirAbs);
-        if (group)
-            group.push(ctx.absPath);
-        else
-            dirGroups.set(ctx.parentDirAbs, [ctx.absPath]);
-    }
-    for (const [dirPath, files] of dirGroups) {
-        const generated = await generateMetadataFlat(stashDir, files);
-        const legacyOverrides = loadStashFile(dirPath, { requireFilename: true });
-        const mergedEntries = legacyOverrides
-            ? generated.entries.map((entry) => mergeLegacyEntry(entry, legacyOverrides.entries))
-            : generated.entries;
-        const stash = mergedEntries.length > 0 ? { entries: mergedEntries } : legacyOverrides;
-        if (!stash || stash.entries.length === 0)
-            continue;
-        for (const entry of stash.entries) {
-            if (filterType && entry.type !== filterType)
-                continue;
-            if (!entry.filename)
-                continue;
-            const entryPath = path.join(dirPath, entry.filename);
-            if (!shouldIndexStashFile(stashDir, entryPath))
-                continue;
-            assets.push({ entry, path: entryPath });
-        }
-    }
-    return assets;
-}
-function mergeLegacyEntry(entry, legacyEntries) {
-    const legacy = legacyEntries.find((candidate) => candidate.filename === entry.filename);
-    return legacy ? { ...entry, ...legacy, filename: entry.filename } : entry;
-}
-async function indexWikiRootAssets(wikiRoot, wikiName, type) {
-    if (type !== "any" && type !== "wiki")
-        return [];
-    const assets = [];
-    for (const ctx of walkStashFlat(wikiRoot)) {
-        if (ctx.ext !== ".md")
-            continue;
-        if (!shouldIndexStashFile(wikiRoot, ctx.absPath, { treatStashRootAsWikiRoot: true }))
-            continue;
-        const relNoExt = ctx.relPath.replace(/\.md$/, "");
-        assets.push({
-            entry: {
-                name: `${wikiName}/${relNoExt}`,
-                type: "wiki",
-                filename: ctx.fileName,
-                description: ctx.frontmatter()?.description,
-                source: "frontmatter",
-            },
-            path: ctx.absPath,
-        });
-    }
-    return assets;
-}
-function compareAssets(a, b) {
-    if (a.entry.type !== b.entry.type)
-        return a.entry.type.localeCompare(b.entry.type);
-    return a.entry.name.localeCompare(b.entry.name);
-}
 /**
  * Deduplicate scored results by file path, keeping only the highest-scored
  * entry per unique path. Sorts by score descending internally to ensure the
  * precondition is always met regardless of caller.
  */
 function deduplicateByPath(items) {
-    // Sort inside to enforce the descending-score precondition
     const sorted = [...items].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
     const seen = new Set();
     return sorted.filter((item) => {
@@ -774,18 +594,6 @@ function deduplicateByPath(items) {
         return true;
     });
 }
-/**
- * Deduplicate IndexedAsset[] by path, keeping the first (highest-priority) entry.
- */
-function deduplicateAssetsByPath(assets) {
-    const seen = new Set();
-    return assets.filter((asset) => {
-        if (seen.has(asset.path))
-            return false;
-        seen.add(asset.path);
-        return true;
-    });
-}
 /**
  * Exact-match scope filter check. Legacy entries without a `scope` object only
  * match when no filter is supplied — which is what the caller guards on
@@ -801,11 +609,3 @@ function entryMatchesScope(scope, filters) {
     }
     return true;
 }
-function realpathOrResolve(targetPath) {
-    try {
-        return fs.realpathSync(targetPath);
-    }
-    catch {
-        return path.resolve(targetPath);
-    }
-}

package/dist/indexer/db.js

@@ -823,11 +823,21 @@ export function getAllEntries(db, entryType) {
 }
 export function findEntryIdByRef(db, ref) {
     const parsed = parseAssetRef(ref);
-    const suffix = `${parsed.type}:${parsed.name}`;
-    const row = db
-        .prepare("SELECT id FROM entries WHERE entry_type = ? AND substr(entry_key, length(entry_key) - length(?) + 1) = ? LIMIT 1")
-        .get(parsed.type, suffix, suffix);
-    return row?.id;
+    const nameVariants = [parsed.name];
+    if (parsed.name.endsWith(".md")) {
+        nameVariants.push(parsed.name.slice(0, -3));
+    }
+    else {
+        nameVariants.push(`${parsed.name}.md`);
+    }
+    const stmt = db.prepare("SELECT id FROM entries WHERE entry_type = ? AND substr(entry_key, length(entry_key) - length(?) + 1) = ? LIMIT 1");
+    for (const name of nameVariants) {
+        const suffix = `${parsed.type}:${name}`;
+        const row = stmt.get(parsed.type, suffix, suffix);
+        if (row)
+            return row.id;
+    }
+    return undefined;
 }
 export function getEntryCount(db) {
     const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get();

package/dist/indexer/ensure-index.js

@@ -0,0 +1,72 @@
+/**
+ * Auto-index: silently run an incremental `akm index` when the local index
+ * is stale or absent, so that `search`, `show`, and `feedback` always operate
+ * against current on-disk state without requiring the user to manually run
+ * `akm index` first.
+ *
+ * This replaces the old filesystem fallbacks that were scattered across
+ * `searchLocal()` and `show.ts`, centralizing the "indexed yet?" gap handling
+ * behind a single entry point.
+ */
+import fs from "node:fs";
+import { getDbPath } from "../core/paths";
+import { warn } from "../core/warn";
+import { closeDatabase, getEntryCount, getMeta, openExistingDatabase } from "./db";
+/**
+ * Check whether the local index is stale relative to the given stash directory.
+ * Returns `true` when the index is missing, empty, or was built against a
+ * different primary stash dir.
+ */
+export function isIndexStale(stashDir) {
+    const dbPath = getDbPath();
+    if (!fs.existsSync(dbPath))
+        return true;
+    let db;
+    try {
+        db = openExistingDatabase(dbPath);
+        const entryCount = getEntryCount(db);
+        if (entryCount === 0)
+            return true;
+        const storedStashDir = getMeta(db, "stashDir");
+        if (storedStashDir !== stashDir) {
+            // Check if the incoming stashDir appears in the stored stashDirs array
+            try {
+                const storedDirs = JSON.parse(getMeta(db, "stashDirs") ?? "[]");
+                if (!storedDirs.includes(stashDir))
+                    return true;
+            }
+            catch {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return true;
+    }
+    finally {
+        if (db)
+            closeDatabase(db);
+    }
+}
+/**
+ * Run an incremental index when the local index is stale. Best-effort —
+ * failures are logged as warnings but never thrown, so the caller can
+ * proceed (and surface a proper "not in index" error if the index is
+ * still unusable).
+ *
+ * Returns `true` if an index run was attempted.
+ */
+export async function ensureIndex(stashDir) {
+    if (!isIndexStale(stashDir))
+        return false;
+    try {
+        const { akmIndex } = await import("./indexer.js");
+        await akmIndex({ stashDir });
+        return true;
+    }
+    catch (error) {
+        warn("Auto-index failed, proceeding with existing index:", error instanceof Error ? error.message : String(error));
+        return true;
+    }
+}

package/dist/indexer/graph-extraction.js

@@ -115,6 +115,16 @@ export async function runGraphExtractionPass(config, sources, signal) {
         totalEntities += extraction.entities.length;
         totalRelations += extraction.relations.length;
     }
+    if (nodes.length === 0) {
+        warn("graph extraction: all extractions failed or returned no entities; leaving existing graph.json untouched.");
+        return {
+            considered,
+            extracted: 0,
+            totalEntities: 0,
+            totalRelations: 0,
+            written: false,
+        };
+    }
     const graph = {
         schemaVersion: GRAPH_FILE_SCHEMA_VERSION,
         generatedAt: new Date().toISOString(),

package/dist/indexer/indexer.js

@@ -99,12 +99,24 @@ export async function akmIndex(options) {
         if (enrich) {
             try {
                 const inferenceResult = await runMemoryInferencePass(config, allSourceEntries, signal);
-                if (inferenceResult.writtenFacts > 0) {
+                if (inferenceResult.writtenFacts > 0 || inferenceResult.skippedNoFacts > 0) {
                     onProgress({
                         phase: "llm",
-                        message: `Memory inference wrote ${inferenceResult.writtenFacts} derived memor${inferenceResult.writtenFacts === 1 ? "y" : "ies"} from ${inferenceResult.splitParents} parent memor${inferenceResult.splitParents === 1 ? "y" : "ies"}.`,
+                        message: `Memory inference reviewed ${inferenceResult.considered} ` +
+                            `${inferenceResult.considered === 1 ? "memory" : "memories"}; wrote ` +
+                            `${inferenceResult.writtenFacts} derived memor${inferenceResult.writtenFacts === 1 ? "y" : "ies"} ` +
+                            `from ${inferenceResult.splitParents} parent memor${inferenceResult.splitParents === 1 ? "y" : "ies"}` +
+                            (inferenceResult.skippedNoFacts > 0
+                                ? `; skipped ${inferenceResult.skippedNoFacts} ${inferenceResult.skippedNoFacts === 1 ? "memory" : "memories"} with unusable LLM responses`
+                                : "") +
+                            ".",
                     });
                 }
+                if (inferenceResult.skippedNoFacts > 0) {
+                    warn(`Memory inference skipped ${inferenceResult.skippedNoFacts} ` +
+                        `${inferenceResult.skippedNoFacts === 1 ? "memory" : "memories"} because the LLM returned empty, invalid, or incomplete derived payloads. ` +
+                        "Check your model and token budget.");
+                }
             }
             catch (err) {
                 warn(`Memory inference pass aborted: ${err instanceof Error ? err.message : String(err)}`);
@@ -1018,13 +1030,13 @@ export async function lookup(ref) {
     const dbPath = getDbPath();
     const db = openExistingDatabase(dbPath);
     try {
-        // entry_key shape: `${stashDir}:${type}:${name}`. Suffix-match on
-        // `:type:name` so we can scope by source dir as a prefix when origin is
-        // supplied. Use parameterised queries throughout — names may include
-        // user-supplied glob characters.
         const escapeLike = (value) => value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-        const suffix = `:${ref.type}:${ref.name}`;
-        const escapedSuffix = escapeLike(suffix);
+        // Canonical names strip .md for markdown assets, but users often pass
+        // refs with .md (e.g. command:release.md). Normalize by trying both.
+        const nameVariants = [ref.name];
+        if (ref.name.endsWith(".md")) {
+            nameVariants.push(ref.name.slice(0, -3));
+        }
         const candidateDirs = (() => {
             if (!ref.origin)
                 return sources.map((s) => s.path);
@@ -1035,20 +1047,24 @@ export async function lookup(ref) {
         })();
         if (candidateDirs.length === 0)
             return null;
-        for (const dir of candidateDirs) {
-            const escapedDir = escapeLike(dir);
-            const row = db
-                .prepare("SELECT entry_key AS entryKey, file_path AS filePath, stash_dir AS stashDir, entry_type AS type FROM entries " +
-                "WHERE entry_key LIKE ? ESCAPE '\\' AND entry_type = ? LIMIT 1")
-                .get(`${escapedDir}${escapedSuffix}`, ref.type);
-            if (row) {
-                return {
-                    entryKey: row.entryKey,
-                    filePath: row.filePath,
-                    stashDir: row.stashDir,
-                    type: row.type,
-                    name: ref.name,
-                };
+        for (const name of nameVariants) {
+            const suffix = `:${ref.type}:${name}`;
+            const escapedSuffix = escapeLike(suffix);
+            for (const dir of candidateDirs) {
+                const escapedDir = escapeLike(dir);
+                const row = db
+                    .prepare("SELECT entry_key AS entryKey, file_path AS filePath, stash_dir AS stashDir, entry_type AS type FROM entries " +
+                    "WHERE entry_key LIKE ? ESCAPE '\\' AND entry_type = ? LIMIT 1")
+                    .get(`${escapedDir}${escapedSuffix}`, ref.type);
+                if (row) {
+                    return {
+                        entryKey: row.entryKey,
+                        filePath: row.filePath,
+                        stashDir: row.stashDir,
+                        type: row.type,
+                        name: ref.name,
+                    };
+                }
             }
         }
         return null;