@vivantel/virage-cli 0.1.6 → 0.1.8

package/dist/cli/dashboard.js

@@ -1,22 +1,18 @@
-import { createServer } from "http";
-import { readFile, writeFile, mkdir } from "fs/promises";
+import express from "express";
+import { WebSocketServer } from "ws";
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
 import { existsSync } from "fs";
-import { join, extname, basename, resolve } from "path";
+import { join, resolve, basename } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
-import { EmbeddingsDb } from "@vivantel/virage-core";
-const MIME = {
-    ".html": "text/html; charset=utf-8",
-    ".js": "application/javascript",
-    ".css": "text/css",
-    ".svg": "image/svg+xml",
-    ".ico": "image/x-icon",
-};
+import { EmbeddingsDb, loadConfig, Orchestrator, ExperimentStore, bootstrapPairedTest, generateEvalDataset, EvalRunner, loadEvalDataset, } from "@vivantel/virage-core";
 const RECENT_PROJECTS_PATH = join(homedir(), ".virage", "recent-projects.json");
 const MAX_PROJECTS = 10;
 let projectsState = { projects: [], activeIndex: 0 };
-// Resolve the compiled dashboard-ui/ directory shipped alongside this package.
-// At runtime the compiled CLI lives at dist/cli/dashboard.js; dashboard-ui is at dist/dashboard-ui/.
+// Cache the loaded config per project root to avoid reloading the embedder model on every search
+let configCache = null;
+// Single-operation guard for WebSocket pipeline runs
+let wsOperationRunning = false;
 const THIS_DIR = fileURLToPath(new URL(".", import.meta.url));
 const UI_DIR = join(THIS_DIR, "..", "dashboard-ui");
 const HAS_UI = existsSync(join(UI_DIR, "index.html"));
@@ -37,7 +33,7 @@ async function loadRecentProjects() {
         }
     }
     catch {
-        /* first run — file does not exist yet */
+        /* first run */
     }
     return { projects: [], activeIndex: 0 };
 }
@@ -51,166 +47,20 @@ async function saveRecentProjects(state) {
     await mkdir(join(homedir(), ".virage"), { recursive: true });
     await writeFile(RECENT_PROJECTS_PATH, JSON.stringify(next, null, 2), "utf-8");
     projectsState = next;
+    configCache = null; // invalidate on project change
 }
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
-        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-        req.on("error", reject);
-    });
+function activeProject() {
+    return projectsState.projects[projectsState.activeIndex];
 }
