ai-runtime-kit 0.9.0 → 0.10.0

package/CHANGELOG.md

@@ -10,6 +10,81 @@ kit.
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-05-14
+
+**First M4 data point.** Kit's first `src/**` feature shipped
+under the v0.6.0+ PRD → Feature → Spec → Plan → Task → TDD →
+Implement → Verify → Review workflow with `TDD-Applies: true`
+tasks. Two TDD pairs (test-commit-before-impl-commit) at 100%
+test-first ordering.
+
+### Added
+- **`validate` command** — checks `.ai/project/` tree
+  structural integrity. Walks every artifact (PRD / feature /
+  spec / plan / task / review) and verifies:
+  - Required `## Parent <Type>` sections per v0.9.0 INDEX §
+    Traceability rules.
+  - Cited parent paths resolve to real files on disk.
+  - `Status` values are in the allowed set per artifact type.
+  Reports errors (missing-parent / empty-parent /
+  unresolved-parent) and warnings (unexpected-status). Exits
+  0 on clean, 1 on any error.
+- `--json` flag for machine-parseable output.
+- `--cwd <dir>` flag for non-default project root.
+- `src/validate.js` (NEW) — pure validator module.
+- `test/validate.test.js` (NEW) — 6 unit tests (clean tree,
+  missing parent, broken path, `(none — ...)` rendering,
+  JSON output, live dogfood smoke).
+
+### Changed
+- `bin/cli.js` — dispatcher gains `validate` subcommand;
+  HELP lists it alongside `init` and `upgrade`.
+- 7 historical specs (v0.4.0 / v0.5.0 / v0.5.1 / v0.6.0 /
+  v0.7.0 / v0.8.0 / v0.8.1) retrofitted with `## Parent
+  Feature` sections (pre-v0.6.0 use `(none —
+  pre-feature-layer)`; v0.8.1 uses `(none —
+  engineering-only)`; the rest cite real feature paths).
+- 7 historical reviews retrofitted with `## Parent Spec`
+  sections. v0.9.0's spec/review already had theirs (the
+  convention F4 shipped was in use immediately on its own
+  review). Retrofit is project-side and not subject to
+  preflight.
+
+### Process
+- **Kit's first `src/**` feature** under the new pipeline.
+  Branch was `feat/validate-cli` (not `chore/runtime-*`)
+  because no `runtime/**` paths in scope.
+- **First non-runtime-scoped feature in the v0.6.0+
+  workflow** — preflight hook did not fire (correctly; no
+  `runtime/**` paths to gate on). The kit's discipline now
+  cleanly distinguishes governance-scoped (preflight gated)
+  from kit-code-scoped (regular feature branches).
+- **First M4 data point.** Two TDD pairs:
+  - T1 (src/validate.js): test commit 16:07:26 → impl
+    16:08:21 (Δ +55s).
+  - T2 (bin/cli.js): test commit 16:09:47 → impl 16:11:53
+    (Δ +2m6s).
+  Both pairs satisfy "test-commit precedes impl-commit." M4
+  score for this feature: 2/2 = 100%.
+- **Validator caught a real concern during dogfood.** The
+  first run reported `TASK_STATUS.md` as a missing-parent
+  error; this file is a top-level status tracker (output of
+  `init`), not a task instance. Fix landed in C4: validator
+  now skips `EXCLUDED_FILENAMES`. The tool catching its own
+  edge case in its first ship cycle is the dogfood loop
+  working as intended.
+- **Spec amended mid-implementation** (third occurrence —
+  v0.5.1, v0.7.0, and now v0.10.0). Original spec excluded
+  retrofitting historical artifacts; the validator's
+  credibility depends on its first dogfood pass being
+  clean, so the spec was amended pre-impl to include
+  retrofit work. Recorded in spec § Status with a comment.
+- **24/24 tests pass** (18 prior + 6 new).
+- **`validate` against this repo's `.ai/` tree**:
+  3 PRDs / 5 features / 9 specs / 0 plans / 0 tasks /
+  8 reviews / **0 errors / 0 warnings / Result: PASS**.
+  VM1 satisfied live on first ship.
+
 ## [0.9.0] - 2026-05-14
 
 **Closes the v0.6.0 nine-phase-workflow PRD's 4-feature

package/README.md

@@ -10,6 +10,16 @@ npx ai-runtime-kit upgrade   # existing kit consumer
 
 ## Status
 
