agentikit 0.0.9 → 0.0.12

package/src/config.ts

@@ -1,24 +1,33 @@
 import fs from "node:fs"
 import path from "node:path"
-import { resolveStashDir } from "./common"
 import type { RegistryInstalledEntry, RegistrySource } from "./registry-types"
 
 // ── Types ───────────────────────────────────────────────────────────────────
 
 export interface EmbeddingConnectionConfig {
+  /** Provider name for display/CLI switching (e.g. "openai", "ollama") */
+  provider?: string
   /** OpenAI-compatible embeddings endpoint (e.g. "http://localhost:11434/v1/embeddings") */
   endpoint: string
   /** Model name to use for embeddings (e.g. "nomic-embed-text") */
   model: string
+  /** Optional output dimension for providers that support it */
+  dimension?: number
   /** Optional API key for authenticated endpoints */
   apiKey?: string
 }
 
 export interface LlmConnectionConfig {
+  /** Provider name for display/CLI switching (e.g. "openai", "ollama") */
+  provider?: string
   /** OpenAI-compatible chat completions endpoint (e.g. "http://localhost:11434/v1/chat/completions") */
   endpoint: string
   /** Model name to use (e.g. "llama3.2") */
   model: string
+  /** Optional sampling temperature */
+  temperature?: number
+  /** Optional response token limit */
+  maxTokens?: number
   /** Optional API key for authenticated endpoints */
   apiKey?: string
 }
