qfai 0.6.0 → 0.6.2

package/README.md

@@ -28,9 +28,9 @@ npx qfai report
 
 `validate` は `--fail-on` / `--strict` によって CI ゲート化できます。`validate` は常に `.qfai/out/validate.json`（`output.validateJsonPath`）へ JSON を出力し、`--format` は表示形式（text/github）のみを制御します。
 `report` は `.qfai/out/validate.json` を読み、既定で `.qfai/out/report.md` を出力します（`--format json` の場合は `.qfai/out/report.json`）。出力先は `--out` で変更できます。入力パスは固定です。
-`doctor` は validate/report の前段で設定/探索/パス/glob/validate.json を診断します。`--format text|json`、`--out` をサポートします。
+`doctor` は validate/report の前段で設定/探索/パス/glob/validate.json を診断します。`--format text|json`、`--out` をサポートします。`--fail-on warning|error` を指定すると該当 severity 以上で exit 1（未指定は常に exit 0）になります。
 `init --yes` は予約フラグです（現行の init は非対話のため挙動差はありません）。既存ファイルがある場合は `--force` が必要です。
-`report.json` は experimental（互換保証なし）として扱います。`reportFormatVersion` を含み、破壊的変更時のみ増分します。
+`report.json` / doctor JSON は experimental（互換保証なし）として扱います。フィールドは例であり固定ではありません。
 
 設定はリポジトリ直下の `qfai.config.yaml` で行います。
 命名規約は `docs/rules/naming.md` を参照してください。

package/dist/cli/index.cjs

