opencode-memsearch 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memsearch",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Persistent cross-session memory for OpenCode, powered by memsearch",
   "type": "module",
   "main": "dist/index.js",

package/scripts/cli.ts

@@ -9,6 +9,7 @@
  */
 
 import { seed } from "./seed-memories"
+import { reindex } from "./reindex"
 
 const HELP = `opencode-memsearch — CLI utilities for the opencode-memsearch plugin
 
@@ -16,7 +17,8 @@ Usage:
   opencode-memsearch <command> [options]
 
 Commands:
-  seed    Backfill memory from existing OpenCode sessions
+  seed      Backfill memory from existing OpenCode sessions
+  reindex   Reset and rebuild vector index from existing memory files
 
 Options:
   --help, -h    Show this help message
@@ -36,6 +38,23 @@ Options:
   --days <n>    Number of days of history to process (default: 14)
   --help, -h    Show this help message`
 
+const REINDEX_HELP = `Reset and rebuild the vector index from existing memory files.
+
+Discovers all project directories from the OpenCode session database,
+resets each memsearch collection, and re-indexes the .memsearch/memory/
+markdown files using the currently configured embedding provider.
+
+This is useful after switching embedding providers (e.g. memsearch[local]
+to memsearch[onnx]) — it rebuilds the vector index without re-running the
+expensive LLM summarization from 'seed'.
+
+Usage:
+  opencode-memsearch reindex [--dry-run]
+
+Options:
+  --dry-run     Preview what would be reset/reindexed without making changes
+  --help, -h    Show this help message`
+
 function parseSeedArgs(args: string[]): { days: number } {
   let days = 14
   for (let i = 0; i < args.length; i++) {
@@ -50,6 +69,10 @@ function parseSeedArgs(args: string[]): { days: number } {
   return { days }
 }
 
+function parseReindexArgs(args: string[]): { dryRun: boolean } {
+  return { dryRun: args.includes("--dry-run") }
+}
+
 async function main() {
   const args = process.argv.slice(2)
   const command = args[0]
@@ -70,6 +93,16 @@ async function main() {
       await seed({ days })
       break
     }
+    case "reindex": {
+      const subArgs = args.slice(1)
+      if (subArgs.includes("--help") || subArgs.includes("-h")) {
+        console.log(REINDEX_HELP)
+        process.exit(0)
+      }
+      const { dryRun } = parseReindexArgs(subArgs)
+      await reindex({ dryRun })
+      break
+    }
     default:
       console.error(`Unknown command: ${command}`)
       console.error()

package/scripts/lib.ts

@@ -0,0 +1,75 @@
+/**
+ * lib.ts — Shared utilities for opencode-memsearch CLI scripts.
+ *
+ * Contains helpers used by both the seed and reindex commands:
+ * database access, collection name derivation, memsearch detection, etc.
+ */
+
+import { Database } from "bun:sqlite"
+import { createHash } from "crypto"
+import { basename, join, resolve } from "path"
+import { homedir } from "os"
+import { $ } from "bun"
+
+// --- Constants ---
+
+export const DB_PATH = join(homedir(), ".local", "share", "opencode", "opencode.db")
+
+// --- Database types ---
+
+export interface DbSession {
+  id: string
+  directory: string
+  title: string
+  parent_id: string | null
+  time_created: number
+  time_updated: number
+}
+
+// --- Helpers ---
+
+export function deriveCollectionName(directory: string): string {
+  const abs = resolve(directory)
+  const sanitized = basename(abs)
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_|_$/g, "")
+    .slice(0, 40)
+  const hash = createHash("sha256").update(abs).digest("hex").slice(0, 8)
+  return `ms_${sanitized}_${hash}`
+}
+
+// --- Database access ---
+
+export function listSessionsFromDb(db: Database, cutoffMs: number): DbSession[] {
+  return db.query<DbSession, [number]>(`
+    SELECT id, directory, title, parent_id, time_created, time_updated
+    FROM session
+    WHERE time_created >= ?
+      AND parent_id IS NULL
+    ORDER BY time_created ASC
+  `).all(cutoffMs)
+}
+
+export function listDistinctDirectories(db: Database): string[] {
+  const rows = db.query<{ directory: string }, []>(`
+    SELECT DISTINCT directory
+    FROM session
+    WHERE parent_id IS NULL
+    ORDER BY directory ASC
+  `).all()
+  return rows.map((r) => r.directory)
+}
+
+// --- Memsearch detection ---
+
+export async function detectMemsearch(): Promise<string[]> {
+  try {
+    await $`which memsearch`.quiet()
+    return ["memsearch"]
+  } catch {}
+  throw new Error(
+    "memsearch is not installed. Install it by running: uv tool install 'memsearch[onnx]' — or with pip: pip install 'memsearch[onnx]'. See https://github.com/jdormit/opencode-memsearch for details."
+  )
+}

package/scripts/reindex.ts

@@ -0,0 +1,135 @@
+/**
+ * reindex.ts — Re-index all memsearch memory files from scratch.
+ *
+ * This module exports a `reindex` function used by the CLI (cli.ts).
+ *
+ * Useful when switching embedding providers (e.g. memsearch[local] -> memsearch[onnx])
+ * without needing to re-run the expensive LLM-based seed process. The memory markdown
+ * files are the source of truth; this command just rebuilds the vector index from them.
+ *
+ * What it does:
+ * 1. Discovers all project directories from the OpenCode SQLite database
+ * 2. For each project with existing .memsearch/memory/ files:
+ *    a. Resets the memsearch collection (drops the old vector data)
+ *    b. Re-indexes the memory markdown files with the current embedding provider
+ */
+
+import { Database } from "bun:sqlite"
+import { readdir } from "fs/promises"
+import { join } from "path"
+import { $ } from "bun"
+
+import {
+  DB_PATH,
+  deriveCollectionName,
+  detectMemsearch,
+  listDistinctDirectories,
+} from "./lib"
+
+// --- Helpers ---
+
+async function hasMemoryFiles(memoryDir: string): Promise<boolean> {
+  try {
+    const files = await readdir(memoryDir)
+    return files.some((f) => f.endsWith(".md"))
+  } catch {
+    return false
+  }
+}
+
+// --- Main ---
+
+export async function reindex(opts: { dryRun: boolean }) {
+  const { dryRun } = opts
+
+  if (dryRun) {
+    console.log("DRY RUN — no changes will be made.\n")
+  }
+
+  // Setup
+  const memsearchCmd = await detectMemsearch()
+  console.log(`Using memsearch: ${memsearchCmd.join(" ")}`)
+
+  // Open database (read-only)
+  const db = new Database(DB_PATH, { readonly: true })
+
+  try {
+    // Discover all project directories
+    const allDirs = listDistinctDirectories(db)
+    console.log(`Found ${allDirs.length} project directories in the OpenCode database.`)
+    console.log()
+
+    // Filter to directories that have memory files
+    const targets: { directory: string; memoryDir: string; collectionName: string }[] = []
+
+    for (const dir of allDirs) {
+      const memoryDir = join(dir, ".memsearch", "memory")
+      if (await hasMemoryFiles(memoryDir)) {
+        targets.push({
+          directory: dir,
+          memoryDir,
+          collectionName: deriveCollectionName(dir),
+        })
+      }
+    }
+
+    if (targets.length === 0) {
+      console.log("No projects with memory files found. Nothing to reindex.")
+      return
+    }
+
+    console.log(`Projects with memory files (${targets.length}):`)
+    for (const t of targets) {
+      console.log(`  ${t.directory}`)
+      console.log(`    collection: ${t.collectionName}`)
+      console.log(`    memory dir: ${t.memoryDir}`)
+    }
+    console.log()
+
+    if (dryRun) {
+      console.log("DRY RUN — would reset and reindex the above collections.")
+      return
+    }
+
+    // Reset and reindex each collection
+    let succeeded = 0
+    let failed = 0
+
+    for (let i = 0; i < targets.length; i++) {
+      const t = targets[i]
+      const label = `[${i + 1}/${targets.length}]`
+
+      console.log(`${label} ${t.directory}`)
+
+      // Reset the collection
+      console.log(`${label}   Resetting collection ${t.collectionName}...`)
+      try {
+        const resetArgs = [...memsearchCmd, "reset", "--collection", t.collectionName, "--yes"]
+        await $`${resetArgs}`.nothrow().quiet()
+      } catch (err) {
+        console.error(`${label}   Failed to reset: ${err}`)
+        failed++
+        continue
+      }
+
+      // Re-index the memory files
+      console.log(`${label}   Indexing ${t.memoryDir}...`)
+      try {
+        const indexArgs = [...memsearchCmd, "index", t.memoryDir, "--collection", t.collectionName, "--force"]
+        const output = await $`${indexArgs}`.nothrow().quiet().text()
+        if (output.trim()) {
+          console.log(`${label}   ${output.trim()}`)
+        }
+        succeeded++
+      } catch (err) {
+        console.error(`${label}   Failed to index: ${err}`)
+        failed++
+      }
+    }
+
+    console.log()
+    console.log(`Reindex complete: ${succeeded} succeeded, ${failed} failed.`)
+  } finally {
+    db.close()
+  }
+}

package/scripts/seed-memories.ts

@@ -12,12 +12,19 @@
  */
 
 import { Database } from "bun:sqlite"
-import { createHash } from "crypto"
 import { appendFile, mkdir, readFile, writeFile, unlink } from "fs/promises"
-import { join, basename, resolve } from "path"
+import { join } from "path"
 import { homedir, tmpdir } from "os"
 import { $ } from "bun"
 
+import {
+  DB_PATH,
+  DbSession,
+  deriveCollectionName,
+  detectMemsearch,
+  listSessionsFromDb,
+} from "./lib"
+
 // --- Configuration ---
 
 interface PluginConfig {
@@ -73,23 +80,10 @@ Rules:
 - Do NOT ask follow-up questions
 - STOP immediately after the last bullet point`
 
-const DB_PATH = join(homedir(), ".local", "share", "opencode", "opencode.db")
 const TEMP_DIR = join(tmpdir(), "memsearch-seed")
 
 // --- Helpers ---
 
-function deriveCollectionName(directory: string): string {
-  const abs = resolve(directory)
-  const sanitized = basename(abs)
-    .toLowerCase()
-    .replace(/[^a-z0-9]/g, "_")
-    .replace(/_+/g, "_")
-    .replace(/^_|_$/g, "")
-    .slice(0, 40)
-  const hash = createHash("sha256").update(abs).digest("hex").slice(0, 8)
-  return `ms_${sanitized}_${hash}`
-}
-
 function formatDate(epochMs: number): string {
   const d = new Date(epochMs)
   const yyyy = d.getFullYear()
@@ -105,15 +99,6 @@ function formatTime(epochMs: number): string {
 
 // --- Database types ---
 
-interface DbSession {
-  id: string
-  directory: string
-  title: string
-  parent_id: string | null
-  time_created: number
-  time_updated: number
-}
-
 interface DbMessage {
   id: string
   session_id: string
@@ -130,16 +115,6 @@ interface DbPart {
 
 // --- Database access ---
 
-function listSessionsFromDb(db: Database, cutoffMs: number): DbSession[] {
-  return db.query<DbSession, [number]>(`
-    SELECT id, directory, title, parent_id, time_created, time_updated
-    FROM session
-    WHERE time_created >= ?
-      AND parent_id IS NULL
-    ORDER BY time_created ASC
-  `).all(cutoffMs)
-}
-
 function getSessionMessages(
   db: Database,
   sessionId: string,
@@ -290,17 +265,6 @@ function getUserText(turn: { info: any; parts: any[] }[]): string {
   return ""
 }
 
-// Detect memsearch command
-async function detectMemsearch(): Promise<string[]> {
-  try {
-    await $`which memsearch`.quiet()
-    return ["memsearch"]
-  } catch {}
-  throw new Error(
-    "memsearch is not installed. Install it by running: uv tool install 'memsearch[onnx]' — or with pip: pip install 'memsearch[onnx]'. See https://github.com/jdormit/opencode-memsearch for details."
-  )
-}
-
 // Summarize a transcript via `opencode run`
 async function summarizeWithOpencode(transcript: string, tempFile: string, model: string): Promise<string> {
   // Write transcript to temp file