@xenonbyte/da-vinci-workflow 0.1.20 → 0.1.22

package/scripts/test-icon-sync.js

@@ -0,0 +1,178 @@
+const assert = require("assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const {
+  MATERIAL_METADATA_URL,
+  LUCIDE_TREE_URL,
+  FEATHER_TREE_URL,
+  PHOSPHOR_TREE_URL,
+  getDefaultCatalogPath,
+  resolveCatalogPath,
+  loadIconCatalog,
+  syncIconCatalog,
+  formatIconSyncReport,
+  parseGoogleMaterialMetadata,
+  parseGitHubTreeIcons,
+  dedupeIconRecords,
+  summarizeSourceResults
+} = require("../lib/icon-sync");
+
+async function runTest(name, fn) {
+  try {
+    await fn();
+    console.log(`PASS ${name}`);
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    throw error;
+  }
+}
+
+function createMockFetch({ failLucide = false } = {}) {
+  return async (url) => {
+    if (url === MATERIAL_METADATA_URL) {
+      return `)]}'\n{"icons":[{"name":"settings","unsupported_families":[]}]}`;
+    }
+    if (url === LUCIDE_TREE_URL) {
+      if (failLucide) {
+        throw new Error("mock lucide outage");
+      }
+      return JSON.stringify({
+        tree: [{ path: "icons/settings.json" }]
+      });
+    }
+    if (url === FEATHER_TREE_URL) {
+      return JSON.stringify({
+        tree: [{ path: "icons/lock.svg" }]
+      });
+    }
+    if (url === PHOSPHOR_TREE_URL) {
+      return JSON.stringify({
+        tree: [{ path: "assets/regular/vault.svg" }]
+      });
+    }
+    throw new Error(`Unexpected URL: ${url}`);
+  };
+}
+
+(async () => {
+  await runTest("google metadata parser extracts material variants", () => {
+    const raw = `)]}'\n{"icons":[{"name":"settings","unsupported_families":[]},{"name":"lock_open","unsupported_families":["Material Icons Sharp"]}]}`;
+    const records = parseGoogleMaterialMetadata(raw);
+    const keys = new Set(records.map((record) => `${record.family}/${record.name}`));
+    assert.ok(keys.has("Material Symbols Rounded/settings"));
+    assert.ok(keys.has("Material Symbols Outlined/settings"));
+    assert.ok(keys.has("Material Symbols Sharp/settings"));
+    assert.ok(keys.has("Material Symbols Rounded/lock_open"));
+    assert.equal(keys.has("Material Symbols Sharp/lock_open"), false);
+  });
+
+  await runTest("github tree parser extracts icon names from paths", () => {
+    const raw = JSON.stringify({
+      tree: [
+        { path: "icons/settings.json" },
+        { path: "icons/lock-open.json" },
+        { path: "icons/nested/skip.json" },
+        { path: "readme.md" }
+      ]
+    });
+    const records = parseGitHubTreeIcons(raw, {
+      family: "lucide",
+      prefix: "icons/",
+      suffix: ".json"
+    });
+    const names = records.map((record) => record.name);
+    assert.deepEqual(names, ["settings", "lock-open"]);
+  });
+
+  await runTest("dedupe keeps first unique family/name pair", () => {
+    const deduped = dedupeIconRecords([
+      { family: "lucide", name: "settings" },
+      { family: "lucide", name: "settings" },
+      { family: "feather", name: "settings" }
+    ]);
+    assert.equal(deduped.length, 2);
+  });
+
+  await runTest("catalog path resolves to home .da-vinci directory by default", () => {
+    const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-home-"));
+    const resolved = getDefaultCatalogPath(tempHome);
+    assert.match(resolved, /\.da-vinci[\/\\]icon-catalog\.json$/);
+  });
+
+  await runTest("load icon catalog reads valid schema", () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-catalog-"));
+    const catalogPath = path.join(tempDir, "icon-catalog.json");
+    fs.writeFileSync(
+      catalogPath,
+      JSON.stringify(
+        {
+          schema: 1,
+          generatedAt: "2026-03-29T00:00:00.000Z",
+          iconCount: 1,
+          icons: [{ family: "lucide", name: "settings", semantic: "settings", tags: [] }]
+        },
+        null,
+        2
+      )
+    );
+
+    const loaded = loadIconCatalog({
+      catalogPath
+    });
+    assert.ok(loaded.catalog);
+    assert.equal(loaded.catalog.icons.length, 1);
+    assert.equal(resolveCatalogPath({ catalogPath }), path.resolve(catalogPath));
+  });
+
+  await runTest("source summary marks degraded when at least one source errors", () => {
+    const summary = summarizeSourceResults({
+      material: { status: "ok" },
+      lucide: { status: "error" },
+      feather: { status: "ok" }
+    });
+    assert.deepEqual(summary, {
+      total: 3,
+      okCount: 2,
+      errorCount: 1,
+      degraded: true
+    });
+  });
+
+  await runTest("icon sync keeps flow non-blocking by default on partial source failure", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-sync-"));
+    const outputPath = path.join(tempDir, "catalog.json");
+    const result = await syncIconCatalog({
+      outputPath,
+      fetchText: createMockFetch({ failLucide: true })
+    });
+
+    assert.equal(result.catalog.syncStatus, "degraded");
+    assert.equal(result.catalog.sourceResults.lucide.status, "error");
+    assert.ok(result.catalog.iconCount > 0);
+    assert.equal(fs.existsSync(outputPath), true);
+    assert.match(formatIconSyncReport(result), /Status: DEGRADED/i);
+  });
+
+  await runTest("icon sync strict mode fails on partial source failure and does not write partial catalog", async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-icon-sync-strict-"));
+    const outputPath = path.join(tempDir, "catalog.json");
+
+    await assert.rejects(
+      () =>
+        syncIconCatalog({
+          outputPath,
+          strict: true,
+          fetchText: createMockFetch({ failLucide: true })
+        }),
+      /strict mode failed/i
+    );
+
+    assert.equal(fs.existsSync(outputPath), false);
+  });
+
+  console.log("All icon-sync tests passed.");
+})().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/scripts/test-mode-consistency.js

