@xenonbyte/da-vinci-workflow 0.2.3 → 0.2.5

package/lib/planning-parsers.js

@@ -1,7 +1,11 @@
 const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
-const { getMarkdownSection } = require("./audit-parsers");
+const {
+  getMarkdownSection,
+  parseDisciplineMarkers,
+  DISCIPLINE_MARKER_NAMES
+} = require("./audit-parsers");
 const { parseRuntimeSpecMarkdown } = require("./artifact-parsers");
 const { pathExists, readTextIfExists } = require("./utils");
 
@@ -62,7 +66,7 @@ function unique(values) {
 }
 
 function resolveImplementationLanding(projectRoot, implementationToken) {
-  const knownExtensions = [".html", ".tsx", ".jsx", ".ts", ".js"];
+  const knownExtensions = [".html", ".tsx", ".jsx", ".ts", ".js", ".vue", ".svelte"];
   const seen = new Set();
   const candidates = [];
   const addCandidate = (relativePath) => {
@@ -89,6 +93,9 @@ function resolveImplementationLanding(projectRoot, implementationToken) {
       addCandidate(path.join(dirPath, `page${extension}`));
     }
   };
+  const addSvelteRoutePageCandidate = (dirPath) => {
+    addCandidate(path.join(dirPath, "+page.svelte"));
+  };
   const resolveFileCandidate = (relativePath) => {
     const absolutePath = path.join(projectRoot, relativePath);
     try {
@@ -114,6 +121,8 @@ function resolveImplementationLanding(projectRoot, implementationToken) {
     addPageCandidates("app");
     addFileCandidates(path.join("src", "app", "page"));
     addPageCandidates(path.join("src", "app"));
+    addSvelteRoutePageCandidate(path.join("src", "routes"));
+    addSvelteRoutePageCandidate("routes");
   } else {
     const routePath = normalized.replace(/^\//, "").replace(/\/+$/, "");
     addFileCandidates(routePath);
@@ -131,6 +140,8 @@ function resolveImplementationLanding(projectRoot, implementationToken) {
     addPageCandidates(path.join("app", routePath));
     addFileCandidates(path.join("src", "app", routePath, "page"));
     addPageCandidates(path.join("src", "app", routePath));
+    addSvelteRoutePageCandidate(path.join("src", "routes", routePath));
+    addSvelteRoutePageCandidate(path.join("routes", routePath));
   }
 
   for (const candidate of candidates) {
@@ -350,33 +361,239 @@ function parsePageMapArtifact(text) {
   };
 }
 
+function parseInlineCodeTokens(line) {
+  const tokens = [];
+  const matches = String(line || "").matchAll(/`([^`]+)`/g);
+  for (const match of matches) {
+    const token = String(match[1] || "").trim();
+    if (token) {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+}
+
+function normalizeExecutionIntent(text) {
+  const normalized = normalizeText(text);
+  if (!normalized) {
+    return "";
+  }
+  if (/bounded parallel|parallel bounded|parallel-safe/.test(normalized)) {
+    return "bounded_parallel";
+  }
+  if (/serial|sequential|one by one/.test(normalized)) {
+    return "serial";
+  }
+  if (/review required|review-required|review heavy|spec review|quality review/.test(normalized)) {
+    return "review_required";
+  }
+  return "";
+}
+
+function hasVerificationIntent(text) {
+  return /verify|verification|coverage|assert|validate|smoke/i.test(String(text || ""));
+}
+
+function hasTestingIntent(text) {
+  return /(?:^|\b)(test|tests|unit test|integration test|e2e|regression|tdd|coverage)(?:\b|$)/i.test(
+    String(text || "")
+  );
+}
+
+function hasReviewIntent(text) {
+  return /review|reviewer|spec review|quality review|qa|audit/i.test(String(text || ""));
+}
+
+function looksLikeCodeChange(text) {
+  return /implement|modify|update|add|create|refactor|fix|remove|rename|rewrite|harden|extend/i.test(
+    String(text || "")
+  );
+}
+
+function isPlaceholderText(text) {
+  return /\b(TBD|TODO|implement later|later fill|to be decided)\b/i.test(String(text || ""));
+}
+
+function extractFileReferences(text) {
+  const references = [];
+  const seen = new Set();
+  const addReference = (value) => {
+    const candidate = String(value || "")
+      .replace(/[`"'(),]/g, "")
+      .trim();
+    if (!candidate) {
+      return;
+    }
+    if (!/[./]/.test(candidate)) {
+      return;
+    }
+    if (candidate.length < 3) {
+      return;
+    }
+    if (seen.has(candidate)) {
+      return;
+    }
+    seen.add(candidate);
+    references.push(candidate);
+  };
+
+  for (const token of parseInlineCodeTokens(text)) {
+    addReference(token);
+  }
+  const plainMatches = String(text || "").matchAll(/(?:^|[\s(])([A-Za-z0-9._/-]+(?:\.[A-Za-z0-9_*.-]+|\/))(?:$|[\s),])/g);
+  for (const match of plainMatches) {
+    addReference(match[1]);
+  }
+  return references;
+}
+
+function extractVerificationCommands(text) {
+  const commands = [];
+  const supportedCommandPattern =
+    /^(?:da-vinci\s+verify-(?:bindings|implementation|structure|coverage)|npm|pnpm|yarn|bun|node|npx|pytest|go test|cargo test|dotnet test|mvn test|gradle test|make test|vitest|jest)\b/i;
+  const addCommand = (value) => {
+    const command = String(value || "").trim();
+    if (!command) {
+      return;
+    }
+    if (!/\s/.test(command)) {
+      return;
+    }
+    if (!supportedCommandPattern.test(command)) {
+      return;
+    }
+    commands.push(command);
+  };
+  for (const token of parseInlineCodeTokens(text)) {
+    addCommand(token);
+  }
+  return unique(commands);
+}
+
+function analyzeTaskGroup(section) {
+  const targetFiles = [];
+  const verificationActions = [];
+  const verificationCommands = [];
+  const placeholderItems = [];
+  const rawFileReferences = [];
+  const executionHints = [];
+
+  const lines = Array.isArray(section.lines) ? section.lines : [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = String(lines[index] || "");
+    rawFileReferences.push(...extractFileReferences(line));
+    if (isPlaceholderText(line)) {
+      placeholderItems.push(line.trim());
+    }
+    if (hasVerificationIntent(line)) {
+      verificationActions.push(line.trim());
+    }
+    verificationCommands.push(...extractVerificationCommands(line));
+    const executionIntent = normalizeExecutionIntent(line);
+    if (executionIntent) {
+      executionHints.push(executionIntent);
+    }
+
+    if (/^\s*target files\s*:\s*$/i.test(line)) {
+      for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+        const followLine = String(lines[cursor] || "");
+        if (/^\s*$/.test(followLine)) {
+          continue;
+        }
+        if (/^\s{0,3}##\s+/.test(followLine)) {
+          break;
+        }
+        if (/^\s*[A-Za-z][A-Za-z0-9 _-]{0,80}\s*:\s*$/.test(followLine)) {
+          break;
+        }
+        const itemMatch = followLine.match(/^\s*-\s+(.+)$/);
+        if (!itemMatch) {
+          break;
+        }
+        const entry = String(itemMatch[1] || "").trim();
+        if (!entry) {
+          continue;
+        }
+        targetFiles.push(...extractFileReferences(entry));
+      }
+    }
+  }
+
+  for (const item of section.checklistItems) {
+    rawFileReferences.push(...extractFileReferences(item.text));
+    if (isPlaceholderText(item.text)) {
+      placeholderItems.push(item.text);
+    }
+    if (hasVerificationIntent(item.text)) {
+      verificationActions.push(item.text);
+    }
+    verificationCommands.push(...extractVerificationCommands(item.text));
+    const executionIntent = normalizeExecutionIntent(item.text);
+    if (executionIntent) {
+      executionHints.push(executionIntent);
+    }
+  }
+
+  const mergedFileReferences = unique([...targetFiles, ...rawFileReferences]);
+  const titleExecutionIntent = normalizeExecutionIntent(section.title);
+  if (titleExecutionIntent) {
+    executionHints.push(titleExecutionIntent);
+  }
+
+  const joinedContent = [section.title, ...lines, ...section.checklistItems.map((item) => item.text)].join("\n");
+  return {
+    ...section,
+    targetFiles: unique(targetFiles),
+    fileReferences: mergedFileReferences,
+    verificationActions: unique(verificationActions.filter(Boolean)),
+    verificationCommands: unique(verificationCommands),
+    executionIntent: unique(executionHints),
+    reviewIntent: hasReviewIntent(joinedContent),
+    testingIntent: hasTestingIntent(joinedContent),
+    codeChangeLikely: looksLikeCodeChange(joinedContent),
+    placeholderItems: unique(placeholderItems.filter(Boolean))
+  };
+}
+
 function parseTasksArtifact(text) {
   const lines = String(text || "").replace(/\r\n?/g, "\n").split("\n");
   const taskGroups = [];
   const checklistItems = [];
   const checkpointItems = [];
   const sections = [];
+  const markers = parseDisciplineMarkers(text);
   let currentSection = null;
 
-  for (const line of lines) {
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex];
     const groupMatch = line.match(/^\s{0,3}##\s+(\d+(?:\.\d+)*)\.\s+(.+)$/);
     if (groupMatch) {
       const group = {
         id: groupMatch[1],
-        title: String(groupMatch[2] || "").trim()
+        title: String(groupMatch[2] || "").trim(),
+        startLine: lineIndex + 1
       };
       taskGroups.push(group);
       if (currentSection) {
-        sections.push(currentSection);
+        currentSection.endLine = lineIndex;
+        sections.push(analyzeTaskGroup(currentSection));
       }
       currentSection = {
         id: group.id,
         title: group.title,
-        checklistItems: []
+        startLine: lineIndex + 1,
+        endLine: lineIndex + 1,
+        checklistItems: [],
+        lines: []
       };
       continue;
     }
 
+    if (currentSection) {
+      currentSection.lines.push(line);
+      currentSection.endLine = lineIndex + 1;
+    }
+
     const checklistMatch = line.match(/^\s*-\s*\[([ xX])\]\s+(.+)$/);
     if (checklistMatch) {
       const checked = String(checklistMatch[1] || "").toLowerCase() === "x";
@@ -384,33 +601,60 @@ function parseTasksArtifact(text) {
       if (!textValue) {
         continue;
       }
-      checklistItems.push({
+      const item = {
         checked,
-        text: textValue
-      });
+        text: textValue,
+        line: lineIndex + 1
+      };
+      checklistItems.push(item);
       if (currentSection) {
-        currentSection.checklistItems.push({
-          checked,
-          text: textValue
-        });
+        currentSection.checklistItems.push(item);
       }
       if (/checkpoint/i.test(textValue)) {
-        checkpointItems.push({
-          checked,
-          text: textValue
-        });
+        checkpointItems.push(item);
       }
     }
   }
   if (currentSection) {
-    sections.push(currentSection);
+    sections.push(analyzeTaskGroup(currentSection));
   }
 
+  const sectionById = new Map(sections.map((section) => [section.id, section]));
+  const normalizedTaskGroups = taskGroups.map((group) => {
+    const section = sectionById.get(group.id);
+    if (!section) {
+      return group;
+    }
+    return {
+      id: group.id,
+      title: group.title,
+      startLine: group.startLine,
+      endLine: section.endLine,
+      targetFiles: section.targetFiles,
+      fileReferences: section.fileReferences,
+      verificationActions: section.verificationActions,
+      verificationCommands: section.verificationCommands,
+      executionIntent: section.executionIntent,
+      reviewIntent: section.reviewIntent,
+      testingIntent: section.testingIntent,
+      codeChangeLikely: section.codeChangeLikely,
+      placeholderItems: section.placeholderItems,
+      checklistItems: section.checklistItems
+    };
+  });
+
   return {
-    taskGroups,
+    taskGroups: normalizedTaskGroups,
     checklistItems,
     checkpointItems,
     sections,
+    markers,
+    markerSummary: {
+      hasDesignApproval: Boolean(markers.markers[DISCIPLINE_MARKER_NAMES.designApproval]),
+      hasPlanSelfReview: Boolean(markers.markers[DISCIPLINE_MARKER_NAMES.planSelfReview]),
+      hasOperatorReviewAck: Boolean(markers.markers[DISCIPLINE_MARKER_NAMES.operatorReviewAck]),
+      malformedCount: markers.malformed.length
+    },
     text: String(text || "")
   };
 }