trackfw 6.0.0 → 6.3.0

package/src/validator/index.js

@@ -254,22 +254,97 @@ function contentHasMarker(content, markers) {
   return false
 }
 
-// adrIsDraft verifica se <adrBasename> contém "Status: Draft" buscando recursivamente nas adrDirs.
-function adrIsDraft(basename) {
-  return adrDraftStatusForRule(basename, null).draft
+// extractAdrHeaderStatus extrai o valor declarado na linha de cabeçalho
+// ("> Date: ... | Status: X") de um ADR. Ancorado à linha — não é substring livre sobre o
+// documento inteiro — para não confundir texto de prosa que mencione "Status: Draft"/"Proposed"
+// (ex: citações de código, exemplos) com o status real do artefato. Retorna '' se a linha não
+// existir.
+function extractAdrHeaderStatus(content) {
+  const marker = '| Status: '
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    const idx = trimmed.indexOf(marker)
+    if (idx >= 0) {
+      let rest = trimmed.slice(idx + marker.length)
+      const pipeIdx = rest.indexOf(' |')
+      if (pipeIdx >= 0) rest = rest.slice(0, pipeIdx)
+      return rest.trim()
+    }
+  }
+  return ''
 }
 
-function adrDraftStatusForRule(basename, messages) {
+// extractFrontmatterField extrai o valor de um campo do bloco frontmatter YAML
+// (delimitado por "---" ... "---" no início do arquivo). Retorna '' se o frontmatter
+// estiver ausente ou o campo não existir/estiver vazio.
+function extractFrontmatterField(content, field) {
+  if (!content.startsWith('---')) return ''
+  const rest = content.slice(3)
+  const end = rest.indexOf('\n---')
+  if (end < 0) return ''
+  const block = rest.slice(0, end)
+  for (const line of block.split('\n')) {
+    const trimmed = line.trim()
+    if (trimmed.startsWith(field + ':')) {
+      let val = trimmed.slice(field.length + 1).trim()
+      val = val.replace(/^["']|["']$/g, '')
+      return val
+    }
+  }
+  return ''
+}
+
+// resolveAdrStatus extrai o valor bruto do status de um ADR: frontmatter `status:`
+// primeiro — é o campo machine-readable canônico, o mesmo que os geradores (`adr new`,
+// NewADRDraft) escrevem e que a regra folder_status já usa como fonte de verdade — com
+// fallback para a linha de cabeçalho ("> Date: ... | Status: X") somente se o
+// frontmatter estiver ausente ou sem o campo (cobre ADRs legados sem frontmatter). Em um
+// ADR bem formado os dois concordam. ML-1D (2026-08-01): alinha o Node ao Go e ao
+// Python, que já liam frontmatter-first (ADR-2026-08-01-nocao-canonica-de-adr-nao-aceito).
+function resolveAdrStatus(content) {
+  const fm = extractFrontmatterField(content, 'status')
+  if (fm) return fm
+  return extractAdrHeaderStatus(content)
+}
+
+// adrNotAcceptedStatusForRule é o helper canônico de "ADR não aceito": único lugar que conhece o
+// vocabulário Draft/Proposed. Verdadeiro para ADR cujo status seja "Draft" ou "Proposed"; qualquer
+// outro status (Accepted, Superseded, Deprecated, Rejected, ...) conta como aceito por exclusão —
+// não há allowlist fechada de status aceitos.
+//
+// A fonte do status é resolveAdrStatus (frontmatter-first, fallback de cabeçalho — ver acima).
+// Crucial: o fallback de cabeçalho extrai o valor de UMA linha específica
+// (extractAdrHeaderStatus), não faz content.includes('Status: Draft') sobre o documento
+// inteiro — esse era o defeito do código herdado (adrDraftStatusForRule original): um ADR
+// com status real "Accepted" mas cuja prosa cita literalmente a string "Status: Draft"
+// (ex: este próprio ADR, que documenta o bug) seria classificado como não aceito. Ver
+// vault/notes para o caso concreto que expôs isso.
+function adrNotAcceptedStatusForRule(rule, basename, messages) {
   const p = findAdrFile(basename)
-  if (!p) return { draft: false, inspected: true }
+  if (!p) return { notAccepted: false, status: '', inspected: true }
   try {
-    return { draft: fs.readFileSync(p, 'utf8').includes('Status: Draft'), inspected: true }
+    const content = fs.readFileSync(p, 'utf8')
+    const status = resolveAdrStatus(content)
+    const notAccepted = status.toLowerCase() === 'draft' || status.toLowerCase() === 'proposed'
+    return { notAccepted, status, inspected: true }
   } catch (err) {
-    if (messages) messages.push(inspectionDiagnostic('blocked_by_draft_adr', p, err))
-    return { draft: false, inspected: false }
+    if (messages) messages.push(inspectionDiagnostic(rule, p, err))
+    return { notAccepted: false, status: '', inspected: false }
   }
 }
 
+// adrIsDraft verifica se <adrBasename> está em status não aceito (Draft ou Proposed) buscando
+// recursivamente nas adrDirs. Nome mantido por compatibilidade (chamadores existentes); delega no
+// helper canônico adrNotAcceptedStatusForRule.
+function adrIsDraft(basename) {
+  return adrDraftStatusForRule(basename, null).draft
+}
+
+function adrDraftStatusForRule(basename, messages) {
+  const result = adrNotAcceptedStatusForRule('blocked_by_draft_adr', basename, messages)
+  return { draft: result.notAccepted, inspected: result.inspected }
+}
+
 // validateWIPHasREQ — roadmaps em wip/ sem marker REQ no conteúdo → violation
 // Suporta modo by_agent via resolveWIPDirs.
 function validateWIPHasREQ() {
@@ -419,29 +494,10 @@ function validateWIPHasAcceptanceCriteria() {
   return violations
 }
 
-// readWIPConfig lê wip_limit e wip_by_squad do trackfw.yaml no CWD.
-// Retorna { limit: 1, bySquad: false } se o arquivo não existe ou campos ausentes.
-function readWIPConfig() {
-  const cfg = { limit: 1, bySquad: false }
-  let content
-  try {
-    content = fs.readFileSync('trackfw.yaml', 'utf8')
-  } catch (_) {
-    return cfg
-  }
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim()
-    if (trimmed.startsWith('wip_limit:')) {
-      const val = trimmed.slice('wip_limit:'.length).trim().split(/\s+/)[0]
-      const n = parseInt(val, 10)
-      if (!isNaN(n) && n > 0) cfg.limit = n
-    }
-    if (trimmed.startsWith('wip_by_squad:')) {
-      const val = trimmed.slice('wip_by_squad:'.length).trim().split(/\s+/)[0]
-      if (val === 'true') cfg.bySquad = true
-    }
-  }
-  return cfg
+// wipConfigFrom deriva { limit, bySquad } a partir do ProjectConfig já normalizado por
+// config.load() — nenhuma releitura de trackfw.yaml acontece aqui.
+function wipConfigFrom(cfg) {
+  return { limit: cfg.wipLimit > 0 ? cfg.wipLimit : 1, bySquad: !!cfg.wipBySquad }
 }
 
 // parseSquadFromFrontmatter extrai o valor do campo "squad:" de um arquivo markdown.
@@ -498,7 +554,7 @@ function validateWIPLimit() {
     return { violations, warnings }
   }
 
-  const wipCfg = readWIPConfig()
+  const wipCfg = wipConfigFrom(cfg)
 
   if (!wipCfg.bySquad) {
     if (files.length > wipCfg.limit) {
@@ -622,13 +678,63 @@ function validateREQsNotBlockedByDraftADRs() {
     const blockedADRs = parseBlockedADRs(filePath)
     for (const adrBasename of blockedADRs) {
       if (adrDraftStatusForRule(adrBasename, violations).draft) {
-        violations.push(`REQ ${path.basename(filePath)} is blocked by Draft ADR: ${adrBasename}`)
+        violations.push(`REQ ${path.basename(filePath)} is blocked by not-accepted ADR: ${adrBasename}`)
       }
     }
   }
   return violations
 }
 
+// reqStatusEquals compara o status de uma REQ (case-insensitive) contra o valor esperado.
+// Casa tanto o frontmatter ("status: X") quanto a linha de cabeçalho ("> Date: ... | Status: X"),
+// mesma lógica de detecção usada por reqStatusIsOpen — duplicada aqui (em vez de generalizar
+// reqStatusIsOpen) para não alterar o comportamento de req_roadmap_lifecycle, que já a consome.
+function reqStatusEquals(content, status) {
+  const target = String(status).toLowerCase()
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim()
+    const idx = trimmed.indexOf(':')
+    if (idx >= 0 && trimmed.slice(0, idx).trim().toLowerCase() === 'status') {
+      return trimmed.slice(idx + 1).trim().replace(/^["']|["']$/g, '').toLowerCase() === target
+    }
+    const marker = '| Status: '
+    const markerIdx = trimmed.indexOf(marker)
+    if (markerIdx >= 0) {
+      let rest = trimmed.slice(markerIdx + marker.length)
+      const pipeIdx = rest.indexOf(' |')
+      if (pipeIdx >= 0) rest = rest.slice(0, pipeIdx)
+      return rest.trim().toLowerCase() === target
+    }
+  }
+  return false
+}
+
+// validateADRAcceptedWhenREQDone — REQ Done cujo ADR vinculado (campo "ADR:") não está aceito
+// (Draft ou Proposed, via o helper canônico adrNotAcceptedStatusForRule) → violation. Fecha a
+// lacuna que deixou um ADR Proposed atravessar sete REQs Done sem nenhum gate detectar.
+function validateADRAcceptedWhenREQDone() {
+  const cfg = config.load()
+  const files = resolveReqFiles(cfg)
+  const violations = []
+  for (const filePath of files) {
+    const content = readFileForRule('adr_accepted_when_req_done', filePath, violations)
+    if (content === null) continue
+    if (!reqStatusEquals(content, 'done')) continue
+
+    const adrRef = extractRefPath(content, 'ADR')
+    if (!adrRef) continue
+    const adrBasename = path.basename(adrRef)
+    const status = adrNotAcceptedStatusForRule('adr_accepted_when_req_done', adrBasename, violations)
+    if (status.notAccepted) {
+      const reqBasename = path.basename(filePath)
+      violations.push(
+        `REQ "${reqBasename}" is Done but linked ADR "${adrBasename}" is not accepted (status: ${status.status})`
+      )
+    }
+  }
+  return violations
+}
+
 // blockedREQs retorna mapa de reqBasename → [adrBasenames Draft] para uso em getStatus()
 function blockedREQs() {
   const cfg = config.load()
@@ -652,37 +758,23 @@ function blockedREQs() {
   return result
 }
 
-// readGovernanceMode lê governance_mode e lenient_until do trackfw.yaml no CWD.
-// Retorna { mode: 'strict', lenientUntil: null } se o arquivo não existe ou campos ausentes.
-function readGovernanceMode() {
-  let content
-  try {
-    content = fs.readFileSync('trackfw.yaml', 'utf8')
-  } catch (_) {
-    return { mode: 'strict', lenientUntil: null }
-  }
-  let mode = 'strict'
+// governanceModeFrom deriva { mode, lenientUntil } a partir do ProjectConfig já normalizado por
+// config.load() — nenhuma releitura de trackfw.yaml acontece aqui. cfg.governanceMode chega como
+// o valor bruto do campo (string vazia se ausente); cfg.lenientUntil chega como a data literal
+// (ex.: "2026-08-02"), convertida aqui para Date.
+function governanceModeFrom(cfg) {
+  const mode = cfg.governanceMode ? cfg.governanceMode : 'strict'
   let lenientUntil = null
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim()
-    if (trimmed.startsWith('governance_mode:')) {
-      const val = trimmed.slice('governance_mode:'.length).trim().split(/\s+/)[0]
-      if (val) mode = val
-    }
-    if (trimmed.startsWith('lenient_until:')) {
-      const val = trimmed.slice('lenient_until:'.length).trim().split(/\s+/)[0]
-      if (val) {
-        const d = new Date(val)
-        if (!isNaN(d.getTime())) lenientUntil = d
-      }
-    }
+  if (cfg.lenientUntil) {
+    const d = new Date(cfg.lenientUntil)
+    if (!isNaN(d.getTime())) lenientUntil = d
   }
   return { mode, lenientUntil }
 }
 
 // isLenient retorna true se o projeto está em modo lenient e o prazo não expirou.
 function isLenient() {
-  const gm = readGovernanceMode()
+  const gm = governanceModeFrom(config.load())
   if (gm.mode !== 'lenient') return false
   if (!gm.lenientUntil) return true
   return new Date() < gm.lenientUntil
@@ -690,7 +782,7 @@ function isLenient() {
 
 // lenientUntilDate retorna a data de expiração formatada (YYYY-MM-DD) ou ''.
 function lenientUntilDate() {
-  const gm = readGovernanceMode()
+  const gm = governanceModeFrom(config.load())
   if (gm.mode !== 'lenient' || !gm.lenientUntil) return ''
   return gm.lenientUntil.toISOString().slice(0, 10)
 }
@@ -735,7 +827,7 @@ function extractRefPath(content, field) {
       let val = trimmed.slice(idx + 1).trim()
       if (!val || val === '—' || val === '-' || val === '–') return null
       val = val.split(/\s+/)[0]
-      val = val.replace(/^["']|["']$/g, '')
+      val = val.replace(/^["'`]|["'`]$/g, '')
       if (val.endsWith('.md')) return val
     }
   }
@@ -754,7 +846,7 @@ function validateRefTargetsExist() {
       const content = readFileForRule('ref_targets_exist', path.join(dir, name), warnings)
       if (content === null) continue
       const ref = extractRefPath(content, 'REQ')
-      if (ref && !referenceExists(ref, [cfg.reqDir])) {
+      if (ref && !referenceExists(ref)) {
         warnings.push(`roadmap "${name}" links to REQ "${ref}" which does not exist`)
       }
     }
@@ -766,11 +858,11 @@ function validateRefTargetsExist() {
     if (content === null) continue
     const name = path.basename(filePath)
     const adrRef = extractRefPath(content, 'ADR')
-    if (adrRef && !referenceExists(adrRef, cfg.adrDirs)) {
+    if (adrRef && !referenceExists(adrRef)) {
       warnings.push(`req "${name}" links to ADR "${adrRef}" which does not exist`)
     }
     const roadmapRef = extractRefPath(content, 'Roadmap')
-    if (roadmapRef && !referenceExists(roadmapRef, [cfg.roadmapDir])) {
+    if (roadmapRef && !referenceExists(roadmapRef)) {
       warnings.push(`req "${name}" links to Roadmap "${roadmapRef}" which does not exist`)
     }
   }
@@ -778,7 +870,7 @@ function validateRefTargetsExist() {
   return warnings
 }
 
-function referenceExists(ref, roots) {
+function referenceExists(ref) {
   const expandedRef = config.expandPath ? config.expandPath(ref) : ref
   if (fs.existsSync(expandedRef)) return true
   return false
@@ -1131,6 +1223,7 @@ async function validateUnfiltered() {
   applyRule('filename_uniqueness',  validateFilenameUniqueness(),          violations, warnings)
   applyRule('branch_has_wip_roadmap', validateBranchHasWIPRoadmap(),      violations, warnings)
   applyRule('blocked_by_draft_adr', validateREQsNotBlockedByDraftADRs(),  violations, warnings)
+  applyRule('adr_accepted_when_req_done', validateADRAcceptedWhenREQDone(), violations, warnings)
   applyRule('note_orphan',           validateNoteOrphan(),                 violations, warnings)
 
   // Regras configuráveis via applyRule (popula _itemMeta automaticamente)
@@ -1187,10 +1280,60 @@ async function validate() {
   return { violations, warnings }
 }
 
+// ROADMAP_STATES enumera os 6 estados de roadmap na ordem exibida pelo bloco Inventory.
+const ROADMAP_STATES = ['backlog', 'analyzing', 'wip', 'blocked', 'done', 'abandoned']
+
+// buildInventorySection monta o bloco "📊 Inventory" — contagem agregada de ADRs, REQs
+// (discriminadas por status real via reqStatusEquals) e roadmaps (pelos 6 estados, incluindo
+// "analyzing", historicamente omitido). Namespacing-agnóstico: agrega através de
+// resolveStateDirs()/resolveReqFiles(), que já resolvem flat vs by_agent.
+function buildInventorySection(cfg) {
+  let adrCount = 0
+  for (const adrDir of cfg.adrDirs || []) {
+    adrCount += walkDirMdWithPathsForRule('status_inventory', adrDir, []).length
+  }
+
+  const reqFiles = resolveReqFiles(cfg)
+  let reqOpen = 0
+  let reqDone = 0
+  let reqClosed = 0
+  for (const filePath of reqFiles) {
+    let content
+    try {
+      content = fs.readFileSync(filePath, 'utf8')
+    } catch (_) {
+      continue
+    }
+    if (reqStatusEquals(content, 'open')) reqOpen++
+    else if (reqStatusEquals(content, 'done')) reqDone++
+    else if (reqStatusEquals(content, 'closed')) reqClosed++
+  }
+
+  const roadmapCounts = {}
+  let roadmapTotal = 0
+  for (const state of ROADMAP_STATES) {
+    let count = 0
+    for (const dir of resolveStateDirs(cfg, state)) {
+      count += listDir(dir).length
+    }
+    roadmapCounts[state] = count
+    roadmapTotal += count
+  }
+
+  let section = '\n📊 Inventory\n'
+  section += `   ${'ADRs'.padEnd(12)}${adrCount}\n`
+  section += `   ${'REQs'.padEnd(12)}${reqFiles.length}  (${reqOpen} Open · ${reqDone} Done · ${reqClosed} Closed)\n`
+  section += `   ${'Roadmaps'.padEnd(12)}${roadmapTotal}\n`
+  section += `     backlog ${roadmapCounts.backlog} · analyzing ${roadmapCounts.analyzing} · wip ${roadmapCounts.wip}\n`
+  section += `     blocked ${roadmapCounts.blocked} · done ${roadmapCounts.done} · abandoned ${roadmapCounts.abandoned}\n`
+  return section
+}
+
 // getStatus retorna string formatada com o status de governança do projeto
 async function getStatus() {
   const cfg = config.load()
   let out = '── trackfw status ──────────────────────\n'
+  out += buildInventorySection(cfg)
 
   if (cfg.roadmapNamespacing === config.NAMESPACING_BY_AGENT) {
     let agents = cfg.agents || []
@@ -1217,7 +1360,7 @@ async function getStatus() {
     out += `\n🔄 WIP (${wip.length})\n`
     for (const f of wip) out += `   ${f}\n`
 
-    const wipCfg = readWIPConfig()
+    const wipCfg = wipConfigFrom(cfg)
     if (wipCfg.bySquad && wip.length > 0) {
       const bySquad = {}
       for (const f of wip) {
@@ -1242,14 +1385,19 @@ async function getStatus() {
       for (const w of staleWIPs) out += `   ${w}\n`
     }
 
+    // Seção: REQs bloqueadas por ADRs não aceitos (Draft ou Proposed). O status exibido por
+    // ADR é resolvido via adrNotAcceptedStatusForRule (helper canônico) em vez de hardcodar
+    // "Draft" — blockedREQs() cobre ambos os status desde que delega em adrIsDraft/
+    // adrDraftStatusForRule, e um rótulo fixo "(Draft)" mentiria para um ADR Proposed.
     const blockedByDraft = blockedREQs()
     const blockedKeys = Object.keys(blockedByDraft)
     if (blockedKeys.length > 0) {
-      out += `\n⏳ REQs blocked by Draft ADRs (${blockedKeys.length})\n`
+      out += `\n⏳ REQs blocked by not-accepted ADRs (${blockedKeys.length})\n`
       for (const reqFile of blockedKeys) {
         out += `   ${reqFile}\n`
         for (const adr of blockedByDraft[reqFile]) {
-          out += `     → ${adr} (Draft)\n`
+          const { status } = adrNotAcceptedStatusForRule('blocked_by_draft_adr', adr, null)
+          out += `     → ${adr} (${status})\n`
         }
       }
     }
@@ -1291,8 +1439,6 @@ module.exports = {
   resolveStateDirs,
   resolveWIPDirs,
   resolveDoneDirs,
-  readGovernanceMode,
-  readWIPConfig,
   parseSquadFromFrontmatter,
   validateFrontmatterPresence,
   // novas funções ML-1B
@@ -1316,4 +1462,12 @@ module.exports = {
   isInsideDir,
   walkDirMdWithPaths,
   validateADRDirsExist,
+  // novas funções ML-1B (2026-08-01 — adr_accepted_when_req_done)
+  extractAdrHeaderStatus,
+  adrNotAcceptedStatusForRule,
+  reqStatusEquals,
+  validateADRAcceptedWhenREQDone,
+  // ML-1D (2026-08-01 — reconciliação de paridade: frontmatter-first)
+  extractFrontmatterField,
+  resolveAdrStatus,
 }