@creeperhost/modlens-mcp 1.6.0

package/scripts/enable-sqlite-vec.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// scripts/enable-sqlite-vec.mjs
+// Creates FTS5 virtual tables, sync triggers, and sqlite-vec vec0 tables.
+// Run after: npm run db:push:sqlite
+
+import Database from "better-sqlite3";
+import { createRequire } from "module";
+
+const url = process.env.DATABASE_URL ?? "";
+const dbPath = url.replace(/^file:\/\//, "").replace(/^file:/, "");
+if (!dbPath) {
+  console.error("DATABASE_URL must be set to a file: path");
+  process.exit(1);
+}
+
+const db = new Database(dbPath);
+
+// Load sqlite-vec extension
+const require = createRequire(import.meta.url);
+try {
+  const sqliteVec = require("sqlite-vec");
+  sqliteVec.load(db);
+  console.log("sqlite-vec loaded");
+} catch (e) {
+  console.warn("sqlite-vec not available — vector search disabled:", e.message);
+}
+
+db.exec(`
+-- FTS5 virtual table for Minecraft source files
+CREATE VIRTUAL TABLE IF NOT EXISTS fts_mc_source (
+  content,
+  class_name,
+  mc_version_id UNINDEXED
+) USING fts5(content, class_name, mc_version_id UNINDEXED);
+
+-- Sync triggers for mc_source_files
+CREATE TRIGGER IF NOT EXISTS mc_source_fts_insert
+AFTER INSERT ON mc_source_files BEGIN
+  INSERT INTO fts_mc_source(rowid, content, class_name, mc_version_id)
+  VALUES (new.id, new.content, new.class_name, new.mc_version_id);
+END;
+
+CREATE TRIGGER IF NOT EXISTS mc_source_fts_delete
+AFTER DELETE ON mc_source_files BEGIN
+  DELETE FROM fts_mc_source WHERE rowid = old.id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS mc_source_fts_update
+AFTER UPDATE ON mc_source_files BEGIN
+  DELETE FROM fts_mc_source WHERE rowid = old.id;
+  INSERT INTO fts_mc_source(rowid, content, class_name, mc_version_id)
+  VALUES (new.id, new.content, new.class_name, new.mc_version_id);
+END;
+
+-- FTS5 virtual table for doc entries
+CREATE VIRTUAL TABLE IF NOT EXISTS fts_doc_entries (
+  title,
+  summary,
+  url UNINDEXED,
+  category UNINDEXED
+) USING fts5(title, summary, url UNINDEXED, category UNINDEXED);
+
+-- Sync triggers for doc_entries
+CREATE TRIGGER IF NOT EXISTS doc_entries_fts_insert
+AFTER INSERT ON doc_entries BEGIN
+  INSERT INTO fts_doc_entries(rowid, title, summary, url, category)
+  VALUES (new.id, new.title, new.summary, new.url, new.category);
+END;
+
+CREATE TRIGGER IF NOT EXISTS doc_entries_fts_delete
+AFTER DELETE ON doc_entries BEGIN
+  DELETE FROM fts_doc_entries WHERE rowid = old.id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS doc_entries_fts_update
+AFTER UPDATE ON doc_entries BEGIN
+  DELETE FROM fts_doc_entries WHERE rowid = old.id;
+  INSERT INTO fts_doc_entries(rowid, title, summary, url, category)
+  VALUES (new.id, new.title, new.summary, new.url, new.category);
+END;
+
+-- FTS5 virtual table for primers
+CREATE VIRTUAL TABLE IF NOT EXISTS fts_primers (
+  title,
+  summary,
+  content
+) USING fts5(title, summary, content);
+
+-- Sync triggers for primers
+CREATE TRIGGER IF NOT EXISTS primers_fts_insert
+AFTER INSERT ON primers BEGIN
+  INSERT INTO fts_primers(rowid, title, summary, content)
+  VALUES (new.id, new.title, new.summary, new.content);
+END;
+
+CREATE TRIGGER IF NOT EXISTS primers_fts_delete
+AFTER DELETE ON primers BEGIN
+  DELETE FROM fts_primers WHERE rowid = old.id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS primers_fts_update
+AFTER UPDATE ON primers BEGIN
+  DELETE FROM fts_primers WHERE rowid = old.id;
+  INSERT INTO fts_primers(rowid, title, summary, content)
+  VALUES (new.id, new.title, new.summary, new.content);
+END;
+
+-- FTS5 virtual table for mod source files (fabric / neoforge / forge / quilt)
+CREATE VIRTUAL TABLE IF NOT EXISTS fts_mod_source (
+  content,
+  class_name,
+  mod_id UNINDEXED
+) USING fts5(content, class_name, mod_id UNINDEXED);
+
+-- Sync triggers for mod_source_files
+CREATE TRIGGER IF NOT EXISTS mod_source_fts_insert
+AFTER INSERT ON mod_source_files BEGIN
+  INSERT INTO fts_mod_source(rowid, content, class_name, mod_id)
+  VALUES (new.id, new.content, new.class_name, new.mod_id);
+END;
+
+CREATE TRIGGER IF NOT EXISTS mod_source_fts_delete
+AFTER DELETE ON mod_source_files BEGIN
+  DELETE FROM fts_mod_source WHERE rowid = old.id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS mod_source_fts_update
+AFTER UPDATE ON mod_source_files BEGIN
+  DELETE FROM fts_mod_source WHERE rowid = old.id;
+  INSERT INTO fts_mod_source(rowid, content, class_name, mod_id)
+  VALUES (new.id, new.content, new.class_name, new.mod_id);
+END;
+`);
+
+console.log("FTS5 virtual tables and triggers created");
+
+// sqlite-vec tables (created only if the extension loaded)
+try {
+  db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_mc_source
+      USING vec0(embedding float[768]);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_mod_source
+      USING vec0(embedding float[768]);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_doc_entries
+      USING vec0(embedding float[768]);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_primers
+      USING vec0(embedding float[768]);
+  `);
+  console.log("sqlite-vec vec0 tables created (dim=768)");
+} catch (e) {
+  console.warn("Skipping vec0 tables (sqlite-vec unavailable):", e.message);
+}
+
+db.close();
+console.log("Done.");

package/scripts/migrate-backend.mjs

@@ -0,0 +1,188 @@
+// scripts/migrate-backend.mjs
+/**
+ * Migrate core modlens data between backends.
+ *
+ * Usage:
+ *   SOURCE_DATABASE_URL=postgresql://... DATABASE_URL=pglite:///path node scripts/migrate-backend.mjs
+ *
+ * Migrates: mods, mod_classes, mod_tags, doc_entries, primers.
+ * Skips:    mc_versions, mc_source_files (too large — user re-indexes).
+ * Safe:     uses INSERT OR IGNORE (SQLite) / ON CONFLICT DO NOTHING (Postgres/PGlite).
+ */
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+
+try { require("dotenv").config(); } catch { /* optional */ }
+
+const TABLES = ["mods", "mod_classes", "mod_tags", "doc_entries", "primers"];
+
+function detectBackend(url) {
+    if (url.startsWith("file:") || url.endsWith(".db")) return "sqlite";
+    if (url.startsWith("pglite://") || url.startsWith("pglite:")) return "pglite";
+    return "postgres";
+}
+
+// ── Source readers ────────────────────────────────────────────────────────────
+
+async function readSourceSqlite(url, table) {
+    const Database = require("better-sqlite3");
+    const path = url.replace(/^file:\/\//, "").replace(/^file:/, "");
+    const db = new Database(path, { readonly: true });
+    const rows = db.prepare(`SELECT * FROM "${table}"`).all();
+    db.close();
+    return rows;
+}
+
+async function readSourcePglite(url, table) {
+    const { PGlite } = require("@electric-sql/pglite");
+    const dataDir = url.replace(/^pglite:\/\//, "");
+    const pg = await PGlite.create(dataDir);
+    const result = await pg.query(`SELECT * FROM "${table}"`);
+    await pg.close();
+    return result.rows;
+}
+
+async function readSourcePostgres(url, table) {
+    const pg = (await import("pg")).default;
+    const client = new pg.Client({ connectionString: url });
+    await client.connect();
+    const result = await client.query(`SELECT * FROM "${table}"`);
+    await client.end();
+    return result.rows;
+}
+
+async function readFromSource(backend, url, table) {
+    if (backend === "sqlite")   return readSourceSqlite(url, table);
+    if (backend === "pglite")   return readSourcePglite(url, table);
+    return readSourcePostgres(url, table);
+}
+
+// ── Target writers ────────────────────────────────────────────────────────────
+
+async function writeTargetSqlite(url, table, rows) {
+    const Database = require("better-sqlite3");
+    const path = url.replace(/^file:\/\//, "").replace(/^file:/, "");
+    const db = new Database(path);
+    const cols = Object.keys(rows[0]);
+    const placeholders = cols.map(() => "?").join(", ");
+    const stmt = db.prepare(
+        `INSERT OR IGNORE INTO "${table}" (${cols.map(c => `"${c}"`).join(", ")}) VALUES (${placeholders})`,
+    );
+    let inserted = 0;
+    let skipped = 0;
+    const insertMany = db.transaction((allRows) => {
+        for (const row of allRows) {
+            const vals = cols.map((c) => {
+                const v = row[c];
+                // Postgres arrays → JSON strings for SQLite column type
+                return Array.isArray(v) ? JSON.stringify(v) : v;
+            });
+            const info = stmt.run(...vals);
+            if (info.changes > 0) inserted++; else skipped++;
+        }
+    });
+    insertMany(rows);
+    db.close();
+    return { inserted, skipped };
+}
+
+async function writeTargetPg(url, table, rows, isPglite) {
+    let client;
+    let needsClose = false;
+    if (isPglite) {
+        const { PGlite } = require("@electric-sql/pglite");
+        const dataDir = url.replace(/^pglite:\/\//, "");
+        client = await PGlite.create(dataDir);
+        needsClose = true;
+    } else {
+        const pg = (await import("pg")).default;
+        client = new pg.Client({ connectionString: url });
+        await client.connect();
+        needsClose = true;
+    }
+
+    const cols = Object.keys(rows[0]);
+    const placeholders = cols.map((_, i) => `$${i + 1}`).join(", ");
+    const sql = `INSERT INTO "${table}" (${cols.map(c => `"${c}"`).join(", ")}) VALUES (${placeholders}) ON CONFLICT DO NOTHING`;
+
+    let inserted = 0;
+    let skipped = 0;
+
+    for (const row of rows) {
+        const vals = cols.map((c) => row[c]);
+        try {
+            const result = await client.query(sql, vals);
+            if ((result.rowCount ?? 0) > 0) inserted++; else skipped++;
+        } catch {
+            skipped++;
+        }
+    }
+
+    if (needsClose) {
+        await (client.end?.() ?? client.close?.());
+    }
+
+    return { inserted, skipped };
+}
+
+// ── Migration runner ──────────────────────────────────────────────────────────
+
+/**
+ * Migrate core data from sourceUrl to targetUrl.
+ * @param {string} sourceUrl
+ * @param {string} targetUrl
+ * @returns {Promise<number>} total rows inserted
+ */
+export async function migrate(sourceUrl, targetUrl) {
+    const srcBackend = detectBackend(sourceUrl);
+    const tgtBackend = detectBackend(targetUrl);
+    console.log(`Migrating ${srcBackend} → ${tgtBackend}`);
+
+    let total = 0;
+
+    for (const table of TABLES) {
+        process.stdout.write(`  Reading ${table}...`);
+        let rows;
+        try {
+            rows = await readFromSource(srcBackend, sourceUrl, table);
+            process.stdout.write(` ${rows.length} rows\n`);
+        } catch (e) {
+            process.stdout.write(` SKIP (${e.message})\n`);
+            continue;
+        }
+        if (!rows.length) { console.log(`    ${table}: 0 rows`); continue; }
+
+        let stats;
+        try {
+            if (tgtBackend === "sqlite") {
+                stats = await writeTargetSqlite(targetUrl, table, rows);
+            } else {
+                stats = await writeTargetPg(targetUrl, table, rows, tgtBackend === "pglite");
+            }
+        } catch (e) {
+            console.error(`    ${table}: write failed — ${e.message}`);
+            continue;
+        }
+        console.log(`    ${table}: ${stats.inserted} inserted, ${stats.skipped} skipped`);
+        total += stats.inserted;
+    }
+
+    console.log(`\nMigration complete. ${total} total rows inserted.`);
+    console.log(
+        "Note: mc_versions / mc_source_files were not migrated — re-run index after setup.",
+    );
+    return total;
+}
+
+// ── CLI entry point ───────────────────────────────────────────────────────────
+
+const isCli = process.argv[1]?.replace(/\\/g, "/").endsWith("migrate-backend.mjs");
+if (isCli) {
+    const sourceUrl = process.env.SOURCE_DATABASE_URL ?? "";
+    const targetUrl = process.env.DATABASE_URL ?? "";
+    if (!sourceUrl || !targetUrl) {
+        console.error("Set SOURCE_DATABASE_URL (old backend) and DATABASE_URL (new backend).");
+        process.exit(1);
+    }
+    await migrate(sourceUrl, targetUrl);
+}

package/scripts/migrate-embed-provenance.mjs

@@ -0,0 +1,80 @@
+/**
+ * Add embed_source and embed_updated_at columns to mc_source_files and mod_source_files.
+ * Safe to re-run — uses IF NOT EXISTS / ADD COLUMN IF NOT EXISTS guards.
+ *
+ * Usage: node scripts/migrate-embed-provenance.mjs
+ */
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+
+try { require("dotenv").config(); } catch { /* optional */ }
+
+const dbUrl = process.env.DATABASE_URL ?? "";
+
+function detectBackend(url) {
+    if (url.startsWith("file:") || url.endsWith(".db")) return "sqlite";
+    if (url.startsWith("pglite://") || url.startsWith("pglite:")) return "pglite";
+    return "postgres";
+}
+
+const TABLES = ["mc_source_files", "mod_source_files"];
+const COLUMNS = [
+    { name: "embed_source",     pgType: "TEXT",        sqliteType: "TEXT" },
+    { name: "embed_updated_at", pgType: "TIMESTAMPTZ", sqliteType: "DATETIME" },
+];
+
+async function migrateSqlite() {
+    const Database = require("better-sqlite3");
+    const path = dbUrl.replace(/^file:\/\//, "").replace(/^file:/, "");
+    const db = new Database(path);
+    for (const table of TABLES) {
+        for (const col of COLUMNS) {
+            try {
+                db.exec(`ALTER TABLE ${table} ADD COLUMN ${col.name} ${col.sqliteType}`);
+                console.log(`  + ${table}.${col.name}`);
+            } catch (e) {
+                if (e.message?.includes("duplicate column")) {
+                    console.log(`  = ${table}.${col.name} (already exists)`);
+                } else {
+                    throw e;
+                }
+            }
+        }
+    }
+    db.close();
+}
+
+async function migratePostgres() {
+    const { Client } = require("pg");
+    const client = new Client({ connectionString: dbUrl });
+    await client.connect();
+    for (const table of TABLES) {
+        for (const col of COLUMNS) {
+            await client.query(`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${col.name} ${col.pgType}`);
+            console.log(`  + ${table}.${col.name}`);
+        }
+    }
+    await client.end();
+}
+
+async function migratePglite() {
+    const { PGlite } = await import("@electric-sql/pglite");
+    const dataDir = dbUrl.replace(/^pglite:\/\//, "").replace(/^pglite:/, "");
+    const db = new PGlite(dataDir);
+    for (const table of TABLES) {
+        for (const col of COLUMNS) {
+            await db.exec(`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS ${col.name} ${col.pgType}`);
+            console.log(`  + ${table}.${col.name}`);
+        }
+    }
+    await db.close();
+}
+
+const backend = detectBackend(dbUrl);
+console.log(`Migrating embed provenance columns (${backend})...`);
+
+if (backend === "sqlite") await migrateSqlite();
+else if (backend === "pglite") await migratePglite();
+else await migratePostgres();
+
+console.log("Done.");

package/scripts/migrate-metadata-source.mjs

@@ -0,0 +1,62 @@
+/**
+ * Add metadata_source column to the mods table.
+ * Safe to re-run — uses IF NOT EXISTS / duplicate column guards.
+ *
+ * Usage: node scripts/migrate-metadata-source.mjs
+ */
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+
+try { require("dotenv").config(); } catch { /* optional */ }
+
+const dbUrl = process.env.DATABASE_URL ?? "";
+
+function detectBackend(url) {
+    if (url.startsWith("file:") || url.endsWith(".db")) return "sqlite";
+    if (url.startsWith("pglite://") || url.startsWith("pglite:")) return "pglite";
+    return "postgres";
+}
+
+async function migrateSqlite() {
+    const Database = require("better-sqlite3");
+    const path = dbUrl.replace(/^file:\/\//, "").replace(/^file:/, "");
+    const db = new Database(path);
+    try {
+        db.exec(`ALTER TABLE mods ADD COLUMN metadata_source TEXT`);
+        console.log("  + mods.metadata_source");
+    } catch (e) {
+        if (e.message?.includes("duplicate column")) {
+            console.log("  = mods.metadata_source (already exists)");
+        } else {
+            throw e;
+        }
+    }
+    db.close();
+}
+
+async function migratePostgres() {
+    const { Client } = require("pg");
+    const client = new Client({ connectionString: dbUrl });
+    await client.connect();
+    await client.query(`ALTER TABLE mods ADD COLUMN IF NOT EXISTS metadata_source TEXT`);
+    console.log("  + mods.metadata_source");
+    await client.end();
+}
+
+async function migratePglite() {
+    const { PGlite } = await import("@electric-sql/pglite");
+    const dataDir = dbUrl.replace(/^pglite:\/\//, "").replace(/^pglite:/, "");
+    const db = new PGlite(dataDir);
+    await db.exec(`ALTER TABLE mods ADD COLUMN IF NOT EXISTS metadata_source TEXT`);
+    console.log("  + mods.metadata_source");
+    await db.close();
+}
+
+const backend = detectBackend(dbUrl);
+console.log(`Migrating metadata_source column (${backend})...`);
+
+if (backend === "sqlite") await migrateSqlite();
+else if (backend === "pglite") await migratePglite();
+else await migratePostgres();
+
+console.log("Done.");

package/scripts/migrate-mod-source-files.mjs

@@ -0,0 +1,67 @@
+/**
+ * Creates the mod_source_files table and a pgvector column for semantic search.
+ * Run via: node scripts/migrate-mod-source-files.mjs
+ *
+ * Safe to re-run — uses IF NOT EXISTS / DO $$ guards throughout.
+ */
+import { PrismaClient } from "@prisma/client";
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const envPath = join(__dirname, "..", ".env");
+if (existsSync(envPath)) {
+    for (const line of readFileSync(envPath, "utf8").split("\n")) {
+        const m = line.match(/^([^#=]+)=(.*)$/);
+        if (m) process.env[m[1].trim()] ??= m[2].trim().replace(/^["']|["']$/g, "");
+    }
+}
+
+const prisma = new PrismaClient();
+
+async function main() {
+    // 1. Create table (no embedding column here — enable-pgvector.mjs owns that
+    //    so the correct OLLAMA_EMBED_DIM dimension is always used)
+    await prisma.$executeRawUnsafe(`
+        CREATE TABLE IF NOT EXISTS mod_source_files (
+            id         SERIAL PRIMARY KEY,
+            mod_id     INTEGER NOT NULL REFERENCES mods(id) ON DELETE CASCADE,
+            class_name TEXT    NOT NULL,
+            content    TEXT    NOT NULL,
+            UNIQUE (mod_id, class_name)
+        )
+    `);
+    console.log("✓ mod_source_files table ready");
+
+    // 2. B-tree index on mod_id
+    await prisma.$executeRawUnsafe(`
+        CREATE INDEX IF NOT EXISTS mod_source_files_mod_id_idx
+        ON mod_source_files (mod_id)
+    `);
+    console.log("✓ mod_source_files_mod_id_idx ready");
+
+    // 3. GIN index for FTS (same pattern as mc_source_files)
+    const ftsExists = await prisma.$queryRaw`
+        SELECT 1 FROM pg_indexes
+        WHERE schemaname = 'public'
+          AND tablename  = 'mod_source_files'
+          AND indexname  = 'mod_source_files_tsv_idx'
+    `;
+    if (ftsExists.length === 0) {
+        await prisma.$executeRawUnsafe(`
+            CREATE INDEX CONCURRENTLY mod_source_files_tsv_idx
+            ON mod_source_files
+            USING GIN (to_tsvector('simple', content))
+        `);
+        console.log("✓ mod_source_files_tsv_idx (GIN FTS) created");
+    } else {
+        console.log("  mod_source_files_tsv_idx already exists, skipping");
+    }
+
+    console.log("\nDone. Run 'npm run db:vector' to add the embedding column with the correct dimension.");
+}
+
+main()
+    .catch((e) => { console.error(e); process.exit(1); })
+    .finally(() => prisma.$disconnect());

package/scripts/post-update.mjs

@@ -0,0 +1,77 @@
+/**
+ * Profile-aware post-update script.
+ * Called by `npm run update` after git pull + npm install + build.
+ * Reads DATABASE_URL / MODLENS_PROFILE from .env and runs the correct
+ * schema migration + vector extension commands for the user's backend.
+ *
+ * Safe to re-run — all underlying scripts use IF NOT EXISTS guards.
+ */
+import { execSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, "..");
+const envPath = join(ROOT, ".env");
+
+// ── Load .env ─────────────────────────────────────────────────────────────────
+if (existsSync(envPath)) {
+    for (const line of readFileSync(envPath, "utf8").split("\n")) {
+        const m = line.match(/^([^#=]+)=(.*)$/);
+        if (m) process.env[m[1].trim()] ??= m[2].trim().replace(/^["']|["']$/g, "");
+    }
+}
+
+const dbUrl = process.env.DATABASE_URL ?? "";
+
+function run(cmd) {
+    console.log(`\n> ${cmd}`);
+    execSync(cmd, { cwd: ROOT, stdio: "inherit" });
+}
+
+// ── Detect backend from DATABASE_URL prefix ───────────────────────────────────
+let backend;
+if (dbUrl.startsWith("postgresql://") || dbUrl.startsWith("postgres://")) {
+    backend = "postgres";
+} else if (dbUrl.startsWith("pglite://") || dbUrl.startsWith("pglite:")) {
+    backend = "pglite";
+} else if (dbUrl.startsWith("file:")) {
+    backend = "sqlite";
+} else {
+    console.warn(`⚠ Could not detect backend from DATABASE_URL="${dbUrl}". Defaulting to postgres.`);
+    backend = "postgres";
+}
+
+console.log(`\nDetected backend: ${backend}`);
+
+// ── Apply schema ──────────────────────────────────────────────────────────────
+if (backend === "sqlite") {
+    // SQLite uses a separate schema file — db push is safest (no migration files)
+    run("npx prisma db push --schema prisma/backends/schema.sqlite.prisma --accept-data-loss");
+} else {
+    // Postgres and PGlite both use the main schema
+    // prisma migrate deploy applies any new migration files; db push is the fallback
+    // for dev setups that use db push instead of migrate
+    try {
+        run("npx prisma migrate deploy");
+    } catch {
+        console.log("  migrate deploy failed (likely db-push setup) — falling back to db push");
+        run("npx prisma db push");
+    }
+    // Extra post-migrate steps for Postgres (GIN FTS indexes, mod_source_files table)
+    if (backend === "postgres") {
+        run("node scripts/create-fts-index.mjs");
+        run("node scripts/migrate-mod-source-files.mjs");
+    }
+}
+
+// ── Vector extension ──────────────────────────────────────────────────────────
+if (backend === "sqlite") {
+    run("node scripts/enable-sqlite-vec.mjs");
+} else {
+    // Postgres and PGlite: adds/resizes embedding columns to match OLLAMA_EMBED_DIM
+    run("node scripts/enable-pgvector.mjs");
+}
+
+console.log("\n✓ Update complete. Restart your MCP client to load the new server.");