fix: auto-recreate database tables when shard DB file is missing

When shard DB files are deleted (e.g. to reset after changing embedding
model), metadata.db still contains stale shard records pointing to the
deleted files. The plugin then tries to use these non-existent databases,
resulting in "no such table: memories" errors.

Add a validation step in getWriteShard() that checks if the shard DB file
actually exists and contains the required tables. If not, it cleans up the
stale metadata record and creates a fresh shard.

Also add an ensureShardTables() method that verifies table integrity and
re-initializes if needed, providing resilience against corrupted or
partially created databases.

Fixes #28

Author: kui123456789

src/services/sqlite/shard-manager.ts

@@ -1,5 +1,6 @@
 import { Database } from "bun:sqlite";
 import { join, basename, isAbsolute } from "node:path";
+import { existsSync } from "node:fs";
 import { CONFIG } from "../../config.js";
 import { connectionManager } from "./connection-manager.js";
 import { log } from "../logger.js";
@@ -188,13 +189,88 @@ export class ShardManager {
     db.run(`CREATE INDEX IF NOT EXISTS idx_is_pinned ON memories(is_pinned)`);
   }
 
+  /**
+   * Check if the shard DB file exists and contains the required 'memories' table.
+   * Returns false if the file is missing or the table doesn't exist.
+   */
+  private isShardValid(shard: ShardInfo): boolean {
+    // Check if the DB file exists on disk
+    if (!existsSync(shard.dbPath)) {
+      log("Shard DB file missing", { dbPath: shard.dbPath, shardId: shard.id });
+      return false;
+    }
+
+    // Check if the 'memories' table exists
+    try {
+      const db = connectionManager.getConnection(shard.dbPath);
+      const result = db.prepare(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memories'`
+      ).get() as any;
+      if (!result) {
+        log("Shard DB missing 'memories' table", { dbPath: shard.dbPath, shardId: shard.id });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      log("Error validating shard DB", { dbPath: shard.dbPath, error: String(error) });
+      return false;
+    }
+  }
+
+  /**
+   * Ensure the shard DB has all required tables. If tables are missing,
+   * re-initialize them. This handles cases where the DB file exists but
+   * was corrupted or partially created.
+   */
+  ensureShardTables(shard: ShardInfo): void {
+    try {
+      const db = connectionManager.getConnection(shard.dbPath);
+      this.initShardDb(db);
+    } catch (error) {
+      log("Error ensuring shard tables", { dbPath: shard.dbPath, error: String(error) });
+    }
+  }
+
+  /**
+   * Remove a stale shard record from metadata.db.
+   * Used when the actual shard DB file has been deleted externally.
+   */
+  private removeStaleShardRecord(shardId: number): void {
+    log("Removing stale shard record from metadata", { shardId });
+    connectionManager.closeConnection(
+      this.metadataDb.prepare(`SELECT db_path FROM shards WHERE id = ?`).get(shardId) as any
+    );
+    const stmt = this.metadataDb.prepare(`DELETE FROM shards WHERE id = ?`);
+    stmt.run(shardId);
+  }
+
   getWriteShard(scope: "user" | "project", scopeHash: string): ShardInfo {
     let shard = this.getActiveShard(scope, scopeHash);
 
     if (!shard) {
       return this.createShard(scope, scopeHash, 0);
     }
 
+    // Validate that the shard DB file exists and has required tables
+    if (!this.isShardValid(shard)) {
+      log("Active shard is invalid, recreating", {
+        scope,
+        scopeHash,
+        shardIndex: shard.shardIndex,
+        dbPath: shard.dbPath,
+      });
+
+      // Close any cached connection to the invalid shard
+      connectionManager.closeConnection(shard.dbPath);
+
+      // Remove the stale metadata record
+      const deleteStmt = this.metadataDb.prepare(`DELETE FROM shards WHERE id = ?`);
+      deleteStmt.run(shard.id);
+
+      // Create a fresh shard with the same index
+      return this.createShard(scope, scopeHash, shard.shardIndex);
+    }
+
     if (shard.vectorCount >= CONFIG.maxVectorsPerShard) {
       this.markShardReadOnly(shard.id);
       return this.createShard(scope, scopeHash, shard.shardIndex + 1);