@@ -889,8 +889,8 @@ var import_promises6 = require("fs/promises");
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 async function resolveToolVersion() {
-  if ("0.6.0".length > 0) {
-    return "0.6.0";
+  if ("0.6.2".length > 0) {
+    return "0.6.2";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -1021,6 +1021,22 @@ async function createDoctorData(options) {
     message: validateJsonExists ? "validate.json exists (report can run)" : "validate.json is missing (run 'qfai validate' before 'qfai report')",
     details: { path: toRelativePath(root, validateJsonAbs) }
   });
+  const outDirAbs = resolvePath(root, config, "outDir");
+  const rel = import_node_path7.default.relative(outDirAbs, validateJsonAbs);
+  const inside = rel !== "" && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
+  addCheck(checks, {
+    id: "output.pathAlignment",
+    severity: inside ? "ok" : "warning",
+    title: "Output path alignment",
+    message: inside ? "validateJsonPath is under outDir" : "validateJsonPath is not under outDir (may be intended, but check configuration)",
+    details: {
+      outDir: toRelativePath(root, outDirAbs),
+      validateJsonPath: toRelativePath(root, validateJsonAbs)
+    }
+  });
+  if (options.rootExplicit) {
+    addCheck(checks, await buildOutDirCollisionCheck(root));
+  }
   const scenarioFiles = await collectScenarioFiles(specsRoot);
   const globs = normalizeGlobs2(config.validation.traceability.testFileGlobs);
   const exclude = normalizeGlobs2([
@@ -1052,23 +1068,9 @@ async function createDoctorData(options) {
       details: { globs, excludeGlobs: exclude, error: String(error2) }
     });
   }
-  const outDirAbs = resolvePath(root, config, "outDir");
-  const rel = import_node_path7.default.relative(outDirAbs, validateJsonAbs);
-  const inside = rel !== "" && !rel.startsWith("..") && !import_node_path7.default.isAbsolute(rel);
-  addCheck(checks, {
-    id: "output.pathAlignment",
-    severity: inside ? "ok" : "warning",
-    title: "Output path alignment",
-    message: inside ? "validateJsonPath is under outDir" : "validateJsonPath is not under outDir (may be intended, but check configuration)",
-    details: {
-      outDir: toRelativePath(root, outDirAbs),
-      validateJsonPath: toRelativePath(root, validateJsonAbs)
-    }
-  });
   return {
     tool: "qfai",
     version,
-    doctorFormatVersion: 1,
     generatedAt,
     root: toRelativePath(process.cwd(), root),
     config: {
@@ -1080,6 +1082,90 @@ async function createDoctorData(options) {
     checks
   };
 }
+var DEFAULT_CONFIG_SEARCH_IGNORE_GLOBS = [
+  ...DEFAULT_TEST_FILE_EXCLUDE_GLOBS,
+  "**/.pnpm/**",
+  "**/tmp/**",
+  "**/.mcp-tools/**"
+];
+async function buildOutDirCollisionCheck(root) {
+  try {
+    const result = await detectOutDirCollisions(root);
+    const relativeRoot = toRelativePath(process.cwd(), result.monorepoRoot);
+    const configRoots = result.configRoots.map((configRoot) => toRelativePath(result.monorepoRoot, configRoot)).sort((a, b) => a.localeCompare(b));
+    const collisions = result.collisions.map((item) => ({
+      outDir: toRelativePath(result.monorepoRoot, item.outDir),
+      roots: item.roots.map(
+        (collisionRoot) => toRelativePath(result.monorepoRoot, collisionRoot)
+      ).sort((a, b) => a.localeCompare(b))
+    })).sort((a, b) => a.outDir.localeCompare(b.outDir));
+    const severity = collisions.length > 0 ? "warning" : "ok";
+    const message = collisions.length > 0 ? `outDir collision detected (count=${collisions.length})` : `outDir collision not detected (configs=${configRoots.length})`;
+    return {
+      id: "output.outDirCollision",
+      severity,
+      title: "OutDir collision",
+      message,
+      details: {
+        monorepoRoot: relativeRoot,
+        configRoots,
+        collisions
+      }
+    };
+  } catch (error2) {
+    return {
+      id: "output.outDirCollision",
+      severity: "error",
+      title: "OutDir collision",
+      message: "OutDir collision scan failed",
+      details: { error: String(error2) }
+    };
+  }
+}
+async function detectOutDirCollisions(root) {
+  const monorepoRoot = await findMonorepoRoot(root);
+  const configPaths = await collectFilesByGlobs(monorepoRoot, {
+    globs: ["**/qfai.config.yaml"],
+    ignore: DEFAULT_CONFIG_SEARCH_IGNORE_GLOBS
+  });
+  const configRoots = Array.from(
+    new Set(configPaths.map((configPath) => import_node_path7.default.dirname(configPath)))
+  ).sort((a, b) => a.localeCompare(b));
+  const outDirToRoots = /* @__PURE__ */ new Map();
+  for (const configRoot of configRoots) {
+    const { config } = await loadConfig(configRoot);
+    const outDir = import_node_path7.default.normalize(resolvePath(configRoot, config, "outDir"));
+    const roots = outDirToRoots.get(outDir) ?? /* @__PURE__ */ new Set();
+    roots.add(configRoot);
+    outDirToRoots.set(outDir, roots);
+  }
+  const collisions = [];
+  for (const [outDir, roots] of outDirToRoots.entries()) {
+    if (roots.size > 1) {
+      collisions.push({
+        outDir,
+        roots: Array.from(roots).sort((a, b) => a.localeCompare(b))
+      });
+    }
+  }
+  return { monorepoRoot, configRoots, collisions };
+}
+async function findMonorepoRoot(startDir) {
+  let current = import_node_path7.default.resolve(startDir);
+  while (true) {
+    const gitPath = import_node_path7.default.join(current, ".git");
+    const workspacePath = import_node_path7.default.join(current, "pnpm-workspace.yaml");
+    if (await exists4(gitPath) || await exists4(workspacePath)) {
+      return current;
+    }
+    const parent = import_node_path7.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return import_node_path7.default.resolve(startDir);
+}
 
 // src/cli/lib/logger.ts
 function info(message) {
@@ -1118,15 +1204,26 @@ async function runDoctor(options) {
     rootExplicit: options.rootExplicit
   });
   const output = options.format === "json" ? formatDoctorJson(data) : formatDoctorText(data);
+  const exitCode = shouldFailDoctor(data.summary, options.failOn) ? 1 : 0;
   if (options.outPath) {
     const outAbs = import_node_path8.default.isAbsolute(options.outPath) ? options.outPath : import_node_path8.default.resolve(process.cwd(), options.outPath);
     await (0, import_promises8.mkdir)(import_node_path8.default.dirname(outAbs), { recursive: true });
     await (0, import_promises8.writeFile)(outAbs, `${output}
 `, "utf-8");
     info(`doctor: wrote ${outAbs}`);
-    return;
+    return exitCode;
   }
   info(output);
+  return exitCode;
+}
+function shouldFailDoctor(summary, failOn) {
+  if (!failOn) {
+    return false;
+  }
+  if (failOn === "error") {
+    return summary.error > 0;
+  }
+  return summary.warning + summary.error > 0;
 }
 
 // src/cli/commands/init.ts
@@ -3021,13 +3118,11 @@ async function createReportData(root, validation, configResult) {
     normalizeScSources(resolvedRoot, scSources)
   );
   const version = await resolveToolVersion();
-  const reportFormatVersion = 1;
   const displayRoot = toRelativePath(resolvedRoot, resolvedRoot);
   const displayConfigPath = toRelativePath(resolvedRoot, configPath);
   return {
     tool: "qfai",
     version,
-    reportFormatVersion,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     root: displayRoot,
     configPath: displayConfigPath,
@@ -3877,12 +3972,16 @@ async function run(argv, cwd) {
       }
       return;
     case "doctor":
-      await runDoctor({
-        root: options.root,
-        rootExplicit: options.rootExplicit,
-        format: options.doctorFormat,
-        ...options.doctorOut !== void 0 ? { outPath: options.doctorOut } : {}
-      });
+      {
+        const exitCode = await runDoctor({
+          root: options.root,
+          rootExplicit: options.rootExplicit,
+          format: options.doctorFormat,
+          ...options.doctorOut !== void 0 ? { outPath: options.doctorOut } : {},
+          ...options.failOn && options.failOn !== "never" ? { failOn: options.failOn } : {}
+        });
+        process.exitCode = exitCode;
+      }
       return;
     default:
       error(`Unknown command: ${command}`);
@@ -3910,6 +4009,7 @@ Options:
   --format <text|json>         doctor \u306E\u51FA\u529B\u5F62\u5F0F
   --strict                     validate: warning \u4EE5\u4E0A\u3067 exit 1
   --fail-on <error|warning|never>  validate: \u5931\u6557\u6761\u4EF6
+  --fail-on <error|warning>        doctor: \u5931\u6557\u6761\u4EF6
   --out <path>                  report/doctor: \u51FA\u529B\u5148
   --in <path>                   report: validate.json \u306E\u5165\u529B\u5148\uFF08config\u3088\u308A\u512A\u5148\uFF09
   --run-validate                report: validate \u3092\u5B9F\u884C\u3057\u3066\u304B\u3089 report \u3092\u751F\u6210