pi-vault-mind 0.7.4 → 0.8.0

package/dist/test/queue-events.test.js

@@ -0,0 +1,146 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { cancelJob, createJob, listJobs, markJobDone, markJobFailed, markJobRunning, subscribeQueue, } from "../src/agent-queue.js";
+const tmpDir = () => path.join(process.cwd(), ".tmp-queue-events-test");
+const makeVault = () => {
+    const vaultPath = tmpDir();
+    if (fs.existsSync(vaultPath))
+        fs.rmSync(vaultPath, { recursive: true });
+    fs.mkdirSync(vaultPath, { recursive: true });
+    return vaultPath;
+};
+const seed = (vaultPath, id) => createJob(vaultPath, {
+    id,
+    vaultPath,
+    filePath: path.join(vaultPath, "test.md"),
+    role: "miner",
+    agentName: "vault-mind-miner",
+    instruction: "test",
+    markerCount: 1,
+});
+describe("agent-queue event emitter", () => {
+    let vaultPath;
+    beforeEach(() => {
+        vaultPath = makeVault();
+    });
+    afterEach(() => {
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("emits job-created when a job is created", () => {
+        const events = [];
+        const off = subscribeQueue((e) => events.push(e));
+        try {
+            const job = seed(vaultPath, "m1");
+            assert.equal(events.length, 1);
+            assert.equal(events[0].type, "job-created");
+            assert.equal(events[0].job.id, "m1");
+            assert.equal(events[0].job.status, "pending");
+            assert.equal(job.status, "pending");
+        }
+        finally {
+            off();
+        }
+    });
+    it("emits job-updated when markJobRunning is called", () => {
+        seed(vaultPath, "m1");
+        const events = [];
+        const off = subscribeQueue((e) => events.push(e));
+        try {
+            markJobRunning(vaultPath, "m1");
+            assert.equal(events.length, 1);
+            assert.equal(events[0].type, "job-updated");
+            assert.equal(events[0].job.status, "running");
+        }
+        finally {
+            off();
+        }
+    });
+    it("emits job-completed when markJobDone is called", () => {
+        seed(vaultPath, "m1");
+        markJobRunning(vaultPath, "m1");
+        const events = [];
+        const off = subscribeQueue((e) => events.push(e));
+        try {
+            markJobDone(vaultPath, "m1");
+            assert.equal(events.length, 1);
+            assert.equal(events[0].type, "job-completed");
+            assert.equal(events[0].job.status, "done");
+        }
+        finally {
+            off();
+        }
+    });
+    it("emits job-completed for failed and cancelled transitions", () => {
+        seed(vaultPath, "m1");
+        markJobRunning(vaultPath, "m1");
+        const events = [];
+        const off = subscribeQueue((e) => events.push(e));
+        try {
+            markJobFailed(vaultPath, "m1", "timeout");
+            cancelJob(vaultPath, "m2"); // does not exist; no event
+            const types = events.map((e) => e.type);
+            assert.deepEqual(types, ["job-completed"]);
+        }
+        finally {
+            off();
+        }
+    });
+    it("does not emit for cancel on non-pending jobs", () => {
+        seed(vaultPath, "m1");
+        markJobRunning(vaultPath, "m1");
+        const events = [];
+        const off = subscribeQueue((e) => events.push(e));
+        try {
+            const result = cancelJob(vaultPath, "m1");
+            assert.equal(result, undefined);
+            assert.equal(events.length, 0);
+        }
+        finally {
+            off();
+        }
+    });
+    it("supports multiple subscribers and unsubscribes correctly", () => {
+        const a = [];
+        const b = [];
+        const offA = subscribeQueue((e) => a.push(e));
+        const offB = subscribeQueue((e) => b.push(e));
+        seed(vaultPath, "m1");
+        assert.equal(a.length, 1);
+        assert.equal(b.length, 1);
+        offA();
+        seed(vaultPath, "m2");
+        assert.equal(a.length, 1);
+        assert.equal(b.length, 2);
+        offB();
+    });
+    it("a bad subscriber does not break the writer or other subscribers", () => {
+        const a = [];
+        subscribeQueue(() => {
+            throw new Error("bad listener");
+        });
+        const offA = subscribeQueue((e) => a.push(e));
+        try {
+            seed(vaultPath, "m1");
+            assert.equal(a.length, 1, "second subscriber still got the event");
+        }
+        finally {
+            offA();
+        }
+    });
+    it("events are not emitted for missing jobs", () => {
+        const events = [];
+        const off = subscribeQueue((e) => events.push(e));
+        try {
+            markJobRunning(vaultPath, "does-not-exist");
+            cancelJob(vaultPath, "does-not-exist");
+            assert.equal(events.length, 0);
+            assert.equal(listJobs(vaultPath).length, 0);
+        }
+        finally {
+            off();
+        }
+    });
+});

package/dist/test/rest-queue.test.js

@@ -0,0 +1,234 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { createJob, markJobFailed, markJobRunning } from "../src/agent-queue.js";
+import { createServerState, startServer, stopServer } from "../src/server.js";
+import { createWatcherState } from "../src/watcher.js";
+const envVar = "PVM_API_TOKEN";
+const tmpDir = () => path.join(process.cwd(), `.tmp-rest-queue-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+const makeVault = () => {
+    const p = tmpDir();
+    if (fs.existsSync(p))
+        fs.rmSync(p, { recursive: true });
+    fs.mkdirSync(p, { recursive: true });
+    return p;
+};
+const fetchJson = async (url, opts = {}) => {
+    const headers = { "Content-Type": "application/json" };
+    if (opts.token)
+        headers.authorization = `Bearer ${opts.token}`;
+    const resp = await fetch(url, {
+        method: opts.method ?? "GET",
+        headers,
+        body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+    });
+    const text = await resp.text();
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        body = text;
+    }
+    return { status: resp.status, body };
+};
+describe("REST queue routes", () => {
+    let vaultPath;
+    let serverState;
+    let watcherState;
+    let port;
+    let savedEnv;
+    let savedHome;
+    const fakePi = {
+        sendUserMessage: () => { },
+        events: { emit: () => { } },
+    };
+    beforeEach(async () => {
+        savedEnv = process.env[envVar];
+        savedHome = process.env.HOME;
+        vaultPath = makeVault();
+        process.env.HOME = vaultPath;
+        process.env[envVar] = "test-token";
+        // Write a minimal global config so defaultVaultPath() resolves
+        const agentDir = path.join(vaultPath, ".pi", "agent");
+        fs.mkdirSync(agentDir, { recursive: true });
+        fs.writeFileSync(path.join(agentDir, "vault-mind.config.json"), JSON.stringify({ wiki: { vaults: { default: { path: vaultPath } } } }), "utf-8");
+        watcherState = createWatcherState();
+        serverState = createServerState(0);
+        startServer(fakePi, serverState, watcherState);
+        // Wait for the server to be ready
+        await new Promise((resolve) => {
+            const check = () => {
+                const addr = serverState.server?.address();
+                if (addr?.port) {
+                    port = addr.port;
+                    resolve();
+                }
+                else
+                    setTimeout(check, 10);
+            };
+            check();
+        });
+    });
+    afterEach(() => {
+        stopServer(serverState);
+        if (savedEnv === undefined)
+            delete process.env[envVar];
+        else
+            process.env[envVar] = savedEnv;
+        if (savedHome === undefined)
+            process.env.HOME = undefined;
+        else
+            process.env.HOME = savedHome;
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("GET /agent/queue returns 401 without token", async () => {
+        const { status } = await fetchJson(`http://127.0.0.1:${port}/agent/queue`);
+        assert.equal(status, 401);
+    });
+    it("GET /agent/queue returns empty array when no jobs exist", async () => {
+        const { status, body } = await fetchJson(`http://127.0.0.1:${port}/agent/queue`, {
+            token: "test-token",
+        });
+        assert.equal(status, 200);
+        assert.deepEqual(body, []);
+    });
+    it("GET /agent/queue returns jobs filtered by status", async () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: path.join(vaultPath, "a.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        createJob(vaultPath, {
+            id: "m2",
+            vaultPath,
+            filePath: path.join(vaultPath, "b.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "b",
+            markerCount: 1,
+        });
+        markJobRunning(vaultPath, "m2");
+        const { status, body } = await fetchJson(`http://127.0.0.1:${port}/agent/queue?status=pending`, { token: "test-token" });
+        assert.equal(status, 200);
+        const jobs = body;
+        assert.equal(jobs.length, 1);
+        assert.equal(jobs[0].id, "m1");
+    });
+    it("GET /agent/jobs/:id returns 404 for missing job", async () => {
+        const { status } = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/nonexistent`, {
+            token: "test-token",
+        });
+        assert.equal(status, 404);
+    });
+    it("GET /agent/jobs/:id returns the job", async () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: path.join(vaultPath, "a.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        const { status, body } = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/m1`, {
+            token: "test-token",
+        });
+        assert.equal(status, 200);
+        assert.equal(body.id, "m1");
+    });
+    it("POST /agent/jobs/:id/retry succeeds on a failed job", async () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: path.join(vaultPath, "a.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        markJobRunning(vaultPath, "m1");
+        markJobFailed(vaultPath, "m1", "timeout");
+        const { status, body } = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/m1/retry`, {
+            method: "POST",
+            token: "test-token",
+        });
+        assert.equal(status, 200);
+        const job = body;
+        assert.equal(job.status, "running");
+        assert.equal(job.attempts, 2);
+    });
+    it("POST /agent/jobs/:id/retry returns 409 on a pending job", async () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: path.join(vaultPath, "a.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        const { status } = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/m1/retry`, {
+            method: "POST",
+            token: "test-token",
+        });
+        assert.equal(status, 409);
+    });
+    it("POST /agent/jobs/:id/cancel succeeds on a pending job", async () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: path.join(vaultPath, "a.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        const { status, body } = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/m1/cancel`, {
+            method: "POST",
+            token: "test-token",
+        });
+        assert.equal(status, 200);
+        assert.equal(body.status, "cancelled");
+    });
+    it("POST /agent/jobs/:id/cancel returns 409 on a running job", async () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: path.join(vaultPath, "a.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        markJobRunning(vaultPath, "m1");
+        const { status } = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/m1/cancel`, {
+            method: "POST",
+            token: "test-token",
+        });
+        assert.equal(status, 409);
+    });
+    it("all queue routes require auth", async () => {
+        const noToken = { token: undefined };
+        const r1 = await fetchJson(`http://127.0.0.1:${port}/agent/queue`, noToken);
+        const r2 = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/x`, noToken);
+        const r3 = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/x/retry`, {
+            ...noToken,
+            method: "POST",
+        });
+        const r4 = await fetchJson(`http://127.0.0.1:${port}/agent/jobs/x/cancel`, {
+            ...noToken,
+            method: "POST",
+        });
+        assert.equal(r1.status, 401);
+        assert.equal(r2.status, 401);
+        assert.equal(r3.status, 401);
+        assert.equal(r4.status, 401);
+    });
+});

