pi-vault-mind 0.14.2 → 0.16.3

package/dist/test/settings-ui.test.js

@@ -3,9 +3,10 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
+import { registerCommands } from "../src/commands.js";
 import { modalUrl } from "../src/modal-config.js";
 import { buildPluginInstallGuidance, detectVaultFromCwd, getMissingOnboardingPlugins, setupWizard, } from "../src/settings-ui.js";
-import { getGlobalConfigPath } from "../src/utils.js";
+import { deriveCollectionNameFromVaultPath, getConfigPath } from "../src/utils.js";
 const savedHome = process.env.HOME;
 const mkTmpDir = (prefix) => fs.mkdtempSync(path.join(os.tmpdir(), prefix));
 const makeCtx = (cwd) => ({
@@ -24,6 +25,19 @@ afterEach(() => {
         process.env.HOME = savedHome;
     }
 });
+// registerCommands(pi) registers "vm" (and "intake"); capture the real handler so
+// tests exercise the actual /vm command dispatch (args tokenizer, handleSetup
+// ordering, etc.), not a hand-built cliArgs object that would bypass a bug entirely.
+const captureVmHandler = () => {
+    const handlers = [];
+    const pi = {
+        registerCommand: (name, spec) => {
+            handlers.push({ name, handler: spec.handler });
+        },
+        getAllTools: () => [],
+    };
+    return { pi, handlers };
+};
 describe("settings-ui vault detection", () => {
     it("detectVaultFromCwd returns cwd when .obsidian exists", () => {
         const vault = mkTmpDir("pvm-vault-detect-");
@@ -68,7 +82,7 @@ describe("setupWizard CLI defaults", () => {
             remoteUrl: "https://example.com/v1",
             model: "embeddinggemma",
         });
-        const cfg = JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"));
+        const cfg = JSON.parse(fs.readFileSync(getConfigPath(vault), "utf-8"));
         const stored = cfg.vaultMind?.vaults?.default?.path;
         assert.ok(stored, "default vault path should be written");
         assert.equal(expandMaybeHome(stored, home), vault);
@@ -84,9 +98,104 @@ describe("setupWizard CLI defaults", () => {
             workspace: "acme-workspace",
             model: "embeddinggemma",
         });
-        const cfg = JSON.parse(fs.readFileSync(getGlobalConfigPath(), "utf-8"));
-        assert.equal(cfg.vaultMind?.embedding?.modal?.workspace, "acme-workspace");
+        const cfg = JSON.parse(fs.readFileSync(getConfigPath(vault), "utf-8"));
+        assert.equal(cfg.vaultMind?.embedding?.workspace, "acme-workspace");
         assert.equal(cfg.vaultMind?.embedding?.remoteUrl, modalUrl("acme-workspace"));
         fs.rmSync(home, { recursive: true, force: true });
     });
 });
+describe("/vm setup CLI arg tokenizer (regression)", () => {
+    it("captures --vault as the leading flag in the CLI-mode args string", async () => {
+        // cwd is deliberately a plain, non-Obsidian directory and distinct from the
+        // --vault target: if detectVaultFromCwd(cwd) could return a fallback vault,
+        // a broken tokenizer that drops --vault would be masked by that fallback.
+        const home = mkTmpDir("pvm-home-");
+        const cwd = mkTmpDir("pvm-cwd-");
+        const vault = mkTmpDir("pvm-vault-");
+        fs.mkdirSync(path.join(vault, ".obsidian"), { recursive: true });
+        process.env.HOME = home;
+        const { pi, handlers } = captureVmHandler();
+        registerCommands(pi);
+        const vm = handlers.find((h) => h.name === "vm");
+        assert.ok(vm, "/vm command should be registered");
+        // Exact invocation documented in docs/getting-started/CLI_ONLY_WALKTHROUGH.md —
+        // --vault has no leading whitespace before its `--`, so a tokenizer that only
+        // strips `--` when preceded by whitespace drops it from cliArgs entirely.
+        await vm?.handler(`setup --vault ${vault} --remoteUrl https://example.com/v1 --model embeddinggemma`, makeCtx(cwd));
+        const cfg = JSON.parse(fs.readFileSync(getConfigPath(cwd), "utf-8"));
+        const stored = cfg.vaultMind?.vaults?.default?.path;
+        assert.ok(stored, "leading --vault flag should populate vaults.default.path");
+        assert.equal(expandMaybeHome(stored, home), vault);
+        assert.equal(cfg.vaultMind?.embedding?.remoteUrl, "https://example.com/v1");
+        assert.equal(cfg.vaultMind?.embedding?.model, "embeddinggemma");
+        fs.rmSync(home, { recursive: true, force: true });
+        fs.rmSync(cwd, { recursive: true, force: true });
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+    it("parses whichever flag comes first, not only --vault", async () => {
+        const home = mkTmpDir("pvm-home-");
+        const cwd = mkTmpDir("pvm-cwd-");
+        const vault = mkTmpDir("pvm-vault-");
+        fs.mkdirSync(path.join(vault, ".obsidian"), { recursive: true });
+        process.env.HOME = home;
+        const { pi, handlers } = captureVmHandler();
+        registerCommands(pi);
+        const vm = handlers.find((h) => h.name === "vm");
+        assert.ok(vm, "/vm command should be registered");
+        // --model leads here instead of --vault; the fix strips leading `--` from
+        // whichever flag is first, so this must not regress to a --vault-only fix.
+        await vm?.handler(`setup --model embeddinggemma --vault ${vault} --remoteUrl https://example.com/v1`, makeCtx(cwd));
+        const cfg = JSON.parse(fs.readFileSync(getConfigPath(cwd), "utf-8"));
+        assert.equal(cfg.vaultMind?.embedding?.model, "embeddinggemma");
+        assert.equal(expandMaybeHome(cfg.vaultMind?.vaults?.default?.path, home), vault);
+        fs.rmSync(home, { recursive: true, force: true });
+        fs.rmSync(cwd, { recursive: true, force: true });
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+});
+describe("/vm setup collection scaffolding (regression)", () => {
+    it("populates collections.main/pending/context_events + draft-context injector on a fresh vault", async () => {
+        const vault = mkTmpDir("pvm-setup-scaffold-");
+        const { pi, handlers } = captureVmHandler();
+        registerCommands(pi);
+        const vm = handlers.find((h) => h.name === "vm");
+        assert.ok(vm, "/vm command should be registered");
+        await vm?.handler(`setup --vault ${vault} --remoteUrl https://example.test --model embeddinggemma --collection customname`, makeCtx(vault));
+        const cfg = JSON.parse(fs.readFileSync(getConfigPath(vault), "utf-8"));
+        // This is exactly the regression handleSetup shipped with: setupWizard() used to
+        // run before handleInit(), and setupWizard always writes the config file first —
+        // so handleInit's "file doesn't exist yet" branch (which populates these defaults)
+        // never fired, and every /vm setup run ended with "collections": {}.
+        assert.ok(cfg.collections?.main, "collections.main should be scaffolded");
+        assert.ok(cfg.collections.main.path.endsWith(path.join("collections", "customname.jsonl")), `expected collections.main.path to end with collections/customname.jsonl, got ${cfg.collections.main.path}`);
+        assert.ok(cfg.collections?.pending, "collections.pending should be scaffolded");
+        assert.ok(cfg.collections?.context_events, "collections.context_events should be scaffolded");
+        assert.ok((cfg.injectors ?? []).some((ij) => ij.name === "draft-context"), "draft-context injector should be scaffolded");
+        for (const rel of [
+            path.join("collections", "customname.jsonl"),
+            path.join("collections", "pending.jsonl"),
+            path.join("collections", "context_events.jsonl"),
+            path.join("collections", "artifact.md"),
+        ]) {
+            assert.ok(fs.existsSync(path.join(vault, rel)), `${rel} should exist on disk`);
+        }
+        assert.equal(cfg.vaultMind?.embedding?.remoteUrl, "https://example.test");
+        assert.equal(cfg.vaultMind?.embedding?.model, "embeddinggemma");
+        assert.ok(cfg.vaultMind?.vaults?.default?.path, "vaults.default.path should be written");
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+    it("derives the default collection name from the vault directory when --collection is omitted", async () => {
+        const vault = mkTmpDir("pvm-setup-scaffold-noflag-");
+        const { pi, handlers } = captureVmHandler();
+        registerCommands(pi);
+        const vm = handlers.find((h) => h.name === "vm");
+        assert.ok(vm, "/vm command should be registered");
+        await vm?.handler(`setup --vault ${vault} --remoteUrl https://example.test --model embeddinggemma`, makeCtx(vault));
+        const cfg = JSON.parse(fs.readFileSync(getConfigPath(vault), "utf-8"));
+        const expectedCollection = deriveCollectionNameFromVaultPath(vault);
+        assert.ok(cfg.collections?.main, "collections.main should be scaffolded");
+        assert.ok(cfg.collections.main.path.endsWith(path.join("collections", `${expectedCollection}.jsonl`)));
+        assert.ok(fs.existsSync(path.join(vault, "collections", `${expectedCollection}.jsonl`)), "derived collection file should exist on disk");
+        fs.rmSync(vault, { recursive: true, force: true });
+    });
+});

package/dist/test/sync.test.js

@@ -23,8 +23,10 @@ const makeCfg = (dataDir) => ({
         dataDir,
         embedding: {
             remoteUrl: "https://pvm.modal.run",
-            modal: { baseUrl: "https://pvm.modal.run", model: MODEL, dim: DIM },
+            model: MODEL,
+            dim: DIM,
         },
+        vaults: { default: { path: dataDir, collectionPrefix: "test" } },
         ftsEnabled: true,
     },
 });
@@ -41,12 +43,10 @@ function exportPagesFetch(pages) {
             count: page.rows.length,
             done: page.done,
         };
-        return {
-            ok: true,
+        return new Response(JSON.stringify(body), {
             status: 200,
-            json: async () => body,
-            text: async () => "",
-        };
+            headers: { "Content-Type": "application/json" },
+        });
     });
 }
 const row = (id, seq, vector) => ({
@@ -94,10 +94,10 @@ describe("Modal sync engine", () => {
             0: { rows: [row("1", 100, [1, 0, 0]), row("2", 150, [0, 1, 0])], next: 150, done: false },
             150: { rows: [row("3", 200, [0, 0, 1])], next: 200, done: true },
         });
-        const res = await syncCollection(cfg, "main");
+        const res = await syncCollection(cfg, "main", dir);
         assert.equal(res.rows, 3);
         assert.equal(res.watermark, 200);
-        assert.equal(getWatermark(cfg, "main", MODEL, DIM), 200);
+        assert.equal(getWatermark(cfg, "test_main", MODEL, DIM), 200);
         const conn = await connect(dir);
         const table = await conn.openTable(`col_main__${MODEL}__${DIM}`);
         assert.equal(await table.countRows(), 3);
@@ -109,8 +109,8 @@ describe("Modal sync engine", () => {
             100: { rows: [row("2", 200, [0, 1, 0])], next: 200, done: true },
             200: { rows: [], next: 200, done: true },
         });
-        await syncCollection(cfg, "main");
-        const second = await syncCollection(cfg, "main"); // since=200 → empty, done
+        await syncCollection(cfg, "main", dir);
+        const second = await syncCollection(cfg, "main", dir); // since=200 → empty, done
         assert.equal(second.rows, 0);
         assert.equal(second.watermark, 200);
         const conn = await connect(dir);
@@ -123,8 +123,8 @@ describe("Modal sync engine", () => {
             0: { rows: [row("1", 100, [1, 0, 0])], next: 100, done: false },
             100: { rows: [row("1", 200, [1, 0, 0])], next: 200, done: true },
         });
-        await syncCollection(cfg, "main"); // inserts id=1
-        await syncCollection(cfg, "main", { full: true }); // re-fetches id=1 → merge by id
+        await syncCollection(cfg, "main", dir); // inserts id=1
+        await syncCollection(cfg, "main", dir, { full: true }); // re-fetches id=1 → merge by id
         const conn = await connect(dir);
         const table = await conn.openTable(`col_main__${MODEL}__${DIM}`);
         assert.equal(await table.countRows(), 1);

package/dist/test/tombstone.test.js

@@ -5,7 +5,9 @@ import { tmpdir } from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 const setupConfig = (dir) => {
-    fs.writeFileSync(path.join(dir, "pi-vault-mind.config.json"), JSON.stringify({
+    const configDir = path.join(dir, ".vault-mind");
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, "vault-mind.config.json"), JSON.stringify({
         version: 2,
         collections: {
             main: {
@@ -17,7 +19,7 @@ const setupConfig = (dir) => {
         injectors: [],
         vaultMind: {
             dataDir: ".lancedb",
-            embedding: { provider: "transformers" },
+            embedding: {},
             ftsEnabled: false,
             graph: { enabled: false },
         },
@@ -27,21 +29,17 @@ const setupConfig = (dir) => {
 describe("tombstone_entry", () => {
     let testDir;
     let collectionPath;
-    let savedHome;
+    let savedCwd;
     beforeEach(() => {
         testDir = path.join(tmpdir(), `pi-vault-mind-tombstone-test-${randomUUID()}`);
         fs.mkdirSync(testDir, { recursive: true });
         setupConfig(testDir);
         collectionPath = path.join(testDir, "collections", "main.jsonl");
-        savedHome = process.env.HOME;
-        process.env.HOME = testDir;
-        process.env.USERPROFILE = testDir;
+        savedCwd = process.cwd();
+        process.chdir(testDir);
     });
     afterEach(() => {
-        if (savedHome !== undefined)
-            process.env.HOME = savedHome;
-        else
-            process.env.HOME = undefined;
+        process.chdir(savedCwd);
         if (fs.existsSync(testDir))
             fs.rmSync(testDir, { recursive: true });
     });

package/dist/test/tool-catalog.test.js

@@ -0,0 +1,86 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { listAllTools, listBuiltinTools, listExtensionTools } from "../src/tool-catalog.js";
+import { registerTools } from "../src/tools.js";
+describe("listAllTools", () => {
+    it("returns 30 entries", () => {
+        const tools = listAllTools();
+        assert.equal(tools.length, 30);
+    });
+});
+describe("listBuiltinTools", () => {
+    it("returns 7 entries, all kind: builtin", () => {
+        const tools = listBuiltinTools();
+        assert.equal(tools.length, 7);
+        for (const t of tools) {
+            assert.equal(t.kind, "builtin", `tool ${t.name} has kind ${t.kind}, expected builtin`);
+        }
+    });
+});
+describe("listExtensionTools", () => {
+    it("returns 23 entries, all kind starts with vm_", () => {
+        const tools = listExtensionTools();
+        assert.equal(tools.length, 23);
+        for (const t of tools) {
+            assert.ok(t.kind.startsWith("vm_"), `tool ${t.name} has kind ${t.kind}, expected vm_*`);
+        }
+    });
+});
+describe("tool catalog integrity", () => {
+    it("has no duplicate names across all tools", () => {
+        const tools = listAllTools();
+        const names = tools.map((t) => t.name);
+        const unique = new Set(names);
+        assert.equal(unique.size, names.length, `duplicate names: ${names}`);
+    });
+    it("every entry has a non-empty name and description", () => {
+        const tools = listAllTools();
+        for (const t of tools) {
+            assert.ok(t.name.length > 0, "tool has empty name");
+            assert.ok(t.description.length > 0, `tool ${t.name} has empty description`);
+        }
+    });
+    it("listAllTools equals listBuiltinTools + listExtensionTools", () => {
+        const all = listAllTools();
+        const builtin = listBuiltinTools();
+        const ext = listExtensionTools();
+        assert.equal(all.length, builtin.length + ext.length);
+        const allNames = new Set(all.map((t) => t.name));
+        const combinedNames = new Set([...builtin.map((t) => t.name), ...ext.map((t) => t.name)]);
+        assert.deepStrictEqual(allNames, combinedNames);
+    });
+    it("vm_search has mode parameter schema", () => {
+        const ext = listExtensionTools();
+        const vmSearch = ext.find((t) => t.name === "vm_search");
+        assert.ok(vmSearch, "vm_search not found");
+        assert.ok(vmSearch?.params, "vm_search missing params schema");
+        const params = vmSearch?.params;
+        const properties = params.properties;
+        assert.deepStrictEqual(properties.mode, {
+            type: "string",
+            enum: ["auto", "hybrid", "semantic", "fts", "graph", "vault", "full"],
+            default: "hybrid",
+        });
+        assert.deepStrictEqual(params.required, ["query"]);
+    });
+});
+describe("tool catalog registry drift guard", () => {
+    it("extension tools in the catalog exactly match registerTools output", () => {
+        const captured = new Set();
+        const capturedList = [];
+        const mock = {
+            registerTool(tool) {
+                captured.add(tool.name);
+                capturedList.push({ name: tool.name });
+            },
+            getAllTools() {
+                return capturedList;
+            },
+        };
+        registerTools(mock);
+        const catalogExtension = new Set(listAllTools()
+            .filter((t) => t.kind !== "builtin")
+            .map((t) => t.name));
+        assert.deepStrictEqual(captured, catalogExtension, "catalog must equal the registered tool set");
+    });
+});