opencode-memsearch 0.3.0 → 0.5.0

package/README.md

@@ -97,21 +97,27 @@ your-project/
 
 You should add `.memsearch/` to your `.gitignore`.
 
-## Seed script
+## CLI
 
-The package includes a seed script that can backfill memory from existing OpenCode sessions. This is useful when first installing the plugin on a project you've already been working on.
+The package includes a CLI for utility tasks. It requires [Bun](https://bun.sh/) to run.
 
-The seed script requires [Bun](https://bun.sh/) to run.
+```bash
+bunx opencode-memsearch --help
+```
+
+### Seed
+
+Backfill memory from existing OpenCode sessions. This is useful when first installing the plugin on a project you've already been working on.
 
 ```bash
 # Seed from the last 14 days of sessions (default)
-npx opencode-memsearch-seed
+bunx opencode-memsearch seed
 
 # Seed from the last 30 days
-npx opencode-memsearch-seed --days 30
+bunx opencode-memsearch seed --days 30
 ```
 
-Run the script from your project directory. It reads directly from the OpenCode SQLite database, summarizes each conversation turn, and writes the results to `.memsearch/memory/`. The seed script respects the same [configuration](#configuration) as the plugin (config file and environment variables).
+The command reads directly from the OpenCode SQLite database, processes all sessions across all projects, summarizes each conversation turn, and writes the results to each project's `.memsearch/memory/` directory. It can be run from anywhere. The seed command respects the same [configuration](#configuration) as the plugin (config file and environment variables).
 
 ## Configuration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memsearch",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Persistent cross-session memory for OpenCode, powered by memsearch",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
     }
   },
   "bin": {
-    "opencode-memsearch-seed": "scripts/seed-memories.ts"
+    "opencode-memsearch": "scripts/cli.ts"
   },
   "files": [
     "dist",

package/scripts/cli.ts

@@ -0,0 +1,117 @@
+#!/usr/bin/env bun
+/**
+ * opencode-memsearch CLI — utilities for the opencode-memsearch plugin.
+ *
+ * Usage:
+ *   bunx opencode-memsearch <command> [options]
+ *
+ * Requires Bun (https://bun.sh/) to run.
+ */
+
+import { seed } from "./seed-memories"
+import { reindex } from "./reindex"
+
+const HELP = `opencode-memsearch — CLI utilities for the opencode-memsearch plugin
+
+Usage:
+  opencode-memsearch <command> [options]
+
+Commands:
+  seed      Backfill memory from existing OpenCode sessions
+  reindex   Reset and rebuild vector index from existing memory files
+
+Options:
+  --help, -h    Show this help message
+
+Run 'opencode-memsearch <command> --help' for command-specific help.`
+
+const SEED_HELP = `Seed memsearch memory files from recent OpenCode sessions.
+
+Reads all sessions from the OpenCode SQLite database, summarizes each
+conversation turn via an LLM, and writes the results to each project's
+.memsearch/memory/ directory. Processes all projects; can be run from anywhere.
+
+Usage:
+  opencode-memsearch seed [--days <n>]
+
+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++) {
+    if (args[i] === "--days" && args[i + 1]) {
+      days = parseInt(args[i + 1], 10)
+      if (isNaN(days) || days < 1) {
+        console.error("Invalid --days value, using default 14")
+        days = 14
+      }
+    }
+  }
+  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]
+
+  if (!command || command === "--help" || command === "-h") {
+    console.log(HELP)
+    process.exit(0)
+  }
+
+  switch (command) {
+    case "seed": {
+      const subArgs = args.slice(1)
+      if (subArgs.includes("--help") || subArgs.includes("-h")) {
+        console.log(SEED_HELP)
+        process.exit(0)
+      }
+      const { days } = parseSeedArgs(subArgs)
+      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()
+      console.log(HELP)
+      process.exit(1)
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal error:", err)
+  process.exit(1)
+})

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

@@ -1,13 +1,9 @@
-#!/usr/bin/env bun
 /**
  * seed-memories.ts — Seed memsearch memory files from recent OpenCode sessions.
  *
- * Usage:
- *   npx opencode-memsearch-seed [--days 14]
+ * This module exports a `seed` function used by the CLI (cli.ts).
  *
- * Requires Bun (https://bun.sh/) to run.
- *
- * This script:
+ * What it does:
  * 1. Reads session + message data directly from the OpenCode SQLite database
  * 2. For each session, formats each conversation turn as a transcript
  * 3. Summarizes each turn via `opencode run` (model is configurable, see README)
@@ -16,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 {
@@ -77,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()
@@ -107,32 +97,8 @@ function formatTime(epochMs: number): string {
   return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`
 }
 
-function parseArgs(): { days: number } {
-  const args = process.argv.slice(2)
-  let days = 14
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--days" && args[i + 1]) {
-      days = parseInt(args[i + 1], 10)
-      if (isNaN(days) || days < 1) {
-        console.error("Invalid --days value, using default 14")
-        days = 14
-      }
-    }
-  }
-  return { days }
-}
-
 // --- 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
@@ -149,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,
@@ -309,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
@@ -354,8 +299,8 @@ async function summarizeWithOpencode(transcript: string, tempFile: string, model
 
 // --- Main ---
 
-async function main() {
-  const { days } = parseArgs()
+export async function seed(opts: { days: number }) {
+  const { days } = opts
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1000
 
   console.log(`Seeding memories from the last ${days} days...`)
@@ -514,7 +459,4 @@ async function main() {
   }
 }
 
-main().catch((err) => {
-  console.error("Fatal error:", err)
-  process.exit(1)
-})
+