pi-vault-mind 0.7.4 → 0.8.0

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

@@ -0,0 +1,204 @@
+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, getJob, listJobs, listPendingByRole, markBatchRunning, markJobFailed, markJobRunning, markerStillPresent, sweepCompletedJobs, } from "../src/agent-queue.js";
+const tmpDir = () => path.join(process.cwd(), ".tmp-agent-queue-test");
+const makeTestFile = (vaultPath, content) => {
+    const dir = path.join(vaultPath, "Agent");
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    const p = path.join(dir, "test.md");
+    fs.writeFileSync(p, content, "utf-8");
+    return p;
+};
+describe("agent-queue", () => {
+    let vaultPath;
+    beforeEach(() => {
+        vaultPath = tmpDir();
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+        fs.mkdirSync(vaultPath, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("creates a pending job and lists it", () => {
+        const job = createJob(vaultPath, {
+            id: "miner-123",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test task",
+            markerCount: 1,
+        });
+        assert.equal(job.status, "pending");
+        assert.equal(job.attempts, 0);
+        assert.deepEqual(listJobs(vaultPath), [job]);
+        assert.deepEqual(listJobs(vaultPath, "pending"), [job]);
+        assert.deepEqual(listJobs(vaultPath, "running"), []);
+    });
+    it("marks a job running and increments attempts", () => {
+        createJob(vaultPath, {
+            id: "miner-123",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test task",
+            markerCount: 1,
+        });
+        const running = markJobRunning(vaultPath, "miner-123") ?? assert.fail("expected job");
+        assert.equal(running.status, "running");
+        assert.equal(running.attempts, 1);
+        assert.ok(running.dispatchedAt);
+    });
+    it("marks a running job done when marker is gone", () => {
+        const filePath = makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 --> summary");
+        createJob(vaultPath, {
+            id: "miner-123",
+            vaultPath,
+            filePath,
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test task",
+            markerCount: 1,
+        });
+        markJobRunning(vaultPath, "miner-123");
+        fs.writeFileSync(filePath, "> summary", "utf-8");
+        const completed = sweepCompletedJobs(vaultPath);
+        assert.equal(completed.length, 1);
+        assert.equal(completed[0].status, "done");
+        assert.equal(getJob(vaultPath, "miner-123")?.status, "done");
+    });
+    it("marks a job failed with an error", () => {
+        createJob(vaultPath, {
+            id: "miner-123",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test task",
+            markerCount: 1,
+        });
+        markJobRunning(vaultPath, "miner-123");
+        const failed = markJobFailed(vaultPath, "miner-123", "timeout") ?? assert.fail("expected job");
+        assert.equal(failed.status, "failed");
+        assert.equal(failed.lastError, "timeout");
+        assert.ok(failed.completedAt);
+    });
+    it("retries a failed job by marking it running again", () => {
+        createJob(vaultPath, {
+            id: "miner-123",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test task",
+            markerCount: 1,
+        });
+        markJobRunning(vaultPath, "miner-123");
+        markJobFailed(vaultPath, "miner-123", "timeout");
+        const retried = markJobRunning(vaultPath, "miner-123") ?? assert.fail("expected job");
+        assert.equal(retried.status, "running");
+        assert.equal(retried.attempts, 2);
+        assert.equal(retried.lastError, undefined);
+    });
+    it("cancels a pending job", () => {
+        createJob(vaultPath, {
+            id: "miner-123",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test task",
+            markerCount: 1,
+        });
+        const cancelled = cancelJob(vaultPath, "miner-123") ?? assert.fail("expected job");
+        assert.equal(cancelled.status, "cancelled");
+        assert.equal(cancelJob(vaultPath, "miner-123"), undefined); // cannot cancel twice
+    });
+    it("markerStillPresent detects dispatch comment", () => {
+        const filePath = makeTestFile(vaultPath, "<!-- pi-dispatch:miner-123 --> summary");
+        assert.equal(markerStillPresent(filePath, "miner-123"), true);
+        fs.writeFileSync(filePath, "> summary", "utf-8");
+        assert.equal(markerStillPresent(filePath, "miner-123"), false);
+    });
+});
+describe("agent-queue batching helpers", () => {
+    let vaultPath;
+    beforeEach(() => {
+        vaultPath = path.join(process.cwd(), ".tmp-agent-queue-batch-test");
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+        fs.mkdirSync(vaultPath, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("listPendingByRole groups pending jobs by vault+role+agent", () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:m1 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        createJob(vaultPath, {
+            id: "m2",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:m2 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "b",
+            markerCount: 1,
+        });
+        createJob(vaultPath, {
+            id: "b1",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:b1 -->"),
+            role: "broadcaster",
+            agentName: "vault-mind-broadcaster",
+            instruction: "c",
+            markerCount: 1,
+        });
+        const groups = listPendingByRole(vaultPath);
+        assert.equal(Object.keys(groups).length, 2);
+        const minerJobs = groups[`${vaultPath}\u0000miner\u0000vault-mind-miner`];
+        assert.equal(minerJobs.length, 2);
+        const bcasterJobs = groups[`${vaultPath}\u0000broadcaster\u0000vault-mind-broadcaster`];
+        assert.equal(bcasterJobs.length, 1);
+    });
+    it("markBatchRunning sets status running and shared batchId", () => {
+        createJob(vaultPath, {
+            id: "m1",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:m1 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "a",
+            markerCount: 1,
+        });
+        createJob(vaultPath, {
+            id: "m2",
+            vaultPath,
+            filePath: makeTestFile(vaultPath, "<!-- pi-dispatch:m2 -->"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "b",
+            markerCount: 1,
+        });
+        markBatchRunning(vaultPath, ["m1", "m2"], "batch-abc");
+        assert.equal(getJob(vaultPath, "m1")?.status, "running");
+        assert.equal(getJob(vaultPath, "m2")?.status, "running");
+        assert.equal(getJob(vaultPath, "m1")?.batchId, "batch-abc");
+        assert.equal(getJob(vaultPath, "m2")?.batchId, "batch-abc");
+        assert.equal(getJob(vaultPath, "m1")?.attempts, 1);
+        assert.equal(getJob(vaultPath, "m2")?.attempts, 1);
+    });
+});

package/dist/test/auth.test.js

@@ -0,0 +1,136 @@
+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 { _resetAuthCache, authoriseRequest, resolveAuthToken } from "../src/auth.js";
+const envVar = "PVM_API_TOKEN";
+const noop = () => { };
+const cleanupEnv = () => {
+    delete process.env[envVar];
+    _resetAuthCache();
+};
+const tmpVault = () => {
+    const p = path.join(process.cwd(), `.tmp-auth-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    if (fs.existsSync(p))
+        fs.rmSync(p, { recursive: true });
+    fs.mkdirSync(p, { recursive: true });
+    return p;
+};
+describe("auth (server-side bearer token)", () => {
+    let savedEnv;
+    let homeSnapshot;
+    let fakeHome = null;
+    beforeEach(() => {
+        savedEnv = process.env[envVar];
+        homeSnapshot = process.env.HOME;
+        cleanupEnv();
+        fakeHome = tmpVault();
+        process.env.HOME = fakeHome;
+    });
+    afterEach(() => {
+        if (savedEnv === undefined)
+            delete process.env[envVar];
+        else
+            process.env[envVar] = savedEnv;
+        if (homeSnapshot === undefined)
+            process.env.HOME = undefined;
+        else
+            process.env.HOME = homeSnapshot;
+        if (fakeHome)
+            fs.rmSync(fakeHome, { recursive: true });
+        _resetAuthCache();
+    });
+    it("env var wins over dotenv and config", () => {
+        process.env[envVar] = "env-token";
+        fs.mkdirSync(path.join(fakeHome, ".pi", "agent"), { recursive: true });
+        fs.writeFileSync(path.join(fakeHome, ".pi", "agent", "vault-mind.env"), 'PVM_API_TOKEN="dotenv-token"\n', "utf-8");
+        const cfg = {
+            version: 2,
+            collections: {},
+            injectors: [],
+            wiki: {
+                dataDir: ".lancedb",
+                embedding: { provider: "modal", modal: { apiToken: "cfg-token" } },
+            },
+        };
+        assert.equal(resolveAuthToken(cfg), "env-token");
+    });
+    it("dotenv wins over config when env is unset", () => {
+        fs.mkdirSync(path.join(fakeHome, ".pi", "agent"), { recursive: true });
+        fs.writeFileSync(path.join(fakeHome, ".pi", "agent", "vault-mind.env"), 'PVM_API_TOKEN="dotenv-token"\n', "utf-8");
+        const cfg = {
+            version: 2,
+            collections: {},
+            injectors: [],
+            wiki: {
+                dataDir: ".lancedb",
+                embedding: { provider: "modal", modal: { apiToken: "cfg-token" } },
+            },
+        };
+        assert.equal(resolveAuthToken(cfg), "dotenv-token");
+    });
+    it("config wins when env and dotenv are unset", () => {
+        const cfg = {
+            version: 2,
+            collections: {},
+            injectors: [],
+            wiki: {
+                dataDir: ".lancedb",
+                embedding: { provider: "modal", modal: { apiToken: "cfg-token" } },
+            },
+        };
+        assert.equal(resolveAuthToken(cfg), "cfg-token");
+    });
+    it("returns null when nothing is configured (auth off)", () => {
+        assert.equal(resolveAuthToken(), null);
+    });
+    it("dotenv parsing handles comments, blank lines, and quotes", () => {
+        fs.mkdirSync(path.join(fakeHome, ".pi", "agent"), { recursive: true });
+        fs.writeFileSync(path.join(fakeHome, ".pi", "agent", "vault-mind.env"), '# a comment\n\nOTHER_VAR=foo\nPVM_API_TOKEN="quoted token"\nPVM_API_TOKEN=unquoted\n', "utf-8");
+        assert.equal(resolveAuthToken(), "quoted token");
+    });
+    it("authoriseRequest returns ok when no token is configured", () => {
+        const result = authoriseRequest({ headers: {} });
+        assert.equal(result.ok, true);
+    });
+    it("authoriseRequest rejects requests with no Authorization header", () => {
+        process.env[envVar] = "secret";
+        const result = authoriseRequest({ headers: {} });
+        assert.equal(result.ok, false);
+        assert.equal(result.reason, "missing");
+    });
+    it("authoriseRequest rejects malformed Authorization header", () => {
+        process.env[envVar] = "secret";
+        const result = authoriseRequest({ headers: { authorization: "Token secret" } });
+        assert.equal(result.ok, false);
+        assert.equal(result.reason, "malformed");
+    });
+    it("authoriseRequest rejects mismatched token", () => {
+        process.env[envVar] = "secret";
+        const result = authoriseRequest({ headers: { authorization: "Bearer wrong" } });
+        assert.equal(result.ok, false);
+        assert.equal(result.reason, "mismatch");
+    });
+    it("authoriseRequest accepts the correct bearer token", () => {
+        process.env[envVar] = "secret";
+        const result = authoriseRequest({ headers: { authorization: "Bearer secret" } });
+        assert.equal(result.ok, true);
+    });
+    it("uses os.homedir() and does not consult process.cwd()", () => {
+        // Set a token in the fake home; switch cwd somewhere else; expect the token.
+        fs.mkdirSync(path.join(fakeHome, ".pi", "agent"), { recursive: true });
+        fs.writeFileSync(path.join(fakeHome, ".pi", "agent", "vault-mind.env"), 'PVM_API_TOKEN="home-token"\n', "utf-8");
+        const cwd = process.cwd();
+        const other = tmpVault();
+        try {
+            process.chdir(other);
+            assert.equal(resolveAuthToken(), "home-token");
+        }
+        finally {
+            process.chdir(cwd);
+            fs.rmSync(other, { recursive: true });
+        }
+    });
+    // silence unused-var
+    noop();
+});

package/dist/test/auto-indexer.test.js

@@ -0,0 +1,2 @@
+import { strict as assert } from "node:assert";
+assert.equal(1, 1);

package/dist/test/dedup.test.js

@@ -0,0 +1,62 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { isDuplicateResult, jaccardSimilarity } from "../src/tools.js";
+describe("jaccardSimilarity", () => {
+    it("returns 1 for identical strings", () => {
+        assert.equal(jaccardSimilarity("hello world", "hello world"), 1);
+    });
+    it("returns 0 when one input is empty", () => {
+        assert.equal(jaccardSimilarity("hello", ""), 0);
+        assert.equal(jaccardSimilarity("", "hello"), 0);
+    });
+    it("is case-insensitive", () => {
+        assert.equal(jaccardSimilarity("Hello World", "hello world"), 1);
+    });
+    it("returns a high score for near-duplicates", () => {
+        const score = jaccardSimilarity("hello world", "hello worlds");
+        assert.ok(score >= 0.85, `expected >= 0.85, got ${score}`);
+    });
+    it("returns a low score for unrelated strings", () => {
+        const score = jaccardSimilarity("hello world", "goodbye moon");
+        assert.ok(score < 0.5, `expected < 0.5, got ${score}`);
+    });
+});
+describe("isDuplicateResult", () => {
+    it("detects exact duplicates", () => {
+        const result = isDuplicateResult([{ fact: "alpha" }], "fact", "alpha", "exact", 0.85);
+        assert.equal(result.duplicate, true);
+        assert.equal(result.matchedValue, "alpha");
+    });
+    it("misses different values in exact mode", () => {
+        const result = isDuplicateResult([{ fact: "alpha" }], "fact", "beta", "exact", 0.85);
+        assert.equal(result.duplicate, false);
+    });
+    it("does not duplicate when incoming value is empty", () => {
+        const result = isDuplicateResult([{ fact: "alpha" }], "fact", "", "exact", 0.85);
+        assert.equal(result.duplicate, false);
+    });
+    it("skips non-string candidate fields", () => {
+        const result = isDuplicateResult([{ fact: 123 }], "fact", "123", "exact", 0.85);
+        assert.equal(result.duplicate, false);
+    });
+    it("detects fuzzy near-duplicates above threshold", () => {
+        const result = isDuplicateResult([{ fact: "hello world" }], "fact", "hello worlds", "fuzzy", 0.85);
+        assert.equal(result.duplicate, true);
+        assert.equal(result.matchedValue, "hello world");
+        assert.ok(result.similarity !== undefined && result.similarity >= 0.85);
+    });
+    it("rejects fuzzy candidates below threshold", () => {
+        const result = isDuplicateResult([{ fact: "hello world" }], "fact", "goodbye moon", "fuzzy", 0.85);
+        assert.equal(result.duplicate, false);
+    });
+    it("checks all results and returns first fuzzy match", () => {
+        const results = [{ fact: "foo bar" }, { fact: "hello world" }, { fact: "baz qux" }];
+        const result = isDuplicateResult(results, "fact", "hello worlds", "fuzzy", 0.85);
+        assert.equal(result.duplicate, true);
+        assert.equal(result.matchedValue, "hello world");
+    });
+    it("honors custom threshold", () => {
+        const result = isDuplicateResult([{ fact: "hello world" }], "fact", "hello there", "fuzzy", 0.99);
+        assert.equal(result.duplicate, false);
+    });
+});

package/dist/test/discover-schema.test.js

@@ -0,0 +1,201 @@
+import { strict as assert } from "node:assert";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { discoverSchemaFromFile, handleDiscoverSchema, inferType, registerDiscoverSchemaTool, runDiscoverSchema, writeCollectionToConfig, } from "../src/discover-schema.js";
+describe("discover-schema", () => {
+    let testDir;
+    let mockCtx;
+    beforeEach(() => {
+        testDir = path.join(tmpdir(), `discover-schema-test-${randomUUID()}`);
+        fs.mkdirSync(testDir, { recursive: true });
+        process.env.HOME = testDir;
+        process.env.USERPROFILE = testDir;
+        mockCtx = {
+            cwd: testDir,
+            hasUI: true,
+            ui: {
+                messages: [],
+                notify(text, type) {
+                    this.messages.push({ text, type });
+                },
+            },
+        };
+    });
+    afterEach(() => {
+        // cleanup best-effort; HOME is already redirected
+        try {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    });
+    it("inferType maps JSON values to scalar types", () => {
+        assert.equal(inferType("hello"), "string");
+        assert.equal(inferType(42), "number");
+        assert.equal(inferType(true), "boolean");
+        assert.equal(inferType([1, 2]), "array");
+        assert.equal(inferType({ a: 1 }), "object");
+        assert.equal(inferType(null), null);
+        assert.equal(inferType(undefined), null);
+        assert.equal(inferType(Number.NaN), null);
+        assert.equal(inferType(Number.POSITIVE_INFINITY), null);
+    });
+    it("discovers schema from a simple jsonl file", () => {
+        const filePath = path.join(testDir, "events.jsonl");
+        fs.writeFileSync(filePath, [
+            JSON.stringify({ id: "1", domain: "auth", fact: "login works", tag: "test", count: 3 }),
+            JSON.stringify({ id: "2", domain: "auth", fact: "logout works", tag: "test", count: 7 }),
+        ].join("\n"));
+        const result = discoverSchemaFromFile(filePath, 100);
+        assert.deepStrictEqual(result.schema.sort(), ["count", "domain", "fact", "id", "tag"]);
+        assert.equal(result.types.id, "string");
+        assert.equal(result.types.domain, "string");
+        assert.equal(result.types.fact, "string");
+        assert.equal(result.types.tag, "string");
+        assert.equal(result.types.count, "number");
+        assert.equal(result.rowCount, 2);
+        assert.equal(result.sampled, 2);
+    });
+    it("discovers arrays and objects", () => {
+        const filePath = path.join(testDir, "nested.jsonl");
+        fs.writeFileSync(filePath, [
+            JSON.stringify({ id: "1", tags: ["a", "b"], meta: { source: "web" } }),
+            JSON.stringify({ id: "2", tags: ["c"], meta: { source: "api" } }),
+        ].join("\n"));
+        const result = discoverSchemaFromFile(filePath, 100);
+        assert.ok(result.schema.includes("id"));
+        assert.ok(result.schema.includes("tags"));
+        assert.ok(result.schema.includes("meta"));
+        assert.equal(result.types.tags, "array");
+        assert.equal(result.types.meta, "object");
+    });
+    it("reports mixed when a field has multiple JSON types", () => {
+        const filePath = path.join(testDir, "mixed.jsonl");
+        fs.writeFileSync(filePath, [JSON.stringify({ id: "1", value: "text" }), JSON.stringify({ id: "2", value: 123 })].join("\n"));
+        const result = discoverSchemaFromFile(filePath, 100);
+        assert.equal(result.types.value, "mixed");
+    });
+    it("ignores malformed lines while sampling", () => {
+        const filePath = path.join(testDir, "noisy.jsonl");
+        fs.writeFileSync(filePath, [
+            JSON.stringify({ id: "1", fact: "ok" }),
+            "not json",
+            JSON.stringify({ id: "2", fact: "also ok" }),
+            "",
+        ].join("\n"));
+        const result = discoverSchemaFromFile(filePath, 100);
+        assert.equal(result.rowCount, 3); // non-empty lines: 2 valid JSON + 1 malformed
+        assert.deepStrictEqual(result.schema.sort(), ["fact", "id"]);
+    });
+    it("samples only the first N rows", () => {
+        const filePath = path.join(testDir, "large.jsonl");
+        const lines = [];
+        for (let i = 0; i < 200; i++) {
+            lines.push(JSON.stringify({ id: String(i), fact: `fact ${i}` }));
+        }
+        fs.writeFileSync(filePath, lines.join("\n"));
+        const result = discoverSchemaFromFile(filePath, 10);
+        assert.equal(result.sampled, 10);
+        assert.equal(result.rowCount, 200);
+    });
+    it("writes a discovered collection to the project config", () => {
+        const collectionsDir = path.join(testDir, "collections");
+        fs.mkdirSync(collectionsDir, { recursive: true });
+        const filePath = path.join(collectionsDir, "events.jsonl");
+        fs.writeFileSync(filePath, [
+            JSON.stringify({ id: "1", domain: "auth", fact: "login" }),
+            JSON.stringify({ id: "2", domain: "auth", fact: "logout" }),
+        ].join("\n"));
+        const result = runDiscoverSchema(testDir, filePath);
+        assert.equal(result.collectionName, "events");
+        assert.equal(result.path, path.join("collections", "events.jsonl"));
+        assert.deepStrictEqual(result.schema.sort(), ["domain", "fact", "id"]);
+        const cfgPath = path.join(testDir, "pi-vault-mind.config.json");
+        assert.ok(fs.existsSync(cfgPath), "config file should be created");
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+        assert.ok(cfg.collections.events, "events collection should exist");
+        assert.equal(cfg.collections.events.path, path.join("collections", "events.jsonl"));
+        assert.deepStrictEqual(cfg.collections.events.schema.sort(), ["domain", "fact", "id"]);
+    });
+    it("uses an explicit collection name when provided", () => {
+        const filePath = path.join(testDir, "events.jsonl");
+        fs.writeFileSync(filePath, JSON.stringify({ id: "1", fact: "x" }));
+        const result = runDiscoverSchema(testDir, filePath, "my_events");
+        assert.equal(result.collectionName, "my_events");
+        const cfgPath = path.join(testDir, "pi-vault-mind.config.json");
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+        assert.ok(cfg.collections.my_events);
+        assert.equal(cfg.collections.my_events.path, "events.jsonl");
+    });
+    it("merges with existing project config without overwriting unrelated keys", () => {
+        const cfgPath = path.join(testDir, "pi-vault-mind.config.json");
+        fs.writeFileSync(cfgPath, JSON.stringify({
+            version: 2,
+            wiki: { dataDir: ".lancedb" },
+            collections: {
+                main: { path: "collections/main.jsonl", schema: ["id", "fact"] },
+            },
+        }));
+        const filePath = path.join(testDir, "new.jsonl");
+        fs.writeFileSync(filePath, JSON.stringify({ id: "1", extra: "data" }));
+        runDiscoverSchema(testDir, filePath, "new");
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+        assert.equal(cfg.version, 2);
+        assert.equal(cfg.wiki.dataDir, ".lancedb");
+        assert.ok(cfg.collections.main);
+        assert.ok(cfg.collections.new);
+    });
+    it("writeCollectionToConfig preserves dedup options", () => {
+        const cfgPath = path.join(testDir, "pi-vault-mind.config.json");
+        fs.writeFileSync(cfgPath, JSON.stringify({ version: 2 }));
+        writeCollectionToConfig(testDir, "main", {
+            path: "collections/main.jsonl",
+            schema: ["id", "fact"],
+            dedupField: "fact",
+            dedupMode: "fuzzy",
+            dedupThreshold: 0.9,
+        });
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+        assert.equal(cfg.collections.main.dedupField, "fact");
+        assert.equal(cfg.collections.main.dedupMode, "fuzzy");
+        assert.equal(cfg.collections.main.dedupThreshold, 0.9);
+    });
+    it("registerDiscoverSchemaTool registers a tool with the expected name", () => {
+        const registered = [];
+        const mockPi = {
+            registerTool: (tool) => {
+                registered.push(tool);
+            },
+        };
+        registerDiscoverSchemaTool(mockPi);
+        assert.equal(registered.length, 1);
+        assert.equal(registered[0].name, "discover_schema");
+        assert.equal(registered[0].label, "Discover JSONL Schema");
+    });
+    it("handleDiscoverSchema registers a collection via slash command", () => {
+        const filePath = path.join(testDir, "cmd.jsonl");
+        fs.writeFileSync(filePath, JSON.stringify({ id: "1", value: 42 }));
+        void handleDiscoverSchema(filePath, mockCtx);
+        assert.equal(mockCtx.ui.messages.length, 1);
+        assert.equal(mockCtx.ui.messages[0].type, "info");
+        assert.ok(mockCtx.ui.messages[0].text.includes("cmd"));
+        const cfg = JSON.parse(fs.readFileSync(path.join(testDir, "pi-vault-mind.config.json"), "utf-8"));
+        assert.ok(cfg.collections.cmd);
+    });
+    it("handleDiscoverSchema reports usage errors", () => {
+        void handleDiscoverSchema("", mockCtx);
+        assert.equal(mockCtx.ui.messages.length, 1);
+        assert.equal(mockCtx.ui.messages[0].type, "error");
+        assert.ok(mockCtx.ui.messages[0].text.includes("Usage"));
+    });
+    it("handleDiscoverSchema reports file errors", () => {
+        void handleDiscoverSchema("missing.jsonl", mockCtx);
+        assert.equal(mockCtx.ui.messages.length, 1);
+        assert.equal(mockCtx.ui.messages[0].type, "error");
+        assert.ok(mockCtx.ui.messages[0].text.includes("File not found"));
+    });
+});

package/dist/test/modal-config.test.js

@@ -8,14 +8,29 @@ const wiki = (over = {}) => ({
 });
 describe("modal-config", () => {
     let origToken;
-    beforeEach(() => {
+    let dotenvExisted = false;
+    let dotenvBak = "";
+    beforeEach(async () => {
         origToken = process.env[MODAL_TOKEN_ENV];
+        // Also guard against the dotenv file (~/.pi/agent/vault-mind.env)
+        // which resolveModalToken reads as a fallback.
+        const fs = await import("node:fs");
+        if (fs.existsSync(MODAL_TOKEN_ENV_PATH)) {
+            dotenvExisted = true;
+            dotenvBak = `${MODAL_TOKEN_ENV_PATH}.bak`;
+            fs.renameSync(MODAL_TOKEN_ENV_PATH, dotenvBak);
+        }
     });
-    afterEach(() => {
+    afterEach(async () => {
         if (origToken === undefined)
             delete process.env[MODAL_TOKEN_ENV];
         else
             process.env[MODAL_TOKEN_ENV] = origToken;
+        if (dotenvExisted) {
+            const fs = await import("node:fs");
+            fs.renameSync(dotenvBak, MODAL_TOKEN_ENV_PATH);
+            dotenvExisted = false;
+        }
     });
     it("resolveModalToken: env wins over config apiToken", () => {
         process.env[MODAL_TOKEN_ENV] = "env-token";