roadmapsmith 0.9.7 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "Evidence-backed ROADMAP.md generator and sync tool for AI coding agents.",
   "main": "src/index.js",
   "bin": {

package/src/io.js

@@ -159,7 +159,7 @@ function detectTestFrameworks(projectRoot, files) {
   if (files.some((file) => file.endsWith('pyproject.toml')) || files.some((file) => file.endsWith('pytest.ini'))) {
     frameworks.add('pytest');
   }
-  if (files.some((file) => /(^|\/)test_.*\.py$/.test(file)) || files.some((file) => /(^|\/)tests\//.test(file))) {
+  if (files.some((file) => /(^|\/)test_[^/]*\.py$/.test(file)) || files.some((file) => /(^|\/)tests\//.test(file))) {
     frameworks.add('python-tests');
   }
   if (files.some((file) => file.endsWith('go.mod'))) {

package/src/parser/index.js

@@ -203,7 +203,7 @@ function upsertManagedBlock(existingContent, managedBody) {
     if (existing.trim().length === 0) {
       return [MANAGED_START, ...bodyLines, MANAGED_END].join('\n');
     }
-    return `${existing.replace(/\s+$/, '')}\n\n${MANAGED_START}\n${managedBody}\n${MANAGED_END}`;
+    return `${existing.trimEnd()}\n\n${MANAGED_START}\n${managedBody}\n${MANAGED_END}`;
   }
 
   const prefix = lines.slice(0, range.start + 1);

package/src/sync/index.js

@@ -45,7 +45,13 @@ function applySync(content, parsedTasks, results) {
     }
 
     if (warningIndex != null && warningIndex >= 0 && warningIndex < lines.length) {
-      lines[warningIndex] = warningText;
+      const existingReason = lines[warningIndex].split('validation failed:')[1];
+      const newReason = reason || 'validation failed';
+      // Preserve existing warning when it's more descriptive than the new generic message.
+      const existingIsMoreSpecific = existingReason && existingReason.trim().length > newReason.length;
+      if (!existingIsMoreSpecific) {
+        lines[warningIndex] = warningText;
+      }
     } else {
       lines.splice(lastChildLineIndex + 1, 0, warningText);
       offset += 1;

package/src/validator/index.js

@@ -249,23 +249,47 @@ function collectPathishTokens(text) {
   return tokens.filter(Boolean);
 }
 
+// LINE_REF_RE matches "path/file.ext:NN" or "path/file.ext:NN-MM" — indicates WHERE
+// to implement, not that implementation exists. Paths matching this pattern are added
+// to lineReferenceHints and excluded from hasDirectReferencePass scoring.
+const LINE_REF_RE = /^(.+?):(\d+)(?:-\d+)?$/;
+
 function extractExplicitPaths(text) {
   const results = new Set();
+  const lineReferenceHints = new Set();
+
   const quoted = String(text).match(/`([^`]+)`/g) || [];
   for (const token of quoted) {
     const clean = token.slice(1, -1);
+    if (clean.includes('*') || clean.includes('?')) continue; // glob
     if (clean.includes('/') || clean.includes('\\') || clean.includes('.')) {
-      results.add(clean);
+      const lineMatch = LINE_REF_RE.exec(clean);
+      if (lineMatch && hasKnownFileExtension(lineMatch[1])) {
+        lineReferenceHints.add(lineMatch[1]);
+        results.add(lineMatch[1]);
+      } else {
+        results.add(clean);
+      }
     }
   }
 
-  const pathTokens = String(text).match(/([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+)/g) || [];
-  for (const raw of pathTokens) {
-    const token = stripTrailingPathPunctuation(raw);
-    if (isLikelyPath(token)) results.add(token);
+  for (const word of String(text).split(/\s+/)) {
+    if (!word.includes('/')) continue;
+    const token = stripTrailingPathPunctuation(word);
+    if (token.includes('*') || token.includes('?')) continue; // glob
+    const lineMatch = LINE_REF_RE.exec(token);
+    if (lineMatch && hasKnownFileExtension(lineMatch[1])) {
+      if (isLikelyPath(lineMatch[1])) {
+        lineReferenceHints.add(lineMatch[1]);
+        results.add(lineMatch[1]);
+      }
+    } else if (isLikelyPath(token)) {
+      results.add(token);
+    }
   }
 
-  return Array.from(results).sort((left, right) => left.localeCompare(right));
+  const paths = Array.from(results).sort((left, right) => left.localeCompare(right));
+  return { paths, lineReferenceHints };
 }
 
 // Standalone filenames (no slash) mentioned in task prose — e.g. "roadmap-skill.config.json",
@@ -644,7 +668,7 @@ function extractEvidencePaths(evidenceText) {
 
 function evidenceLineHasPassingSummary(evidenceText) {
   const text = String(evidenceText || '');
-  if (/\b\d+\s*\/\s*\d+\s+tests?\s+passing\b/i.test(text)) {
+  if (/\b\d+(?:\s*\/\s*\d+)?\s+tests?\s+passing\b/i.test(text)) {
     return true;
   }
   if (/\b(?:vitest|jest|npm test|pnpm test|yarn test|bun test)\b.*\b(?:pass(?:ing|ed)?|green|success(?:ful|fully)?)\b/i.test(text)) {
@@ -800,9 +824,6 @@ function findNegativeImplementationSignals(candidatePaths, fileIndex) {
 
   const indexedFiles = new Map(fileIndex.map((file) => [file.relativePath, file]));
   const negativeSignals = [
-    /\bTODO\b/i,
-    /\bFIXME\b/i,
-    /\bdisabled\b/i,
     /\bnot implemented\b/i,
     /throw\s+new\s+Error\s*\(\s*['"`][^'"`]*not implemented/i
   ];
@@ -1012,12 +1033,16 @@ function buildValidationContext(projectRoot, config, plugins) {
 }
 
 function validateTask(task, context, config, plugins) {
-  const pathHints = extractExplicitPaths(task.text);
+  const { paths: pathHints, lineReferenceHints } = extractExplicitPaths(task.text);
+  // Paths that are line-reference hints (file.ts:NN) indicate WHERE to implement,
+  // not that implementation exists. They are excluded from hasDirectReferencePass.
+  const purePathHints = pathHints.filter((p) => !lineReferenceHints.has(p));
   const standaloneFilenames = extractStandaloneFilenames(task.text);
   const symbolHints = extractSymbolHints(task.text);
   const authoritativeEvidence = evaluateAuthoritativeEvidence(task, context.fileIndex);
 
   const filesFromPaths = findFilesByPathHints(pathHints, context.fileIndex);
+  const filesFromPurePathHints = findFilesByPathHints(purePathHints, context.fileIndex);
   const filesFromSymbols = findFilesBySymbols(symbolHints, context.fileIndex);
   // Combine path hints AND standalone filenames for token exclusion so that tokens
   // derived from any referenced filename (e.g. "roadmap-skill" from
@@ -1110,7 +1135,7 @@ function validateTask(task, context, config, plugins) {
     }
   }
 
-  if (requiresTest && !evidence.test && !authoritativeEvidence.passed) {
+  if (requiresTest && !evidence.test && !authoritativeEvidence.passed && filesFromPurePathHints.length === 0) {
     reasons.push('missing test evidence');
   }
 
@@ -1123,7 +1148,8 @@ function validateTask(task, context, config, plugins) {
   const attempted = hasStrongEvidence || hasWeakEvidence || pathHints.length > 0 || symbolHints.length > 0 || authoritativeEvidence.active;
   const { categories: strongEvidenceCategories } = countStrongEvidenceCategories(task.text, evidence);
   const strongEvidenceCount = strongEvidenceCategories.length;
-  const hasDirectReferencePass = filesFromPaths.length > 0 || filesFromSymbols.length > 0;
+  // Only pure path hints (not line-reference hints like file.ts:169) count as direct evidence.
+  const hasDirectReferencePass = filesFromPurePathHints.length > 0 || filesFromSymbols.length > 0;
   const hasArtifactTaskPass = evidence.artifact && (
     isDocTask(task.text) ||
     evidence.heuristicArtifacts.length > 0 ||
@@ -1166,6 +1192,23 @@ function validateTask(task, context, config, plugins) {
     passed = false;
   }
 
+  const shouldPreserveCheckedTask =
+    task.checked &&
+    !passed &&
+    !authoritativeEvidence.active &&
+    purePathHints.length === 0 &&
+    symbolHints.length === 0 &&
+    !hasDirectReferencePass &&
+    evidence.structuralEvidence !== false &&
+    negativeSignalMatches.length === 0;
+  let preservedCheckedState = false;
+  if (shouldPreserveCheckedTask) {
+    passed = true;
+    confidence = 'low';
+    uniqueReasons = [];
+    preservedCheckedState = true;
+  }
+
   // True when the only passing evidence is artifact/doc files and the task is not a doc task.
   // Used by auditValidation to flag implementation tasks that pass solely via documentation.
   const evidenceIsDocOnly = !evidence.code && !evidence.test && evidence.artifact && !isDocTask(task.text);
@@ -1179,15 +1222,32 @@ function validateTask(task, context, config, plugins) {
     evidenceIsDocOnly,
     requiresTest,
     hasEvidence: hasStrongEvidence || hasWeakEvidence,
-    attempted
+    attempted,
+    preservedCheckedState
   };
 }
 
+const BLOCKED_BY_RE = /\bBlocked\s+by:\s*([^\n.]+)/i;
+
 function validateTasks(tasks, context, config, plugins) {
   const result = {};
   for (const task of tasks) {
     result[task.id] = validateTask(task, context, config, plugins);
   }
+
+  // Post-pass: milestone tasks with "Blocked by: id-a, id-b" cannot pass
+  // while any listed dependency is still failing.
+  for (const task of tasks) {
+    const m = BLOCKED_BY_RE.exec(task.text);
+    if (!m) continue;
+    const blockedIds = m[1].split(/[\s,]+/).map((s) => s.trim()).filter(Boolean);
+    const failingDeps = blockedIds.filter((id) => result[id] && !result[id].passed);
+    if (failingDeps.length > 0 && result[task.id] && result[task.id].passed) {
+      result[task.id].passed = false;
+      result[task.id].reasons = [`blocked by incomplete tasks: ${failingDeps.join(', ')}`];
+    }
+  }
+
   return result;
 }
 
@@ -1237,6 +1297,9 @@ function applyMinimumConfidence(results, minimumConfidence) {
   const minRank = CONFIDENCE_RANK[minimumConfidence] ?? 0;
   if (minRank === 0) return;
   for (const result of Object.values(results)) {
+    if (result.preservedCheckedState) {
+      continue;
+    }
     if ((CONFIDENCE_RANK[result.confidence] ?? 0) < minRank) {
       result.passed = false;
       result.reasons = [