@comfanion/usethis_search 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Comfanion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# @comfanion/usethis_search
+
+OpenCode plugin that provides semantic search and index management tools.
+
+## Tools
+
+- `search` (semantic search)
+- `codeindex` (index status, list, reindex)
+
+## Storage
+
+- Vectors are stored in `.opencode/vectors/<index>/` in the project.
+
+## Install (OpenCode)
+
+Add to `opencode.json`:
+
+```json
+{
+  "plugin": ["@comfanion/usethis_search"]
+}
+```

package/file-indexer.ts

@@ -0,0 +1,460 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import path from "path"
+import fs from "fs/promises"
+import fsSync from "fs"
+
+import { CodebaseIndexer } from "./vectorizer/index.js"
+
+/**
+ * File Indexer Plugin
+ *
+ * Automatically manages semantic search indexes:
+ * - On plugin load (opencode startup): freshen existing indexes
+ * - On file edit: queue file for reindexing (debounced)
+ *
+ * Configuration in .opencode/vectorizer.yaml:
+ *   vectorizer:
+ *     enabled: true       # Master switch
+ *     auto_index: true    # Enable this plugin
+ *     debounce_ms: 1000   # Wait time before indexing
+ */
+
+const DEBUG = process.env.DEBUG?.includes("file-indexer") || process.env.DEBUG === "*"
+const SKIP_AUTO_INDEX = process.env.OPENCODE_SKIP_AUTO_INDEX === "1"
+
+let logFilePath: string | null = null
+
+function logFile(msg: string): void {
+  if (logFilePath) {
+    try {
+      const timestamp = new Date().toISOString().slice(11, 19)
+      fsSync.appendFileSync(logFilePath, `${timestamp} ${msg}\n`)
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function log(msg: string): void {
+  if (DEBUG) console.log(`[file-indexer] ${msg}`)
+  logFile(msg)
+}
+
+function debug(msg: string): void {
+  if (DEBUG) log(msg)
+}
+
+const DEFAULT_CONFIG = {
+  enabled: true,
+  auto_index: true,
+  debounce_ms: 1000,
+  indexes: {
+    code: { enabled: true, extensions: [".js", ".ts", ".jsx", ".tsx", ".py", ".go", ".rs", ".java", ".kt", ".swift", ".c", ".cpp", ".h", ".hpp", ".cs", ".rb", ".php", ".scala", ".clj"] },
+    docs: { enabled: true, extensions: [".md", ".mdx", ".txt", ".rst", ".adoc"] },
+    config: { enabled: false, extensions: [".yaml", ".yml", ".json", ".toml", ".ini", ".xml"] },
+  },
+  exclude: ["node_modules", "vendor", "dist", "build", "out", "__pycache__"],
+}
+
+interface VectorizerConfig {
+  enabled: boolean
+  auto_index: boolean
+  debounce_ms: number
+  indexes: Record<string, { enabled: boolean; extensions: string[] }>
+  exclude: string[]
+}
+
+const FUN_MESSAGES = {
+  en: {
+    indexing: (files: number) => `Indexing ${files} files...`,
+    fun: (files: number, mins: number) => {
+      if (files < 20) return `Quick coffee? ☕`
+      if (files < 100) return `~${mins}min. Stretch break? 🧘`
+      if (files < 500) return `~${mins}min. Make coffee ☕ and relax 🛋️`
+      return `~${mins}min. Go touch grass 🌿 or take a nap 😴`
+    },
+    done: (files: number, duration: string) => {
+      if (files < 20) return `Done! ${files} files in ${duration}. Fast! 🚀`
+      if (files < 100) return `Indexed ${files} files in ${duration}. Let's go! 🎸`
+      return `${files} files in ${duration}. Worth the wait! 🎉`
+    },
+    fresh: () => `Everything's fresh! Nothing to do 😎`,
+    error: (msg: string) => `Oops! ${msg} 😬`,
+  },
+  uk: {
+    indexing: (files: number) => `Індексую ${files} файлів...`,
+    fun: (files: number, mins: number) => {
+      if (files < 20) return `Швидка кава? ☕`
+      if (files < 100) return `~${mins}хв. Розімнись! 🧘`
+      if (files < 500) return `~${mins}хв. Зроби каву ☕ і відпочинь 🛋️`
+      return `~${mins}хв. Йди погуляй 🌿 або поспи 😴`
+    },
+    done: (files: number, duration: string) => {
+      if (files < 20) return `Готово! ${files} файлів за ${duration}. Швидко! 🚀`
+      if (files < 100) return `${files} файлів за ${duration}. Поїхали! 🎸`
+      return `${files} файлів за ${duration}. Варто було чекати! 🎉`
+    },
+    fresh: () => `Все свіже! Нічого робити 😎`,
+    error: (msg: string) => `Ой! ${msg} 😬`,
+  },
+  ru: {
+    indexing: (files: number) => `Индексирую ${files} файлов...`,
+    fun: (files: number, mins: number) => {
+      if (files < 20) return `Кофе? ☕`
+      if (files < 100) return `~${mins}мин. Разомнись! 🧘`
+      if (files < 500) return `~${mins}мин. Сделай кофе ☕ и отдохни 🛋️`
+      return `~${mins}мин. Иди погуляй 🌿 или поспи 😴`
+    },
+    done: (files: number, duration: string) => {
+      if (files < 20) return `Готово! ${files} файлов за ${duration}. Быстро! 🚀`
+      if (files < 100) return `${files} файлов за ${duration}. Поехали! 🎸`
+      return `${files} файлов за ${duration}. Стоило подождать! 🎉`
+    },
+    fresh: () => `Всё свежее! Делать нечего 😎`,
+    error: (msg: string) => `Ой! ${msg} 😬`,
+  },
+}
+
+type Lang = keyof typeof FUN_MESSAGES
+
+async function getLanguage(projectRoot: string): Promise<Lang> {
+  try {
+    const configPath = path.join(projectRoot, ".opencode", "config.yaml")
+    const content = await fs.readFile(configPath, "utf8")
+    const match = content.match(/communication_language:\s*["']?(\w+)["']?/i)
+    const lang = match?.[1]?.toLowerCase()
+    if (lang === "ukrainian" || lang === "uk") return "uk"
+    if (lang === "russian" || lang === "ru") return "ru"
+    return "en"
+  } catch {
+    return "en"
+  }
+}
+
+function estimateTime(fileCount: number): number {
+  const modelLoadTime = 30
+  const perFileTime = 0.5
+  const totalSeconds = modelLoadTime + fileCount * perFileTime
+  return Math.ceil(totalSeconds / 60)
+}
+
+function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${Math.round(seconds)}s`
+  const mins = Math.floor(seconds / 60)
+  const secs = Math.round(seconds % 60)
+  return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`
+}
+
+const pendingFiles: Map<string, { indexName: string; timestamp: number }> = new Map()
+
+async function loadConfig(projectRoot: string): Promise<VectorizerConfig> {
+  try {
+    const candidates = [path.join(projectRoot, ".opencode", "vectorizer.yaml")]
+
+    let content: string | null = null
+    for (const configPath of candidates) {
+      try {
+        content = await fs.readFile(configPath, "utf8")
+        break
+      } catch {
+        // try next
+      }
+    }
+
+    if (!content) {
+      debug("No vectorizer config file found, using defaults")
+      return DEFAULT_CONFIG
+    }
+
+    const vectorizerMatch = content.match(/vectorizer:\s*\n([\s\S]*?)(?=\n[a-zA-Z_\-]+:|$)/i)
+    if (!vectorizerMatch) {
+      debug("No vectorizer section, using defaults")
+      return DEFAULT_CONFIG
+    }
+
+    const section = vectorizerMatch[1]
+
+    const enabledMatch = section.match(/^\s+enabled:\s*(true|false)/m)
+    const enabled = enabledMatch ? enabledMatch[1] === "true" : DEFAULT_CONFIG.enabled
+
+    const autoIndexMatch = section.match(/^\s+auto_index:\s*(true|false)/m)
+    const auto_index = autoIndexMatch ? autoIndexMatch[1] === "true" : DEFAULT_CONFIG.auto_index
+
+    const debounceMatch = section.match(/^\s+debounce_ms:\s*(\d+)/m)
+    const debounce_ms = debounceMatch ? parseInt(debounceMatch[1]) : DEFAULT_CONFIG.debounce_ms
+
+    const excludeMatch = section.match(/exclude:\s*\n((?:\s+-\s+.+\n?)+)/m)
+    let exclude = DEFAULT_CONFIG.exclude
+    if (excludeMatch) {
+      exclude = excludeMatch[1].match(/-\s+(.+)/g)?.map((m) => m.replace(/^-\s+/, "").trim()) || DEFAULT_CONFIG.exclude
+    }
+
+    return { enabled, auto_index, debounce_ms, indexes: DEFAULT_CONFIG.indexes, exclude }
+  } catch (e) {
+    debug(`Failed to load config: ${(e as Error).message}`)
+    return DEFAULT_CONFIG
+  }
+}
+
+function getIndexForFile(filePath: string, config: VectorizerConfig): string | null {
+  const ext = path.extname(filePath).toLowerCase()
+  for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
+    if (indexConfig.enabled && indexConfig.extensions.includes(ext)) {
+      return indexName
+    }
+  }
+  return null
+}
+
+function isExcluded(relativePath: string, config: VectorizerConfig): boolean {
+  const norm = relativePath.replace(/\\/g, "/")
+  return config.exclude.some((pattern) => {
+    const p = pattern.replace(/\\/g, "/").replace(/\/+$/, "")
+    return norm === p || norm.startsWith(`${p}/`) || norm.includes(`/${p}/`)
+  })
+}
+
+async function hasIndex(projectRoot: string, indexName: string): Promise<boolean> {
+  try {
+    await fs.access(path.join(projectRoot, ".opencode", "vectors", indexName, "hashes.json"))
+    return true
+  } catch {
+    return false
+  }
+}
+
+interface IndexResult {
+  totalFiles: number
+  elapsedSeconds: number
+  action: "created" | "rebuilt" | "freshened" | "skipped"
+}
+
+async function ensureIndexOnSessionStart(
+  projectRoot: string,
+  config: VectorizerConfig,
+  onStart?: (totalFiles: number, estimatedMins: number) => void,
+): Promise<IndexResult> {
+  if (SKIP_AUTO_INDEX) {
+    return { totalFiles: 0, elapsedSeconds: 0, action: "skipped" }
+  }
+
+  let totalFiles = 0
+  let elapsedSeconds = 0
+  let action: IndexResult["action"] = "skipped"
+
+  const overallStart = Date.now()
+
+  // First pass - count files and check health
+  let needsWork = false
+  let totalExpectedFiles = 0
+
+  for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
+    if (!indexConfig.enabled) continue
+    const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+    try {
+      const indexExists = await hasIndex(projectRoot, indexName)
+      const health = await indexer.checkHealth(config.exclude)
+
+      if (!indexExists || health.needsReindex) {
+        totalExpectedFiles += health.expectedCount
+        needsWork = true
+      }
+    } finally {
+      await indexer.unloadModel()
+    }
+  }
+
+  if (needsWork && onStart) {
+    onStart(totalExpectedFiles, estimateTime(totalExpectedFiles))
+  }
+
+  // Second pass - do the actual work
+  for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
+    if (!indexConfig.enabled) continue
+
+    const indexExists = await hasIndex(projectRoot, indexName)
+    const startTime = Date.now()
+
+    const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+    try {
+      if (!indexExists) {
+        log(`Creating "${indexName}" index...`)
+        const stats = await indexer.indexAll((indexed: number, total: number, file: string) => {
+          if (indexed % 10 === 0 || indexed === total) {
+            logFile(`"${indexName}": ${indexed}/${total} - ${file}`)
+          }
+        }, config.exclude)
+        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+        log(`"${indexName}": done ${stats.indexed} files (${elapsed}s)`)
+        totalFiles += stats.indexed
+        action = "created"
+      } else {
+        const health = await indexer.checkHealth(config.exclude)
+
+        if (health.needsReindex) {
+          log(`Rebuilding "${indexName}" (${health.reason}: ${health.currentCount} vs ${health.expectedCount} files)...`)
+          const stats = await indexer.indexAll((indexed: number, total: number, file: string) => {
+            if (indexed % 10 === 0 || indexed === total) {
+              logFile(`"${indexName}": ${indexed}/${total} - ${file}`)
+            }
+          }, config.exclude)
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+          log(`"${indexName}": rebuilt ${stats.indexed} files (${elapsed}s)`)
+          totalFiles += stats.indexed
+          action = "rebuilt"
+        } else {
+          log(`Freshening "${indexName}"...`)
+          const stats = await indexer.freshen()
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1)
+
+          if (stats.updated > 0 || stats.deleted > 0) {
+            log(`"${indexName}": +${stats.updated} -${stats.deleted} (${elapsed}s)`)
+            action = "freshened"
+          } else {
+            log(`"${indexName}": fresh (${elapsed}s)`)
+          }
+        }
+      }
+    } finally {
+      await indexer.unloadModel()
+    }
+  }
+
+  elapsedSeconds = (Date.now() - overallStart) / 1000
+  log(`Indexes ready!`)
+  return { totalFiles, elapsedSeconds, action }
+}
+
+async function processPendingFiles(projectRoot: string, config: VectorizerConfig): Promise<void> {
+  if (pendingFiles.size === 0) return
+  if (SKIP_AUTO_INDEX) {
+    pendingFiles.clear()
+    return
+  }
+
+  const now = Date.now()
+  const filesToProcess: Map<string, string[]> = new Map()
+
+  for (const [filePath, info] of pendingFiles.entries()) {
+    if (now - info.timestamp >= config.debounce_ms) {
+      const files = filesToProcess.get(info.indexName) || []
+      files.push(filePath)
+      filesToProcess.set(info.indexName, files)
+      pendingFiles.delete(filePath)
+    }
+  }
+
+  if (filesToProcess.size === 0) return
+
+  debug(`Processing ${filesToProcess.size} index(es)...`)
+
+  for (const [indexName, files] of filesToProcess.entries()) {
+    const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+    try {
+      for (const filePath of files) {
+        try {
+          const wasIndexed = await indexer.indexSingleFile(filePath)
+          if (wasIndexed) {
+            log(`Reindexed: ${path.relative(projectRoot, filePath)} → ${indexName}`)
+          } else {
+            logFile(`Skipped (unchanged): ${path.relative(projectRoot, filePath)}`)
+          }
+        } catch (e) {
+          log(`Error reindexing ${path.relative(projectRoot, filePath)}: ${(e as Error).message}`)
+        }
+      }
+    } finally {
+      await indexer.unloadModel()
+    }
+  }
+}
+
+export const FileIndexerPlugin: Plugin = async ({ directory, client }) => {
+  let processingTimeout: NodeJS.Timeout | null = null
+  const config = await loadConfig(directory)
+
+  const toast = async (message: string, variant: "info" | "success" | "error" = "info") => {
+    try {
+      await client?.tui?.showToast?.({ body: { message, variant } })
+    } catch {}
+  }
+
+  log(`Plugin loaded for: ${path.basename(directory)}`)
+
+  if (!config.enabled || !config.auto_index) {
+    log(`Plugin DISABLED (enabled: ${config.enabled}, auto_index: ${config.auto_index})`)
+    return { event: async () => {} }
+  }
+
+  logFilePath = path.join(directory, ".opencode", "indexer.log")
+  try {
+    fsSync.writeFileSync(logFilePath, "")
+  } catch {
+    logFilePath = null
+  }
+
+  log(`Plugin ACTIVE`)
+
+  const lang = await getLanguage(directory)
+  const messages = FUN_MESSAGES[lang]
+
+  if (!SKIP_AUTO_INDEX) {
+    setTimeout(async () => {
+      try {
+        const result = await ensureIndexOnSessionStart(
+          directory,
+          config,
+          async (totalFiles, estimatedMins) => {
+            await toast(messages.indexing(totalFiles), "info")
+            if (totalFiles > 0) {
+              setTimeout(() => toast(messages.fun(totalFiles, estimatedMins), "info"), 1500)
+            }
+          },
+        )
+
+        if (result.action === "skipped") {
+          toast(messages.fresh(), "success")
+        } else {
+          const duration = formatDuration(result.elapsedSeconds)
+          toast(messages.done(result.totalFiles, duration), "success")
+        }
+      } catch (e: any) {
+        toast(messages.error(e.message), "error")
+      }
+    }, 1000)
+  }
+
+  function queueFileForIndexing(filePath: string): void {
+    const relativePath = path.relative(directory, filePath)
+    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) return
+    if (isExcluded(relativePath, config)) return
+
+    const indexName = getIndexForFile(filePath, config)
+    if (!indexName) return
+
+    debug(`Queued: ${relativePath} -> ${indexName}`)
+    pendingFiles.set(filePath, { indexName, timestamp: Date.now() })
+
+    if (processingTimeout) {
+      clearTimeout(processingTimeout)
+    }
+    processingTimeout = setTimeout(async () => {
+      await processPendingFiles(directory, config)
+    }, config.debounce_ms + 100)
+  }
+
+  return {
+    event: async ({ event }) => {
+      if (event.type === "file.edited" || event.type === "file.watcher.updated") {
+        const props = (event as any).properties || {}
+        const filePath = props.file || props.path || props.filePath
+        if (filePath) {
+          log(`Event: ${event.type} → ${filePath}`)
+          queueFileForIndexing(filePath)
+        }
+      }
+    },
+  }
+}
+
+export default FileIndexerPlugin