@@ -26,14 +35,16 @@ export interface LlmConnectionConfig {
 export interface AgentikitConfig {
   /** Whether semantic search is enabled. Default: true */
   semanticSearch: boolean
-  /** Additional stash directories to search alongside the primary one */
-  additionalStashDirs: string[]
+  /** User-mounted read-only stash directories */
+  mountedStashDirs: string[]
   /** OpenAI-compatible embedding endpoint config. If not set, uses local @xenova/transformers */
   embedding?: EmbeddingConnectionConfig
   /** OpenAI-compatible LLM endpoint config for metadata generation. If not set, uses heuristic generation */
   llm?: LlmConnectionConfig
   /** Installed registry sources and local cache metadata */
   registry?: RegistryConfig
+  /** Registry index URLs for kit discovery. Default: official agentikit-registry on GitHub */
+  registryUrls?: string[]
 }
 
 export interface RegistryConfig {
@@ -44,48 +55,99 @@ export interface RegistryConfig {
 
 export const DEFAULT_CONFIG: AgentikitConfig = {
   semanticSearch: true,
-  additionalStashDirs: [],
+  mountedStashDirs: [],
 }
 
 // ── Paths ───────────────────────────────────────────────────────────────────
 
-export function getConfigPath(stashDir: string): string {
-  return path.join(stashDir, "config.json")
+export function getConfigDir(
+  env: NodeJS.ProcessEnv = process.env,
+  platform = process.platform,
+): string {
+  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 getConfigPath(): string {
+  return path.join(getConfigDir(), "config.json")
 }
 
 // ── Load / Save / Update ────────────────────────────────────────────────────
 
-export function loadConfig(stashDir?: string): AgentikitConfig {
-  const dir = stashDir ?? resolveStashDir()
-  const configPath = getConfigPath(dir)
+export function loadConfig(): AgentikitConfig {
+  const configPath = getConfigPath()
+  const raw = readConfigObject(configPath)
+  const config = raw ? pickKnownKeys(raw) : { ...DEFAULT_CONFIG }
+
+  // Inject API keys from environment variables.
+  // API keys should be provided via AKM_EMBED_API_KEY and AKM_LLM_API_KEY
+  // rather than stored in the config file.
+  if (config.embedding && !config.embedding.apiKey) {
+    const envKey = process.env.AKM_EMBED_API_KEY?.trim()
+    if (envKey) config.embedding.apiKey = envKey
+  }
+  if (config.llm && !config.llm.apiKey) {
+    const envKey = process.env.AKM_LLM_API_KEY?.trim()
+    if (envKey) config.llm.apiKey = envKey
+  }
+
+  return config
+}
 
-  let raw: Record<string, unknown>
+export function saveConfig(config: AgentikitConfig): void {
+  const configPath = getConfigPath()
+  const dir = path.dirname(configPath)
+  fs.mkdirSync(dir, { recursive: true })
+  const sanitized = sanitizeConfigForWrite(config)
+  const tmpPath = configPath + `.tmp.${process.pid}`
   try {
-    raw = JSON.parse(fs.readFileSync(configPath, "utf8"))
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-      return { ...DEFAULT_CONFIG }
-    }
-  } catch {
-    return { ...DEFAULT_CONFIG }
+    fs.writeFileSync(tmpPath, JSON.stringify(sanitized, null, 2) + "\n", "utf8")
+    fs.renameSync(tmpPath, configPath)
+  } catch (err) {
+    try { fs.unlinkSync(tmpPath) } catch { /* ignore cleanup failure */ }
+    throw err
   }
-
-  return pickKnownKeys(raw)
 }
 
-export function saveConfig(config: AgentikitConfig, stashDir?: string): void {
-  const dir = stashDir ?? resolveStashDir()
-  const configPath = getConfigPath(dir)
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8")
+/**
+ * Strip apiKey fields before writing config to disk.
+ * API keys should be provided via environment variables
+ * AKM_EMBED_API_KEY and AKM_LLM_API_KEY.
+ */
+function sanitizeConfigForWrite(config: AgentikitConfig): AgentikitConfig {
+  const sanitized = { ...config }
+  if (sanitized.embedding) {
+    const { apiKey, ...rest } = sanitized.embedding
+    sanitized.embedding = rest as EmbeddingConnectionConfig
+  }
+  if (sanitized.llm) {
+    const { apiKey, ...rest } = sanitized.llm
+    sanitized.llm = rest as LlmConnectionConfig
+  }
+  return sanitized
 }
 
-export function updateConfig(
-  partial: Partial<AgentikitConfig>,
-  stashDir?: string,
-): AgentikitConfig {
-  const dir = stashDir ?? resolveStashDir()
-  const current = loadConfig(dir)
+export function updateConfig(partial: Partial<AgentikitConfig>): AgentikitConfig {
+  const current = loadConfig()
   const merged: AgentikitConfig = { ...current, ...partial }
-  saveConfig(merged, dir)
+  saveConfig(merged)
   return merged
 }
 
@@ -98,35 +160,95 @@ function pickKnownKeys(raw: Record<string, unknown>): AgentikitConfig {
     config.semanticSearch = raw.semanticSearch
   }
 
-  if (Array.isArray(raw.additionalStashDirs)) {
-    config.additionalStashDirs = raw.additionalStashDirs.filter(
+  if (Array.isArray(raw.mountedStashDirs)) {
+    config.mountedStashDirs = raw.mountedStashDirs.filter(
       (d): d is string => typeof d === "string",
     )
   }
 
-  const embedding = parseConnectionConfig(raw.embedding)
+  const embedding = parseEmbeddingConfig(raw.embedding)
   if (embedding) config.embedding = embedding
 
-  const llm = parseConnectionConfig(raw.llm)
+  const llm = parseLlmConfig(raw.llm)
   if (llm) config.llm = llm
 
   const registry = parseRegistryConfig(raw.registry)
   if (registry) config.registry = registry
 
+  if (Array.isArray(raw.registryUrls)) {
+    config.registryUrls = raw.registryUrls.filter(
+      (u): u is string => typeof u === "string" && u.startsWith("http"),
+    )
+  }
+
   return config
 }
 
-function parseConnectionConfig(
-  value: unknown,
-): EmbeddingConnectionConfig | LlmConnectionConfig | undefined {
+function readConfigObject(configPath: string): Record<string, unknown> | undefined {
+  try {
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf8"))
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return undefined
+    return raw
+  } catch {
+    return undefined
+  }
+}
+
+function parseEmbeddingConfig(value: unknown): EmbeddingConnectionConfig | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined
+  const obj = value as Record<string, unknown>
+  if (typeof obj.endpoint !== "string" || !obj.endpoint) return undefined
+  if (typeof obj.model !== "string" || !obj.model) return undefined
+  const result: EmbeddingConnectionConfig = {
+    endpoint: obj.endpoint,
+    model: obj.model,
+  }
+  if (typeof obj.provider === "string" && obj.provider) {
+    result.provider = obj.provider
+  }
+  if ("dimension" in obj) {
+    if (
+      typeof obj.dimension !== "number" ||
+      !Number.isFinite(obj.dimension) ||
+      !Number.isInteger(obj.dimension) ||
+      obj.dimension <= 0
+    ) {
+      return undefined
+    }
+    result.dimension = obj.dimension
+  }
+  if (typeof obj.apiKey === "string" && obj.apiKey) {
+    result.apiKey = obj.apiKey
+  }
+  return result
+}
+
+function parseLlmConfig(value: unknown): LlmConnectionConfig | undefined {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined
   const obj = value as Record<string, unknown>
   if (typeof obj.endpoint !== "string" || !obj.endpoint) return undefined
   if (typeof obj.model !== "string" || !obj.model) return undefined
-  const result: { endpoint: string; model: string; apiKey?: string } = {
+  const result: LlmConnectionConfig = {
     endpoint: obj.endpoint,
     model: obj.model,
   }
+  if (typeof obj.provider === "string" && obj.provider) {
+    result.provider = obj.provider
+  }
+  if (typeof obj.temperature === "number" && Number.isFinite(obj.temperature)) {
+    result.temperature = obj.temperature
+  }
+  if ("maxTokens" in obj) {
+    if (
+      typeof obj.maxTokens !== "number" ||
+      !Number.isFinite(obj.maxTokens) ||
+      !Number.isInteger(obj.maxTokens) ||
+      obj.maxTokens <= 0
+    ) {
+      return undefined
+    }
+    result.maxTokens = obj.maxTokens
+  }
   if (typeof obj.apiKey === "string" && obj.apiKey) {
     result.apiKey = obj.apiKey
   }
@@ -179,5 +301,5 @@ function asNonEmptyString(value: unknown): string | undefined {
 }
 
 function asRegistrySource(value: unknown): RegistrySource | undefined {
-  return value === "npm" || value === "github" ? value : undefined
+  return value === "npm" || value === "github" || value === "git" ? value : undefined
 }

package/src/db.ts

@@ -0,0 +1,411 @@
+import fs from "node:fs"
+import path from "node:path"
+import { Database } from "bun:sqlite"
+import type { StashEntry } from "./metadata"
+import type { EmbeddingVector } from "./embedder"
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+export interface DbIndexedEntry {
+  id: number
+  entryKey: string
+  dirPath: string
+  filePath: string
+  stashDir: string
+  entry: StashEntry
+  searchText: string
+}
+
+export interface DbSearchResult {
+  id: number
+  filePath: string
+  entry: StashEntry
+  searchText: string
+  bm25Score: number
+}
+
+export interface DbVecResult {
+  id: number
+  distance: number
+}
+
+// ── Constants ───────────────────────────────────────────────────────────────
+
+export const DB_VERSION = 5
+export const EMBEDDING_DIM = 384
+
+// ── Path ────────────────────────────────────────────────────────────────────
+
+export function getDbPath(): string {
+  const cacheDir =
+    process.env.XDG_CACHE_HOME ||
+    path.join(process.env.HOME || process.env.USERPROFILE || "", ".cache")
+  return path.join(cacheDir, "agentikit", "index.db")
+}
+
+// ── Database lifecycle ──────────────────────────────────────────────────────
+
+export function openDatabase(dbPath?: string, options?: { embeddingDim?: number }): Database {
+  const resolvedPath = dbPath ?? getDbPath()
+  const dir = path.dirname(resolvedPath)
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+
+  const db = new Database(resolvedPath)
+  db.exec("PRAGMA journal_mode = WAL")
+  db.exec("PRAGMA foreign_keys = ON")
+
+  // Try to load sqlite-vec extension
+  loadVecExtension(db)
+
+  ensureSchema(db, options?.embeddingDim ?? EMBEDDING_DIM)
+  return db
+}
+
+export function closeDatabase(db: Database): void {
+  db.close()
+}
+
+// ── sqlite-vec extension ────────────────────────────────────────────────────
+
+let vecAvailable = false
+
+function loadVecExtension(db: Database): void {
+  try {
+    const sqliteVec = require("sqlite-vec")
+    sqliteVec.load(db)
+    vecAvailable = true
+  } catch {
+    console.warn("sqlite-vec extension not available, embeddings will be skipped")
+    vecAvailable = false
+  }
+}
+
+export function isVecAvailable(): boolean {
+  return vecAvailable
+}
+
+// ── Schema ──────────────────────────────────────────────────────────────────
+
+function ensureSchema(db: Database, embeddingDim: number): void {
+  // Create meta table first so we can check version
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS index_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `)
+
+  // 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 entries_vec")
+    db.exec("DROP TABLE IF EXISTS entries_fts")
+    db.exec("DROP INDEX IF EXISTS idx_entries_dir")
+    db.exec("DROP INDEX IF EXISTS idx_entries_type")
+    db.exec("DROP TABLE IF EXISTS entries")
+    db.exec("DELETE FROM index_meta")
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      entry_key   TEXT NOT NULL UNIQUE,
+      dir_path    TEXT NOT NULL,
+      file_path   TEXT NOT NULL,
+      stash_dir   TEXT NOT NULL,
+      entry_json  TEXT NOT NULL,
+      search_text TEXT NOT NULL,
+      entry_type  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entries_dir ON entries(dir_path);
+    CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type);
+  `)
+
+  // FTS5 table — standalone with explicit entry_id for joining
+  const ftsExists = db
+    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_fts'")
+    .get()
+  if (!ftsExists) {
+    db.exec(`
+      CREATE VIRTUAL TABLE entries_fts USING fts5(
+        entry_id UNINDEXED,
+        search_text,
+        tokenize='porter unicode61'
+      );
+    `)
+  }
+
+  // sqlite-vec table
+  if (vecAvailable) {
+    // Check if stored embedding dimension differs from configured one
+    const storedDim = getMeta(db, "embeddingDim")
+    if (storedDim && storedDim !== String(embeddingDim)) {
+      try { db.exec("DROP TABLE IF EXISTS entries_vec") } catch { /* ignore */ }
+    }
+
+    const vecExists = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'")
+      .get()
+    if (!vecExists) {
+      db.exec(`
+        CREATE VIRTUAL TABLE entries_vec USING vec0(
+          id       INTEGER PRIMARY KEY,
+          embedding FLOAT[${embeddingDim}]
+        );
+      `)
+    }
+    setMeta(db, "embeddingDim", String(embeddingDim))
+  }
+
+  // Set version if not present
+  const version = getMeta(db, "version")
+  if (!version) {
+    setMeta(db, "version", String(DB_VERSION))
+  }
+}
+
+// ── Meta helpers ────────────────────────────────────────────────────────────
+
+export function getMeta(db: Database, key: string): string | undefined {
+  const row = db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key) as
+    | { value: string }
+    | undefined
+  return row?.value
+}
+
+export function setMeta(db: Database, key: string, value: string): void {
+  db.prepare("INSERT OR REPLACE INTO index_meta (key, value) VALUES (?, ?)").run(key, value)
+}
+
+// ── Entry operations ────────────────────────────────────────────────────────
+
+export function upsertEntry(
+  db: Database,
+  entryKey: string,
+  dirPath: string,
+  filePath: string,
+  stashDir: string,
+  entry: StashEntry,
+  searchText: string,
+): number {
+  const stmt = db.prepare(`
+    INSERT INTO entries (entry_key, dir_path, file_path, stash_dir, entry_json, search_text, entry_type)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(entry_key) DO UPDATE SET
+      dir_path = excluded.dir_path,
+      file_path = excluded.file_path,
+      stash_dir = excluded.stash_dir,
+      entry_json = excluded.entry_json,
+      search_text = excluded.search_text,
+      entry_type = excluded.entry_type
+  `)
+  stmt.run(entryKey, dirPath, filePath, stashDir, JSON.stringify(entry), searchText, entry.type)
+  // Fetch the row id explicitly since last_insert_rowid() is unreliable for ON CONFLICT DO UPDATE
+  const row = db.prepare("SELECT id FROM entries WHERE entry_key = ?").get(entryKey) as { id: number }
+  return row.id
+}
+
+export function deleteEntriesByDir(db: Database, dirPath: string): void {
+  if (vecAvailable) {
+    const ids = db
+      .prepare("SELECT id FROM entries WHERE dir_path = ?")
+      .all(dirPath) as Array<{ id: number }>
+    for (const { id } of ids) {
+      try {
+        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id)
+      } catch { /* ignore if vec table missing */ }
+    }
+  }
+  db.prepare("DELETE FROM entries WHERE dir_path = ?").run(dirPath)
+}
+
+export function rebuildFts(db: Database): void {
+  db.exec("DELETE FROM entries_fts")
+  db.exec("INSERT INTO entries_fts (entry_id, search_text) SELECT CAST(id AS TEXT), search_text FROM entries")
+}
+
+// ── Vector operations ───────────────────────────────────────────────────────
+
+export function upsertEmbedding(
+  db: Database,
+  entryId: number,
+  embedding: EmbeddingVector,
+): void {
+  if (!vecAvailable) return
+  const buf = float32Buffer(embedding)
+  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)
+}
+
+export function searchVec(
+  db: Database,
+  queryEmbedding: EmbeddingVector,
+  k: number,
+): DbVecResult[] {
+  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) as DbVecResult[]
+  } catch {
+    return []
+  }
+}
+
+function float32Buffer(vec: number[]): Buffer {
+  const f32 = new Float32Array(vec)
+  return Buffer.from(f32.buffer)
+}
+
+// ── FTS5 search ─────────────────────────────────────────────────────────────
+
+export function searchFts(
+  db: Database,
+  query: string,
+  limit: number,
+  entryType?: string,
+): DbSearchResult[] {
+  const ftsQuery = sanitizeFtsQuery(query)
+  if (!ftsQuery) return []
+
+  let sql: string
+  let params: unknown[]
+
+  if (entryType && entryType !== "any") {
+    sql = `
+      SELECT e.id, e.file_path AS filePath, e.entry_json, e.search_text AS searchText,
+             bm25(entries_fts) AS bm25Score
+      FROM entries_fts f
+      JOIN entries e ON e.id = CAST(f.entry_id AS INTEGER)
+      WHERE entries_fts MATCH ?
+        AND e.entry_type = ?
+      ORDER BY bm25Score
+      LIMIT ?
+    `
+    params = [ftsQuery, entryType, limit]
+  } else {
+    sql = `
+      SELECT e.id, e.file_path AS filePath, e.entry_json, e.search_text AS searchText,
+             bm25(entries_fts) AS bm25Score
+      FROM entries_fts f
+      JOIN entries e ON e.id = CAST(f.entry_id AS INTEGER)
+      WHERE entries_fts MATCH ?
+      ORDER BY bm25Score
+      LIMIT ?
+    `
+    params = [ftsQuery, limit]
+  }
+
+  try {
+    const rows = db.prepare(sql).all(...(params as import("bun:sqlite").SQLQueryBindings[])) as Array<{
+      id: number
+      filePath: string
+      entry_json: string
+      searchText: string
+      bm25Score: number
+    }>
+
+    return rows.map((row) => ({
+      id: row.id,
+      filePath: row.filePath,
+      entry: JSON.parse(row.entry_json) as StashEntry,
+      searchText: row.searchText,
+      bm25Score: row.bm25Score,
+    }))
+  } catch {
+    return []
+  }
+}
+
+function sanitizeFtsQuery(query: string): string {
+  const tokens = query
+    .replace(/[^a-zA-Z0-9\s]/g, " ")
+    .split(/\s+/)
+    .filter((t) => t.length > 1)
+  if (tokens.length === 0) return ""
+  // Use unquoted tokens so the porter stemmer can normalize word forms
+  return tokens.join(" OR ")
+}
+
+// ── All entries ─────────────────────────────────────────────────────────────
+
+export function getAllEntries(
+  db: Database,
+  entryType?: string,
+): DbIndexedEntry[] {
+  let sql: string
+  let params: unknown[]
+
+  if (entryType && entryType !== "any") {
+    sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE entry_type = ?"
+    params = [entryType]
+  } else {
+    sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries"
+    params = []
+  }
+
+  const rows = db.prepare(sql).all(...(params as import("bun:sqlite").SQLQueryBindings[])) as Array<{
+    id: number
+    entry_key: string
+    dir_path: string
+    file_path: string
+    stash_dir: string
+    entry_json: string
+    search_text: string
+  }>
+
+  return rows.map((row) => ({
+    id: row.id,
+    entryKey: row.entry_key,
+    dirPath: row.dir_path,
+    filePath: row.file_path,
+    stashDir: row.stash_dir,
+    entry: JSON.parse(row.entry_json) as StashEntry,
+    searchText: row.search_text,
+  }))
+}
+
+export function getEntryCount(db: Database): number {
+  const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get() as { cnt: number }
+  return row.cnt
+}
+
+export function getEntryById(db: Database, id: number): { filePath: string; entry: StashEntry } | undefined {
+  const row = db
+    .prepare("SELECT file_path, entry_json FROM entries WHERE id = ?")
+    .get(id) as { file_path: string; entry_json: string } | undefined
+  if (!row) return undefined
+  return { filePath: row.file_path, entry: JSON.parse(row.entry_json) as StashEntry }
+}
+
+export function getEntriesByDir(db: Database, dirPath: string): DbIndexedEntry[] {
+  const rows = db
+    .prepare(
+      "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE dir_path = ?",
+    )
+    .all(dirPath) as Array<{
+    id: number
+    entry_key: string
+    dir_path: string
+    file_path: string
+    stash_dir: string
+    entry_json: string
+    search_text: string
+  }>
+
+  return rows.map((row) => ({
+    id: row.id,
+    entryKey: row.entry_key,
+    dirPath: row.dir_path,
+    filePath: row.file_path,
+    stashDir: row.stash_dir,
+    entry: JSON.parse(row.entry_json) as StashEntry,
+    searchText: row.search_text,
+  }))
+}