@xenonbyte/da-vinci-workflow 0.2.8 → 0.2.9

package/lib/execution-signals.js

@@ -118,6 +118,38 @@ function readExecutionSignals(projectRoot, options = {}) {
   );
 }
 
+function listExecutionSignalPathsForChange(projectRoot, options = {}) {
+  const changeId = options.changeId ? String(options.changeId).trim() : "";
+  const signalsDir = resolveSignalsDir(projectRoot);
+  if (!changeId || !pathExists(signalsDir)) {
+    return [];
+  }
+
+  const entries = fs
+    .readdirSync(signalsDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".json"));
+  const paths = [];
+
+  for (const entry of entries) {
+    const absolutePath = path.join(signalsDir, entry.name);
+    const parsedName = parseSignalFileName(entry.name);
+    let include = false;
+
+    try {
+      const payload = JSON.parse(fs.readFileSync(absolutePath, "utf8"));
+      include = String(payload.changeId || "") === changeId;
+    } catch (_error) {
+      include = String(parsedName.changeId || "").trim() === changeId;
+    }
+
+    if (include) {
+      paths.push(absolutePath);
+    }
+  }
+
+  return paths.sort((left, right) => left.localeCompare(right));
+}
+
 function summarizeSignalsBySurface(signals) {
   const summary = {};
   for (const signal of signals || []) {
@@ -148,6 +180,7 @@ function getLatestSignalBySurfacePrefix(signals, prefix) {
 module.exports = {
   writeExecutionSignal,
   readExecutionSignals,
+  listExecutionSignalPathsForChange,
   summarizeSignalsBySurface,
   listSignalsBySurfacePrefix,
   getLatestSignalBySurfacePrefix

package/lib/fs-safety.js

@@ -1,6 +1,7 @@
 const fs = require("fs");
 const path = require("path");
 const { pathExists } = require("./utils");
+const { isPathInside } = require("./path-inside");
 
 const DEFAULT_MAX_DEPTH = 32;
 const DEFAULT_MAX_ENTRIES = 20000;
@@ -19,18 +20,6 @@ function toPositiveInteger(value, fallback) {
   return normalized;
 }
 
-function isPathInside(basePath, targetPath) {
-  const resolvedBase = path.resolve(basePath);
-  const resolvedTarget = path.resolve(targetPath);
-
-  if (resolvedBase === resolvedTarget) {
-    return true;
-  }
-
-  const relative = path.relative(resolvedBase, resolvedTarget);
-  return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
-}
-
 function listFilesRecursiveSafe(rootDir, options = {}) {
   const maxDepth = toPositiveInteger(options.maxDepth, DEFAULT_MAX_DEPTH);
   const maxEntries = toPositiveInteger(options.maxEntries, DEFAULT_MAX_ENTRIES);

package/lib/path-inside.js

@@ -0,0 +1,17 @@
+const path = require("path");
+
+function isPathInside(basePath, targetPath) {
+  const resolvedBase = path.resolve(basePath);
+  const resolvedTarget = path.resolve(targetPath);
+
+  if (resolvedBase === resolvedTarget) {
+    return true;
+  }
+
+  const relative = path.relative(resolvedBase, resolvedTarget);
+  return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+
+module.exports = {
+  isPathInside
+};

package/lib/utils.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const path = require("path");
+const { isPathInside } = require("./path-inside");
 
 const HAS_SYNC_WAIT =
   typeof SharedArrayBuffer === "function" &&
@@ -36,13 +37,7 @@ function normalizeRelativePath(relativePath) {
 }
 
 function pathWithinRoot(projectRoot, candidatePath) {
-  const root = path.resolve(projectRoot);
-  const candidate = path.resolve(candidatePath);
-  if (candidate === root) {
-    return true;
-  }
-  const prefix = root.endsWith(path.sep) ? root : `${root}${path.sep}`;
-  return candidate.startsWith(prefix);
+  return isPathInside(projectRoot, candidatePath);
 }
 
 function uniqueValues(values) {

package/lib/workflow-base-view.js

@@ -0,0 +1,134 @@
+const { getStageById } = require("./workflow-contract");
+const {
+  deriveStageFromArtifacts,
+  buildBaseHandoffGates
+} = require("./workflow-stage");
+
+/**
+ * @typedef {Object} WorkflowFindings
+ * @property {string[]} blockers
+ * @property {string[]} warnings
+ * @property {string[]} notes
+ */
+
+/**
+ * @typedef {Object} WorkflowArtifactState
+ * @property {boolean} workflowRootReady
+ * @property {boolean} changeSelected
+ * @property {boolean} proposal
+ * @property {string[]} specFiles
+ * @property {boolean} design
+ * @property {boolean} pencilDesign
+ * @property {boolean} pencilBindings
+ * @property {boolean} tasks
+ * @property {boolean} verification
+ */
+
+/**
+ * @typedef {Object.<string, string>} WorkflowCheckpointStatusMap
+ */
+
+/**
+ * @typedef {Object} WorkflowCompletionAudit
+ * @property {string} [status]
+ * @property {string[]} [failures]
+ * @property {string[]} [warnings]
+ * @property {string[]} [notes]
+ */
+
+/**
+ * @typedef {Object} PersistedWorkflowRecord
+ * @property {string} [stage]
+ * @property {Object.<string, string>} [gates]
+ */
+
+/**
+ * @typedef {Object} WorkflowBaseView
+ * @property {"persisted"|"derived"} source
+ * @property {string} stageId
+ * @property {WorkflowFindings} findings
+ * @property {Object.<string, string>} baseGates
+ * @property {WorkflowCompletionAudit | null} completionAudit
+ * @property {Array<object>} taskGroupSeed
+ */
+
+function cloneFindings(findings) {
+  return {
+    blockers: Array.isArray(findings && findings.blockers) ? findings.blockers.slice() : [],
+    warnings: Array.isArray(findings && findings.warnings) ? findings.warnings.slice() : [],
+    notes: Array.isArray(findings && findings.notes) ? findings.notes.slice() : []
+  };
+}
+
+function resolveCompletionAudit(stageId, resolver) {
+  if (typeof resolver !== "function") {
+    return null;
+  }
+  return resolver(stageId);
+}
+
+/**
+ * Normalize a trusted persisted workflow snapshot into the shared base-view shape.
+ *
+ * @param {{
+ *   persistedRecord?: PersistedWorkflowRecord,
+ *   findings?: WorkflowFindings,
+ *   taskGroupSeed?: Array<object>,
+ *   resolveCompletionAudit?: (stageId: string) => (WorkflowCompletionAudit | null)
+ * }} [options]
+ * @returns {WorkflowBaseView}
+ */
+function buildPersistedWorkflowBaseView(options = {}) {
+  const persistedRecord = options.persistedRecord || {};
+  const stage = getStageById(persistedRecord.stage) || getStageById("bootstrap");
+
+  return {
+    source: "persisted",
+    stageId: stage.id,
+    findings: cloneFindings(options.findings),
+    baseGates:
+      persistedRecord && persistedRecord.gates && typeof persistedRecord.gates === "object"
+        ? { ...persistedRecord.gates }
+        : {},
+    completionAudit: resolveCompletionAudit(stage.id, options.resolveCompletionAudit),
+    taskGroupSeed: Array.isArray(options.taskGroupSeed) ? options.taskGroupSeed : []
+  };
+}
+
+/**
+ * Build the artifact/checkpoint-backed base view before runtime overlays apply.
+ *
+ * @param {{
+ *   artifactState?: WorkflowArtifactState,
+ *   checkpointStatuses?: WorkflowCheckpointStatusMap,
+ *   findings?: WorkflowFindings,
+ *   taskGroupSeed?: Array<object>,
+ *   resolveCompletionAudit?: (stageId: string) => (WorkflowCompletionAudit | null)
+ * }} [options]
+ * @returns {WorkflowBaseView}
+ */
+function buildDerivedWorkflowBaseView(options = {}) {
+  const findings = cloneFindings(options.findings);
+  const stageId = deriveStageFromArtifacts(
+    options.artifactState || {},
+    options.checkpointStatuses || {},
+    findings
+  );
+  const completionAudit = resolveCompletionAudit(stageId, options.resolveCompletionAudit);
+
+  return {
+    source: "derived",
+    stageId,
+    findings,
+    baseGates: buildBaseHandoffGates(options.artifactState || {}, options.checkpointStatuses || {}, {
+      completionAudit
+    }),
+    completionAudit,
+    taskGroupSeed: Array.isArray(options.taskGroupSeed) ? options.taskGroupSeed : []
+  };
+}
+
+module.exports = {
+  buildPersistedWorkflowBaseView,
+  buildDerivedWorkflowBaseView
+};