pi-vault-mind 0.11.0 → 0.12.0

package/dist/src/server.d.ts

@@ -18,7 +18,8 @@
  *   GET  /vm/status, POST /vm/init, POST /vm/setup, POST /server/start,
  *   GET  /vault-mind/config, GET /agent/queue, GET /agent/jobs/:id,
  *   POST /agent/jobs/:id/retry, POST /agent/jobs/:id/cancel,
- *   POST /vm/search, POST /vm/append, WS /agent/stream.
+ *   POST /vm/search, POST /vm/append, WS /agent/stream,
+ *   GET  /vm/pending, POST /vm/approve.
  */
 import * as http from "node:http";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";

package/dist/src/server.js

@@ -18,7 +18,8 @@
  *   GET  /vm/status, POST /vm/init, POST /vm/setup, POST /server/start,
  *   GET  /vault-mind/config, GET /agent/queue, GET /agent/jobs/:id,
  *   POST /agent/jobs/:id/retry, POST /agent/jobs/:id/cancel,
- *   POST /vm/search, POST /vm/append, WS /agent/stream.
+ *   POST /vm/search, POST /vm/append, WS /agent/stream,
+ *   GET  /vm/pending, POST /vm/approve.
  */
 import * as fs from "node:fs";
 import * as http from "node:http";
@@ -28,7 +29,8 @@ import { WebSocket, WebSocketServer } from "ws";
 import { cancelJobHelper, getJob, listJobs, retryJob, subscribeQueue, } from "./agent-queue.js";
 import { authoriseRequest, resolveAuthToken } from "./auth.js";
 import { GITIGNORE_ENTRIES } from "./commands.js";
-import { searchHybrid, upsertEntry } from "./lance.js";
+import { queryGraph } from "./graph.js";
+import { searchFts, searchHybrid, upsertEntry } from "./lance.js";
 import { DEFAULT_CONFIG } from "./types.js";
 import { ensureDir, expandHome, findConfig, loadConfig, resolveInitCollectionName, shrinkHome, } from "./utils.js";
 import { processQueue, scanFile, startWatcher, stopWatcher } from "./watcher.js";
@@ -190,6 +192,38 @@ export function startServer(pi, serverState, watcherState) {
                     }
                     withAuth(req, res, () => handleVmAppend(req, res, serverState), { requireWrite: true });
                     break;
+                case "/vm/fts-search":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleVmFtsSearch(req, res, serverState));
+                    break;
+                case "/vm/graph":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleVmGraph(req, res, serverState));
+                    break;
+                case "/vm/approve":
+                    if (req.method !== "POST") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleVmApprove(req, res, serverState), { requireWrite: true });
+                    break;
+                case "/vm/pending":
+                    if (req.method !== "GET") {
+                        res.writeHead(405);
+                        res.end(JSON.stringify({ error: "Method not allowed" }));
+                        return;
+                    }
+                    withAuth(req, res, () => handleVmPending(res, serverState));
+                    break;
                 default:
                     if (url.pathname.startsWith("/agent/jobs/")) {
                         withAuth(req, res, () => handleAgentJob(req, res, url.pathname), {
@@ -838,3 +872,140 @@ async function handleVmAppend(req, res, serverState) {
         res.end(JSON.stringify({ error: message }));
     }
 }
+async function handleVmFtsSearch(req, res, serverState) {
+    const body = (await readJsonBody(req));
+    if (!body.query) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "query required" }));
+        return;
+    }
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const collection = body.collection || "main";
+    const limit = body.limit ?? 10;
+    try {
+        const results = await searchFts(cfg.vaultMind.dataDir, collection, body.query, limit, cfg.vaultMind);
+        res.writeHead(200);
+        res.end(JSON.stringify({ hits: results, collection, query: body.query }));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: message }));
+    }
+}
+async function handleVmGraph(req, res, serverState) {
+    const body = (await readJsonBody(req));
+    if (!body.entity) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "entity required" }));
+        return;
+    }
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const depth = body.depth ?? 1;
+    try {
+        const results = await queryGraph(cfg.vaultMind.dataDir, cfg.vaultMind, body.entity, depth);
+        res.writeHead(200);
+        res.end(JSON.stringify({ entity: body.entity, depth, results }));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        res.writeHead(500);
+        res.end(JSON.stringify({ error: message }));
+    }
+}
+// ── Pending review route ─────────────────────────────────────────────────────
+async function handleVmApprove(req, res, serverState) {
+    const body = (await readJsonBody(req));
+    const id = typeof body.id === "string" ? body.id : undefined;
+    const collection = typeof body.collection === "string" ? body.collection : undefined;
+    const action = body.action === "approve" || body.action === "reject" ? body.action : undefined;
+    if (!id || !collection || !action) {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: "Missing required fields: id, collection, action (approve|reject)." }));
+        return;
+    }
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const def = cfg.collections[collection];
+    if (!def) {
+        res.writeHead(400);
+        res.end(JSON.stringify({
+            error: `Unknown collection "${collection}".`,
+            available: Object.keys(cfg.collections),
+        }));
+        return;
+    }
+    if (!fs.existsSync(def.path)) {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: `Collection file not found: ${def.path}` }));
+        return;
+    }
+    const raw = fs.readFileSync(def.path, "utf-8");
+    const hasTrailingNewline = raw.endsWith("\n");
+    const lines = raw.split("\n");
+    const entries = hasTrailingNewline ? lines.slice(0, -1) : lines;
+    let foundIndex = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const line = entries[i].trim();
+        if (!line)
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry && entry.id === id) {
+                foundIndex = i;
+                break;
+            }
+        }
+        catch {
+            /* skip malformed lines */
+        }
+    }
+    if (foundIndex === -1) {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: `Entry "${id}" not found in collection "${collection}".` }));
+        return;
+    }
+    const entry = JSON.parse(entries[foundIndex]);
+    entry.status = action === "approve" ? "approved" : "rejected";
+    entries[foundIndex] = JSON.stringify(entry);
+    fs.writeFileSync(def.path, `${entries.join("\n")}\n`, "utf-8");
+    res.writeHead(200);
+    res.end(JSON.stringify({ ok: true, id, action }));
+}
+function handleVmPending(res, serverState) {
+    const vaultPath = serverState.vaultPath || process.cwd();
+    const cfg = loadConfig(vaultPath);
+    const pending = [];
+    for (const [collectionName, def] of Object.entries(cfg.collections)) {
+        if (!fs.existsSync(def.path))
+            continue;
+        let raw;
+        try {
+            raw = fs.readFileSync(def.path, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const lines = raw.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (!trimmed)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (entry.status !== "pending")
+                continue;
+            const id = typeof entry.id === "string" ? entry.id : String(i + 1);
+            pending.push({ id, collection: collectionName, entry });
+        }
+    }
+    res.writeHead(200);
+    res.end(JSON.stringify({ pending }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vault-mind",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Passive Obsidian vault extension for pi. Watches @agent markers, dispatches forked subagents (Miner, Broadcaster, Heavy-Lifter), stores in LanceDB with vector + FTS + graph. Multi-agent 'Drop & Forget' workflow for the pi agent ecosystem.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/scripts/reset-test-vault.sh

@@ -26,6 +26,8 @@ rm -f  "$VAULT/pi-vault-mind.config.json"
 rm -rf "$VAULT/.lancedb"
 rm -rf "$VAULT/collections"
 rm -f  "$VAULT/_sync_state.json"
+rm -rf "$VAULT/.vault-mind"
+rm -f  "$VAULT/.obsidian/plugins/vault-mind/data.json"
 
 # Update plugin to latest build (if in the pi-vault-mind repo)
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"