pi-vault-mind 0.7.0

package/dist/test/index.test.js

@@ -0,0 +1,368 @@
+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";
+describe("pi-vault-mind", () => {
+    let testDir;
+    beforeEach(() => {
+        testDir = path.join(tmpdir(), `pi-vault-mind-test-${randomUUID()}`);
+        fs.mkdirSync(testDir, { recursive: true });
+        const collectionsDir = path.join(testDir, "collections");
+        fs.mkdirSync(collectionsDir, { recursive: true });
+        process.env.HOME = testDir;
+        process.env.USERPROFILE = testDir;
+    });
+    afterEach(() => {
+        // Preserve original env, don't delete (shared with build)
+    });
+    it("package exports a default function", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const mod = await import("../index.js");
+            assert.equal(typeof mod.default, "function");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("registerTools is exported from tools module", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const mod = await import("../src/tools.js");
+            assert.ok(mod.registerTools, "registerTools should be exported");
+            assert.equal(typeof mod.registerTools, "function");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("registerCommands is exported from commands module", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const mod = await import("../src/commands.js");
+            assert.ok(mod.registerCommands, "registerCommands should be exported");
+            assert.equal(typeof mod.registerCommands, "function");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("config is written and read correctly", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const configPath = path.join(testDir, "pi-vault-mind.config.json");
+            const collectionsDir = path.join(testDir, "collections");
+            fs.mkdirSync(collectionsDir, { recursive: true });
+            fs.writeFileSync(path.join(collectionsDir, "main.jsonl"), '{"id":"1","domain":"test","fact":"hello world","tag":"test"}\n');
+            fs.writeFileSync(configPath, JSON.stringify({
+                version: 2,
+                collections: {
+                    main: {
+                        path: "collections/main.jsonl",
+                        schema: ["id", "domain", "fact", "tag"],
+                    },
+                },
+                injectors: [],
+                wiki: {
+                    dataDir: ".lancedb",
+                    embedding: {
+                        provider: "transformers",
+                        ollamaModel: "embeddinggemma",
+                        ollamaHost: "http://127.0.0.1:11434",
+                    },
+                    graph: { enabled: false, canvasSync: false },
+                    ftsEnabled: false,
+                },
+            }));
+            const mod = await import("../src/utils.js");
+            const cfg = mod.loadConfig(testDir);
+            assert.ok(cfg, "config should be loaded");
+            assert.equal(cfg.version, 2);
+            assert.ok(cfg.collections.main, "should have main collection");
+            assert.equal(cfg.wiki.embedding.provider, "transformers");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("types module has DEFAULT_CONFIG with correct shape", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const types = await import("../src/types.js");
+            assert.ok(types.DEFAULT_CONFIG, "DEFAULT_CONFIG should exist");
+            assert.equal(types.DEFAULT_CONFIG.version, 2);
+            assert.ok(types.DEFAULT_CONFIG.collections, "collections should exist");
+            assert.ok(types.DEFAULT_CONFIG.collections.main, "should have main collection");
+            assert.equal(types.DEFAULT_CONFIG.wiki.embedding.provider, "transformers");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("lance module exports all expected functions", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const lance = await import("../src/lance.js");
+            assert.equal(typeof lance.connect, "function", "connect should be exported");
+            assert.equal(typeof lance.upsertEntry, "function", "upsertEntry should be exported");
+            assert.equal(typeof lance.searchHybrid, "function", "searchHybrid should be exported");
+            assert.equal(typeof lance.getStatus, "function", "getStatus should be exported");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("graph module exports expected functions", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const graph = await import("../src/graph.js");
+            assert.equal(typeof graph.graphUpsert, "function", "graphUpsert should be exported");
+            assert.equal(typeof graph.queryGraph, "function", "queryGraph should be exported");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    // ── Watcher e2e tests ──────────────────────────────────────────────────
+    it("watcher module exports expected functions", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            assert.equal(typeof watcher.startWatcher, "function", "startWatcher should be exported");
+            assert.equal(typeof watcher.stopWatcher, "function", "stopWatcher should be exported");
+            assert.equal(typeof watcher.getWatcherStatus, "function", "getWatcherStatus should be exported");
+            assert.equal(typeof watcher.createWatcherState, "function", "createWatcherState should be exported");
+            assert.equal(typeof watcher.scanFile, "function", "scanFile should be exported");
+            assert.equal(typeof watcher.generateDispatchId, "function", "generateDispatchId should be exported");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("createWatcherState returns a valid state object", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const state = watcher.createWatcherState();
+            assert.equal(state.running, false);
+            assert.ok(state.watchers instanceof Map);
+            assert.ok(state.debounceTimers instanceof Map);
+            assert.ok(state.processing instanceof Set);
+            assert.ok(Array.isArray(state.pendingQueue));
+            assert.ok(state.activeDispatches_ instanceof Map);
+            assert.equal(state.maxConcurrent, 3);
+            assert.equal(state.activeDispatches, 0);
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("scanFile parses @agent markers correctly", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const testFilePath = path.join(testDir, "test-note.md");
+            fs.writeFileSync(testFilePath, [
+                "# Research Notes",
+                "",
+                "Some context before the marker.",
+                "",
+                "@agent-miner Extract all technical claims from this section",
+                "",
+                "RLHF uses PPO to fine-tune language models based on human preferences.",
+                "The reward model is trained on pairwise comparison data.",
+                "",
+                "@agent-broadcaster Generate a study guide from these notes",
+                "",
+                "More content after the markers.",
+            ].join("\n"));
+            const groups = watcher.scanFile(testFilePath);
+            assert.equal(groups.length, 2, "should detect 2 groups (miner + broadcaster)");
+            const minerGroup = groups.find((g) => g.role === "miner");
+            assert.ok(minerGroup, "should have a miner group");
+            assert.equal(minerGroup.markers.length, 1);
+            assert.ok(minerGroup.markers[0].instruction.includes("Extract all technical claims"));
+            assert.ok(minerGroup.dispatchId.startsWith("miner-"), "dispatch ID should start with role");
+            assert.ok(minerGroup.combinedInstruction.includes("File:"), "combined instruction should include file path");
+            const broadcasterGroup = groups.find((g) => g.role === "broadcaster");
+            assert.ok(broadcasterGroup, "should have a broadcaster group");
+            assert.equal(broadcasterGroup.markers.length, 1);
+            assert.ok(broadcasterGroup.markers[0].instruction.includes("Generate a study guide"));
+            fs.unlinkSync(testFilePath);
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("scanFile groups same-role markers together", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const testFilePath = path.join(testDir, "multi-miner.md");
+            fs.writeFileSync(testFilePath, [
+                "@agent-miner Extract entities from paragraph 1",
+                "",
+                "Paragraph 1 content.",
+                "",
+                "@agent-miner Extract entities from paragraph 2",
+                "",
+                "Paragraph 2 content.",
+            ].join("\n"));
+            const groups = watcher.scanFile(testFilePath);
+            assert.equal(groups.length, 1, "should bundle same-role markers into 1 group");
+            assert.equal(groups[0].markers.length, 2, "should have 2 markers in the group");
+            assert.equal(groups[0].role, "miner");
+            assert.ok(groups[0].combinedInstruction.includes("Multiple markers (2)"), "should note multiple markers");
+            fs.unlinkSync(testFilePath);
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("scanFile isolates named IDs into separate groups", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const testFilePath = path.join(testDir, "named-ids.md");
+            fs.writeFileSync(testFilePath, [
+                "@agent-miner:security Audit the auth flow",
+                "",
+                "Auth flow details.",
+                "",
+                "@agent-miner:performance Check database queries",
+                "",
+                "Query details.",
+            ].join("\n"));
+            const groups = watcher.scanFile(testFilePath);
+            assert.equal(groups.length, 2, "should create separate groups for named IDs");
+            assert.equal(groups[0].markers.length, 1);
+            assert.equal(groups[1].markers.length, 1);
+            assert.notEqual(groups[0].dispatchId, groups[1].dispatchId, "dispatch IDs should be unique");
+            const ids = groups.map((g) => g.taskId);
+            assert.ok(ids.includes("miner:security") || ids.includes("security"), "should include security taskId");
+            assert.ok(ids.includes("miner:performance") || ids.includes("performance"), "should include performance taskId");
+            fs.unlinkSync(testFilePath);
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("scanFile returns empty array for files without markers", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const testFilePath = path.join(testDir, "no-markers.md");
+            fs.writeFileSync(testFilePath, "# Just a regular note\n\nNo markers here.\n");
+            const groups = watcher.scanFile(testFilePath);
+            assert.equal(groups.length, 0, "should return empty array for marker-free files");
+            fs.unlinkSync(testFilePath);
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("scanFile handles non-existent files gracefully", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const groups = watcher.scanFile("/nonexistent/file.md");
+            assert.equal(groups.length, 0, "should return empty array for missing files");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("generateDispatchId creates unique IDs with role prefix", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const id1 = watcher.generateDispatchId("miner");
+            assert.ok(id1.startsWith("miner-"), "should start with role prefix");
+            assert.ok(id1.length > 10, "should be reasonably long");
+            const id2 = watcher.generateDispatchId("miner");
+            assert.notEqual(id1, id2, "consecutive IDs should be unique");
+            const broadcaster = watcher.generateDispatchId("broadcaster");
+            assert.ok(broadcaster.startsWith("broadcaster-"));
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("markProcessing replaces markers with dispatch comments", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const testFilePath = path.join(testDir, "writeback-test.md");
+            const originalContent = [
+                "# Test Note",
+                "",
+                "@agent-miner Extract claims",
+                "",
+                "Some content.",
+                "",
+                "@agent-broadcaster Make podcast",
+                "",
+                "More content.",
+            ].join("\n");
+            fs.writeFileSync(testFilePath, originalContent);
+            const groups = watcher.scanFile(testFilePath);
+            assert.equal(groups.length, 2, "should detect 2 groups");
+            for (const group of groups) {
+                assert.ok(group.dispatchId, "each group should have a dispatchId");
+                assert.ok(group.dispatchId.match(/^(miner|broadcaster)-\d+-[a-z0-9]+$/), `dispatchId format: ${group.dispatchId}`);
+            }
+            // Verify the original file still has @agent markers (scanFile doesn't modify)
+            const content = fs.readFileSync(testFilePath, "utf-8");
+            assert.ok(content.includes("@agent-miner"), "scanFile should not modify the file");
+            assert.ok(content.includes("@agent-broadcaster"), "scanFile should not modify the file");
+            fs.unlinkSync(testFilePath);
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+    it("getWatcherStatus reports state correctly", async () => {
+        const cwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const watcher = await import("../src/watcher.js");
+            const state = watcher.createWatcherState();
+            let status = watcher.getWatcherStatus(state);
+            assert.ok(status.includes("STOPPED"), "should show STOPPED initially");
+            assert.ok(status.includes("0"), "should show zero active vaults");
+            // Add a dispatch record
+            state.activeDispatches_.set("test-1", {
+                dispatchId: "test-1",
+                filePath: "/vault/notes/research.md",
+                role: "miner",
+                agentName: "vault-mind-miner",
+                dispatchedAt: new Date().toISOString(),
+                markerCount: 2,
+            });
+            status = watcher.getWatcherStatus(state);
+            assert.ok(status.includes("test-1"), "should show dispatch record");
+            assert.ok(status.includes("vault-mind-miner"), "should show agent name");
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    });
+});

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "pi-vault-mind",
+  "version": "0.7.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",
+  "type": "module",
+  "files": [
+    "dist",
+    "skills",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi-skills",
+    "vault-mind",
+    "jsonl",
+    "lance",
+    "lancedb",
+    "search",
+    "knowledge-base",
+    "agent-tools",
+    "hitl",
+    "semantic-search",
+    "obsidian",
+    "obsidian-vault",
+    "subagent",
+    "subagents",
+    "passive",
+    "file-watcher",
+    "graph",
+    "knowledge-graph",
+    "notebooklm",
+    "pkm"
+  ],
+  "author": "Kyle Brodeur",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kylebrodeur/pi-vault-mind.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kylebrodeur/pi-vault-mind/issues"
+  },
+  "homepage": "https://github.com/kylebrodeur/pi-vault-mind#readme",
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "pi": {
+    "extensions": [
+      "./dist/index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "dependencies": {
+    "@lancedb/lancedb": "latest",
+    "@xenova/transformers": "latest",
+    "apache-arrow": "^21.1.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.75.0 <1.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@earendil-works/pi-coding-agent": "^0.79.0",
+    "@earendil-works/pi-tui": "^0.79.0",
+    "@types/node": "^20.0.0",
+    "husky": "^9.1.6",
+    "typebox": "^1.1.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "check": "biome check --write . && tsc --noEmit",
+    "build": "tsc && tsc -p tsconfig.test.json",
+    "dev": "tsc --watch",
+    "test": "node --test dist/test/index.test.js"
+  }
+}