agentikit 0.0.8 → 0.0.12

package/src/handlers/script-handler.ts

@@ -0,0 +1,92 @@
+import path from "node:path"
+import { SCRIPT_EXTENSIONS, SCRIPT_EXTENSIONS_BROAD } from "../asset-spec"
+import { hasErrnoCode, toPosix } from "../common"
+import { buildToolInfo } from "../tool-runner"
+import { extractDescriptionFromComments } from "../metadata"
+import type { AssetTypeHandler, ShowInput } from "../asset-type-handler"
+import type { ShowResponse, LocalSearchHit } from "../stash-types"
+import type { StashEntry } from "../metadata"
+
+/** Extensions that buildToolInfo can handle (tool-runner supported) */
+const RUNNABLE_EXTENSIONS = SCRIPT_EXTENSIONS
+
+export const scriptHandler: AssetTypeHandler = {
+  typeName: "script",
+  stashDir: "scripts",
+
+  isRelevantFile(fileName: string): boolean {
+    return SCRIPT_EXTENSIONS_BROAD.has(path.extname(fileName).toLowerCase())
+  },
+
+  toCanonicalName(typeRoot: string, filePath: string): string | undefined {
+    return toPosix(path.relative(typeRoot, filePath))
+  },
+
+  toAssetPath(typeRoot: string, name: string): string {
+    return path.join(typeRoot, name)
+  },
+
+  buildShowResponse(input: ShowInput): ShowResponse {
+    const ext = path.extname(input.path).toLowerCase()
+
+    // For extensions supported by tool-runner, show runCmd
+    if (RUNNABLE_EXTENSIONS.has(ext)) {
+      const stashDirs = input.stashDirs ?? []
+      const assetStashDir = stashDirs.find((d) =>
+        path.resolve(input.path).startsWith(path.resolve(d) + path.sep),
+      ) ?? stashDirs[0]
+
+      if (assetStashDir) {
+        try {
+          const toolInfo = buildToolInfo(assetStashDir, input.path)
+          return {
+            type: "script",
+            name: input.name,
+            path: input.path,
+            runCmd: toolInfo.runCmd,
+            kind: toolInfo.kind,
+          }
+        } catch {
+          // Fall through to content display
+        }
+      }
+    }
+
+    // For other extensions or when buildToolInfo fails, show file content
+    return {
+      type: "script",
+      name: input.name,
+      path: input.path,
+      content: input.content,
+    }
+  },
+
+  enrichSearchHit(hit: LocalSearchHit, stashDir: string): void {
+    const ext = path.extname(hit.path).toLowerCase()
+    if (!RUNNABLE_EXTENSIONS.has(ext)) return
+
+    try {
+      const toolInfo = buildToolInfo(stashDir, hit.path)
+      hit.runCmd = toolInfo.runCmd
+      hit.kind = toolInfo.kind
+    } catch (error: unknown) {
+      if (!hasErrnoCode(error, "ENOENT")) throw error
+    }
+  },
+
+  defaultUsageGuide: [
+    "Use the hit's runCmd for execution when available, or run the script directly with the appropriate interpreter.",
+    "Use `akm show <openRef>` to inspect the script before running it.",
+  ],
+
+  extractTypeMetadata(entry: StashEntry, file: string, ext: string): void {
+    if (ext !== ".md") {
+      const commentDesc = extractDescriptionFromComments(file)
+      if (commentDesc && !entry.description) {
+        entry.description = commentDesc
+        entry.source = "comments"
+        entry.confidence = 0.7
+      }
+    }
+  },
+}

package/src/handlers/skill-handler.ts

@@ -0,0 +1,37 @@
+import path from "node:path"
+import { toPosix } from "../common"
+import type { AssetTypeHandler, ShowInput } from "../asset-type-handler"
+import type { ShowResponse } from "../stash-types"
+
+export const skillHandler: AssetTypeHandler = {
+  typeName: "skill",
+  stashDir: "skills",
+
+  isRelevantFile(fileName: string): boolean {
+    return fileName === "SKILL.md"
+  },
+
+  toCanonicalName(typeRoot: string, filePath: string): string | undefined {
+    const relDir = toPosix(path.dirname(path.relative(typeRoot, filePath)))
+    if (!relDir || relDir === ".") return undefined
+    return relDir
+  },
+
+  toAssetPath(typeRoot: string, name: string): string {
+    return path.join(typeRoot, name, "SKILL.md")
+  },
+
+  buildShowResponse(input: ShowInput): ShowResponse {
+    return {
+      type: "skill",
+      name: input.name,
+      path: input.path,
+      content: input.content,
+    }
+  },
+
+  defaultUsageGuide: [
+    "Read and apply the skill instructions as written, then adapt examples to your current repo state and task.",
+    "Use `akm show <openRef>` to read the full SKILL.md for required steps and constraints.",
+  ],
+}