@@ -286,4 +286,54 @@ runTest("design-supervisor review stays distinct from preferred adapters and is
   }
 });
 
+runTest("build prompts require completion audit and do not treat compile success as workflow completion", () => {
+  const buildPrompts = [
+    "commands/claude/dv/build.md",
+    "commands/codex/prompts/dv-build.md",
+    "commands/gemini/dv/build.toml"
+  ];
+
+  for (const file of buildPrompts) {
+    const content = read(file);
+    assert.match(content, /BUILD SUCCESSFUL/, `${file} should explicitly treat build success as compile-only evidence`);
+    assert.match(
+      content,
+      /da-vinci audit --mode completion --change <change-id> <project-path>/,
+      `${file} should require completion audit before terminal completion claims`
+    );
+    assert.match(
+      content,
+      /do not report `design complete` or `workflow complete`/i,
+      `${file} should prevent terminal completion claims while in-scope tasks remain`
+    );
+  }
+});
+
+runTest("continue prompts keep build routing blocked while design gates are unresolved", () => {
+  const continuePrompts = [
+    "commands/claude/dv/continue.md",
+    "commands/codex/prompts/dv-continue.md",
+    "commands/gemini/dv/continue.toml"
+  ];
+
+  for (const file of continuePrompts) {
+    const content = read(file);
+    assert.match(
+      content,
+      /missing shell-visible project-local `.pen`/,
+      `${file} should block build routing when project-local .pen persistence is unresolved`
+    );
+    assert.match(
+      content,
+      /active\/unclosed Pencil session/,
+      `${file} should block build routing when Pencil session is still active`
+    );
+    assert.match(
+      content,
+      /design-supervisor review still BLOCK\/unaccepted/,
+      `${file} should block build routing when required design-supervisor review has not cleared`
+    );
+  }
+});
+
 console.log("All mode consistency tests passed.");

package/scripts/test-pen-persistence.js

@@ -17,6 +17,7 @@ const {
 } = require("../lib/pencil-lock");
 
 const fixturePath = path.join(__dirname, "fixtures", "complex-sample.pen");
+const mockPencilPath = path.join(__dirname, "fixtures", "mock-pencil.js");
 
 function runTest(name, fn) {
   try {
@@ -65,7 +66,8 @@ runTest("writePenFromPayloadFiles writes and reopens a complex sample", () => {
     nodesFile,
     variablesFile,
     version: fixture.version,
-    verifyWithPencil: true
+    verifyWithPencil: true,
+    pencilBin: mockPencilPath
   });
 
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));
@@ -82,7 +84,8 @@ runTest("snapshotPenFile round-trips a complex sample", () => {
   const result = snapshotPenFile({
     inputPath: fixturePath,
     outputPath,
-    verifyWithPencil: true
+    verifyWithPencil: true,
+    pencilBin: mockPencilPath
   });
 
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));
@@ -97,7 +100,8 @@ runTest("ensurePenFile seeds a missing project-local .pen and state", () => {
 
   const result = ensurePenFile({
     outputPath,
-    verifyWithPencil: true
+    verifyWithPencil: true,
+    pencilBin: mockPencilPath
   });
 
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));

package/scripts/test-pencil-session.js

@@ -149,4 +149,44 @@ runTest("pencil-session end fails when live payload is stale", () => {
   });
 });
 
+runTest("pencil-session end requires live payload unless force is used", () => {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tempDir = createTempDir();
+  const projectRoot = path.join(tempDir, "project");
+  const homeDir = path.join(tempDir, "home");
+  const penPath = path.join(projectRoot, ".da-vinci", "designs", "cipher.pen");
+  const { nodesFile, variablesFile } = writePayloadFiles(tempDir, fixture);
+
+  beginPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    homeDir
+  });
+  persistPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version,
+    homeDir
+  });
+
+  assert.throws(
+    () =>
+      endPencilSession({
+        projectPath: projectRoot,
+        penPath,
+        homeDir
+      }),
+    /without a live MCP snapshot/i
+  );
+
+  endPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    homeDir,
+    force: true
+  });
+});
+
 console.log("All Pencil session tests passed.");

package/scripts/test-persistence-flows.js

@@ -241,9 +241,39 @@ runTest("parallel mixed projects are serialized by the global Pencil lock", () =
     runCli(harness, ["pencil-session", "begin", "--project", existing.root, "--pen", existing.penPath]),
     /lock is already held/i
   );
+  expectOk(
+    "parallel A persist",
+    runCli(harness, [
+      "pencil-session",
+      "persist",
+      "--project",
+      freshA.root,
+      "--pen",
+      freshA.penPath,
+      "--nodes-file",
+      freshA.nodesFile,
+      "--variables-file",
+      freshA.variablesFile,
+      "--version",
+      fixture.version
+    ])
+  );
   expectOk(
     "parallel A end",
-    runCli(harness, ["pencil-session", "end", "--project", freshA.root, "--pen", freshA.penPath])
+    runCli(harness, [
+      "pencil-session",
+      "end",
+      "--project",
+      freshA.root,
+      "--pen",
+      freshA.penPath,
+      "--nodes-file",
+      freshA.nodesFile,
+      "--variables-file",
+      freshA.variablesFile,
+      "--version",
+      fixture.version
+    ])
   );
 
   expectOk(