package/index.ts

@@ -0,0 +1,19 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+import search from "./tools/search"
+import codeindex from "./tools/codeindex"
+import FileIndexerPlugin from "./file-indexer"
+
+export const UsethisSearchPlugin: Plugin = async (ctx) => {
+  const fileIndexerHooks = await FileIndexerPlugin(ctx as any)
+
+  return {
+    ...fileIndexerHooks,
+    tool: {
+      search,
+      codeindex,
+    },
+  }
+}
+
+export default UsethisSearchPlugin

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@comfanion/usethis_search",
+  "version": "0.1.0",
+  "description": "OpenCode plugin: semantic search + code index management",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": "./index.ts",
+  "scripts": {
+    "test": "bun test"
+  },
+  "files": [
+    "index.ts",
+    "file-indexer.ts",
+    "tools/search.ts",
+    "tools/codeindex.ts",
+    "vectorizer/index.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "1.1.39",
+    "@xenova/transformers": "^2.17.0",
+    "glob": "^10.3.10",
+    "vectordb": "^0.4.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.1.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT"
+}

package/tools/codeindex.ts

@@ -0,0 +1,159 @@
+/**
+ * Code Index Status & Management Tool
+ *
+ * Uses bundled vectorizer. Index data is stored in `.opencode/vectors/<index>/`.
+ */
+
+import { tool } from "@opencode-ai/plugin"
+import path from "path"
+import fs from "fs/promises"
+
+import { CodebaseIndexer } from "../vectorizer/index.js"
+
+const INDEX_EXTENSIONS: Record<string, string[]> = {
+  code: [".js", ".ts", ".jsx", ".tsx", ".go", ".py", ".rs", ".java", ".kt", ".swift", ".c", ".cpp", ".h", ".cs", ".rb", ".php"],
+  docs: [".md", ".mdx", ".txt", ".rst", ".adoc"],
+  config: [".yaml", ".yml", ".json", ".toml", ".ini", ".xml"],
+}
+
+const INDEX_DESCRIPTIONS: Record<string, string> = {
+  code: "Source code files",
+  docs: "Documentation files",
+  config: "Configuration files",
+}
+
+async function walkDir(dir: string, extensions: string[], ignore: string[] = []): Promise<string[]> {
+  const files: string[] = []
+
+  async function walk(currentDir: string) {
+    try {
+      const entries = await fs.readdir(currentDir, { withFileTypes: true })
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name)
+        const relativePath = path.relative(dir, fullPath)
+
+        if (ignore.some((ig) => relativePath.startsWith(ig) || entry.name === ig)) {
+          continue
+        }
+
+        if (entry.isDirectory()) {
+          await walk(fullPath)
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase()
+          if (extensions.includes(ext)) {
+            files.push(fullPath)
+          }
+        }
+      }
+    } catch {}
+  }
+
+  await walk(dir)
+  return files
+}
+
+export default tool({
+  description: `Check codebase index status or trigger re-indexing for semantic search.
+
+Actions:
+- "status" → Show index statistics
+- "list" → List all available indexes with stats
+- "reindex" → Re-index files using local vectorizer
+
+Available indexes:
+- "code" - Source code files
+- "docs" - Documentation files
+- "config" - Configuration files`,
+
+  args: {
+    action: tool.schema.enum(["status", "list", "reindex"]).describe("Action to perform"),
+    index: tool.schema.string().optional().default("code").describe("Index name: code, docs, config"),
+    dir: tool.schema.string().optional().describe("Directory to index (default: project root)"),
+  },
+
+  async execute(args) {
+    const projectRoot = process.cwd()
+    const vectorsDir = path.join(projectRoot, ".opencode", "vectors")
+    const indexName = args.index || "code"
+
+    if (args.action === "list") {
+      let output = `## Codebase Index Overview\n\n`
+      const indexes: string[] = []
+      try {
+        const entries = await fs.readdir(vectorsDir, { withFileTypes: true })
+        for (const entry of entries) {
+          if (entry.isDirectory()) indexes.push(entry.name)
+        }
+      } catch {}
+
+      if (indexes.length === 0) {
+        output += `⚠️ No indexes created yet\n\nCreate indexes:\n\n\`\`\`\n`
+        output += `codeindex({ action: "reindex", index: "code" })\n`
+        output += `codeindex({ action: "reindex", index: "docs", dir: "docs/" })\n`
+        output += `\`\`\`\n`
+      } else {
+        output += `### Active Indexes\n\n`
+        for (const idx of indexes) {
+          try {
+            const hashesPath = path.join(vectorsDir, idx, "hashes.json")
+            const hashes = JSON.parse(await fs.readFile(hashesPath, "utf8"))
+            const fileCount = Object.keys(hashes).length
+            const desc = INDEX_DESCRIPTIONS[idx] || "Custom index"
+            output += `- ${idx} - ${desc} (files: ${fileCount})\n`
+          } catch {
+            output += `- ${idx}\n`
+          }
+        }
+      }
+
+      output += `\n### Usage\n\n\`\`\`\nsearch({ query: "your query", index: "code" })\n\`\`\``
+      return output
+    }
+
+    if (args.action === "status") {
+      const hashesFile = path.join(vectorsDir, indexName, "hashes.json")
+      try {
+        const hashesContent = await fs.readFile(hashesFile, "utf8")
+        const hashes = JSON.parse(hashesContent)
+        const fileCount = Object.keys(hashes).length
+        const sampleFiles = Object.keys(hashes).slice(0, 5)
+        const desc = INDEX_DESCRIPTIONS[indexName] || "Custom index"
+
+        return `## Index Status: "${indexName}"\n\n**Description:** ${desc}\n**Files indexed:** ${fileCount}\n\n**Sample indexed files:**\n${sampleFiles.map((f) => `- ${f}`).join("\n")}${fileCount > 5 ? `\n- ... and ${fileCount - 5} more` : ""}`
+      } catch {
+        return `## Index Status: "${indexName}"\n\nIndex "${indexName}" not created yet. Create it with: codeindex({ action: "reindex", index: "${indexName}" })`
+      }
+    }
+
+    if (args.action === "reindex") {
+      try {
+        const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+
+        const baseDir = args.dir ? path.resolve(projectRoot, args.dir) : projectRoot
+        const extensions = INDEX_EXTENSIONS[indexName] || INDEX_EXTENSIONS.code
+
+        const ignoreList = ["node_modules", ".git", "dist", "build", ".opencode", "vendor", "__pycache__"]
+        const files = await walkDir(baseDir, extensions, ignoreList)
+
+        let indexed = 0
+        let skipped = 0
+        for (const filePath of files) {
+          try {
+            const wasIndexed = await indexer.indexFile(filePath)
+            if (wasIndexed) indexed++
+            else skipped++
+          } catch {}
+        }
+
+        await indexer.unloadModel()
+        const stats = await indexer.getStats()
+
+        return `## Re-indexing Complete ✅\n\n**Index:** ${indexName}\n**Directory:** ${args.dir || "(project root)"}\n**Files found:** ${files.length}\n**Files indexed:** ${indexed}\n**Files unchanged:** ${skipped}\n**Total chunks:** ${stats.chunkCount}`
+      } catch (error: any) {
+        return `❌ Re-indexing failed: ${error.message || String(error)}`
+      }
+    }
+
+    return `Unknown action: ${args.action}. Use: status, list, or reindex`
+  },
+})

