@fernado03/zoo-flow 0.5.2 → 0.7.0

package/scripts/eval-routing.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const templateRoot = path.join(packageRoot, "templates", "full");
+const casesPath = process.argv[2]
+  ? path.resolve(process.cwd(), process.argv[2])
+  : path.join(templateRoot, ".zoo-flow", "evals", "routing-cases.jsonl");
+const routingPath = path.join(templateRoot, ".roo", "rules-custom-orchestrator", "00-routing.md");
+
+const allowedModes = new Set(["system-architect", "code-tweaker"]);
+const allowedRiskLevels = new Set(["R1", "R2", "R3", "R4", "R5"]);
+const failures = [];
+
+function getFrontmatterMode(text) {
+  if (!text.startsWith("---")) return null;
+  const lines = text.split(/\r?\n/);
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  if (end === -1) return null;
+  const frontmatter = lines.slice(1, end).join("\n");
+  const match = frontmatter.match(/^mode:\s*([^\r\n#]+)\s*$/m);
+  return match ? match[1].trim().replace(/^['"]|['"]$/g, "") : null;
+}
+
+function fail(lineNumber, message) {
+  failures.push(`Line ${lineNumber}: ${message}`);
+}
+
+const routingText = fs.existsSync(routingPath) ? fs.readFileSync(routingPath, "utf8") : "";
+const approvalPhrases = ["free-form request is never self-approving", "propose", "wait for approval"];
+
+if (!fs.existsSync(casesPath)) {
+  failures.push(`Missing ${path.relative(packageRoot, casesPath)}`);
+} else {
+  const lines = fs.readFileSync(casesPath, "utf8").split(/\r?\n/);
+
+  lines.forEach((line, index) => {
+    const lineNumber = index + 1;
+    const trimmed = line.trim();
+    if (!trimmed) return;
+
+    let record;
+    try {
+      record = JSON.parse(trimmed);
+    } catch (error) {
+      fail(lineNumber, `invalid JSON: ${error.message}`);
+      return;
+    }
+
+    for (const key of ["name", "user", "expected_workflow", "expected_command", "expected_mode"]) {
+      if (typeof record[key] !== "string" || record[key].trim() === "") {
+        fail(lineNumber, `${key} must be a non-empty string`);
+      }
+    }
+
+    if (typeof record.must_require_approval !== "boolean") {
+      fail(lineNumber, "must_require_approval must be a boolean");
+    }
+
+    if (!Array.isArray(record.must_not_include)) {
+      fail(lineNumber, "must_not_include must be an array");
+    }
+
+    if (!allowedModes.has(record.expected_mode)) {
+      fail(lineNumber, `expected_mode must be one of ${Array.from(allowedModes).join(", ")}`);
+    }
+
+    // Validate new fields
+    if (record.risk !== undefined && !allowedRiskLevels.has(record.risk)) {
+      fail(lineNumber, `risk must be one of ${Array.from(allowedRiskLevels).join(", ")}, got ${record.risk}`);
+    }
+
+    if (record.context_required !== undefined && typeof record.context_required !== "boolean") {
+      fail(lineNumber, "context_required must be a boolean");
+    }
+
+    if (record.no_doc_bloat !== undefined && typeof record.no_doc_bloat !== "boolean") {
+      fail(lineNumber, "no_doc_bloat must be a boolean");
+    }
+
+    if (record.forbidden_followups !== undefined) {
+      if (!Array.isArray(record.forbidden_followups)) {
+        fail(lineNumber, "forbidden_followups must be an array");
+      }
+    }
+
+    if (record.recommended_followup !== undefined && typeof record.recommended_followup !== "string") {
+      fail(lineNumber, "recommended_followup must be a string");
+    }
+
+    // Check that no_doc_bloat cases do not reference architecture/docs reading
+    if (record.no_doc_bloat && Array.isArray(record.must_not_include)) {
+      for (const phrase of record.must_not_include) {
+        if (/doc|architect|context/i.test(phrase)) continue; // explicit no-doc entries are fine
+      }
+    }
+
+    if (typeof record.expected_command === "string") {
+      if (!record.expected_command.startsWith("/")) {
+        fail(lineNumber, "expected_command must start with /");
+      } else {
+        const commandName = record.expected_command.slice(1);
+        const commandPath = path.join(templateRoot, ".roo", "commands", `${commandName}.md`);
+        if (!fs.existsSync(commandPath)) {
+          fail(lineNumber, `missing command file for ${record.expected_command}`);
+        } else {
+          const actualMode = getFrontmatterMode(fs.readFileSync(commandPath, "utf8"));
+          if (actualMode !== record.expected_mode) {
+            fail(lineNumber, `${record.expected_command} mode must be ${record.expected_mode}, got ${actualMode || "none"}`);
+          }
+        }
+      }
+    }
+
+    if (typeof record.expected_workflow === "string" && !routingText.includes(record.expected_workflow)) {
+      fail(lineNumber, `expected_workflow not found in routing rule: ${record.expected_workflow}`);
+    }
+
+    if (record.must_require_approval === true) {
+      const routingLower = routingText.toLowerCase();
+      for (const phrase of approvalPhrases) {
+        if (!routingLower.includes(phrase)) {
+          fail(lineNumber, `routing rule missing approval-gate phrase: ${phrase}`);
+        }
+      }
+    }
+
+    // Check that no_doc_bloat cases have context_required: false
+    if (record.no_doc_bloat === true && record.context_required !== false) {
+      fail(lineNumber, "no_doc_bloat cases must have context_required: false");
+    }
+  });
+}
+
+if (failures.length > 0) {
+  console.error("\nRouting eval validation failed:\n");
+  for (const failure of failures) {
+    console.error(`- ${failure}`);
+  }
+  console.error("");
+  process.exit(1);
+}
+
+console.log(`Routing eval validation passed: ${path.relative(packageRoot, casesPath)}`);

package/scripts/score-quality.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const scorecardPath = path.join(packageRoot, "quality", "scorecard.json");
+
+if (!fs.existsSync(scorecardPath)) {
+  console.error("Error: quality/scorecard.json not found");
+  process.exit(1);
+}
+
+const scorecard = JSON.parse(fs.readFileSync(scorecardPath, "utf8"));
+const templateRoot = path.join(packageRoot, "templates", "full");
+
+const failures = [];
+const results = {};
+
+function check(condition, description, category) {
+  if (!condition) {
+    failures.push(`  FAIL: ${description}`);
+    return false;
+  }
+  return true;
+}
+
+// ── command_integrity ──
+(function () {
+  const r = { pass: 0, total: 0 };
+
+  const commandsDir = path.join(templateRoot, ".roo", "commands");
+  if (fs.existsSync(commandsDir)) {
+    const files = fs.readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const text = fs.readFileSync(path.join(commandsDir, file), "utf8");
+      const isModeless = file === "caveman.md";
+      r.total++;
+      if (isModeless) {
+        r.pass++; // modeless by design, not a failure
+      } else {
+        const hasMode = /^mode:\s*\S+/m.test(text);
+        r.pass += check(hasMode, `${file} has mode declaration`, "command_integrity") ? 1 : 0;
+      }
+    }
+  }
+  r.total += 5; // required rules
+  for (const rule of ["00-paths.md", "01-command-protocol.md", "02-three-failure-rule.md", "03-manual-reply-protocol.md", "04-context-economy.md"]) {
+    const p = path.join(templateRoot, ".roo", "rules", rule);
+    r.pass += check(fs.existsSync(p), `Global rule ${rule} exists`, "command_integrity") ? 1 : 0;
+  }
+
+  const modeDirs = ["code-tweaker", "system-architect", "custom-orchestrator"];
+  for (const slug of modeDirs) {
+    const dir = path.join(templateRoot, ".roo", `rules-${slug}`);
+    r.total++;
+    r.pass += check(fs.existsSync(dir), `Mode rule folder rules-${slug} exists`, "command_integrity") ? 1 : 0;
+  }
+
+  results.command_integrity = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── skill_quality ──
+(function () {
+  const r = { pass: 0, total: 0 };
+  const commandsDir = path.join(templateRoot, ".roo", "commands");
+  const skillRefRegex = /^Skill:\s*`?(\.roo\/skills\/[^\s`]+SKILL\.md)`?\s*$/m;
+
+  if (fs.existsSync(commandsDir)) {
+    const files = fs.readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const text = fs.readFileSync(path.join(commandsDir, file), "utf8");
+      const refs = text.match(skillRefRegex);
+      if (refs) {
+        const skillPath = path.join(templateRoot, refs[1]);
+        r.total++;
+        r.pass += check(fs.existsSync(skillPath), `${file} references existing skill ${refs[1]}`, "skill_quality") ? 1 : 0;
+      }
+    }
+  }
+
+  // Check canonical marker usage (no non-canonical wrappers)
+  if (fs.existsSync(commandsDir)) {
+    const files = fs.readdirSync(commandsDir).filter((f) => f.endsWith(".md"));
+    // Import thin wrapper check from doctor
+    const isThinNonCanonical = (text) => {
+      const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      const runSkillLines = lines.filter((l) => /^run skill:/i.test(l));
+      if (runSkillLines.length !== 1) return false;
+      const otherLines = lines.filter((l) => !/^run skill:/i.test(l) && l !== "$ARGUMENTS");
+      return otherLines.every((l) => l.length <= 120 && !/^(#{1,6}\s|[-*]\s|\d+[.)]\s|[A-Z][A-Z\s]+:)/.test(l));
+    };
+    for (const file of files) {
+      const text = fs.readFileSync(path.join(commandsDir, file), "utf8");
+      r.total++;
+      r.pass += check(!isThinNonCanonical(text), `${file} is not a thin non-canonical wrapper`, "skill_quality") ? 1 : 0;
+    }
+  }
+
+  results.skill_quality = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── validation_depth ──
+(function () {
+  const r = { pass: 0, total: 0 };
+
+  const requiredFiles = [
+    ".roomodes",
+    ".roo/",
+    ".roo/commands/",
+    ".roo/skills/",
+    ".roo/rules/",
+    ".roo/rules-custom-orchestrator/00-routing.md",
+    ".roo/rules-code-tweaker/",
+    ".roo/rules-system-architect/"
+  ];
+
+  for (const file of requiredFiles) {
+    r.total++;
+    r.pass += check(fs.existsSync(path.join(templateRoot, file)), `Template has ${file}`, "validation_depth") ? 1 : 0;
+  }
+
+  // Check for no built-in delegation in routing
+  const routingPath = path.join(templateRoot, ".roo", "rules-custom-orchestrator", "00-routing.md");
+  if (fs.existsSync(routingPath)) {
+    const text = fs.readFileSync(routingPath, "utf8");
+    const builtIns = ["ask", "code", "debug", "architect", "orchestrator"];
+    for (const bi of builtIns) {
+      const regex = new RegExp(`\\bnew_task\\b[^\\n]*\\bslug:\\s*${bi}\\b`, "i");
+      r.total++;
+      r.pass += check(!regex.test(text), `No delegation to built-in mode: ${bi}`, "validation_depth") ? 1 : 0;
+    }
+  }
+
+  // Check for .zoo/ leakage
+  const allFiles = [];
+  const walkDir = (dir) => {
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir)) {
+      const full = path.join(dir, entry);
+      if (fs.statSync(full).isDirectory()) {
+        if (!entry.startsWith(".") || entry === ".zoo-flow") walkDir(full);
+      } else {
+        allFiles.push(full);
+      }
+    }
+  };
+  walkDir(templateRoot);
+
+  const textExts = new Set([".md", ".json", ".txt", ".yaml", ".yml", ".jsonl"]);
+  for (const file of allFiles) {
+    if (!textExts.has(path.extname(file))) continue;
+    const text = fs.readFileSync(file, "utf8");
+    const rel = path.relative(templateRoot, file);
+    r.total++;
+    r.pass += check(!text.includes(".zoo/"), `No .zoo/ path in ${rel}`, "validation_depth") ? 1 : 0;
+  }
+
+  results.validation_depth = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── token_economy ──
+(function () {
+  const r = { pass: 0, total: 0 };
+
+  const contextEcoPath = path.join(templateRoot, ".roo", "rules", "04-context-economy.md");
+  r.total++;
+  r.pass += check(fs.existsSync(contextEcoPath), "context-economy rule exists", "token_economy") ? 1 : 0;
+
+  if (fs.existsSync(contextEcoPath)) {
+    const text = fs.readFileSync(contextEcoPath, "utf8");
+    r.total++;
+    r.pass += check(/Do not read.*by default/i.test(text), "Domain-doc read gate exists", "token_economy") ? 1 : 0;
+  }
+
+  results.token_economy = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── verification ──
+(function () {
+  const r = { pass: 0, total: 0 };
+
+  const verifyCmd = path.join(templateRoot, ".roo", "commands", "verify.md");
+  r.total++;
+  r.pass += check(fs.existsSync(verifyCmd), "verify command exists", "verification") ? 1 : 0;
+
+  const verifySkill = path.join(templateRoot, ".roo", "skills", "engineering", "verify", "SKILL.md");
+  r.total++;
+  r.pass += check(fs.existsSync(verifySkill), "verify skill exists", "verification") ? 1 : 0;
+
+  if (fs.existsSync(verifySkill)) {
+    const text = fs.readFileSync(verifySkill, "utf8");
+    r.total++;
+    r.pass += check(/never say/i.test(text) && /verified/i.test(text), "verify skill has no-claim-unless-run", "verification") ? 1 : 0;
+  }
+
+  // Doctor fixture tests exist
+  const fixtureDir = path.join(packageRoot, "tests", "fixtures", "doctor");
+  r.total++;
+  r.pass += check(fs.existsSync(fixtureDir), "doctor fixtures exist", "verification") ? 1 : 0;
+
+  results.verification = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── review_process ──
+(function () {
+  const r = { pass: 0, total: 0 };
+
+  const reviewCmd = path.join(templateRoot, ".roo", "commands", "review.md");
+  r.total++;
+  r.pass += check(fs.existsSync(reviewCmd), "review command exists", "review_process") ? 1 : 0;
+
+  const reviewSkill = path.join(templateRoot, ".roo", "skills", "engineering", "review", "SKILL.md");
+  r.total++;
+  r.pass += check(fs.existsSync(reviewSkill), "review skill exists", "review_process") ? 1 : 0;
+
+  if (fs.existsSync(reviewSkill)) {
+    const text = fs.readFileSync(reviewSkill, "utf8");
+    r.total++;
+    r.pass += check(/security/i.test(text), "review skill has security axis", "review_process") ? 1 : 0;
+    r.total++;
+    r.pass += check(/Review result:/i.test(text), "review skill has canonical result line", "review_process") ? 1 : 0;
+  }
+
+  results.review_process = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── release_readiness ──
+(function () {
+  const r = { pass: 0, total: 0 };
+
+  const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+  const scripts = pkg.scripts || {};
+
+  r.total++;
+  r.pass += check(!!scripts["release:check"], "release:check script exists", "release_readiness") ? 1 : 0;
+
+  r.total++;
+  r.pass += check(fs.existsSync(scorecardPath), "quality/scorecard.json exists", "release_readiness") ? 1 : 0;
+
+  r.total++;
+  r.pass += check(fs.existsSync(path.join(packageRoot, "scripts", "test-doctor.js")), "test-doctor.js exists", "release_readiness") ? 1 : 0;
+
+  r.total++;
+  r.pass += check(fs.existsSync(path.join(packageRoot, "scripts", "eval-routing.js")), "eval-routing.js exists", "release_readiness") ? 1 : 0;
+
+  r.total++;
+  r.pass += check(fs.existsSync(path.join(packageRoot, "scripts", "check-package-links.js")), "check-package-links.js exists", "release_readiness") ? 1 : 0;
+
+  results.release_readiness = r.total > 0 ? Math.round((r.pass / r.total) * 100) / 10 : 0;
+})();
+
+// ── Compute weighted score ──
+let totalWeight = 0;
+let weightedSum = 0;
+
+for (const [category, data] of Object.entries(scorecard.categories)) {
+  const result = results[category];
+  if (result !== undefined) {
+    totalWeight += data.weight;
+    weightedSum += result * data.weight;
+  }
+}
+
+const finalScore = totalWeight > 0 ? Math.round((weightedSum / totalWeight) * 100) / 100 : 0;
+const minimum = scorecard.minimum_score || 9.5;
+
+console.log("\nQuality scorecard results:\n");
+for (const [category, data] of Object.entries(scorecard.categories)) {
+  const result = results[category];
+  if (result !== undefined) {
+    const status = result >= 9.5 ? "✅" : "❌";
+    console.log(`  ${status} ${category}: ${result.toFixed(1)}/10 (weight: ${(data.weight * 100).toFixed(0)}%)`);
+  }
+}
+
+console.log(`\n  Weighted composite score: ${finalScore.toFixed(2)}/10`);
+console.log(`  Minimum required: ${minimum}/10`);
+
+if (finalScore < minimum) {
+  console.error(`\n  ❌ Score ${finalScore.toFixed(2)} is below minimum ${minimum}\n`);
+  process.exit(1);
+}
+
+for (const failure of failures) {
+  console.error(`  ⚠  ${failure}`);
+}
+
+console.log(`\n  ✅ Quality scorecard passed\n`);

package/scripts/test-doctor.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const templateRoot = path.join(packageRoot, "templates", "full");
+const fixturesRoot = path.join(packageRoot, "tests", "fixtures", "doctor");
+const cliPath = path.join(packageRoot, "bin", "zoo-flow.js");
+
+const failures = [];
+
+function copyRecursive(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function replaceInFile(filePath, from, to) {
+  const text = fs.readFileSync(filePath, "utf8");
+  fs.writeFileSync(filePath, text.replace(from, to));
+}
+
+function mutate(root, mutation) {
+  if (mutation === "none") return;
+
+  const command = (name) => path.join(root, ".roo", "commands", name);
+  const skill = (...parts) => path.join(root, ".roo", "skills", ...parts);
+
+  if (mutation === "missing-roomodes") {
+    fs.rmSync(path.join(root, ".roomodes"));
+  } else if (mutation === "missing-command") {
+    fs.rmSync(command("review.md"));
+  } else if (mutation === "missing-skill") {
+    fs.rmSync(skill("engineering", "tweak", "SKILL.md"));
+  } else if (mutation === "bad-skill-wrapper") {
+    replaceInFile(command("caveman.md"), "Skill:", "Run skill:");
+  } else if (mutation === "bad-mode-slug") {
+    replaceInFile(command("review.md"), "mode: system-architect", "mode: architect");
+  } else if (mutation === "bad-built-in-delegation") {
+    fs.appendFileSync(path.join(root, ".roo", "rules-custom-orchestrator", "00-routing.md"), "\nUse new_task to architect for review.\n");
+  } else if (mutation === "bad-zoo-path") {
+    fs.appendFileSync(path.join(root, ".roo", "rules", "00-paths.md"), "\nBad path: .zoo/commands/example.md\n");
+  } else if (mutation === "helper-missing-mode") {
+    replaceInFile(command("diagnose.md"), /^mode: system-architect\r?\n/m, "");
+  } else if (mutation === "helper-not-permitted") {
+    replaceInFile(path.join(root, ".roomodes"), "/diagnose, ", "");
+  } else {
+    throw new Error(`Unknown mutation: ${mutation}`);
+  }
+}
+
+for (const fixtureName of fs.readdirSync(fixturesRoot)) {
+  const fixturePath = path.join(fixturesRoot, fixtureName, "fixture.json");
+  if (!fs.existsSync(fixturePath)) continue;
+
+  const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+  const tmpParent = fs.mkdtempSync(path.join(os.tmpdir(), "zoo-flow-doctor-"));
+  const tmpTemplate = path.join(tmpParent, "template");
+
+  try {
+    copyRecursive(templateRoot, tmpTemplate);
+    mutate(tmpTemplate, fixture.mutation);
+
+    const result = spawnSync(process.execPath, [cliPath, "doctor"], {
+      cwd: tmpTemplate,
+      encoding: "utf8"
+    });
+    const output = `${result.stdout}\n${result.stderr}`;
+    const passed = result.status === 0;
+
+    if (fixture.expect === "pass" && !passed) {
+      failures.push(`${fixtureName}: expected pass, got failure\n${output}`);
+    }
+    if (fixture.expect === "fail" && passed) {
+      failures.push(`${fixtureName}: expected failure, got pass`);
+    }
+    if (fixture.message && !output.includes(fixture.message)) {
+      failures.push(`${fixtureName}: output missing ${JSON.stringify(fixture.message)}\n${output}`);
+    }
+  } finally {
+    fs.rmSync(tmpParent, { recursive: true, force: true });
+  }
+}
+
+if (failures.length > 0) {
+  console.error("\nDoctor fixture tests failed:\n");
+  for (const failure of failures) {
+    console.error(`- ${failure}`);
+  }
+  console.error("");
+  process.exit(1);
+}
+
+console.log("Doctor fixture tests passed");

package/scripts/test-project-shapes.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageRoot = path.resolve(__dirname, "..");
+const fixturesDir = path.join(packageRoot, "tests", "fixtures", "project-shapes");
+const templateRoot = path.join(packageRoot, "templates", "full");
+
+const failures = [];
+
+if (!fs.existsSync(fixturesDir)) {
+  console.log("Project-shape tests skipped: no tests/fixtures/project-shapes directory");
+  process.exit(0);
+}
+
+const fixtures = fs.readdirSync(fixturesDir).filter((entry) => {
+  return fs.statSync(path.join(fixturesDir, entry)).isDirectory();
+});
+
+if (fixtures.length === 0) {
+  console.log("Project-shape tests skipped: empty tests/fixtures/project-shapes directory");
+  process.exit(0);
+}
+
+function detectShape(root) {
+  const hasPkg = fs.existsSync(path.join(root, "package.json"));
+
+  if (hasPkg) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+      const keywords = Array.isArray(pkg.keywords) ? pkg.keywords : [];
+
+      if (keywords.includes("web-app")) return "web-app";
+      if (keywords.includes("library")) return "library";
+      if (keywords.includes("cli")) return "cli-tool";
+      if (keywords.includes("monorepo")) return "monorepo";
+      if (keywords.includes("data-pipeline")) return "data-pipeline";
+      if (keywords.includes("serverless")) return "serverless";
+    } catch {
+      // fall through
+    }
+  }
+
+  const topFolders = fs.readdirSync(root).filter((entry) => {
+    return fs.statSync(path.join(root, entry)).isDirectory() && !entry.startsWith(".");
+  });
+
+  if (topFolders.includes("app") || topFolders.includes("pages")) return "web-app";
+  if (topFolders.includes("cmd")) return "cli-tool";
+  if (topFolders.includes("packages")) return "monorepo";
+  if (topFolders.includes("lib")) return "library";
+  if (topFolders.includes("pipelines")) return "data-pipeline";
+  if (topFolders.includes("functions") || topFolders.includes("handlers")) return "serverless";
+
+  return "unknown";
+}
+
+for (const fixture of fixtures) {
+  const fixturePath = path.join(fixturesDir, fixture);
+  const metaPath = path.join(fixturePath, "fixture.json");
+
+  if (!fs.existsSync(metaPath)) {
+    failures.push(`${fixture}: missing fixture.json`);
+    continue;
+  }
+
+  let meta;
+  try {
+    meta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+  } catch (error) {
+    failures.push(`${fixture}: invalid fixture.json — ${error.message}`);
+    continue;
+  }
+
+  if (!meta.expected_shape) {
+    failures.push(`${fixture}: fixture.json missing expected_shape`);
+    continue;
+  }
+
+  const detected = detectShape(fixturePath);
+  if (detected !== meta.expected_shape) {
+    failures.push(`${fixture}: expected shape ${meta.expected_shape}, detected ${detected}`);
+  }
+}
+
+if (failures.length > 0) {
+  console.error("\nProject-shape fixture tests failed:\n");
+  for (const failure of failures) {
+    console.error(`- ${failure}`);
+  }
+  console.error("");
+  process.exit(1);
+}
+
+console.log(`Project-shape fixture tests passed: ${fixtures.length} shapes`);