package/dist/test/rest-setup.test.js

@@ -0,0 +1,213 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as http from "node:http";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { _resetAuthCache } from "../src/auth.js";
+import { createServerState, startServer, stopServer } from "../src/server.js";
+import { createWatcherState } from "../src/watcher.js";
+const envVar = "PVM_API_TOKEN";
+const tmpVault = () => {
+    const p = path.join(process.cwd(), `.tmp-rest-setup-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    if (fs.existsSync(p))
+        fs.rmSync(p, { recursive: true });
+    fs.mkdirSync(p, { recursive: true });
+    return p;
+};
+const fetchJson = (host, port, method, path, body, token) => {
+    return new Promise((resolve, reject) => {
+        const req = http.request({
+            hostname: host,
+            port,
+            path,
+            method,
+            headers: {
+                "Content-Type": "application/json",
+                ...(token ? { Authorization: `Bearer ${token}` } : {}),
+            },
+        }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 0, body: JSON.parse(data || "{}") });
+                }
+                catch {
+                    resolve({ status: res.statusCode ?? 0, body: data });
+                }
+            });
+        });
+        req.on("error", reject);
+        if (body !== undefined)
+            req.write(JSON.stringify(body));
+        req.end();
+    });
+};
+describe("REST setup routes", () => {
+    let vaultPath;
+    let serverState;
+    let watcherState;
+    let port;
+    let savedEnv;
+    let savedHome;
+    beforeEach(async () => {
+        savedEnv = process.env[envVar];
+        savedHome = process.env.HOME;
+        vaultPath = tmpVault();
+        process.env.HOME = vaultPath;
+        process.env[envVar] = "test-token";
+        _resetAuthCache();
+        watcherState = createWatcherState();
+        serverState = createServerState(0);
+        startServer({
+            sendUserMessage: () => { },
+            events: { emit: () => { } },
+            getAllTools: () => [],
+            registerCommand: () => { },
+            registerTool: () => { },
+        }, serverState, watcherState);
+        // Wait for the server to be listening, then read the actual port
+        await new Promise((resolve, reject) => {
+            const srv = serverState.server;
+            if (!srv)
+                return reject(new Error("server not created"));
+            if (srv.listening) {
+                const addr = srv.address();
+                port = typeof addr === "object" && addr ? addr.port : 0;
+                return resolve();
+            }
+            srv.once("listening", () => {
+                const addr = srv.address();
+                port = typeof addr === "object" && addr ? addr.port : 0;
+                resolve();
+            });
+            srv.once("error", reject);
+        });
+    });
+    afterEach(() => {
+        stopServer(serverState);
+        if (savedEnv === undefined)
+            delete process.env[envVar];
+        else
+            process.env[envVar] = savedEnv;
+        if (savedHome === undefined)
+            process.env.HOME = undefined;
+        else
+            process.env.HOME = savedHome;
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+        _resetAuthCache();
+    });
+    it("GET /wiki/status returns ok and configured flag", async () => {
+        const { status, body } = await fetchJson("127.0.0.1", port, "GET", "/wiki/status", undefined, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.ok, true);
+        assert.equal(typeof b.configured, "boolean");
+        assert.equal(typeof b.watcher, "boolean");
+        assert.equal(typeof b.provider, "string");
+        assert.equal(typeof b.version, "string");
+    });
+    it("GET /wiki/status returns 401 without token", async () => {
+        const { status } = await fetchJson("127.0.0.1", port, "GET", "/wiki/status");
+        assert.equal(status, 401);
+    });
+    it("POST /wiki/init scaffolds config and collections", async () => {
+        const { status, body } = await fetchJson("127.0.0.1", port, "POST", "/wiki/init", { vaultPath }, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.ok, true);
+        assert.equal(b.path, vaultPath);
+        assert.ok(fs.existsSync(path.join(vaultPath, "pi-vault-mind.config.json")));
+        assert.ok(fs.existsSync(path.join(vaultPath, "collections", "main.jsonl")));
+        assert.ok(fs.existsSync(path.join(vaultPath, ".gitignore")));
+    });
+    it("POST /wiki/init is idempotent", async () => {
+        await fetchJson("127.0.0.1", port, "POST", "/wiki/init", { vaultPath }, "test-token");
+        const { status, body } = await fetchJson("127.0.0.1", port, "POST", "/wiki/init", { vaultPath }, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.ok, true);
+    });
+    it("POST /wiki/init returns 401 without token", async () => {
+        const { status } = await fetchJson("127.0.0.1", port, "POST", "/wiki/init", { vaultPath });
+        assert.equal(status, 401);
+    });
+    it("POST /wiki/setup writes global config", async () => {
+        const { status, body } = await fetchJson("127.0.0.1", port, "POST", "/wiki/setup", { vault: vaultPath, provider: "ollama", model: "embeddinggemma" }, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.ok, true);
+        const globalPath = path.join(vaultPath, ".pi", "agent", "vault-mind.config.json");
+        assert.ok(fs.existsSync(globalPath));
+        const cfg = JSON.parse(fs.readFileSync(globalPath, "utf-8"));
+        assert.equal(cfg.wiki.embedding.provider, "ollama");
+        assert.equal(cfg.wiki.embedding.ollamaModel, "embeddinggemma");
+    });
+    it("POST /wiki/setup returns 401 without token", async () => {
+        const { status } = await fetchJson("127.0.0.1", port, "POST", "/wiki/setup", {
+            vault: vaultPath,
+            provider: "ollama",
+        });
+        assert.equal(status, 401);
+    });
+    it("POST /server/start returns ok when already running", async () => {
+        const { status, body } = await fetchJson("127.0.0.1", port, "POST", "/server/start", undefined, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.ok, true);
+        assert.equal(b.alreadyRunning, true);
+    });
+    it("GET /vault-mind/config returns config snapshot", async () => {
+        // First run init + setup so there is config to read
+        await fetchJson("127.0.0.1", port, "POST", "/wiki/init", { vaultPath }, "test-token");
+        await fetchJson("127.0.0.1", port, "POST", "/wiki/setup", { vault: vaultPath, provider: "ollama" }, "test-token");
+        const { status, body } = await fetchJson("127.0.0.1", port, "GET", "/vault-mind/config", undefined, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(typeof b.hasToken, "boolean");
+        assert.equal(typeof b.version, "string");
+        assert.ok(b.global !== null || b.project !== null);
+    });
+    it("GET /vault-mind/config returns 401 without token", async () => {
+        const { status } = await fetchJson("127.0.0.1", port, "GET", "/vault-mind/config");
+        assert.equal(status, 401);
+    });
+    it("POST /vault-mind/context stores editor context", async () => {
+        const { status, body } = await fetchJson("127.0.0.1", port, "POST", "/vault-mind/context", { filePath: "notes/foo.md", selection: "hello", cursor: 42 }, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.ok, true);
+        const ctx = b.context;
+        assert.equal(ctx.filePath, "notes/foo.md");
+        assert.equal(ctx.selection, "hello");
+        assert.equal(ctx.cursor, 42);
+    });
+    it("GET /vault-mind/context returns the latest editor context", async () => {
+        await fetchJson("127.0.0.1", port, "POST", "/vault-mind/context", { filePath: "notes/bar.md", selection: "world", cursor: 7 }, "test-token");
+        const { status, body } = await fetchJson("127.0.0.1", port, "GET", "/vault-mind/context", undefined, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.filePath, "notes/bar.md");
+        assert.equal(b.selection, "world");
+        assert.equal(b.cursor, 7);
+    });
+    it("GET /vault-mind/context returns nulls when no context has been pushed", async () => {
+        const { status, body } = await fetchJson("127.0.0.1", port, "GET", "/vault-mind/context", undefined, "test-token");
+        assert.equal(status, 200);
+        const b = body;
+        assert.equal(b.filePath, null);
+        assert.equal(b.selection, null);
+        assert.equal(b.cursor, null);
+    });
+    it("/vault-mind/context routes require auth", async () => {
+        const post = await fetchJson("127.0.0.1", port, "POST", "/vault-mind/context", {
+            filePath: "x.md",
+        });
+        assert.equal(post.status, 401);
+        const get = await fetchJson("127.0.0.1", port, "GET", "/vault-mind/context");
+        assert.equal(get.status, 401);
+    });
+});