qfai 0.6.0 → 0.6.3

package/dist/cli/index.mjs

@@ -870,8 +870,8 @@ import { readFile as readFile3 } from "fs/promises";
 import path6 from "path";
 import { fileURLToPath } from "url";
 async function resolveToolVersion() {
-  if ("0.6.0".length > 0) {
-    return "0.6.0";
+  if ("0.6.3".length > 0) {
+    return "0.6.3";
   }
   try {
     const packagePath = resolvePackageJsonPath();
@@ -1002,6 +1002,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 = path7.relative(outDirAbs, validateJsonAbs);
+  const inside = rel !== "" && !rel.startsWith("..") && !path7.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([
@@ -1033,23 +1049,9 @@ async function createDoctorData(options) {
       details: { globs, excludeGlobs: exclude, error: String(error2) }
     });
   }
-  const outDirAbs = resolvePath(root, config, "outDir");
-  const rel = path7.relative(outDirAbs, validateJsonAbs);
-  const inside = rel !== "" && !rel.startsWith("..") && !path7.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: {
@@ -1061,6 +1063,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) => path7.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 = path7.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 = path7.resolve(startDir);
+  while (true) {
+    const gitPath = path7.join(current, ".git");
+    const workspacePath = path7.join(current, "pnpm-workspace.yaml");
+    if (await exists4(gitPath) || await exists4(workspacePath)) {
+      return current;
+    }
+    const parent = path7.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return path7.resolve(startDir);
+}
 
 // src/cli/lib/logger.ts
 function info(message) {
@@ -1099,15 +1185,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 = path8.isAbsolute(options.outPath) ? options.outPath : path8.resolve(process.cwd(), options.outPath);
     await mkdir(path8.dirname(outAbs), { recursive: true });
     await 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
@@ -3002,13 +3099,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,
@@ -3858,12 +3953,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}`);
@@ -3891,6 +3990,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