+**v0.10.0** — Adds the **`validate` command** — checks
+`.ai/project/` tree structural integrity (every artifact carries
+its required `## Parent <Type>` section; every cited parent path
+resolves on disk; Status values are valid). Reports errors and
+warnings; exits 0 on clean / 1 on errors; `--json` for machine
+output. **First `src/**` feature shipped under the v0.6.0+
+PRD → Feature → Spec → Plan → Task → TDD → Implement → Verify
+→ Review pipeline; first M4 data point — 2/2 TDD pairs at
+100% test-first ordering.**
+
 **v0.9.0** — Formalizes the **`## Parent <Type>` traceability
 convention** across all artifact templates. Every kit artifact
 (spec / plan / task / review) now carries a structural

package/bin/cli.js

@@ -10,6 +10,7 @@ Usage: ai-runtime-kit <command> [options]
 Commands:
   init        Initialize .ai/ runtime in the current directory.
   upgrade     Upgrade .ai/runtime/ to the kit's current version.
+  validate    Check .ai/project/ tree structural integrity.
   --help, -h  Show this help.
   --version   Show kit version.
 
@@ -38,6 +39,9 @@ async function main() {
     case 'upgrade':
       await require('../src/upgrade').run(rest);
       return;
+    case 'validate':
+      require('../src/validate').run(rest);
+      return;
     default:
       console.error(`ai-runtime-kit: unknown command '${cmd}'`);
       console.error('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-runtime-kit",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Reusable AI engineering runtime: BOOTSTRAP, workflows, safety, hooks, and templates for software projects driven by AI agents.",
   "bin": {
     "ai-runtime-kit": "./bin/cli.js"

package/src/validate.js

@@ -0,0 +1,235 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+
+// Per v0.9.0 INDEX § Traceability:
+//   PRD     — no parent required (chain root)
+//   Feature — ## Parent PRD
+//   Spec    — ## Parent Feature
+//   Plan    — ## Parent Spec
+//   Task    — ## Parent Spec + ## Parent Plan
+//   Review  — ## Parent Spec
+const ARTIFACT_RULES = {
+  prds:     { dir: 'prds',     required: [] },
+  features: { dir: 'features', required: ['Parent PRD'] },
+  specs:    { dir: 'specs',    required: ['Parent Feature'] },
+  plans:    { dir: 'plans',    required: ['Parent Spec'] },
+  tasks:    { dir: 'tasks',    required: ['Parent Spec', 'Parent Plan'] },
+  reviews:  { dir: 'reviews',  required: ['Parent Spec'] },
+};
+
+const VALID_STATUSES = {
+  prds:     ['DRAFT', 'APPROVED', 'REJECTED', 'SUPERSEDED'],
+  features: ['DRAFT', 'APPROVED', 'REJECTED', 'SUPERSEDED'],
+  specs:    ['DRAFT', 'APPROVED', 'REJECTED', 'SUPERSEDED'],
+  plans:    ['PLANNED', 'IN_PROGRESS', 'DONE'],
+  tasks:    ['TODO', 'IN_PROGRESS', 'IN_REVIEW', 'DONE'],
+};
+
+// Files within an artifact dir that are NOT instances of that
+// artifact type. TASK_STATUS.md is a top-level status tracker
+// produced by `init`, not a per-task instance.
+const EXCLUDED_FILENAMES = new Set(['TASK_STATUS.md']);
+
+function walkMd(dir) {
+  if (!fs.existsSync(dir)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (EXCLUDED_FILENAMES.has(entry.name)) continue;
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walkMd(p));
+    else if (entry.isFile() && entry.name.endsWith('.md')) out.push(p);
+  }
+  return out;
+}
+
+function parseSections(content) {
+  // Returns { sectionName: bodyString }.
+  // Sections are top-level `## ` headings.
+  const lines = content.split('\n');
+  const sections = {};
+  let cur = null;
+  let buf = [];
+  for (const line of lines) {
+    const m = line.match(/^##\s+(.+?)\s*$/);
+    if (m) {
+      if (cur !== null) sections[cur] = buf.join('\n').trim();
+      cur = m[1].trim();
+      buf = [];
+    } else if (cur !== null) {
+      buf.push(line);
+    }
+  }
+  if (cur !== null) sections[cur] = buf.join('\n').trim();
+  return sections;
+}
+
+function firstValueLine(body) {
+  // Returns first non-empty, non-comment line; strips surrounding backticks.
+  for (const raw of body.split('\n')) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith('<!--')) continue;
+    return line.replace(/^`/, '').replace(/`$/, '');
+  }
+  return null;
+}
+
+function isNoneRendering(value) {
+  return value !== null && value.startsWith('(none');
+}
+
+function validate(projectRoot, _options = {}) {
+  const errors = [];
+  const warnings = [];
+  const summary = { prds: 0, features: 0, specs: 0, plans: 0, tasks: 0, reviews: 0 };
+
+  const aiProject = path.join(projectRoot, '.ai', 'project');
+  if (!fs.existsSync(aiProject)) {
+    return { errors, warnings, summary };
+  }
+
+  for (const [artifact, rule] of Object.entries(ARTIFACT_RULES)) {
+    const dir = path.join(aiProject, rule.dir);
+    const files = walkMd(dir);
+    summary[artifact] = files.length;
+
+    for (const file of files) {
+      const relFile = path.relative(projectRoot, file);
+      const content = fs.readFileSync(file, 'utf8');
+      const sections = parseSections(content);
+
+      for (const parentName of rule.required) {
+        const sectionBody = sections[parentName];
+        if (sectionBody === undefined) {
+          errors.push({
+            artifact,
+            file: relFile,
+            type: 'missing-parent',
+            message: `Missing required ## ${parentName} section`,
+          });
+          continue;
+        }
+        const value = firstValueLine(sectionBody);
+        if (value === null) {
+          errors.push({
+            artifact,
+            file: relFile,
+            type: 'empty-parent',
+            message: `## ${parentName} section is empty`,
+          });
+          continue;
+        }
+        if (isNoneRendering(value)) continue;
+        const resolved = path.join(projectRoot, value);
+        if (!fs.existsSync(resolved)) {
+          errors.push({
+            artifact,
+            file: relFile,
+            type: 'unresolved-parent',
+            message: `## ${parentName} points to non-existent path: ${value}`,
+          });
+        }
+      }
+
+      const allowedStatuses = VALID_STATUSES[artifact];
+      if (allowedStatuses && sections.Status !== undefined) {
+        const statusValue = firstValueLine(sections.Status);
+        if (statusValue !== null && !allowedStatuses.includes(statusValue)) {
+          warnings.push({
+            artifact,
+            file: relFile,
+            type: 'unexpected-status',
+            message: `Status "${statusValue}" not in allowed values: ${allowedStatuses.join(', ')}`,
+          });
+        }
+      }
+    }
+  }
+
+  return { errors, warnings, summary };
+}
+
+function run(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args: argv,
+      options: {
+        cwd: { type: 'string' },
+        json: { type: 'boolean', default: false },
+        help: { type: 'boolean', short: 'h', default: false },
+      },
+      strict: true,
+      allowPositionals: false,
+    });
+  } catch (e) {
+    console.error(`validate: ${e.message}`);
+    process.exit(1);
+  }
+
+  if (parsed.values.help) {
+    printHelp();
+    return;
+  }
+
+  const cwd = path.resolve(parsed.values.cwd ?? process.cwd());
+  const result = validate(cwd);
+  const status = result.errors.length === 0 ? 'PASS' : 'FAIL';
+
+  if (parsed.values.json) {
+    console.log(JSON.stringify({ ...result, result: status }, null, 2));
+  } else {
+    console.log(`Validating .ai/project/ at ${cwd}\n`);
+    for (const [name, count] of Object.entries(result.summary)) {
+      console.log(`  ${name.padEnd(10)} ${count}`);
+    }
+    console.log('');
+    if (result.errors.length > 0) {
+      console.log(`Errors: ${result.errors.length}`);
+      for (const e of result.errors) {
+        console.log(`  - ${e.file}: ${e.type}: ${e.message}`);
+      }
+    } else {
+      console.log('Errors:   none');
+    }
+    if (result.warnings.length > 0) {
+      console.log(`Warnings: ${result.warnings.length}`);
+      for (const w of result.warnings) {
+        console.log(`  - ${w.file}: ${w.type}: ${w.message}`);
+      }
+    } else {
+      console.log('Warnings: none');
+    }
+    console.log('');
+    console.log(
+      `Result: ${status === 'PASS' ? 'PASS (clean tree)' : `FAIL (${result.errors.length} errors)`}`,
+    );
+  }
+
+  process.exit(result.errors.length === 0 ? 0 : 1);
+}
+
+function printHelp() {
+  console.log(`ai-runtime-kit validate [options]
+
+Validate the .ai/project/ tree's structural integrity. Walks
+every artifact and checks that:
+
+  - Required ## Parent <Type> sections are present per the
+    v0.9.0 INDEX § Traceability rules.
+  - Cited parent paths resolve to real files on disk.
+  - Status values are in the allowed set per artifact type.
+
+Options:
+  --cwd <dir>   Target project root (default: process.cwd())
+  --json        Output structured JSON instead of human text
+  -h, --help    Show this help
+
+Exits 0 on no errors (warnings allowed and printed); 1 on any
+error. See .ai/runtime/INDEX.md § Traceability for the rules.`);
+}
+
+module.exports = { validate, run, printHelp };