package/src/handlers/tool-handler.ts

@@ -0,0 +1,71 @@
+import path from "node:path"
+import { SCRIPT_EXTENSIONS } from "../asset-spec"
+import { hasErrnoCode, toPosix } from "../common"
+import { buildToolInfo } from "../tool-runner"
+import { extractDescriptionFromComments } from "../metadata"
+import type { AssetTypeHandler, ShowInput } from "../asset-type-handler"
+import type { ShowResponse, LocalSearchHit } from "../stash-types"
+import type { StashEntry } from "../metadata"
+
+export const toolHandler: AssetTypeHandler = {
+  typeName: "tool",
+  stashDir: "tools",
+
+  isRelevantFile(fileName: string): boolean {
+    return SCRIPT_EXTENSIONS.has(path.extname(fileName).toLowerCase())
+  },
+
+  toCanonicalName(typeRoot: string, filePath: string): string | undefined {
+    return toPosix(path.relative(typeRoot, filePath))
+  },
+
+  toAssetPath(typeRoot: string, name: string): string {
+    return path.join(typeRoot, name)
+  },
+
+  buildShowResponse(input: ShowInput): ShowResponse {
+    const stashDirs = input.stashDirs ?? []
+    const assetStashDir = stashDirs.find((d) =>
+      path.resolve(input.path).startsWith(path.resolve(d) + path.sep),
+    ) ?? stashDirs[0]
+
+    if (!assetStashDir) {
+      return { type: "tool", name: input.name, path: input.path, content: input.content }
+    }
+
+    const toolInfo = buildToolInfo(assetStashDir, input.path)
+    return {
+      type: "tool",
+      name: input.name,
+      path: input.path,
+      runCmd: toolInfo.runCmd,
+      kind: toolInfo.kind,
+    }
+  },
+
+  enrichSearchHit(hit: LocalSearchHit, stashDir: string): void {
+    try {
+      const toolInfo = buildToolInfo(stashDir, hit.path)
+      hit.runCmd = toolInfo.runCmd
+      hit.kind = toolInfo.kind
+    } catch (error: unknown) {
+      if (!hasErrnoCode(error, "ENOENT")) throw error
+    }
+  },
+
+  defaultUsageGuide: [
+    "Use the hit's runCmd for execution so runtime and working directory stay correct.",
+    "Use `akm show <openRef>` to inspect the tool before running it.",
+  ],
+
+  extractTypeMetadata(entry: StashEntry, file: string, ext: string): void {
+    if (SCRIPT_EXTENSIONS.has(ext) && ext !== ".md") {
+      const commentDesc = extractDescriptionFromComments(file)
+      if (commentDesc && !entry.description) {
+        entry.description = commentDesc
+        entry.source = "comments"
+        entry.confidence = 0.7
+      }
+    }
+  },
+}

package/src/indexer.ts

@@ -9,33 +9,27 @@ import {
   writeStashFile,
   generateMetadata,
 } from "./metadata"
-import { TfIdfAdapter, type ScoredEntry, type SerializedTfIdf } from "./similarity"
 import { walkStash } from "./walker"
-import type { EmbeddingVector } from "./embedder"
 import type { LlmConnectionConfig } from "./config"
+import {
+  openDatabase,
+  closeDatabase,
+  getDbPath,
+  getMeta,
+  setMeta,
+  upsertEntry,
+  deleteEntriesByDir,
+  rebuildFts,
+  upsertEmbedding,
+  getEntriesByDir,
+  getEntryCount,
+  isVecAvailable,
+  DB_VERSION,
+  type DbIndexedEntry,
+} from "./db"
 
 // ── Types ───────────────────────────────────────────────────────────────────
 