package/tools/search.ts

@@ -0,0 +1,115 @@
+/**
+ * Semantic Code Search Tool
+ *
+ * Uses local embeddings + LanceDB vector store via bundled vectorizer.
+ * Index data is stored in `.opencode/vectors/<index>/`.
+ */
+
+import { tool } from "@opencode-ai/plugin"
+import path from "path"
+import fs from "fs/promises"
+
+import { CodebaseIndexer } from "../vectorizer/index.js"
+
+export default tool({
+  description: `Search the codebase semantically. Use this to find relevant code snippets, functions, or files based on meaning, not just text matching.
+
+Available indexes:
+- "code" (default) - Source code files (*.js, *.ts, *.py, *.go, etc.)
+- "docs" - Documentation files (*.md, *.txt, etc.)
+- "config" - Configuration files (*.yaml, *.json, etc.)
+- searchAll: true - Search across all indexes
+
+Examples:
+- "authentication logic" → finds auth-related code
+- "database connection handling" → finds DB setup code
+- "how to deploy" with index: "docs" → finds deployment docs
+- "API keys" with index: "config" → finds config with API settings`,
+
+  args: {
+    query: tool.schema.string().describe("Semantic search query describing what you're looking for"),
+    index: tool.schema.string().optional().default("code").describe("Index to search: code, docs, config, or custom name"),
+    limit: tool.schema.number().optional().default(10).describe("Number of results to return (default: 10)"),
+    searchAll: tool.schema.boolean().optional().default(false).describe("Search all indexes instead of just one"),
+    freshen: tool.schema.boolean().optional().default(true).describe("Auto-update stale files before searching (default: true)"),
+    includeArchived: tool.schema.boolean().optional().default(false).describe("Include archived files in results (default: false). Files are archived if in /archive/ folder or have 'archived: true' in frontmatter."),
+  },
+
+  async execute(args) {
+    const projectRoot = process.cwd()
+
+    try {
+      let allResults: any[] = []
+      const limit = args.limit || 10
+      const indexName = args.index || "code"
+
+      // Auto-freshen stale files before searching
+      if (args.freshen !== false) {
+        const tempIndexer = await new CodebaseIndexer(projectRoot, indexName).init()
+        await tempIndexer.freshen()
+        await tempIndexer.unloadModel()
+      }
+
+      if (args.searchAll) {
+        const tempIndexer = await new CodebaseIndexer(projectRoot, "code").init()
+        const indexes = await tempIndexer.listIndexes()
+        await tempIndexer.unloadModel()
+
+        if (indexes.length === 0) {
+          return `❌ No indexes found. Create one with: codeindex({ action: "reindex", index: "code" })`
+        }
+
+        for (const idx of indexes) {
+          const indexer = await new CodebaseIndexer(projectRoot, idx).init()
+          if (args.freshen !== false) {
+            await indexer.freshen()
+          }
+          const results = await indexer.search(args.query, limit, args.includeArchived)
+          allResults.push(...results.map((r: any) => ({ ...r, _index: idx })))
+          await indexer.unloadModel()
+        }
+
+        allResults.sort((a, b) => (a._distance || 0) - (b._distance || 0))
+        allResults = allResults.slice(0, limit)
+      } else {
+        const hashesFile = path.join(projectRoot, ".opencode", "vectors", indexName, "hashes.json")
+        try {
+          await fs.access(hashesFile)
+        } catch {
+          return `❌ Index "${indexName}" not found. Create it with: codeindex({ action: "reindex", index: "${indexName}" })`
+        }
+
+        const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+        const results = await indexer.search(args.query, limit, args.includeArchived)
+        allResults = results.map((r: any) => ({ ...r, _index: indexName }))
+        await indexer.unloadModel()
+      }
+
+      if (allResults.length === 0) {
+        const scope = args.searchAll ? "any index" : `index "${indexName}"`
+        return `No results found in ${scope} for: "${args.query}"\n\nTry:\n- Different keywords\n- Re-index with: codeindex({ action: "reindex", index: "${indexName}" })`
+      }
+
+      const scope = args.searchAll ? "all indexes" : `index "${indexName}"`
+      let output = `## Search Results for: "${args.query}" (${scope})\n\n`
+
+      for (let i = 0; i < allResults.length; i++) {
+        const r = allResults[i]
+        const score = r._distance ? (1 - r._distance).toFixed(3) : "N/A"
+        const indexLabel = args.searchAll ? ` [${r._index}]` : ""
+
+        output += `### ${i + 1}. ${r.file}${indexLabel}\n`
+        output += `**Relevance:** ${score}\n\n`
+        output += "```\n"
+        const content = r.content.length > 500 ? r.content.substring(0, 500) + "\n... (truncated)" : r.content
+        output += content
+        output += "\n```\n\n"
+      }
+
+      output += `---\n*Found ${allResults.length} results. Use Read tool to see full files.*`
+      return output
+    } catch (error: any) {
+      return `❌ Search failed: ${error.message || String(error)}`
+    }
+  },
+})