-async function serveStatic(urlPath, res) {
-    if (!HAS_UI)
-        return false;
-    const normalized = urlPath === "/" || urlPath === "" ? "/index.html" : urlPath;
-    // Only serve known static assets; fall back to index.html for SPA routing
-    const filePath = join(UI_DIR, normalized);
-    const ext = extname(filePath).toLowerCase();
-    try {
-        const content = await readFile(filePath);
-        res.setHeader("Content-Type", MIME[ext] ?? "application/octet-stream");
-        res.end(content);
-        return true;
-    }
-    catch {
-        // Try index.html for SPA client-side routing (non-asset paths)
-        if (!normalized.startsWith("/assets/") && ext === ".html") {
-            try {
-                const html = await readFile(join(UI_DIR, "index.html"));
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                res.end(html);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        return false;
-    }
-}
-export async function runDashboard(opts) {
-    if (!HAS_UI) {
-        console.warn("⚠️  Dashboard UI not found. Run `npm run build -w @vivantel/virage-dashboard` first.");
-    }
-    // Derive the startup project from CLI options and register it
-    const startupRoot = resolve(opts.dbPath, "..", "..");
-    const startupProject = projectFromRoot(startupRoot, {
-        embeddingsDb: resolve(opts.dbPath),
-    });
-    const loaded = await loadRecentProjects();
-    const existingIdx = loaded.projects.findIndex((p) => p.rootPath === startupProject.rootPath);
-    if (existingIdx >= 0) {
-        loaded.projects[existingIdx] = startupProject;
-        loaded.activeIndex = existingIdx;
-    }
-    else {
-        loaded.projects.unshift(startupProject);
-        loaded.activeIndex = 0;
-    }
-    await saveRecentProjects(loaded);
-    const server = createServer(async (req, res) => {
-        const url = req.url ?? "/";
-        res.setHeader("Content-Type", "application/json");
-        try {
-            const active = projectsState.projects[projectsState.activeIndex];
-            if (url === "/api/status" && req.method === "GET") {
-                const status = await getStatus(active.embeddingsDb);
-                res.end(JSON.stringify(status));
-                return;
-            }
-            if (url === "/api/chunks" && req.method === "GET") {
-                const chunks = await getChunksHistogram(active.embeddingsDb);
-                res.end(JSON.stringify(chunks));
-                return;
-            }
-            if (url === "/api/embeddings/anomalies" && req.method === "GET") {
-                const anomalies = await getAnomalies(active.embeddingsDb);
-                res.end(JSON.stringify(anomalies));
-                return;
-            }
-            if (url === "/api/projects" && req.method === "GET") {
-                res.end(JSON.stringify(projectsState));
-                return;
-            }
-            if (url === "/api/projects/add" && req.method === "POST") {
-                const body = JSON.parse(await readBody(req));
-                if (typeof body.rootPath !== "string" || !body.rootPath.trim()) {
-                    res.statusCode = 400;
-                    res.end(JSON.stringify({ error: "rootPath is required" }));
-                    return;
-                }
-                const entry = projectFromRoot(body.rootPath.trim());
-                if (!existsSync(entry.embeddingsDb)) {
-                    res.statusCode = 422;
-                    res.end(JSON.stringify({
-                        error: `No .virage data found in ${entry.rootPath}`,
-                    }));
-                    return;
-                }
-                const idx = projectsState.projects.findIndex((p) => p.rootPath === entry.rootPath);
-                const next = {
-                    ...projectsState,
-                    projects: [...projectsState.projects],
-                };
-                if (idx >= 0) {
-                    next.projects[idx] = { ...entry, lastUsed: Date.now() };
-                    next.activeIndex = idx;
-                }
-                else {
-                    next.projects = [entry, ...next.projects];
-                    next.activeIndex = 0;
-                }
-                await saveRecentProjects(next);
-                res.end(JSON.stringify(projectsState));
-                return;
-            }
-            if (url === "/api/projects/switch" && req.method === "POST") {
-                const body = JSON.parse(await readBody(req));
-                const index = Number(body.index);
-                if (!Number.isInteger(index) ||
-                    index < 0 ||
-                    index >= projectsState.projects.length) {
-                    res.statusCode = 400;
-                    res.end(JSON.stringify({ error: "Invalid index" }));
-                    return;
-                }
-                const next = {
-                    projects: [...projectsState.projects],
-                    activeIndex: index,
-                };
-                next.projects[index] = {
-                    ...next.projects[index],
-                    lastUsed: Date.now(),
-                };
-                await saveRecentProjects(next);
-                res.end(JSON.stringify(projectsState));
-                return;
-            }
-            // Serve React app static assets
-            const served = await serveStatic(url, res);
-            if (!served) {
-                res.statusCode = 404;
-                res.end(JSON.stringify({ error: "Not found" }));
-            }
-        }
-        catch (err) {
-            res.statusCode = 500;
-            res.end(JSON.stringify({ error: err.message }));
-        }
-    });
-    server.listen(opts.port, () => {
-        console.log(`🚀 RAG Dashboard running at http://localhost:${opts.port}`);
-        console.log("   Press Ctrl+C to stop");
-    });
-    // Keep process alive
-    await new Promise((resolve) => {
-        process.on("SIGINT", () => {
-            server.close();
-            resolve();
-        });
-    });
+async function getCachedConfig(configPath) {
+    if (configCache?.path === configPath)
+        return configCache.cfg;
+    const cfg = await loadConfig(configPath);
+    await cfg.vectorStore.initialize();
+    configCache = { path: configPath, cfg };
+    return cfg;
 }
+// ─── Status helpers (preserved from original) ─────────────────────────────────
 async function getStatus(dbPath) {
     let totalChunks = 0;
     let totalEmbeddings = 0;
@@ -273,4 +123,389 @@ async function getAnomalies(dbPath) {
         return { anomalies: [] };
     }
 }
+// ─── WebSocket handler ─────────────────────────────────────────────────────────
+function safeSend(ws, msg) {
+    if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify(msg));
+    }
+}
+async function handleWsOperation(ws, op) {
+    const active = activeProject();
+    if (!active) {
+        safeSend(ws, { type: "error", message: "No active project" });
+        return;
+    }
+    const configPath = join(active.rootPath, "virage.config.json");
+    if (!existsSync(configPath)) {
+        safeSend(ws, {
+            type: "error",
+            message: `virage.config.json not found in ${active.rootPath}`,
+        });
+        return;
+    }
+    try {
+        const cfg = await getCachedConfig(configPath);
+        if (op === "update") {
+            const orchestrator = new Orchestrator({
+                ...cfg,
+                options: {
+                    ...cfg.options,
+                    onChunkProgress: (done, total) => safeSend(ws, { type: "progress", stage: "chunk", done, total }),
+                    onEmbedProgress: (done, total) => safeSend(ws, { type: "progress", stage: "embed", done, total }),
+                    onUploadProgress: (done, total) => safeSend(ws, { type: "progress", stage: "upload", done, total }),
+                },
+            });
+            safeSend(ws, { type: "progress", stage: "starting", done: 0, total: 0 });
+            await orchestrator.run();
+            safeSend(ws, { type: "done" });
+        }
+        else if (op === "eval-generate") {
+            const db = new EmbeddingsDb(active.embeddingsDb);
+            const chunks = db.getAllChunks();
+            db.close();
+            safeSend(ws, {
+                type: "progress",
+                stage: "eval-generate",
+                message: `Generating eval dataset from ${chunks.length} chunks...`,
+            });
+            const outputPath = join(active.rootPath, ".virage", "eval-dataset.json");
+            await generateEvalDataset(chunks, { includeNegatives: false, paraphraseRatio: 0 }, outputPath);
+            safeSend(ws, {
+                type: "done",
+                message: `Eval dataset written to ${outputPath}`,
+            });
+        }
+        else if (op === "evaluate") {
+            const datasetPath = join(active.rootPath, ".virage", "eval-dataset.json");
+            if (!existsSync(datasetPath)) {
+                safeSend(ws, {
+                    type: "error",
+                    message: "No eval dataset found. Run eval-generate first.",
+                });
+                return;
+            }
+            const dataset = await loadEvalDataset(datasetPath);
+            safeSend(ws, {
+                type: "progress",
+                stage: "evaluate",
+                message: `Evaluating ${dataset.queries.length} queries...`,
+            });
+            const runner = new EvalRunner(cfg.vectorStore, cfg.embedder, dataset, 10);
+            const result = await runner.run((completed, total) => safeSend(ws, {
+                type: "progress",
+                stage: "evaluate",
+                done: completed,
+                total,
+            }));
+            safeSend(ws, { type: "done", result });
+        }
+        else {
+            safeSend(ws, { type: "error", message: `Unknown operation: ${op}` });
+        }
+    }
+    catch (err) {
+        safeSend(ws, {
+            type: "error",
+            message: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+// ─── Main entry point ──────────────────────────────────────────────────────────
+export async function runDashboard(opts) {
+    if (!HAS_UI) {
+        console.warn("⚠️  Dashboard UI not found. Run `npm run build -w @vivantel/virage-dashboard` first.");
+    }
+    const startupRoot = resolve(opts.dbPath, "..", "..");
+    const startupProject = projectFromRoot(startupRoot, {
+        embeddingsDb: resolve(opts.dbPath),
+    });
+    const loaded = await loadRecentProjects();
+    const existingIdx = loaded.projects.findIndex((p) => p.rootPath === startupProject.rootPath);
+    if (existingIdx >= 0) {
+        loaded.projects[existingIdx] = startupProject;
+        loaded.activeIndex = existingIdx;
+    }
+    else {
+        loaded.projects.unshift(startupProject);
+        loaded.activeIndex = 0;
+    }
+    await saveRecentProjects(loaded);
+    const app = express();
+    app.use(express.json());
+    // ─── Existing routes ────────────────────────────────────────────────────────
+    app.get("/api/status", async (_req, res) => {
+        const active = activeProject();
+        res.json(await getStatus(active?.embeddingsDb ?? opts.dbPath));
+    });
+    app.get("/api/chunks", async (_req, res) => {
+        const active = activeProject();
+        res.json(await getChunksHistogram(active?.embeddingsDb ?? opts.dbPath));
+    });
+    app.get("/api/embeddings/anomalies", async (_req, res) => {
+        const active = activeProject();
+        res.json(await getAnomalies(active?.embeddingsDb ?? opts.dbPath));
+    });
+    app.get("/api/projects", (_req, res) => {
+        res.json(projectsState);
+    });
+    app.post("/api/projects/add", async (req, res) => {
+        const body = req.body;
+        if (typeof body.rootPath !== "string" || !body.rootPath.trim()) {
+            res.status(400).json({ error: "rootPath is required" });
+            return;
+        }
+        const entry = projectFromRoot(body.rootPath.trim());
+        if (!existsSync(entry.embeddingsDb)) {
+            res.status(422).json({
+                error: `No .virage data found in ${entry.rootPath}`,
+            });
+            return;
+        }
+        const idx = projectsState.projects.findIndex((p) => p.rootPath === entry.rootPath);
+        const next = { ...projectsState, projects: [...projectsState.projects] };
+        if (idx >= 0) {
+            next.projects[idx] = { ...entry, lastUsed: Date.now() };
+            next.activeIndex = idx;
+        }
+        else {
+            next.projects = [entry, ...next.projects];
+            next.activeIndex = 0;
+        }
+        await saveRecentProjects(next);
+        res.json(projectsState);
+    });
+    app.post("/api/projects/switch", async (req, res) => {
+        const body = req.body;
+        const index = Number(body.index);
+        if (!Number.isInteger(index) ||
+            index < 0 ||
+            index >= projectsState.projects.length) {
+            res.status(400).json({ error: "Invalid index" });
+            return;
+        }
+        const next = {
+            projects: [...projectsState.projects],
+            activeIndex: index,
+        };
+        next.projects[index] = { ...next.projects[index], lastUsed: Date.now() };
+        await saveRecentProjects(next);
+        res.json(projectsState);
+    });
+    // ─── New chunk routes ────────────────────────────────────────────────────────
+    app.get("/api/chunks/all", (req, res) => {
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const db = new EmbeddingsDb(active.embeddingsDb);
+            let chunks = db.getAllChunks();
+            db.close();
+            const sf = req.query["sourceFile"];
+            if (typeof sf === "string") {
+                chunks = chunks.filter((c) => c.sourceFile === sf);
+            }
+            res.json({ chunks });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete("/api/chunks/file", (req, res) => {
+        const body = req.body;
+        if (typeof body.sourceFile !== "string" || !body.sourceFile.trim()) {
+            res.status(400).json({ error: "sourceFile is required" });
+            return;
+        }
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const db = new EmbeddingsDb(active.embeddingsDb);
+            db.deleteBySourceFile(body.sourceFile.trim());
+            db.close();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete("/api/chunks/all", (_req, res) => {
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const db = new EmbeddingsDb(active.embeddingsDb);
+            db.clearAll();
+            db.close();
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ─── RAG search route ────────────────────────────────────────────────────────
+    app.post("/api/search", async (req, res) => {
+        const body = req.body;
+        if (typeof body.query !== "string" || !body.query.trim()) {
+            res.status(400).json({ error: "query is required" });
+            return;
+        }
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        const configPath = join(active.rootPath, "virage.config.json");
+        if (!existsSync(configPath)) {
+            res
+                .status(422)
+                .json({ error: `virage.config.json not found in ${active.rootPath}` });
+            return;
+        }
+        try {
+            const cfg = await getCachedConfig(configPath);
+            const topK = typeof body.topK === "number" ? body.topK : 5;
+            const embedding = await cfg.embedder.embed(body.query.trim());
+            const results = await cfg.vectorStore.search(embedding, topK);
+            res.json({ results });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ─── Experiment routes ───────────────────────────────────────────────────────
+    const ID_RE = /^[a-zA-Z0-9_-]+$/;
+    app.get("/api/experiments", async (_req, res) => {
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const store = new ExperimentStore(join(active.rootPath, ".rag-experiments"));
+            const runs = await store.list();
+            res.json({ runs });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get("/api/experiments/:id", async (req, res) => {
+        if (!ID_RE.test(req.params["id"] ?? "")) {
+            res.status(400).json({ error: "Invalid experiment id" });
+            return;
+        }
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const store = new ExperimentStore(join(active.rootPath, ".rag-experiments"));
+            const run = await store.load(req.params["id"]);
+            res.json(run);
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
+    app.delete("/api/experiments/:id", async (req, res) => {
+        if (!ID_RE.test(req.params["id"] ?? "")) {
+            res.status(400).json({ error: "Invalid experiment id" });
+            return;
+        }
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const filePath = join(active.rootPath, ".rag-experiments", `${req.params["id"]}.json`);
+            await unlink(filePath);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post("/api/experiments/compare", async (req, res) => {
+        const body = req.body;
+        if (typeof body.baseline !== "string" ||
+            typeof body.candidate !== "string") {
+            res
+                .status(400)
+                .json({ error: "baseline and candidate ids are required" });
+            return;
+        }
+        const active = activeProject();
+        if (!active) {
+            res.status(503).json({ error: "No active project" });
+            return;
+        }
+        try {
+            const store = new ExperimentStore(join(active.rootPath, ".rag-experiments"));
+            const [bRun, cRun] = await Promise.all([
+                store.load(body.baseline),
+                store.load(body.candidate),
+            ]);
+            if (!bRun.perQueryRrScores || !cRun.perQueryRrScores) {
+                res
+                    .status(422)
+                    .json({ error: "Per-query scores unavailable for comparison" });
+                return;
+            }
+            const result = bootstrapPairedTest(bRun.perQueryRrScores, cRun.perQueryRrScores);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // ─── Static assets + SPA fallback ───────────────────────────────────────────
+    if (HAS_UI) {
+        app.use(express.static(UI_DIR));
+        app.get("*", (_req, res) => {
+            res.sendFile(join(UI_DIR, "index.html"));
+        });
+    }
+    // ─── Start server + attach WebSocket ────────────────────────────────────────
+    const server = app.listen(opts.port, () => {
+        console.log(`🚀 RAG Dashboard running at http://localhost:${opts.port}`);
+        console.log("   Press Ctrl+C to stop");
+    });
+    const wss = new WebSocketServer({ server, path: "/ws" });
+    wss.on("connection", (ws) => {
+        ws.on("message", (raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch {
+                safeSend(ws, { type: "error", message: "Invalid JSON" });
+                return;
+            }
+            if (wsOperationRunning) {
+                safeSend(ws, { type: "busy" });
+                return;
+            }
+            wsOperationRunning = true;
+            handleWsOperation(ws, msg.op ?? "").finally(() => {
+                wsOperationRunning = false;
+            });
+        });
+    });
+    await new Promise((resolve) => {
+        process.on("SIGINT", () => {
+            wss.close();
+            server.close();
+            resolve();
+        });
+    });
+}
 //# sourceMappingURL=dashboard.js.map