@xenonbyte/da-vinci-workflow 0.1.16 → 0.1.17

package/scripts/test-mcp-runtime-gate.js

@@ -27,6 +27,9 @@ runTest("healthy completion passes", () => {
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     claimedAnchorIds: ["GfwiK", "mCZ1G", "V8zfE"],
     claimedReviewedScreenIds: ["GfwiK", "mCZ1G", "V8zfE"],
     reviewTargets: ["GfwiK", "mCZ1G", "V8zfE"],
@@ -55,6 +58,9 @@ runTest("unnamed editor blocks runtime gate", () => {
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     claimedAnchorIds: ["GfwiK"],
     claimedReviewedScreenIds: ["GfwiK"],
     reviewTargets: ["GfwiK"],
@@ -74,6 +80,9 @@ runTest("live screens without shell-visible pen block source convergence", () =>
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: false,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     claimedAnchorIds: ["GfwiK"],
     claimedReviewedScreenIds: ["GfwiK"],
     reviewTargets: ["GfwiK"],
@@ -93,6 +102,9 @@ runTest("missing claimed anchor blocks screen presence", () => {
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     claimedAnchorIds: ["GfwiK", "mCZ1G"],
     claimedReviewedScreenIds: ["GfwiK"],
     reviewTargets: ["GfwiK"],
@@ -112,6 +124,9 @@ runTest("ignored review blockers block review execution", () => {
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     claimedAnchorIds: ["GfwiK"],
     claimedReviewedScreenIds: ["GfwiK"],
     reviewTargets: ["GfwiK"],
@@ -148,6 +163,9 @@ runTest("first-write phase can skip screen and review checks", () => {
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     liveScreens: [{ id: "GfwiK", name: "Splash" }]
   });
 
@@ -166,6 +184,9 @@ runTest("documented reconciliation downgrades mismatch to warn", () => {
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
     documentedReconciliation: true,
     claimedAnchorIds: ["GfwiK"],
     claimedReviewedScreenIds: ["GfwiK"],
@@ -186,6 +207,73 @@ runTest("same basename but different absolute path blocks without reconciliation
     registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
     shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
+    claimedAnchorIds: ["GfwiK"],
+    claimedReviewedScreenIds: ["GfwiK"],
+    reviewTargets: ["GfwiK"],
+    liveScreens: [{ id: "GfwiK", name: "Splash" }]
+  });
+
+  assert.equal(result.sourceConvergence.status, BLOCK);
+  assert.equal(result.finalStatus, BLOCK);
+});
+
+runTest("completion without explicit pen sync verification blocks", () => {
+  const result = evaluateMcpRuntimeGate({
+    phase: "completion",
+    mcpAvailable: true,
+    projectRoot: "/repo",
+    activeEditor: "/repo/.da-vinci/designs/cipher-redesign.pen",
+    registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
+    shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
+    shellVisiblePenExists: true,
+    claimedAnchorIds: ["GfwiK"],
+    claimedReviewedScreenIds: ["GfwiK"],
+    reviewTargets: ["GfwiK"],
+    liveScreens: [{ id: "GfwiK", name: "Splash" }]
+  });
+
+  assert.equal(result.sourceConvergence.status, BLOCK);
+  assert.equal(result.finalStatus, BLOCK);
+});
+
+runTest("completion with mismatched live and persisted hashes blocks", () => {
+  const result = evaluateMcpRuntimeGate({
+    phase: "completion",
+    mcpAvailable: true,
+    projectRoot: "/repo",
+    activeEditor: "/repo/.da-vinci/designs/cipher-redesign.pen",
+    registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
+    shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
+    shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "newer",
+    persistedSnapshotHash: "older",
+    claimedAnchorIds: ["GfwiK"],
+    claimedReviewedScreenIds: ["GfwiK"],
+    reviewTargets: ["GfwiK"],
+    liveScreens: [{ id: "GfwiK", name: "Splash" }]
+  });
+
+  assert.equal(result.sourceConvergence.status, BLOCK);
+  assert.equal(result.finalStatus, BLOCK);
+});
+
+runTest("registered pen plus empty filePath usage blocks", () => {
+  const result = evaluateMcpRuntimeGate({
+    phase: "completion",
+    mcpAvailable: true,
+    projectRoot: "/repo",
+    activeEditor: "/repo/.da-vinci/designs/cipher-redesign.pen",
+    registeredPenPath: ".da-vinci/designs/cipher-redesign.pen",
+    shellVisiblePenPath: ".da-vinci/designs/cipher-redesign.pen",
+    shellVisiblePenExists: true,
+    penSyncVerified: true,
+    liveSnapshotHash: "abc123",
+    persistedSnapshotHash: "abc123",
+    usedEmptyFilePath: true,
     claimedAnchorIds: ["GfwiK"],
     claimedReviewedScreenIds: ["GfwiK"],
     reviewTargets: ["GfwiK"],

package/scripts/test-pen-persistence.js

@@ -5,8 +5,16 @@ const path = require("path");
 const {
   buildPenDocument,
   writePenFromPayloadFiles,
-  snapshotPenFile
+  snapshotPenFile,
+  ensurePenFile,
+  comparePenSync,
+  getStandardPenStatePath
 } = require("../lib/pen-persistence");
+const {
+  acquirePencilLock,
+  releasePencilLock,
+  getPencilLockStatus
+} = require("../lib/pencil-lock");
 
 const fixturePath = path.join(__dirname, "fixtures", "complex-sample.pen");
 
@@ -24,6 +32,17 @@ function createTempDir() {
   return fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-pen-persistence-"));
 }
 
+function writePayloadFiles(tempDir, fixture) {
+  const nodesFile = path.join(tempDir, "nodes.json");
+  const variablesFile = path.join(tempDir, "variables.json");
+  fs.writeFileSync(nodesFile, JSON.stringify({ nodes: fixture.children }, null, 2));
+  fs.writeFileSync(variablesFile, JSON.stringify({ variables: fixture.variables }, null, 2));
+  return {
+    nodesFile,
+    variablesFile
+  };
+}
+
 runTest("buildPenDocument preserves fixture structure", () => {
   const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
   const document = buildPenDocument({
@@ -38,13 +57,9 @@ runTest("buildPenDocument preserves fixture structure", () => {
 runTest("writePenFromPayloadFiles writes and reopens a complex sample", () => {
   const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
   const tempDir = createTempDir();
-  const nodesFile = path.join(tempDir, "nodes.json");
-  const variablesFile = path.join(tempDir, "variables.json");
+  const { nodesFile, variablesFile } = writePayloadFiles(tempDir, fixture);
   const outputPath = path.join(tempDir, "written.pen");
 
-  fs.writeFileSync(nodesFile, JSON.stringify({ nodes: fixture.children }, null, 2));
-  fs.writeFileSync(variablesFile, JSON.stringify({ variables: fixture.variables }, null, 2));
-
   const result = writePenFromPayloadFiles({
     outputPath,
     nodesFile,
@@ -56,6 +71,7 @@ runTest("writePenFromPayloadFiles writes and reopens a complex sample", () => {
   const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));
   assert.deepEqual(written, fixture);
   assert.deepEqual(result.verification.topLevelIds, fixture.children.map((node) => node.id));
+  assert.equal(result.state.snapshotHash, JSON.parse(fs.readFileSync(result.statePath, "utf8")).snapshotHash);
 });
 
 runTest("snapshotPenFile round-trips a complex sample", () => {
@@ -74,6 +90,130 @@ runTest("snapshotPenFile round-trips a complex sample", () => {
   assert.deepEqual(result.verification.topLevelIds, fixture.children.map((node) => node.id));
 });
 
+runTest("ensurePenFile seeds a missing project-local .pen and state", () => {
+  const tempDir = createTempDir();
+  const projectRoot = path.join(tempDir, "project");
+  const outputPath = path.join(projectRoot, ".da-vinci", "designs", "seed.pen");
+
+  const result = ensurePenFile({
+    outputPath,
+    verifyWithPencil: true
+  });
+
+  const written = JSON.parse(fs.readFileSync(outputPath, "utf8"));
+  assert.equal(result.created, true);
+  assert.deepEqual(written, { version: "2.9", children: [] });
+  assert.equal(fs.existsSync(getStandardPenStatePath(outputPath)), true);
+  assert.deepEqual(result.verification.topLevelIds, []);
+});
+
+runTest("ensurePenFile preserves an existing .pen and refreshes state", () => {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tempDir = createTempDir();
+  const outputPath = path.join(tempDir, "project", ".da-vinci", "designs", "existing.pen");
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  fs.writeFileSync(outputPath, JSON.stringify(fixture, null, 2));
+
+  const result = ensurePenFile({ outputPath });
+
+  assert.equal(result.created, false);
+  assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf8")), fixture);
+  assert.equal(fs.existsSync(result.statePath), true);
+});
+
+runTest("comparePenSync passes when payload matches persisted .pen", () => {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tempDir = createTempDir();
+  const { nodesFile, variablesFile } = writePayloadFiles(tempDir, fixture);
+  const outputPath = path.join(tempDir, "written.pen");
+
+  writePenFromPayloadFiles({
+    outputPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version
+  });
+
+  const result = comparePenSync({
+    penPath: outputPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version
+  });
+
+  assert.equal(result.inSync, true);
+  assert.equal(result.usedStateFile, true);
+});
+
+runTest("comparePenSync fails when live payload is newer than disk", () => {
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tempDir = createTempDir();
+  const { nodesFile, variablesFile } = writePayloadFiles(tempDir, fixture);
+  const outputPath = path.join(tempDir, "written.pen");
+
+  writePenFromPayloadFiles({
+    outputPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version
+  });
+
+  const drifted = JSON.parse(fs.readFileSync(nodesFile, "utf8"));
+  drifted.nodes = drifted.nodes.concat([
+    {
+      id: "new-screen",
+      type: "frame",
+      children: []
+    }
+  ]);
+  fs.writeFileSync(nodesFile, JSON.stringify(drifted, null, 2));
+
+  const result = comparePenSync({
+    penPath: outputPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version
+  });
+
+  assert.equal(result.inSync, false);
+  assert.notEqual(result.liveHash, result.persistedHash);
+});
+
+runTest("global Pencil lock serializes projects", () => {
+  const tempDir = createTempDir();
+  const homeDir = path.join(tempDir, "home");
+  const projectA = path.join(tempDir, "project-a");
+  const projectB = path.join(tempDir, "project-b");
+
+  const first = acquirePencilLock({
+    projectPath: projectA,
+    owner: "project-a",
+    homeDir
+  });
+  assert.equal(first.acquired, true);
+
+  assert.throws(
+    () =>
+      acquirePencilLock({
+        projectPath: projectB,
+        owner: "project-b",
+        homeDir,
+        waitMs: 0
+      }),
+    /already held/i
+  );
+
+  const status = getPencilLockStatus({ homeDir });
+  assert.equal(status.lock.projectPath, path.resolve(projectA));
+
+  const released = releasePencilLock({
+    projectPath: projectA,
+    homeDir
+  });
+  assert.equal(released.released, true);
+  assert.equal(getPencilLockStatus({ homeDir }).lock, null);
+});
+
 runTest("truncated nodes payload is rejected", () => {
   const tempDir = createTempDir();
   const nodesFile = path.join(tempDir, "nodes.json");

package/scripts/test-pencil-session.js

@@ -0,0 +1,152 @@
+const assert = require("assert/strict");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const {
+  beginPencilSession,
+  persistPencilSession,
+  endPencilSession,
+  getPencilSessionStatus,
+  getSessionStatePath
+} = require("../lib/pencil-session");
+
+const fixturePath = path.join(__dirname, "fixtures", "complex-sample.pen");
+
+function runTest(name, fn) {
+  try {
+    fn();
+    console.log(`PASS ${name}`);
+  } catch (error) {
+    console.error(`FAIL ${name}`);
+    throw error;
+  }
+}
+
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-pencil-session-"));
+}
+
+function writePayloadFiles(tempDir, fixture) {
+  const nodesFile = path.join(tempDir, "nodes.json");
+  const variablesFile = path.join(tempDir, "variables.json");
+  fs.writeFileSync(nodesFile, JSON.stringify({ nodes: fixture.children }, null, 2));
+  fs.writeFileSync(variablesFile, JSON.stringify({ variables: fixture.variables }, null, 2));
+  return { nodesFile, variablesFile };
+}
+
+runTest("pencil-session begin seeds pen and acquires lock", () => {
+  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 result = beginPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    homeDir
+  });
+
+  assert.equal(fs.existsSync(penPath), true);
+  assert.equal(result.session.status, "active");
+  assert.equal(result.session.penPath, path.resolve(penPath));
+  assert.equal(fs.existsSync(getSessionStatePath(projectRoot)), true);
+
+  endPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    homeDir,
+    force: true
+  });
+});
+
+runTest("pencil-session persist writes and syncs latest payload", () => {
+  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
+  });
+
+  const persistResult = persistPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version,
+    homeDir
+  });
+
+  assert.equal(persistResult.syncResult.inSync, true);
+  assert.equal(persistResult.session.status, "active");
+  assert.ok(persistResult.session.lastPersistedHash);
+
+  const status = getPencilSessionStatus({
+    projectPath: projectRoot,
+    homeDir
+  });
+  assert.equal(status.session.lastPersistedHash, persistResult.session.lastPersistedHash);
+
+  endPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    nodesFile,
+    variablesFile,
+    version: fixture.version,
+    homeDir
+  });
+});
+
+runTest("pencil-session end fails when live payload is stale", () => {
+  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
+  });
+
+  const drifted = JSON.parse(fs.readFileSync(nodesFile, "utf8"));
+  drifted.nodes.push({ id: "drift", type: "frame", children: [] });
+  fs.writeFileSync(nodesFile, JSON.stringify(drifted, null, 2));
+
+  assert.throws(
+    () =>
+      endPencilSession({
+        projectPath: projectRoot,
+        penPath,
+        nodesFile,
+        variablesFile,
+        version: fixture.version,
+        homeDir
+      }),
+    /out of sync/i
+  );
+
+  endPencilSession({
+    projectPath: projectRoot,
+    penPath,
+    homeDir,
+    force: true
+  });
+});
+
+console.log("All Pencil session tests passed.");