package/vectorizer/index.js

@@ -0,0 +1,555 @@
+// OpenCode Vectorizer - Semantic Code Search with Multi-Index Support
+
+import { pipeline, env } from "@xenova/transformers";
+import * as lancedb from "vectordb";
+import fs from "fs/promises";
+import path from "path";
+import crypto from "crypto";
+
+// Suppress transformers.js logs unless DEBUG is set
+const DEBUG = process.env.DEBUG?.includes("vectorizer") || process.env.DEBUG === "*";
+if (!DEBUG) {
+  env.allowLocalModels = true;
+  env.useBrowserCache = false;
+  env.logLevel = "error";
+}
+
+/**
+ * Default index presets (can be overridden by config).
+ */
+const DEFAULT_PRESETS = {
+  code: {
+    pattern: "**/*.{js,ts,jsx,tsx,mjs,cjs,py,go,rs,java,kt,swift,c,cpp,h,hpp,cs,rb,php,scala,clj}",
+    ignore: [
+      "**/node_modules/**",
+      "**/.git/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.opencode/**",
+      "**/docs/**",
+      "**/vendor/**",
+      "**/__pycache__/**",
+    ],
+    description: "Source code files (excludes docs, vendor, node_modules)",
+  },
+  docs: {
+    pattern: "docs/**/*.{md,mdx,txt,rst,adoc}",
+    ignore: [],
+    description: "Documentation in docs/ folder",
+  },
+  config: {
+    pattern: "**/*.{yaml,yml,json,toml,ini,env,xml}",
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.opencode/**"],
+    description: "Configuration files",
+  },
+  all: {
+    pattern:
+      "**/*.{js,ts,jsx,tsx,mjs,cjs,py,go,rs,java,kt,swift,c,cpp,h,hpp,cs,rb,php,scala,clj,md,mdx,txt,rst,adoc,yaml,yml,json,toml}",
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.opencode/**"],
+    description: "All supported files",
+  },
+};
+
+// Will be populated from config if available
+let INDEX_PRESETS = { ...DEFAULT_PRESETS };
+let GLOBAL_IGNORE = [];
+
+// Default embedding model (fast). Can be overridden by config.
+let EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
+
+function defaultVectorizerYaml() {
+  return (
+    `vectorizer:\n` +
+    `  enabled: true\n` +
+    `  auto_index: true\n` +
+    `  model: \"${EMBEDDING_MODEL}\"\n` +
+    `  debounce_ms: 1000\n` +
+    `  indexes:\n` +
+    `    code:\n` +
+    `      enabled: true\n` +
+    `      pattern: \"${DEFAULT_PRESETS.code.pattern}\"\n` +
+    `      ignore:\n` +
+    DEFAULT_PRESETS.code.ignore.map((p) => `        - \"${p}\"\n`).join("") +
+    `    docs:\n` +
+    `      enabled: true\n` +
+    `      pattern: \"${DEFAULT_PRESETS.docs.pattern}\"\n` +
+    `      ignore: []\n` +
+    `    config:\n` +
+    `      enabled: false\n` +
+    `      pattern: \"${DEFAULT_PRESETS.config.pattern}\"\n` +
+    `      ignore:\n` +
+    DEFAULT_PRESETS.config.ignore.map((p) => `        - \"${p}\"\n`).join("") +
+    `  exclude:\n` +
+    `    - node_modules\n` +
+    `    - vendor\n` +
+    `    - dist\n` +
+    `    - build\n` +
+    `    - out\n` +
+    `    - __pycache__\n`
+  );
+}
+
+async function ensureDefaultConfig(projectRoot) {
+  try {
+    const configDir = path.join(projectRoot, ".opencode");
+    const outPath = path.join(configDir, "vectorizer.yaml");
+    await fs.mkdir(configDir, { recursive: true });
+
+    await fs.access(outPath).catch(async () => {
+      await fs.writeFile(outPath, defaultVectorizerYaml(), "utf8");
+      if (DEBUG) console.log("[vectorizer] Wrote default config:", outPath);
+    });
+  } catch {
+    // non-fatal
+  }
+}
+
+/**
+ * Load index configuration from .opencode/vectorizer.yaml (preferred) or .opencode/config.yaml.
+ */
+async function loadConfig(projectRoot) {
+  try {
+    const candidates = [path.join(projectRoot, ".opencode", "vectorizer.yaml")];
+
+    let content = null;
+    for (const configPath of candidates) {
+      try {
+        content = await fs.readFile(configPath, "utf8");
+        break;
+      } catch {
+        // try next
+      }
+    }
+
+    if (!content) {
+      await ensureDefaultConfig(projectRoot);
+      return;
+    }
+
+    // Parse vectorizer section from YAML
+    const vectorizerMatch = content.match(/^vectorizer:([\s\S]*?)(?=^[a-zA-Z_\-]+:|\Z)/m);
+    if (!vectorizerMatch) {
+      await ensureDefaultConfig(projectRoot);
+      return;
+    }
+
+    const section = vectorizerMatch[1];
+
+    // Parse embedding model
+    const modelMatch = section.match(/^\s{2}model:\s*["']?([^"'\n]+)["']?/m);
+    if (modelMatch) {
+      EMBEDDING_MODEL = modelMatch[1].trim();
+      if (DEBUG) console.log("[vectorizer] Using model from config:", EMBEDDING_MODEL);
+    }
+
+    // Parse global exclude
+    const excludeMatch = section.match(/^\s{2}exclude:\s*\n((?:\s{4}-\s+.+\n?)*)/m);
+    if (excludeMatch) {
+      GLOBAL_IGNORE = excludeMatch[1]
+        .split("\n")
+        .map((line) => line.replace(/^\s*-\s*/, "").trim())
+        .filter(Boolean)
+        .map((p) => (p.includes("*") ? p : `**/${p}/**`));
+    }
+
+    // Parse indexes section
+    const indexesMatch = section.match(/^\s{2}indexes:\s*\n([\s\S]*?)(?=^\s{2}[a-zA-Z_\-]+:|\s{2}exclude:|\Z)/m);
+    if (!indexesMatch) return;
+
+    const indexesSection = indexesMatch[1];
+
+    // Parse each index (code, docs, config)
+    for (const indexName of ["code", "docs", "config"]) {
+      const indexRegex = new RegExp(
+        `^\\s{4}${indexName}:\\s*\\n([\\s\\S]*?)(?=^\\s{4}[a-zA-Z_\\-]+:|\\Z)`,
+        "m",
+      );
+      const indexMatch = indexesSection.match(indexRegex);
+      if (!indexMatch) continue;
+
+      const indexSection = indexMatch[1];
+
+      // Parse enabled
+      const enabledMatch = indexSection.match(/^\s+enabled:\s*(true|false)/m);
+      const enabled = enabledMatch ? enabledMatch[1] === "true" : true;
+
+      // Parse pattern
+      const patternMatch = indexSection.match(/^\s+pattern:\s*["']?([^"'\n]+)["']?/m);
+      const pattern = patternMatch ? patternMatch[1].trim() : DEFAULT_PRESETS[indexName]?.pattern;
+
+      // Parse ignore array
+      const ignoreMatch = indexSection.match(/^\s+ignore:\s*\n((?:\s+-\s+.+\n?)*)/m);
+      let ignore = [];
+      if (ignoreMatch) {
+        ignore = ignoreMatch[1]
+          .split("\n")
+          .map((line) => line.replace(/^\s*-\s*/, "").replace(/["']/g, "").trim())
+          .filter(Boolean);
+      }
+
+      if (enabled && pattern) {
+        INDEX_PRESETS[indexName] = {
+          pattern,
+          ignore,
+          description: `${indexName} files from config`,
+        };
+      }
+    }
+
+    if (DEBUG) console.log("[vectorizer] Loaded config:", { INDEX_PRESETS, GLOBAL_IGNORE });
+  } catch {
+    if (DEBUG) console.log("[vectorizer] Using default presets (config load failed)");
+  }
+}
+
+class CodebaseIndexer {
+  constructor(projectRoot, indexName = "code") {
+    this.root = projectRoot;
+    this.indexName = indexName;
+    this.baseDir = path.join(projectRoot, ".opencode", "vectors");
+    this.cacheDir = path.join(this.baseDir, indexName);
+    this.model = null;
+    this.db = null;
+    this.hashes = {};
+    this.configLoaded = false;
+  }
+
+  async init() {
+    if (!this.configLoaded) {
+      await loadConfig(this.root);
+      this.configLoaded = true;
+    }
+    await fs.mkdir(this.cacheDir, { recursive: true });
+    this.db = await lancedb.connect(path.join(this.cacheDir, "lancedb"));
+    await this.loadHashes();
+    return this;
+  }
+
+  async loadModel() {
+    if (!this.model) {
+      if (DEBUG) console.log(`[vectorizer] Loading embedding model: ${EMBEDDING_MODEL}...`);
+      this.model = await pipeline("feature-extraction", EMBEDDING_MODEL, {
+        progress_callback: DEBUG ? undefined : null,
+      });
+      if (DEBUG) console.log(`[vectorizer] Model loaded: ${EMBEDDING_MODEL}`);
+    }
+    return this.model;
+  }
+
+  async unloadModel() {
+    this.model = null;
+    if (global.gc) global.gc();
+  }
+
+  async loadHashes() {
+    try {
+      const hashFile = path.join(this.cacheDir, "hashes.json");
+      const data = await fs.readFile(hashFile, "utf8");
+      this.hashes = JSON.parse(data);
+    } catch {
+      this.hashes = {};
+    }
+  }
+
+  async saveHashes() {
+    const hashFile = path.join(this.cacheDir, "hashes.json");
+    await fs.writeFile(hashFile, JSON.stringify(this.hashes, null, 2));
+  }
+
+  fileHash(content) {
+    return crypto.createHash("md5").update(content).digest("hex");
+  }
+
+  isArchived(relPath, content) {
+    if (relPath.includes("/archive/") || relPath.startsWith("archive/")) {
+      return true;
+    }
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+      const frontmatter = frontmatterMatch[1];
+      if (/^archived:\s*true/m.test(frontmatter)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  async embed(text) {
+    const model = await this.loadModel();
+    const result = await model(text, { pooling: "mean", normalize: true });
+    return Array.from(result.data);
+  }
+
+  chunkCode(content, maxChars = 1500) {
+    const chunks = [];
+    const lines = content.split("\n");
+    let current = [];
+    let currentLen = 0;
+
+    for (const line of lines) {
+      if (currentLen + line.length > maxChars && current.length > 0) {
+        chunks.push(current.join("\n"));
+        current = [];
+        currentLen = 0;
+      }
+      current.push(line);
+      currentLen += line.length + 1;
+    }
+
+    if (current.length > 0) {
+      chunks.push(current.join("\n"));
+    }
+
+    return chunks;
+  }
+
+  needsIndex(filePath, content) {
+    const relPath = path.relative(this.root, filePath);
+    const currentHash = this.fileHash(content);
+    return this.hashes[relPath] !== currentHash;
+  }
+
+  async indexFile(filePath) {
+    const relPath = path.relative(this.root, filePath);
+
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf8");
+    } catch {
+      return false;
+    }
+
+    const hash = this.fileHash(content);
+    if (this.hashes[relPath] === hash) {
+      return false;
+    }
+
+    const chunks = this.chunkCode(content);
+    const archived = this.isArchived(relPath, content);
+    const data = [];
+
+    for (let i = 0; i < chunks.length; i++) {
+      const embedding = await this.embed(chunks[i]);
+      data.push({
+        file: relPath,
+        chunk_index: i,
+        content: chunks[i],
+        vector: embedding,
+        archived: archived,
+      });
+    }
+
+    const tableName = "chunks";
+    const tables = await this.db.tableNames();
+    if (tables.includes(tableName)) {
+      const table = await this.db.openTable(tableName);
+      await table.add(data);
+    } else {
+      await this.db.createTable(tableName, data);
+    }
+
+    this.hashes[relPath] = hash;
+    await this.saveHashes();
+
+    return true;
+  }
+
+  async search(query, limit = 5, includeArchived = false) {
+    const tableName = "chunks";
+    const tables = await this.db.tableNames();
+    if (!tables.includes(tableName)) {
+      return [];
+    }
+
+    const queryEmbedding = await this.embed(query);
+    const table = await this.db.openTable(tableName);
+
+    const fetchLimit = includeArchived ? limit : limit * 3;
+    let results = await table.search(queryEmbedding).limit(fetchLimit).execute();
+
+    if (!includeArchived) {
+      results = results.filter((r) => !r.archived);
+    }
+
+    return results.slice(0, limit);
+  }
+
+  async checkHealth(extraIgnore = []) {
+    const { glob } = await import("glob");
+    const preset = INDEX_PRESETS[this.indexName] || DEFAULT_PRESETS.code;
+
+    const ignore = [
+      ...(preset.ignore || []),
+      ...GLOBAL_IGNORE,
+      ...extraIgnore.map((p) => (p.includes("*") ? p : `**/${p}/**`)),
+    ];
+
+    const expectedFiles = await glob(preset.pattern, {
+      cwd: this.root,
+      nodir: true,
+      ignore,
+    });
+
+    const indexedFiles = Object.keys(this.hashes);
+    const currentCount = indexedFiles.length;
+    const expectedCount = expectedFiles.length;
+
+    const diff = Math.abs(currentCount - expectedCount);
+    const threshold = Math.max(5, expectedCount * 0.2);
+
+    if (currentCount === 0 && expectedCount > 0) {
+      return { needsReindex: true, reason: "empty", currentCount, expectedCount };
+    }
+
+    if (diff > threshold) {
+      return { needsReindex: true, reason: "mismatch", currentCount, expectedCount };
+    }
+
+    return { needsReindex: false, reason: "ok", currentCount, expectedCount };
+  }
+
+  async freshen() {
+    let checked = 0;
+    let updated = 0;
+    let deleted = 0;
+
+    const indexedFiles = Object.keys(this.hashes);
+    for (const relPath of indexedFiles) {
+      checked++;
+      const filePath = path.join(this.root, relPath);
+
+      try {
+        const content = await fs.readFile(filePath, "utf8");
+        const currentHash = this.fileHash(content);
+
+        if (this.hashes[relPath] !== currentHash) {
+          await this.indexFile(filePath);
+          updated++;
+        }
+      } catch {
+        delete this.hashes[relPath];
+        deleted++;
+      }
+    }
+
+    if (deleted > 0) {
+      await this.saveHashes();
+    }
+
+    return { checked, updated, deleted };
+  }
+
+  async indexAll(onProgress = null, extraIgnore = []) {
+    const { glob } = await import("glob");
+    const preset = INDEX_PRESETS[this.indexName] || DEFAULT_PRESETS.code;
+
+    const ignore = [
+      ...(preset.ignore || []),
+      ...GLOBAL_IGNORE,
+      ...extraIgnore.map((p) => (p.includes("*") ? p : `**/${p}/**`)),
+    ];
+
+    const files = await glob(preset.pattern, {
+      cwd: this.root,
+      nodir: true,
+      ignore,
+    });
+
+    let indexed = 0;
+    let skipped = 0;
+
+    for (const relPath of files) {
+      const filePath = path.join(this.root, relPath);
+      try {
+        const wasIndexed = await this.indexFile(filePath);
+        if (wasIndexed) {
+          indexed++;
+          if (onProgress) onProgress(indexed, files.length, relPath);
+        } else {
+          skipped++;
+        }
+      } catch {
+        skipped++;
+      }
+    }
+
+    return { indexed, skipped, total: files.length };
+  }
+
+  async indexSingleFile(filePath) {
+    const absPath = path.isAbsolute(filePath) ? filePath : path.join(this.root, filePath);
+    return await this.indexFile(absPath);
+  }
+
+  async getStats() {
+    const fileCount = Object.keys(this.hashes).length;
+    let chunkCount = 0;
+
+    try {
+      const tables = await this.db.tableNames();
+      if (tables.includes("chunks")) {
+        const table = await this.db.openTable("chunks");
+        chunkCount = await table.countRows();
+      }
+    } catch {}
+
+    const preset = INDEX_PRESETS[this.indexName];
+    return {
+      indexName: this.indexName,
+      description: preset?.description || "Custom index",
+      model: EMBEDDING_MODEL,
+      fileCount,
+      chunkCount,
+    };
+  }
+
+  async getAllStats() {
+    const stats = [];
+    try {
+      const entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== "lancedb") {
+          try {
+            const indexer = await new CodebaseIndexer(this.root, entry.name).init();
+            const stat = await indexer.getStats();
+            if (stat.fileCount > 0 || stat.chunkCount > 0) {
+              stats.push(stat);
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+    return stats;
+  }
+
+  async clear() {
+    await fs.rm(this.cacheDir, { recursive: true, force: true });
+    this.hashes = {};
+    await this.init();
+  }
+
+  async clearAll() {
+    await fs.rm(this.baseDir, { recursive: true, force: true });
+    this.hashes = {};
+    await this.init();
+  }
+
+  async listIndexes() {
+    const indexes = [];
+    try {
+      const entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== "lancedb") {
+          indexes.push(entry.name);
+        }
+      }
+    } catch {}
+    return indexes;
+  }
+}
+
+function getEmbeddingModel() {
+  return EMBEDDING_MODEL;
+}
+
+export { CodebaseIndexer, INDEX_PRESETS, getEmbeddingModel };