roadmapsmith 0.9.8 → 0.9.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roadmapsmith",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "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

@@ -178,7 +178,11 @@ function hasFileExtension(token) {
 }
 
 function isLikelyPath(token) {
-  if (/^\.{1,2}\/|^\//.test(token)) return true;
+  if (token.includes('*') || token.includes('?')) return false; // glob/wildcard
+  if (/^\.{1,2}\/|^\//.test(token)) {
+    // Bare "/" or "./" with nothing after is not a real path (e.g. "API / ESC-POS" → "/")
+    return /[A-Za-z0-9_]/.test(token);
+  }
   if (hasFileExtension(token)) return true;
   if (KNOWN_PATH_ROOTS.some((root) => token.startsWith(root))) return true;
   // The ">= 2 slashes" rule was intentionally removed: it caused conceptual slash phrases
@@ -249,23 +253,51 @@ 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('\\') || clean.includes('.')) {
+    if (clean.includes('*') || clean.includes('?')) continue; // glob
+    const hasSlash = clean.includes('/') || clean.includes('\\');
+    // Require a slash or a known file extension — rejects property access like err.message,
+    // fs.readFileSync, error.stack (whose extensions are not in KNOWN_FILE_EXTENSIONS).
+    if (!hasSlash && !hasKnownFileExtension(clean)) continue;
+    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)
+    .filter((p) => !p.includes('*') && !p.includes('?'))
+    .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 +676,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)) {
@@ -1009,12 +1041,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
@@ -1032,7 +1068,9 @@ function validateTask(task, context, config, plugins) {
     code: filesFromCode.length > 0 || filesFromSymbols.length > 0,
     test: filesFromTests.length > 0,
     artifact: filesFromArtifacts.length > 0,
-    files: filesFromPaths,
+    // Use only pure path hints (not line-reference hints) so that "file.ts:169" style hints
+    // — which indicate WHERE to implement — do not contribute to feature-surface scoring.
+    files: filesFromPurePathHints,
     symbols: filesFromSymbols,
     codeFiles: filesFromCode,
     weakPathFiles: filesFromWeakPathTokens,
@@ -1049,7 +1087,9 @@ function validateTask(task, context, config, plugins) {
   applyAuthoritativeEvidence(evidence, authoritativeEvidence, context.fileIndex);
 
   const reasons = [];
-  if (pathHints.length > 0 && filesFromPaths.length === 0) {
+  // Suppress path hint failures when authoritative evidence already confirms the task —
+  // a bad path hint (typo, moved file) should not override a passing Evidence line.
+  if (pathHints.length > 0 && filesFromPaths.length === 0 && !authoritativeEvidence.passed) {
     reasons.push(`missing referenced file(s): ${pathHints.join(', ')}`);
   }
   if (Array.isArray(authoritativeEvidence.reasons) && authoritativeEvidence.reasons.length > 0) {
@@ -1107,7 +1147,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');
   }
 
@@ -1120,7 +1160,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 ||
@@ -1153,7 +1194,19 @@ function validateTask(task, context, config, plugins) {
     uniqueReasons = Array.from(new Set(uniqueReasons));
   }
 
-  let passed = authoritativeEvidence.passed || hasDirectReferencePass || hasArtifactTaskPass || hasTrustedRuleEvidencePass || meetsStrongThreshold;
+  // hasDirectReferencePass is intentionally excluded: a path hint in task text indicates
+  // WHERE to implement, not that implementation is done. Unchecked tasks need authoritative
+  // evidence, artifact evidence, or strong code+test threshold to pass.
+  // Already-checked tasks with found path hints are preserved via shouldPreserveCheckedTask.
+  let passed = authoritativeEvidence.passed || hasArtifactTaskPass || hasTrustedRuleEvidencePass || meetsStrongThreshold;
+
+  if (!passed && !task.checked && hasDirectReferencePass) {
+    const locationReason = 'file reference shows implementation location, not confirmed completion';
+    if (!uniqueReasons.includes(locationReason)) {
+      uniqueReasons.push(locationReason);
+    }
+  }
+
   if (task.warningText && passed && !authoritativeEvidence.passed && !meetsStrongThreshold) {
     passed = false;
     uniqueReasons.push(task.warningText);
@@ -1163,15 +1216,20 @@ function validateTask(task, context, config, plugins) {
     passed = false;
   }
 
+  // Preserve already-checked tasks when the validator can't confirm implementation but also
+  // can't find strong evidence against it. Two cases:
+  //   1. No path/symbol hints at all — no machine-readable claims to evaluate.
+  //   2. Path hints resolve to existing files but code/test evidence is absent —
+  //      file presence is not implementation; don't uncheck on that alone.
+  // Symbol hints are NOT preserved: a missing symbol is a concrete falsifiable claim.
   const shouldPreserveCheckedTask =
     task.checked &&
     !passed &&
     !authoritativeEvidence.active &&
-    pathHints.length === 0 &&
     symbolHints.length === 0 &&
-    !hasDirectReferencePass &&
+    negativeSignalMatches.length === 0 &&
     evidence.structuralEvidence !== false &&
-    negativeSignalMatches.length === 0;
+    (hasDirectReferencePass || purePathHints.length === 0);
   let preservedCheckedState = false;
   if (shouldPreserveCheckedTask) {
     passed = true;
@@ -1198,11 +1256,27 @@ function validateTask(task, context, config, plugins) {
   };
 }
 
+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;
 }