pi-vault-mind 0.14.2 → 0.16.3

package/dist/test/vault-tools.test.js

@@ -6,9 +6,11 @@ import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
 import { resetConnection, upsertPrecomputed } from "../src/lance.js";
 import { MODAL_TOKEN_ENV } from "../src/modal-config.js";
-import { registerVaultTools, vaultAppendTool, vaultListTool, vaultReadTool, vaultSearchTool, vaultTagsTool, vaultWriteTool, } from "../src/vault-tools.js";
+import { registerVaultTools, searchVaultNative, vaultAppendTool, vaultListTool, vaultReadTool, vaultSearchTool, vaultTagsTool, vaultWriteTool, } from "../src/vault-tools.js";
 const setupConfig = (dir, vaultPath) => {
-    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: {
@@ -22,7 +24,7 @@ const setupConfig = (dir, vaultPath) => {
             dataDir: ".lancedb",
             embedding: {
                 remoteUrl: "https://pvm.modal.run",
-                modal: { baseUrl: "https://pvm.modal.run", model: "testmodel" },
+                model: "testmodel",
             },
             ftsEnabled: true,
             graph: { enabled: false },
@@ -49,25 +51,21 @@ const makeMockPi = () => {
 describe("vault tools", () => {
     let testDir;
     let vaultPath;
-    let savedHome;
+    let savedCwd;
     let origToken;
     beforeEach(() => {
         testDir = path.join(tmpdir(), `pi-vault-mind-vault-tools-${randomUUID()}`);
         vaultPath = path.join(testDir, "vault");
         fs.mkdirSync(vaultPath, { recursive: true });
         setupConfig(testDir, vaultPath);
-        savedHome = process.env.HOME;
-        process.env.HOME = testDir;
-        process.env.USERPROFILE = testDir;
+        savedCwd = process.cwd();
+        process.chdir(testDir);
         origToken = process.env[MODAL_TOKEN_ENV];
         process.env[MODAL_TOKEN_ENV] = "tok";
         resetConnection();
     });
     afterEach(() => {
-        if (savedHome !== undefined)
-            process.env.HOME = savedHome;
-        else
-            process.env.HOME = undefined;
+        process.chdir(savedCwd);
         if (origToken === undefined)
             delete process.env[MODAL_TOKEN_ENV];
         else
@@ -161,7 +159,7 @@ describe("vault tools", () => {
                 dataDir: path.join(testDir, ".lancedb"),
                 embedding: {
                     remoteUrl: "https://pvm.modal.run",
-                    modal: { baseUrl: "https://pvm.modal.run", model: "testmodel" },
+                    model: "testmodel",
                 },
                 ftsEnabled: true,
                 graph: { enabled: false },
@@ -221,4 +219,97 @@ describe("vault tools", () => {
             assert.equal(pi.tools.length, 6);
         });
     });
+    describe("searchVaultNative", () => {
+        const writeNote = (rel, opts = {}) => {
+            const full = path.join(vaultPath, rel);
+            fs.mkdirSync(path.dirname(full), { recursive: true });
+            const lines = [];
+            if (opts.title !== undefined || opts.tags !== undefined) {
+                lines.push("---");
+                if (opts.title !== undefined)
+                    lines.push(`title: ${opts.title}`);
+                if (opts.tags !== undefined)
+                    lines.push(`tags: [${opts.tags.join(", ")}]`);
+                lines.push("---");
+            }
+            if (opts.body !== undefined)
+                lines.push(opts.body);
+            fs.writeFileSync(full, lines.join("\n"));
+        };
+        it("ranks exact title > title substring > path-only and drops zero-score files", async () => {
+            writeNote("alpha.md", { title: "Widget" }); // exact title +10
+            writeNote("bravo.md", { title: "Widget Toolkit" }); // title substring +5
+            writeNote("widget/charlie.md", { title: "Notes" }); // path-only via subdir +2
+            writeNote("unrelated.md", { title: "Something Else" }); // score 0 -> excluded
+            const hits = await searchVaultNative(vaultPath, "widget", 10);
+            assert.deepEqual(hits.map((h) => h.source), ["alpha.md", "bravo.md", "widget/charlie.md"]);
+        });
+        it("uses frontmatter title over basename for scoring and the title field", async () => {
+            writeNote("random-file-name.md", { title: "Kubernetes" }); // fm title exact +10
+            writeNote("kubernetes.md", { title: "Networking" }); // fm masks basename; only path +2
+            const hits = await searchVaultNative(vaultPath, "kubernetes", 10);
+            assert.deepEqual(hits.map((h) => h.source), ["random-file-name.md", "kubernetes.md"]);
+            assert.equal(hits[0].title, "Kubernetes");
+            assert.equal(hits.find((h) => h.source === "kubernetes.md")?.title, "Networking");
+        });
+        it("scores a file whose tag equals the query with no title or path match", async () => {
+            writeNote("journal.md", { title: "Journal", tags: ["devops", "misc"] }); // frontmatter tag
+            writeNote("notes.md", { body: "See #devops for the pipeline" }); // inline tag
+            writeNote("misc.md", { title: "Misc", body: "nothing relevant here" }); // no match
+            const hits = await searchVaultNative(vaultPath, "devops", 10);
+            assert.deepEqual(hits.map((h) => h.source), ["journal.md", "notes.md"]);
+            for (const hit of hits)
+                assert.ok(hit.tags.includes("devops"));
+        });
+        it("includes and boosts files carrying tags-param tags, tolerating a leading #", async () => {
+            writeNote("a.md", { title: "A", tags: ["project", "urgent"] }); // +3 +3
+            writeNote("b.md", { title: "B", tags: ["project"] }); // +3
+            writeNote("c.md", { title: "C", tags: ["other"] }); // score 0 -> excluded
+            const hits = await searchVaultNative(vaultPath, "no-query-match", 10, ["#project", "urgent"]);
+            assert.deepEqual(hits.map((h) => h.source), ["a.md", "b.md"]);
+        });
+        it("breaks score ties by source ascending", async () => {
+            writeNote("zebra.md", { title: "Report" });
+            writeNote("apple.md", { title: "Report" });
+            const hits = await searchVaultNative(vaultPath, "report", 10);
+            assert.deepEqual(hits.map((h) => h.source), ["apple.md", "zebra.md"]);
+        });
+        it("slices the ranked results down to limit", async () => {
+            writeNote("n1.md", { title: "Note" });
+            writeNote("n2.md", { title: "Note" });
+            writeNote("n3.md", { title: "Note" });
+            writeNote("n4.md", { title: "Note" });
+            const hits = await searchVaultNative(vaultPath, "note", 2);
+            assert.deepEqual(hits.map((h) => h.source), ["n1.md", "n2.md"]);
+        });
+        it("returns [] for empty query, whitespace query, empty path, or missing path", async () => {
+            writeNote("match.md", { title: "Match" });
+            assert.deepEqual(await searchVaultNative(vaultPath, "", 10), []);
+            assert.deepEqual(await searchVaultNative(vaultPath, "   ", 10), []);
+            assert.deepEqual(await searchVaultNative("", "match", 10), []);
+            assert.deepEqual(await searchVaultNative(path.join(testDir, "does-not-exist"), "match", 10), []);
+        });
+        it("ignores non-.md files", async () => {
+            writeNote("config.md", { title: "Config" });
+            fs.writeFileSync(path.join(vaultPath, "config.txt"), "config config config");
+            fs.writeFileSync(path.join(vaultPath, "config.json"), '{"config": true}');
+            const hits = await searchVaultNative(vaultPath, "config", 10);
+            assert.deepEqual(hits.map((h) => h.source), ["config.md"]);
+        });
+        it("shapes hits as { source, title, tags[], _source } with union tags and forward-slash source", async () => {
+            writeNote("sub/dir/deep.md", {
+                title: "Deep",
+                tags: ["alpha", "beta"],
+                body: "content #gamma",
+            });
+            const hits = await searchVaultNative(vaultPath, "deep", 10);
+            assert.equal(hits.length, 1);
+            const hit = hits[0];
+            assert.equal(hit.source, "sub/dir/deep.md");
+            assert.equal(hit.title, "Deep");
+            assert.equal(hit._source, "vault");
+            assert.ok(Array.isArray(hit.tags));
+            assert.deepEqual([...hit.tags].sort(), ["alpha", "beta", "gamma"]);
+        });
+    });
 });

package/dist/test/vault-writer.test.js

@@ -0,0 +1,371 @@
+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 { connect, resetConnection } from "../src/lance.js";
+import { VaultWriter } from "../src/vault-writer.js";
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+const makeCfg = (vaultPath) => ({
+    dataDir: path.join(vaultPath, ".lancedb"),
+    embedding: {},
+    folders: { inbox: "inbox", library: "library" },
+});
+const setupConfigFile = (vaultPath, collections) => {
+    const configDir = path.join(vaultPath, ".vault-mind");
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(path.join(configDir, "vault-mind.config.json"), JSON.stringify({ collections }), "utf-8");
+};
+// ---------------------------------------------------------------------------
+// constructor
+// ---------------------------------------------------------------------------
+describe("VaultWriter constructor", () => {
+    it("stores vaultPath and cfg (exercised via writeEntry)", async () => {
+        const vaultPath = path.join(tmpdir(), `vw-ctor-${randomUUID()}`);
+        const cfg = makeCfg(vaultPath);
+        const writer = new VaultWriter(vaultPath, cfg);
+        const filepath = await writer.writeEntry("test", {
+            id: "ctor-test",
+            fact: "constructor stores state",
+        });
+        assert.ok(fs.existsSync(filepath));
+        const content = fs.readFileSync(filepath, "utf-8");
+        assert.ok(content.includes('id: "ctor-test"'));
+        assert.ok(content.includes("collection: test"));
+        assert.ok(content.includes("constructor stores state"));
+        fs.rmSync(vaultPath, { recursive: true });
+    });
+});
+// ---------------------------------------------------------------------------
+// writeEntry
+// ---------------------------------------------------------------------------
+describe("writeEntry", () => {
+    let vaultPath;
+    let cfg;
+    let writer;
+    beforeEach(() => {
+        vaultPath = path.join(tmpdir(), `vw-write-${randomUUID()}`);
+        cfg = makeCfg(vaultPath);
+        writer = new VaultWriter(vaultPath, cfg);
+    });
+    afterEach(() => {
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("creates a .md file in the inbox with frontmatter and body", async () => {
+        const filepath = await writer.writeEntry("notes", {
+            id: "abc-123",
+            fact: "The quick brown fox jumps over the lazy dog",
+            domain: "biology",
+            tag: "animals",
+            source: "observation",
+            created_at: "2025-01-15T10:00:00.000Z",
+            artifact: "[[fox-sighting.png]]",
+        });
+        assert.ok(fs.existsSync(filepath));
+        assert.ok(filepath.endsWith("abc-123.md"));
+        assert.ok(filepath.includes(path.join("inbox")));
+        const content = fs.readFileSync(filepath, "utf-8");
+        // frontmatter
+        assert.ok(content.includes("---"));
+        assert.ok(content.includes('id: "abc-123"'));
+        assert.ok(content.includes("collection: notes"));
+        assert.ok(content.includes("domain: biology"));
+        assert.ok(content.includes("tag: animals"));
+        assert.ok(content.includes("source: observation"));
+        assert.ok(content.includes("created: 2025-01-15T10:00:00.000Z"));
+        // body
+        assert.ok(content.includes("# The quick brown fox jumps over the lazy dog"));
+        assert.ok(content.includes("The quick brown fox jumps over the lazy dog"));
+        assert.ok(content.includes("**See also:** [[fox-sighting.png]]"));
+    });
+    it("generates filename from entry.id", async () => {
+        const filepath = await writer.writeEntry("test", {
+            id: "my-custom-id",
+            fact: "some fact",
+        });
+        assert.ok(filepath.endsWith("my-custom-id.md"));
+    });
+    it("generates filename from entry.fact when id is missing", async () => {
+        const filepath = await writer.writeEntry("test", {
+            fact: "Hello World! This is a test fact with special chars: @#$%",
+        });
+        // fact sliced to 40 chars, non-alphanumeric replaced with "-"
+        assert.ok(filepath.endsWith("Hello-World--This-is-a-test-fact-with-sp.md"));
+    });
+    it('falls back to "entry" when neither id nor fact', async () => {
+        const filepath = await writer.writeEntry("test", {
+            domain: "general",
+        });
+        assert.ok(filepath.endsWith("entry.md"));
+    });
+    it("writes identity in frontmatter when present", async () => {
+        const filepath = await writer.writeEntry("test", {
+            id: "with-identity",
+            fact: "fact with identity",
+            identity: "alice",
+        });
+        const content = fs.readFileSync(filepath, "utf-8");
+        assert.ok(content.includes('identity: "alice"'));
+    });
+    it("omits identity line when identity is absent", async () => {
+        const filepath = await writer.writeEntry("test", {
+            id: "no-identity",
+            fact: "fact without identity",
+        });
+        const content = fs.readFileSync(filepath, "utf-8");
+        assert.ok(!content.includes("identity:"));
+    });
+    it("omits artifact line when artifact is absent", async () => {
+        const filepath = await writer.writeEntry("test", {
+            id: "no-artifact",
+            fact: "fact without artifact",
+        });
+        const content = fs.readFileSync(filepath, "utf-8");
+        assert.ok(!content.includes("**See also:**"));
+    });
+    it("uses current timestamp when created_at is missing", async () => {
+        const before = new Date().toISOString();
+        const filepath = await writer.writeEntry("test", {
+            id: "no-created",
+            fact: "fact without created_at",
+        });
+        const after = new Date().toISOString();
+        const content = fs.readFileSync(filepath, "utf-8");
+        const match = content.match(/created: (.+)/);
+        assert.ok(match, "created field missing");
+        const created = match[1];
+        assert.ok(created >= before && created <= after, `created ${created} not in [${before}, ${after}]`);
+    });
+    it("writes multiple entries without collision", async () => {
+        const a = await writer.writeEntry("test", { id: "entry-a", fact: "Fact A" });
+        const b = await writer.writeEntry("test", { id: "entry-b", fact: "Fact B" });
+        assert.ok(fs.existsSync(a));
+        assert.ok(fs.existsSync(b));
+        assert.notEqual(a, b);
+    });
+});
+// ---------------------------------------------------------------------------
+// syncEntries
+// ---------------------------------------------------------------------------
+describe("syncEntries", () => {
+    let vaultPath;
+    let cfg;
+    let writer;
+    let savedCwd;
+    beforeEach(() => {
+        vaultPath = path.join(tmpdir(), `vw-sync-${randomUUID()}`);
+        fs.mkdirSync(vaultPath, { recursive: true });
+        cfg = makeCfg(vaultPath);
+        writer = new VaultWriter(vaultPath, cfg);
+        // syncEntries calls loadConfig(vaultPath) which reads
+        // <vaultPath>/.vault-mind/vault-mind.config.json, then reads
+        // the JSONL file at def.path (relative to cwd).
+        savedCwd = process.cwd();
+        process.chdir(vaultPath);
+    });
+    afterEach(() => {
+        process.chdir(savedCwd);
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("syncs entries from a JSONL collection file", async () => {
+        const jsonlPath = path.join(vaultPath, "collections", "main.jsonl");
+        fs.mkdirSync(path.dirname(jsonlPath), { recursive: true });
+        fs.writeFileSync(jsonlPath, `${[
+            JSON.stringify({ id: "e1", fact: "First entry", tag: "alpha" }),
+            JSON.stringify({ id: "e2", fact: "Second entry", tag: "beta" }),
+            JSON.stringify({ id: "e3", fact: "Third entry", tag: "alpha" }),
+        ].join("\n")}\n`, "utf-8");
+        setupConfigFile(vaultPath, {
+            main: { path: "collections/main.jsonl", schema: ["id", "fact", "tag"] },
+        });
+        const count = await writer.syncEntries("main", "", 10);
+        assert.equal(count, 3);
+        // all three should be written to inbox
+        const inboxDir = path.join(vaultPath, "inbox");
+        const files = fs.readdirSync(inboxDir);
+        assert.equal(files.length, 3);
+    });
+    it("filters entries by substring query", async () => {
+        const jsonlPath = path.join(vaultPath, "collections", "main.jsonl");
+        fs.mkdirSync(path.dirname(jsonlPath), { recursive: true });
+        fs.writeFileSync(jsonlPath, `${[
+            JSON.stringify({ id: "e1", fact: "Apple pie recipe", tag: "food" }),
+            JSON.stringify({ id: "e2", fact: "Banana bread", tag: "food" }),
+            JSON.stringify({ id: "e3", fact: "Carrot cake", tag: "dessert" }),
+        ].join("\n")}\n`, "utf-8");
+        setupConfigFile(vaultPath, {
+            main: { path: "collections/main.jsonl", schema: ["id", "fact", "tag"] },
+        });
+        const count = await writer.syncEntries("main", "apple", 10);
+        assert.equal(count, 1);
+        const inboxDir = path.join(vaultPath, "inbox");
+        const files = fs.readdirSync(inboxDir);
+        assert.equal(files.length, 1);
+        assert.ok(files[0].startsWith("e1"));
+    });
+    it("filters entries by tag: prefix", async () => {
+        const jsonlPath = path.join(vaultPath, "collections", "main.jsonl");
+        fs.mkdirSync(path.dirname(jsonlPath), { recursive: true });
+        fs.writeFileSync(jsonlPath, `${[
+            JSON.stringify({ id: "e1", fact: "Fact one", tag: "alpha" }),
+            JSON.stringify({ id: "e2", fact: "Fact two", tag: "beta" }),
+            JSON.stringify({ id: "e3", fact: "Fact three", tag: "alpha" }),
+        ].join("\n")}\n`, "utf-8");
+        setupConfigFile(vaultPath, {
+            main: { path: "collections/main.jsonl", schema: ["id", "fact", "tag"] },
+        });
+        const count = await writer.syncEntries("main", "tag:alpha", 10);
+        assert.equal(count, 2);
+        const inboxDir = path.join(vaultPath, "inbox");
+        const files = fs.readdirSync(inboxDir);
+        assert.equal(files.length, 2);
+    });
+    it("respects the limit parameter", async () => {
+        const jsonlPath = path.join(vaultPath, "collections", "main.jsonl");
+        fs.mkdirSync(path.dirname(jsonlPath), { recursive: true });
+        const lines = [];
+        for (let i = 0; i < 10; i++) {
+            lines.push(JSON.stringify({ id: `e${i}`, fact: `Entry ${i}`, tag: "common" }));
+        }
+        fs.writeFileSync(jsonlPath, `${lines.join("\n")}\n`, "utf-8");
+        setupConfigFile(vaultPath, {
+            main: { path: "collections/main.jsonl", schema: ["id", "fact", "tag"] },
+        });
+        const count = await writer.syncEntries("main", "", 3);
+        assert.equal(count, 3);
+        const inboxDir = path.join(vaultPath, "inbox");
+        assert.equal(fs.readdirSync(inboxDir).length, 3);
+    });
+    it("returns 0 when collection is not in config", async () => {
+        setupConfigFile(vaultPath, {});
+        const count = await writer.syncEntries("nonexistent", "", 10);
+        assert.equal(count, 0);
+    });
+    it("returns 0 when collection file does not exist", async () => {
+        setupConfigFile(vaultPath, {
+            main: { path: "collections/missing.jsonl", schema: ["id"] },
+        });
+        const count = await writer.syncEntries("main", "", 10);
+        assert.equal(count, 0);
+    });
+    it("skips malformed JSON lines", async () => {
+        const jsonlPath = path.join(vaultPath, "collections", "main.jsonl");
+        fs.mkdirSync(path.dirname(jsonlPath), { recursive: true });
+        fs.writeFileSync(jsonlPath, `${[
+            JSON.stringify({ id: "good", fact: "valid entry" }),
+            "not valid json {{{",
+            JSON.stringify({ id: "also-good", fact: "another valid entry" }),
+        ].join("\n")}\n`, "utf-8");
+        setupConfigFile(vaultPath, {
+            main: { path: "collections/main.jsonl", schema: ["id", "fact"] },
+        });
+        const count = await writer.syncEntries("main", "", 10);
+        assert.equal(count, 2);
+        const inboxDir = path.join(vaultPath, "inbox");
+        assert.equal(fs.readdirSync(inboxDir).length, 2);
+    });
+});
+// ---------------------------------------------------------------------------
+// syncGraphToCanvas
+// ---------------------------------------------------------------------------
+describe("syncGraphToCanvas", () => {
+    let vaultPath;
+    let cfg;
+    let writer;
+    beforeEach(() => {
+        vaultPath = path.join(tmpdir(), `vw-graph-${randomUUID()}`);
+        cfg = makeCfg(vaultPath);
+        writer = new VaultWriter(vaultPath, cfg);
+        resetConnection();
+    });
+    afterEach(() => {
+        resetConnection();
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+    });
+    it("generates a .canvas file from entities and relations", async () => {
+        const db = await connect(cfg.dataDir);
+        await db.createTable("entities", [
+            { id: "1", name: "Entity One" },
+            { id: "2", name: "Entity Two" },
+        ]);
+        await db.createTable("relations", [
+            { from_entity_id: "1", to_entity_id: "2", relation_type: "related_to" },
+        ]);
+        const edgeCount = await writer.syncGraphToCanvas();
+        assert.equal(edgeCount, 1);
+        const canvasPath = path.join(vaultPath, "library", "Library-Graph.canvas");
+        assert.ok(fs.existsSync(canvasPath));
+        const canvas = JSON.parse(fs.readFileSync(canvasPath, "utf-8"));
+        assert.ok(Array.isArray(canvas.nodes));
+        assert.ok(Array.isArray(canvas.edges));
+        assert.equal(canvas.nodes.length, 2);
+        assert.equal(canvas.edges.length, 1);
+        // verify node structure
+        assert.equal(canvas.nodes[0].id, "e-1");
+        assert.equal(canvas.nodes[0].type, "text");
+        assert.equal(canvas.nodes[0].file, "Entity-One.md");
+        // verify edge structure
+        assert.equal(canvas.edges[0].id, "edge-0");
+        assert.equal(canvas.edges[0].fromNode, "e-1");
+        assert.equal(canvas.edges[0].toNode, "e-2");
+        assert.equal(canvas.edges[0].label, "related_to");
+    });
+    it("uses custom canvasPath from graph config", async () => {
+        const customCfg = {
+            ...makeCfg(vaultPath),
+            graph: { canvasPath: "Custom/MyGraph.canvas" },
+        };
+        const customWriter = new VaultWriter(vaultPath, customCfg);
+        const db = await connect(cfg.dataDir);
+        await db.createTable("entities", [{ id: "1", name: "Solo" }]);
+        await customWriter.syncGraphToCanvas();
+        const canvasPath = path.join(vaultPath, "Custom", "MyGraph.canvas");
+        assert.ok(fs.existsSync(canvasPath));
+    });
+    it("returns 0 when no tables exist", async () => {
+        // Connect to create the data dir but don't create any tables
+        await connect(cfg.dataDir);
+        const edgeCount = await writer.syncGraphToCanvas();
+        assert.equal(edgeCount, 0);
+        const canvasPath = path.join(vaultPath, "library", "Library-Graph.canvas");
+        assert.ok(fs.existsSync(canvasPath));
+        const canvas = JSON.parse(fs.readFileSync(canvasPath, "utf-8"));
+        assert.equal(canvas.nodes.length, 0);
+        assert.equal(canvas.edges.length, 0);
+    });
+    it("handles entities without a name field", async () => {
+        const db = await connect(cfg.dataDir);
+        await db.createTable("entities", [{ id: "99" }]);
+        await writer.syncGraphToCanvas();
+        const canvasPath = path.join(vaultPath, "library", "Library-Graph.canvas");
+        const canvas = JSON.parse(fs.readFileSync(canvasPath, "utf-8"));
+        assert.equal(canvas.nodes.length, 1);
+        assert.equal(canvas.nodes[0].id, "e-99");
+        // no name → no file property
+        assert.equal(canvas.nodes[0].file, undefined);
+    });
+    it("handles relations without a relation_type", async () => {
+        const db = await connect(cfg.dataDir);
+        await db.createTable("entities", [{ id: "1" }, { id: "2" }]);
+        await db.createTable("relations", [{ from_entity_id: "1", to_entity_id: "2" }]);
+        await writer.syncGraphToCanvas();
+        const canvasPath = path.join(vaultPath, "library", "Library-Graph.canvas");
+        const canvas = JSON.parse(fs.readFileSync(canvasPath, "utf-8"));
+        assert.equal(canvas.edges.length, 1);
+        // no relation_type → label is undefined
+        assert.equal(canvas.edges[0].label, undefined);
+    });
+    it("creates the library directory if it does not exist", async () => {
+        await connect(cfg.dataDir);
+        const libDir = path.join(vaultPath, "library");
+        assert.ok(!fs.existsSync(libDir), "library dir should not exist before call");
+        await writer.syncGraphToCanvas();
+        assert.ok(fs.existsSync(libDir), "library dir should be created");
+    });
+});