-export interface IndexedEntry {
-  entry: StashEntry
-  path: string
-  dirPath: string
-  embedding?: EmbeddingVector
-}
-
-export interface SearchIndex {
-  version: number
-  builtAt: string
-  stashDir: string
-  /** All stash directories that were indexed (primary + additional) */
-  stashDirs?: string[]
-  entries: IndexedEntry[]
-  /** Serialized TF-IDF state (term frequencies, idf values) */
-  tfidf?: SerializedTfIdf
-  /** Whether embeddings are included in entries */
-  hasEmbeddings?: boolean
-}
-
 export interface IndexResponse {
   stashDir: string
   totalEntries: number
@@ -45,211 +39,240 @@ export interface IndexResponse {
   directoriesScanned: number
   directoriesSkipped: number
   /** Timing counters in milliseconds */
-  timing?: { totalMs: number; walkMs: number; embedMs: number; tfidfMs: number }
+  timing?: { totalMs: number; walkMs: number; embedMs: number; ftsMs: number }
 }
 
-// ── Constants ───────────────────────────────────────────────────────────────
+// ── Indexer ──────────────────────────────────────────────────────────────────
 
-const INDEX_VERSION = 4
+export async function agentikitIndex(options?: { stashDir?: string; full?: boolean }): Promise<IndexResponse> {
+  const stashDir = options?.stashDir || resolveStashDir()
 
-// ── Index Path ──────────────────────────────────────────────────────────────
+  // Load config and resolve all stash sources
+  const { loadConfig } = await import("./config.js")
+  const config = loadConfig()
+  const { resolveAllStashDirs } = await import("./stash-source.js")
+  const allStashDirs = resolveAllStashDirs(stashDir)
 
-export function getIndexPath(): string {
-  const cacheDir = process.env.XDG_CACHE_HOME
-    || path.join(process.env.HOME || process.env.USERPROFILE || "", ".cache")
-  return path.join(cacheDir, "agentikit", "index.json")
-}
+  const t0 = Date.now()
+
+  // Open database — pass embedding dimension from config if available
+  const dbPath = getDbPath()
+  const embeddingDim = config.embedding?.dimension
+  const db = openDatabase(dbPath, embeddingDim ? { embeddingDim } : undefined)
 
-export function loadSearchIndex(): SearchIndex | null {
-  const indexPath = getIndexPath()
-  if (!fs.existsSync(indexPath)) return null
   try {
-    const raw = JSON.parse(fs.readFileSync(indexPath, "utf8"))
-    if (raw?.version !== INDEX_VERSION) return null
-    return raw as SearchIndex
-  } catch {
-    return null
-  }
-}
+    // Check if we should do incremental
+    const prevStashDir = getMeta(db, "stashDir")
+    const prevBuiltAt = getMeta(db, "builtAt")
+    const isIncremental = !options?.full && prevStashDir === stashDir && !!prevBuiltAt
+    const builtAtMs = isIncremental ? new Date(prevBuiltAt!).getTime() : 0
+
+    if (options?.full || !isIncremental) {
+      // Wipe all entries for full rebuild or stashDir change
+      db.exec("DELETE FROM entries")
+      db.exec("DELETE FROM entries_fts")
+      if (isVecAvailable()) {
+        try { db.exec("DELETE FROM entries_vec") } catch { /* ignore */ }
+      }
+    }
 
-// ── Indexer ──────────────────────────────────────────────────────────────────
+    const tWalkStart = Date.now()
 
-export async function agentikitIndex(options?: { stashDir?: string; full?: boolean }): Promise<IndexResponse> {
-  const stashDir = options?.stashDir || resolveStashDir()
+    // Walk stash dirs and index entries
+    const { scannedDirs, skippedDirs, generatedCount, dirsNeedingLlm } = indexEntries(db, allStashDirs, stashDir, isIncremental, builtAtMs)
 
-  // Load config to get additional stash dirs and semantic search setting
-  const { loadConfig } = await import("./config.js")
-  const config = loadConfig(stashDir)
+    // Enhance entries with LLM if configured
+    await enhanceDirsWithLlm(db, config, dirsNeedingLlm)
 
-  const allStashDirs = [stashDir]
-  for (const d of config.additionalStashDirs) {
-    try {
-      if (fs.statSync(d).isDirectory() && !allStashDirs.includes(path.resolve(d))) {
-        allStashDirs.push(path.resolve(d))
-      }
-    } catch { /* skip nonexistent dirs */ }
-  }
+    const tWalkEnd = Date.now()
 
-  const t0 = Date.now()
-  const allEntries: IndexedEntry[] = []
-  let generatedCount = 0
-  let scannedDirs = 0
-  let skippedDirs = 0
+    // Rebuild FTS after all inserts
+    rebuildFts(db)
+    const tFtsEnd = Date.now()
+
+    // Generate embeddings if semantic search is enabled
+    const hasEmbeddings = await generateEmbeddingsForDb(db, config)
+
+    const tEmbedEnd = Date.now()
+
+    // Update metadata
+    setMeta(db, "version", String(DB_VERSION))
+    setMeta(db, "builtAt", new Date().toISOString())
+    setMeta(db, "stashDir", stashDir)
+    setMeta(db, "stashDirs", JSON.stringify(allStashDirs))
+    setMeta(db, "hasEmbeddings", hasEmbeddings ? "1" : "0")
+
+    const totalEntries = getEntryCount(db)
 
-  // Load previous index for incremental mode
-  const previousIndex = !options?.full ? loadSearchIndex() : null
-  const isIncremental = previousIndex !== null && previousIndex.stashDir === stashDir
-  const builtAtMs = isIncremental ? new Date(previousIndex.builtAt).getTime() : 0
-
-  // Build lookup of previous entries by dirPath
-  const previousEntriesByDir = new Map<string, IndexedEntry[]>()
-  if (isIncremental) {
-    for (const ie of previousIndex.entries) {
-      const list = previousEntriesByDir.get(ie.dirPath) || []
-      list.push(ie)
-      previousEntriesByDir.set(ie.dirPath, list)
+    const tEnd = Date.now()
+
+    return {
+      stashDir,
+      totalEntries,
+      generatedMetadata: generatedCount,
+      indexPath: dbPath,
+      mode: isIncremental ? "incremental" : "full",
+      directoriesScanned: scannedDirs,
+      directoriesSkipped: skippedDirs,
+      timing: {
+        totalMs: tEnd - t0,
+        walkMs: tWalkEnd - tWalkStart,
+        embedMs: tEmbedEnd - tFtsEnd,
+        ftsMs: tFtsEnd - tWalkEnd,
+      },
     }
+  } finally {
+    closeDatabase(db)
   }
+}
+
+// ── Extracted helpers for agentikitIndex ─────────────────────────────────────
 
+function indexEntries(
+  db: import("bun:sqlite").Database,
+  allStashDirs: string[],
+  stashDir: string,
+  isIncremental: boolean,
+  builtAtMs: number,
+): { scannedDirs: number; skippedDirs: number; generatedCount: number; dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }> } {
+  let scannedDirs = 0
+  let skippedDirs = 0
+  let generatedCount = 0
   const seenPaths = new Set<string>()
-  const tWalkStart = Date.now()
-
-  for (const currentStashDir of allStashDirs) {
-    for (const assetType of ASSET_TYPES as AgentikitAssetType[]) {
-      const typeRoot = path.join(currentStashDir, TYPE_DIRS[assetType])
-      try {
-        if (!fs.statSync(typeRoot).isDirectory()) continue
-      } catch { continue }
-
-      // Group files by their immediate parent directory
-      const dirGroups = walkStash(typeRoot, assetType)
-
-      for (const { dirPath, files } of dirGroups) {
-        // Deduplicate by dirPath across stash dirs
-        if (seenPaths.has(path.resolve(dirPath))) continue
-        seenPaths.add(path.resolve(dirPath))
-
-        // Incremental: skip directories that haven't changed
-        const prevEntries = previousEntriesByDir.get(dirPath)
-        if (isIncremental && prevEntries && !isDirStale(dirPath, files, prevEntries, builtAtMs)) {
-          allEntries.push(...prevEntries)
-          skippedDirs++
-          continue
-        }
+  const dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }> = []
 
-        scannedDirs++
+  const insertTransaction = db.transaction(() => {
+    for (const currentStashDir of allStashDirs) {
+      for (const assetType of ASSET_TYPES as AgentikitAssetType[]) {
+        const typeRoot = path.join(currentStashDir, TYPE_DIRS[assetType])
+        try {
+          if (!fs.statSync(typeRoot).isDirectory()) continue
+        } catch { continue }
+
+        const dirGroups = walkStash(typeRoot, assetType)
+
+        for (const { dirPath, files } of dirGroups) {
+          if (seenPaths.has(path.resolve(dirPath))) continue
+          seenPaths.add(path.resolve(dirPath))
+
+          // Incremental: skip directories that haven't changed
+          if (isIncremental) {
+            const prevEntries = getEntriesByDir(db, dirPath)
+            if (prevEntries.length > 0 && !isDirStale(dirPath, files, prevEntries, builtAtMs)) {
+              skippedDirs++
+              continue
+            }
+          }
 
-        // Try loading existing .stash.json
-        let stash = loadStashFile(dirPath)
+          scannedDirs++
 
-        if (stash) {
-          const migration = migrateGeneratedSkillMetadata(stash, files, typeRoot)
-          if (migration.changed) {
-            stash = migration.stash
-            writeStashFile(dirPath, stash)
-          }
-        }
+          // Delete old entries for this dir (will be re-inserted)
+          deleteEntriesByDir(db, dirPath)
 
-        if (!stash) {
-          // Generate metadata
-          stash = generateMetadata(dirPath, assetType, files, typeRoot)
-          // Enhance with LLM if configured
-          if (config.llm && stash.entries.length > 0) {
-            stash = await enhanceStashWithLlm(config.llm, stash, dirPath, files)
-          }
-          if (stash.entries.length > 0) {
-            writeStashFile(dirPath, stash)
-            generatedCount += stash.entries.length
+          // Try loading existing .stash.json (user metadata overrides)
+          let stash = loadStashFile(dirPath)
+
+          if (stash) {
+            const migration = migrateGeneratedSkillMetadata(stash, files, typeRoot)
+            if (migration.changed) {
+              stash = migration.stash
+              writeStashFile(dirPath, stash)
+            }
           }
-        }
 
-        if (stash) {
-          for (const entry of stash.entries) {
-            const entryPath = entry.entry
-              ? path.join(dirPath, entry.entry)
-              : files[0] || dirPath
-            allEntries.push({ entry, path: entryPath, dirPath })
+          if (!stash) {
+            // Generate metadata heuristically
+            stash = generateMetadata(dirPath, assetType, files, typeRoot)
+            if (stash.entries.length > 0) {
+              writeStashFile(dirPath, stash)
+              generatedCount += stash.entries.length
+            }
           }
-        }
-      }
-    }
-  }
 
-  const tWalkEnd = Date.now()
-
-  // Build TF-IDF index
-  const adapter = new TfIdfAdapter()
-  const scoredEntries: ScoredEntry[] = allEntries.map((ie) => ({
-    id: `${ie.entry.type}:${ie.entry.name}`,
-    text: buildSearchText(ie.entry),
-    entry: ie.entry,
-    path: ie.path,
-  }))
-  adapter.buildIndex(scoredEntries)
-  const tTfidfEnd = Date.now()
-
-  // Generate embeddings if semantic search is enabled
-  let hasEmbeddings = false
-  if (config.semanticSearch) {
-    try {
-      const { embed } = await import("./embedder.js")
-      for (const ie of allEntries) {
-        if (!ie.embedding) {
-          const text = buildSearchText(ie.entry)
-          ie.embedding = await embed(text, config.embedding)
+          if (stash) {
+            for (const entry of stash.entries) {
+              const entryPath = entry.entry
+                ? path.join(dirPath, entry.entry)
+                : files[0] || dirPath
+              const entryKey = `${currentStashDir}:${entry.type}:${entry.name}`
+              const searchText = buildSearchText(entry)
+
+              upsertEntry(db, entryKey, dirPath, entryPath, currentStashDir, entry, searchText)
+            }
+
+            // Collect dirs needing LLM enhancement during the first walk
+            if (stash.entries.some((e) => e.generated)) {
+              dirsNeedingLlm.push({ dirPath, files, assetType, currentStashDir })
+            }
+          }
         }
       }
-      hasEmbeddings = true
-    } catch {
-      // Embedding provider not available, continue without embeddings
     }
-  }
+  })
 
-  const tEmbedEnd = Date.now()
+  insertTransaction()
 
-  // Persist index
-  const indexPath = getIndexPath()
-  const indexDir = path.dirname(indexPath)
-  if (!fs.existsSync(indexDir)) {
-    fs.mkdirSync(indexDir, { recursive: true })
-  }
+  return { scannedDirs, skippedDirs, generatedCount, dirsNeedingLlm }
+}
 
-  const index: SearchIndex = {
-    version: INDEX_VERSION,
-    builtAt: new Date().toISOString(),
-    stashDir,
-    stashDirs: allStashDirs,
-    entries: allEntries,
-    tfidf: adapter.serialize(),
-    hasEmbeddings,
+async function enhanceDirsWithLlm(
+  db: import("bun:sqlite").Database,
+  config: import("./config").AgentikitConfig,
+  dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }>,
+): Promise<void> {
+  if (!config.llm || dirsNeedingLlm.length === 0) return
+
+  for (const { dirPath, files, currentStashDir } of dirsNeedingLlm) {
+    let stash = loadStashFile(dirPath)
+    if (!stash) continue
+    stash = await enhanceStashWithLlm(config.llm, stash, dirPath, files)
+    writeStashFile(dirPath, stash)
+
+    // Re-upsert enhanced entries
+    for (const entry of stash.entries) {
+      const entryPath = entry.entry ? path.join(dirPath, entry.entry) : files[0] || dirPath
+      const entryKey = `${currentStashDir}:${entry.type}:${entry.name}`
+      const searchText = buildSearchText(entry)
+      upsertEntry(db, entryKey, dirPath, entryPath, currentStashDir, entry, searchText)
+    }
   }
-  fs.writeFileSync(indexPath, JSON.stringify(index) + "\n", "utf8")
+}
 
-  const tEnd = Date.now()
+async function generateEmbeddingsForDb(
+  db: import("bun:sqlite").Database,
+  config: import("./config").AgentikitConfig,
+): Promise<boolean> {
+  if (!config.semanticSearch || !isVecAvailable()) return false
 
-  return {
-    stashDir,
-    totalEntries: allEntries.length,
-    generatedMetadata: generatedCount,
-    indexPath,
-    mode: isIncremental ? "incremental" : "full",
-    directoriesScanned: scannedDirs,
-    directoriesSkipped: skippedDirs,
-    timing: {
-      totalMs: tEnd - t0,
-      walkMs: tWalkEnd - tWalkStart, // includes metadata generation (interleaved)
-      embedMs: tEmbedEnd - tTfidfEnd,
-      tfidfMs: tTfidfEnd - tWalkEnd,
-    },
+  try {
+    const { embed } = await import("./embedder.js")
+    const allEntries = getAllEntriesForEmbedding(db)
+    for (const { id, searchText } of allEntries) {
+      const embedding = await embed(searchText, config.embedding)
+      upsertEmbedding(db, id, embedding)
+    }
+    return true
+  } catch (error) {
+    console.warn("Embedding generation failed, continuing without:", error instanceof Error ? error.message : String(error))
+    return false
   }
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
+function getAllEntriesForEmbedding(db: import("bun:sqlite").Database): Array<{ id: number; searchText: string }> {
+  return db
+    .prepare(`
+      SELECT e.id, e.search_text AS searchText FROM entries e
+      WHERE NOT EXISTS (SELECT 1 FROM entries_vec v WHERE v.id = e.id)
+    `)
+    .all() as Array<{ id: number; searchText: string }>
+}
+
 function isDirStale(
   dirPath: string,
   currentFiles: string[],
-  previousEntries: IndexedEntry[],
+  previousEntries: DbIndexedEntry[],
   builtAtMs: number,
 ): boolean {
   // Check if file set changed (additions or deletions)
@@ -327,7 +350,6 @@ async function enhanceStashWithLlm(
   const enhanced: StashEntry[] = []
   for (const entry of stash.entries) {
     try {
-      // Find the file matching this entry for content context
       const entryFile = entry.entry
         ? files.find((f) => path.basename(f) === entry.entry) ?? files[0]
         : files[0]
@@ -345,7 +367,6 @@ async function enhanceStashWithLlm(
       if (improvements.tags?.length) updated.tags = improvements.tags
       enhanced.push(updated)
     } catch {
-      // LLM enhancement failed for this entry, keep original
       enhanced.push(entry)
     }
   }