qfai 0.2.5

package/dist/index.mjs

@@ -0,0 +1,1523 @@
+// src/core/config.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { parse as parseYaml } from "yaml";
+var defaultConfig = {
+  paths: {
+    specDir: "qfai/spec",
+    decisionsDir: "qfai/spec/decisions",
+    scenariosDir: "qfai/spec",
+    rulesDir: "qfai/rules",
+    contractsDir: "qfai/contracts",
+    uiContractsDir: "qfai/contracts/ui",
+    apiContractsDir: "qfai/contracts/api",
+    dataContractsDir: "qfai/contracts/db",
+    srcDir: "src",
+    testsDir: "tests"
+  },
+  validation: {
+    failOn: "error",
+    require: {
+      specSections: [
+        "\u80CC\u666F",
+        "\u30B9\u30B3\u30FC\u30D7",
+        "\u975E\u30B4\u30FC\u30EB",
+        "\u7528\u8A9E",
+        "\u524D\u63D0",
+        "\u6C7A\u5B9A\u4E8B\u9805",
+        "\u696D\u52D9\u30EB\u30FC\u30EB"
+      ]
+    },
+    traceability: {
+      brMustHaveSc: true,
+      scMustTouchContracts: true,
+      allowOrphanContracts: false
+    }
+  },
+  output: {
+    format: "text",
+    jsonPath: ".qfai/out/validate.json"
+  }
+};
+function getConfigPath(root) {
+  return path.join(root, "qfai.config.yaml");
+}
+async function loadConfig(root) {
+  const configPath = getConfigPath(root);
+  const issues = [];
+  let parsed;
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    parsed = parseYaml(raw);
+  } catch (error) {
+    if (isMissingFile(error)) {
+      return { config: defaultConfig, issues, configPath };
+    }
+    issues.push(configIssue(configPath, formatError(error)));
+    return { config: defaultConfig, issues, configPath };
+  }
+  const normalized = normalizeConfig(parsed, configPath, issues);
+  return { config: normalized, issues, configPath };
+}
+function resolvePath(root, config, key) {
+  return path.resolve(root, config.paths[key]);
+}
+function normalizeConfig(raw, configPath, issues) {
+  if (!isRecord(raw)) {
+    issues.push(configIssue(configPath, "\u8A2D\u5B9A\u30D5\u30A1\u30A4\u30EB\u306E\u5F62\u5F0F\u304C\u4E0D\u6B63\u3067\u3059\u3002"));
+    return defaultConfig;
+  }
+  return {
+    paths: normalizePaths(raw.paths, configPath, issues),
+    validation: normalizeValidation(raw.validation, configPath, issues),
+    output: normalizeOutput(raw.output, configPath, issues)
+  };
+}
+function normalizePaths(raw, configPath, issues) {
+  const base = defaultConfig.paths;
+  if (!raw) {
+    return base;
+  }
+  if (!isRecord(raw)) {
+    issues.push(
+      configIssue(configPath, "paths \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+    );
+    return base;
+  }
+  return {
+    specDir: readString(
+      raw.specDir,
+      base.specDir,
+      "paths.specDir",
+      configPath,
+      issues
+    ),
+    decisionsDir: readString(
+      raw.decisionsDir,
+      base.decisionsDir,
+      "paths.decisionsDir",
+      configPath,
+      issues
+    ),
+    scenariosDir: readString(
+      raw.scenariosDir,
+      base.scenariosDir,
+      "paths.scenariosDir",
+      configPath,
+      issues
+    ),
+    rulesDir: readString(
+      raw.rulesDir,
+      base.rulesDir,
+      "paths.rulesDir",
+      configPath,
+      issues
+    ),
+    contractsDir: readString(
+      raw.contractsDir,
+      base.contractsDir,
+      "paths.contractsDir",
+      configPath,
+      issues
+    ),
+    uiContractsDir: readString(
+      raw.uiContractsDir,
+      base.uiContractsDir,
+      "paths.uiContractsDir",
+      configPath,
+      issues
+    ),
+    apiContractsDir: readString(
+      raw.apiContractsDir,
+      base.apiContractsDir,
+      "paths.apiContractsDir",
+      configPath,
+      issues
+    ),
+    dataContractsDir: readString(
+      raw.dataContractsDir,
+      base.dataContractsDir,
+      "paths.dataContractsDir",
+      configPath,
+      issues
+    ),
+    srcDir: readString(
+      raw.srcDir,
+      base.srcDir,
+      "paths.srcDir",
+      configPath,
+      issues
+    ),
+    testsDir: readString(
+      raw.testsDir,
+      base.testsDir,
+      "paths.testsDir",
+      configPath,
+      issues
+    )
+  };
+}
+function normalizeValidation(raw, configPath, issues) {
+  const base = defaultConfig.validation;
+  if (!raw) {
+    return base;
+  }
+  if (!isRecord(raw)) {
+    issues.push(
+      configIssue(
+        configPath,
+        "validation \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+      )
+    );
+    return base;
+  }
+  let requireRaw;
+  if (raw.require === void 0) {
+    requireRaw = void 0;
+  } else if (isRecord(raw.require)) {
+    requireRaw = raw.require;
+  } else {
+    issues.push(
+      configIssue(
+        configPath,
+        "validation.require \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+      )
+    );
+    requireRaw = void 0;
+  }
+  let traceabilityRaw;
+  if (raw.traceability === void 0) {
+    traceabilityRaw = void 0;
+  } else if (isRecord(raw.traceability)) {
+    traceabilityRaw = raw.traceability;
+  } else {
+    issues.push(
+      configIssue(
+        configPath,
+        "validation.traceability \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002"
+      )
+    );
+    traceabilityRaw = void 0;
+  }
+  return {
+    failOn: readFailOn(
+      raw.failOn,
+      base.failOn,
+      "validation.failOn",
+      configPath,
+      issues
+    ),
+    require: {
+      specSections: readStringArray(
+        requireRaw?.specSections,
+        base.require.specSections,
+        "validation.require.specSections",
+        configPath,
+        issues
+      )
+    },
+    traceability: {
+      brMustHaveSc: readBoolean(
+        traceabilityRaw?.brMustHaveSc,
+        base.traceability.brMustHaveSc,
+        "validation.traceability.brMustHaveSc",
+        configPath,
+        issues
+      ),
+      scMustTouchContracts: readBoolean(
+        traceabilityRaw?.scMustTouchContracts,
+        base.traceability.scMustTouchContracts,
+        "validation.traceability.scMustTouchContracts",
+        configPath,
+        issues
+      ),
+      allowOrphanContracts: readBoolean(
+        traceabilityRaw?.allowOrphanContracts,
+        base.traceability.allowOrphanContracts,
+        "validation.traceability.allowOrphanContracts",
+        configPath,
+        issues
+      )
+    }
+  };
+}
+function normalizeOutput(raw, configPath, issues) {
+  const base = defaultConfig.output;
+  if (!raw) {
+    return base;
+  }
+  if (!isRecord(raw)) {
+    issues.push(
+      configIssue(configPath, "output \u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002")
+    );
+    return base;
+  }
+  return {
+    format: readOutputFormat(
+      raw.format,
+      base.format,
+      "output.format",
+      configPath,
+      issues
+    ),
+    jsonPath: readString(
+      raw.jsonPath,
+      base.jsonPath,
+      "output.jsonPath",
+      configPath,
+      issues
+    )
+  };
+}
+function readString(value, fallback, label, configPath, issues) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
+  }
+  if (value !== void 0) {
+    issues.push(
+      configIssue(configPath, `${label} \u306F\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`)
+    );
+  }
+  return fallback;
+}
+function readStringArray(value, fallback, label, configPath, issues) {
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value;
+  }
+  if (value !== void 0) {
+    issues.push(
+      configIssue(configPath, `${label} \u306F\u6587\u5B57\u5217\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`)
+    );
+  }
+  return fallback;
+}
+function readBoolean(value, fallback, label, configPath, issues) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value !== void 0) {
+    issues.push(
+      configIssue(configPath, `${label} \u306F\u771F\u507D\u5024\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`)
+    );
+  }
+  return fallback;
+}
+function readFailOn(value, fallback, label, configPath, issues) {
+  if (value === "never" || value === "warning" || value === "error") {
+    return value;
+  }
+  if (value !== void 0) {
+    issues.push(
+      configIssue(
+        configPath,
+        `${label} \u306F never|warning|error \u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`
+      )
+    );
+  }
+  return fallback;
+}
+function readOutputFormat(value, fallback, label, configPath, issues) {
+  if (value === "text" || value === "json" || value === "github") {
+    return value;
+  }
+  if (value !== void 0) {
+    issues.push(
+      configIssue(
+        configPath,
+        `${label} \u306F text|json|github \u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`
+      )
+    );
+  }
+  return fallback;
+}
+function configIssue(file, message) {
+  return {
+    code: "QFAI_CONFIG_INVALID",
+    severity: "error",
+    message,
+    file,
+    rule: "config.invalid"
+  };
+}
+function isMissingFile(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    return error.code === "ENOENT";
+  }
+  return false;
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/core/ids.ts
+var ID_PATTERNS = {
+  SPEC: /\bSPEC-[A-Z0-9-]+\b/g,
+  BR: /\bBR-[A-Z0-9-]+\b/g,
+  SC: /\bSC-[A-Z0-9-]+\b/g,
+  UI: /\bUI-[A-Z0-9-]+\b/g,
+  API: /\bAPI-[A-Z0-9-]+\b/g,
+  DATA: /\bDATA-[A-Z0-9-]+\b/g
+};
+var LOOSE_ID_PATTERNS = {
+  SPEC: /\bSPEC-[A-Za-z0-9_-]+\b/gi,
+  BR: /\bBR-[A-Za-z0-9_-]+\b/gi,
+  SC: /\bSC-[A-Za-z0-9_-]+\b/gi,
+  UI: /\bUI-[A-Za-z0-9_-]+\b/gi,
+  API: /\bAPI-[A-Za-z0-9_-]+\b/gi,
+  DATA: /\bDATA-[A-Za-z0-9_-]+\b/gi
+};
+function extractIds(text, prefix) {
+  const pattern = ID_PATTERNS[prefix];
+  const matches = text.match(pattern);
+  return unique(matches ?? []);
+}
+function extractAllIds(text) {
+  const all = [];
+  Object.keys(ID_PATTERNS).forEach((prefix) => {
+    all.push(...extractIds(text, prefix));
+  });
+  return unique(all);
+}
+function extractInvalidIds(text, prefixes) {
+  const invalid = [];
+  for (const prefix of prefixes) {
+    const candidates = text.match(LOOSE_ID_PATTERNS[prefix]) ?? [];
+    for (const candidate of candidates) {
+      if (!isValidId(candidate, prefix)) {
+        invalid.push(candidate);
+      }
+    }
+  }
+  return unique(invalid);
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+function isValidId(value, prefix) {
+  const pattern = ID_PATTERNS[prefix];
+  const strict = new RegExp(pattern.source);
+  return strict.test(value);
+}
+
+// src/core/report.ts
+import { readFile as readFile7 } from "fs/promises";
+
+// src/core/discovery.ts
+import path3 from "path";
+
+// src/core/fs.ts
+import { access, readdir } from "fs/promises";
+import path2 from "path";
+var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".pnpm",
+  "tmp",
+  ".mcp-tools"
+]);
+async function collectFiles(root, options = {}) {
+  const entries = [];
+  if (!await exists(root)) {
+    return entries;
+  }
+  const ignoreDirs = /* @__PURE__ */ new Set([
+    ...DEFAULT_IGNORE_DIRS,
+    ...options.ignoreDirs ?? []
+  ]);
+  const extensions = options.extensions?.map((ext) => ext.toLowerCase()) ?? [];
+  await walk(root, root, ignoreDirs, extensions, entries);
+  return entries;
+}
+async function walk(base, current, ignoreDirs, extensions, out) {
+  const items = await readdir(current, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path2.join(current, item.name);
+    if (item.isDirectory()) {
+      if (ignoreDirs.has(item.name)) {
+        continue;
+      }
+      await walk(base, fullPath, ignoreDirs, extensions, out);
+      continue;
+    }
+    if (item.isFile()) {
+      if (extensions.length > 0) {
+        const ext = path2.extname(item.name).toLowerCase();
+        if (!extensions.includes(ext)) {
+          continue;
+        }
+      }
+      out.push(fullPath);
+    }
+  }
+}
+async function exists(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/core/discovery.ts
+var LEGACY_SPEC_NAME = "spec.md";
+var SPEC_NAMED_PATTERN = /^spec-\d{4}-[^/\\]+\.md$/i;
+async function collectSpecFiles(specRoot) {
+  const files = await collectFiles(specRoot, { extensions: [".md"] });
+  return files.filter((file) => isSpecFile(file));
+}
+async function collectUiContractFiles(uiRoot) {
+  return collectFiles(uiRoot, { extensions: [".yaml", ".yml"] });
+}
+async function collectApiContractFiles(apiRoot) {
+  return collectFiles(apiRoot, { extensions: [".yaml", ".yml", ".json"] });
+}
+async function collectDataContractFiles(dataRoot) {
+  return collectFiles(dataRoot, { extensions: [".sql"] });
+}
+async function collectContractFiles(uiRoot, apiRoot, dataRoot) {
+  const [ui, api, db] = await Promise.all([
+    collectUiContractFiles(uiRoot),
+    collectApiContractFiles(apiRoot),
+    collectDataContractFiles(dataRoot)
+  ]);
+  return { ui, api, db };
+}
+function isSpecFile(filePath) {
+  const name = path3.basename(filePath).toLowerCase();
+  return name === LEGACY_SPEC_NAME || SPEC_NAMED_PATTERN.test(name);
+}
+
+// src/core/types.ts
+var VALIDATION_SCHEMA_VERSION = "0.2";
+
+// src/core/version.ts
+import { readFile as readFile2 } from "fs/promises";
+import path4 from "path";
+import { fileURLToPath } from "url";
+async function resolveToolVersion() {
+  if ("0.2.5".length > 0) {
+    return "0.2.5";
+  }
+  try {
+    const packagePath = resolvePackageJsonPath();
+    const raw = await readFile2(packagePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const version = typeof parsed.version === "string" ? parsed.version : "";
+    return version.length > 0 ? version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function resolvePackageJsonPath() {
+  const base = import.meta.url;
+  const basePath = base.startsWith("file:") ? fileURLToPath(base) : base;
+  return path4.resolve(path4.dirname(basePath), "../../package.json");
+}
+
+// src/core/validators/contracts.ts
+import { readFile as readFile3 } from "fs/promises";
+import path5 from "path";
+import { parse as parseYaml2 } from "yaml";
+var SQL_DANGEROUS_PATTERNS = [
+  { pattern: /\bDROP\s+TABLE\b/i, label: "DROP TABLE" },
+  { pattern: /\bDROP\s+DATABASE\b/i, label: "DROP DATABASE" },
+  { pattern: /\bTRUNCATE\b/i, label: "TRUNCATE" },
+  {
+    pattern: /\bALTER\s+TABLE\b[\s\S]*\bDROP\b/i,
+    label: "ALTER TABLE ... DROP"
+  }
+];
+async function validateContracts(root, config) {
+  const issues = [];
+  issues.push(
+    ...await validateUiContracts(resolvePath(root, config, "uiContractsDir"))
+  );
+  issues.push(
+    ...await validateApiContracts(
+      resolvePath(root, config, "apiContractsDir")
+    )
+  );
+  issues.push(
+    ...await validateDataContracts(
+      resolvePath(root, config, "dataContractsDir")
+    )
+  );
+  return issues;
+}
+async function validateUiContracts(uiRoot) {
+  const files = await collectUiContractFiles(uiRoot);
+  if (files.length === 0) {
+    return [
+      issue(
+        "QFAI-UI-000",
+        "UI \u5951\u7D04\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        uiRoot,
+        "contracts.ui.files"
+      )
+    ];
+  }
+  const issues = [];
+  for (const file of files) {
+    const text = await readFile3(file, "utf-8");
+    const invalidIds = extractInvalidIds(text, [
+      "SPEC",
+      "BR",
+      "SC",
+      "UI",
+      "API",
+      "DATA"
+    ]);
+    if (invalidIds.length > 0) {
+      issues.push(
+        issue(
+          "QFAI_ID_INVALID_FORMAT",
+          `ID \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u304C\u4E0D\u6B63\u3067\u3059: ${invalidIds.join(", ")}`,
+          "error",
+          file,
+          "id.format",
+          invalidIds
+        )
+      );
+    }
+    try {
+      const doc = parseYaml2(text);
+      const id = typeof doc.id === "string" ? doc.id : "";
+      if (!id.startsWith("UI-")) {
+        issues.push(
+          issue(
+            "QFAI-UI-001",
+            "UI \u5951\u7D04\u306E id \u306F UI- \u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002",
+            "error",
+            file,
+            "contracts.ui.id"
+          )
+        );
+      }
+    } catch (error) {
+      issues.push(
+        issue(
+          "QFAI-UI-002",
+          `UI YAML \u306E\u89E3\u6790\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${formatError2(error)}`,
+          "error",
+          file,
+          "contracts.ui.parse"
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateApiContracts(apiRoot) {
+  const files = await collectApiContractFiles(apiRoot);
+  if (files.length === 0) {
+    return [
+      issue(
+        "QFAI-API-000",
+        "API \u5951\u7D04\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        apiRoot,
+        "contracts.api.files"
+      )
+    ];
+  }
+  const issues = [];
+  for (const file of files) {
+    const text = await readFile3(file, "utf-8");
+    const invalidIds = extractInvalidIds(text, [
+      "SPEC",
+      "BR",
+      "SC",
+      "UI",
+      "API",
+      "DATA"
+    ]);
+    if (invalidIds.length > 0) {
+      issues.push(
+        issue(
+          "QFAI_ID_INVALID_FORMAT",
+          `ID \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u304C\u4E0D\u6B63\u3067\u3059: ${invalidIds.join(", ")}`,
+          "error",
+          file,
+          "id.format",
+          invalidIds
+        )
+      );
+    }
+    try {
+      const doc = parseStructured(file, text);
+      if (!doc || !hasOpenApi(doc)) {
+        issues.push(
+          issue(
+            "QFAI-API-001",
+            "OpenAPI \u5B9A\u7FA9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+            "error",
+            file,
+            "contracts.api.openapi"
+          )
+        );
+      }
+    } catch (error) {
+      issues.push(
+        issue(
+          "QFAI-API-002",
+          `API \u5B9A\u7FA9\u306E\u89E3\u6790\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${formatError2(error)}`,
+          "error",
+          file,
+          "contracts.api.parse"
+        )
+      );
+    }
+  }
+  return issues;
+}
+async function validateDataContracts(dataRoot) {
+  const files = await collectDataContractFiles(dataRoot);
+  if (files.length === 0) {
+    return [
+      issue(
+        "QFAI-DATA-000",
+        "DATA \u5951\u7D04\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        dataRoot,
+        "contracts.data.files"
+      )
+    ];
+  }
+  const issues = [];
+  for (const file of files) {
+    const text = await readFile3(file, "utf-8");
+    const invalidIds = extractInvalidIds(text, [
+      "SPEC",
+      "BR",
+      "SC",
+      "UI",
+      "API",
+      "DATA"
+    ]);
+    if (invalidIds.length > 0) {
+      issues.push(
+        issue(
+          "QFAI_ID_INVALID_FORMAT",
+          `ID \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u304C\u4E0D\u6B63\u3067\u3059: ${invalidIds.join(", ")}`,
+          "error",
+          file,
+          "id.format",
+          invalidIds
+        )
+      );
+    }
+    issues.push(...lintSql(text, file));
+  }
+  return issues;
+}
+function lintSql(text, file) {
+  const issues = [];
+  for (const { pattern, label } of SQL_DANGEROUS_PATTERNS) {
+    if (pattern.test(text)) {
+      issues.push(
+        issue(
+          "QFAI-DATA-001",
+          `\u5371\u967A\u306A SQL \u64CD\u4F5C\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u3059: ${label}`,
+          "warning",
+          file,
+          "contracts.data.sql"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function parseStructured(file, text) {
+  const ext = path5.extname(file).toLowerCase();
+  if (ext === ".json") {
+    return JSON.parse(text);
+  }
+  return parseYaml2(text);
+}
+function hasOpenApi(doc) {
+  return typeof doc.openapi === "string" && doc.openapi.length > 0;
+}
+function formatError2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function issue(code, message, severity, file, rule, refs) {
+  const issue5 = {
+    code,
+    severity,
+    message
+  };
+  if (file) {
+    issue5.file = file;
+  }
+  if (rule) {
+    issue5.rule = rule;
+  }
+  if (refs && refs.length > 0) {
+    issue5.refs = refs;
+  }
+  return issue5;
+}
+
+// src/core/validators/scenario.ts
+import { readFile as readFile4 } from "fs/promises";
+var GIVEN_PATTERN = /\bGiven\b/;
+var WHEN_PATTERN = /\bWhen\b/;
+var THEN_PATTERN = /\bThen\b/;
+async function validateScenarios(root, config) {
+  const scenariosRoot = resolvePath(root, config, "scenariosDir");
+  const files = await collectFiles(scenariosRoot, {
+    extensions: [".feature"]
+  });
+  if (files.length === 0) {
+    return [
+      issue2(
+        "QFAI-SC-000",
+        "Scenario \u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        scenariosRoot,
+        "scenario.files"
+      )
+    ];
+  }
+  const issues = [];
+  for (const file of files) {
+    const text = await readFile4(file, "utf-8");
+    issues.push(...validateScenarioContent(text, file));
+  }
+  return issues;
+}
+function validateScenarioContent(text, file) {
+  const issues = [];
+  const invalidIds = extractInvalidIds(text, [
+    "SPEC",
+    "BR",
+    "SC",
+    "UI",
+    "API",
+    "DATA"
+  ]);
+  if (invalidIds.length > 0) {
+    issues.push(
+      issue2(
+        "QFAI_ID_INVALID_FORMAT",
+        `ID \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u304C\u4E0D\u6B63\u3067\u3059: ${invalidIds.join(", ")}`,
+        "error",
+        file,
+        "id.format",
+        invalidIds
+      )
+    );
+  }
+  const scIds = extractIds(text, "SC");
+  if (scIds.length === 0) {
+    issues.push(
+      issue2(
+        "QFAI-SC-001",
+        "SC ID \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "error",
+        file,
+        "scenario.id"
+      )
+    );
+  }
+  const specIds = extractIds(text, "SPEC");
+  if (specIds.length === 0) {
+    issues.push(
+      issue2(
+        "QFAI-SC-002",
+        "SC \u306F SPEC \u3092\u53C2\u7167\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002",
+        "error",
+        file,
+        "scenario.spec"
+      )
+    );
+  }
+  const brIds = extractIds(text, "BR");
+  if (brIds.length === 0) {
+    issues.push(
+      issue2(
+        "QFAI-SC-003",
+        "SC \u306F BR \u3092\u53C2\u7167\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002",
+        "error",
+        file,
+        "scenario.br"
+      )
+    );
+  }
+  const missingSteps = [];
+  if (!GIVEN_PATTERN.test(text)) {
+    missingSteps.push("Given");
+  }
+  if (!WHEN_PATTERN.test(text)) {
+    missingSteps.push("When");
+  }
+  if (!THEN_PATTERN.test(text)) {
+    missingSteps.push("Then");
+  }
+  if (missingSteps.length > 0) {
+    issues.push(
+      issue2(
+        "QFAI-SC-005",
+        `Given/When/Then \u304C\u4E0D\u8DB3\u3057\u3066\u3044\u307E\u3059: ${missingSteps.join(", ")}`,
+        "warning",
+        file,
+        "scenario.steps"
+      )
+    );
+  }
+  return issues;
+}
+function issue2(code, message, severity, file, rule, refs) {
+  const issue5 = {
+    code,
+    severity,
+    message
+  };
+  if (file) {
+    issue5.file = file;
+  }
+  if (rule) {
+    issue5.rule = rule;
+  }
+  if (refs && refs.length > 0) {
+    issue5.refs = refs;
+  }
+  return issue5;
+}
+
+// src/core/validators/spec.ts
+import { readFile as readFile5 } from "fs/promises";
+async function validateSpecs(root, config) {
+  const specsRoot = resolvePath(root, config, "specDir");
+  const files = await collectSpecFiles(specsRoot);
+  if (files.length === 0) {
+    return [
+      issue3(
+        "QFAI-SPEC-000",
+        "Spec \u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        specsRoot,
+        "spec.files"
+      )
+    ];
+  }
+  const issues = [];
+  for (const file of files) {
+    const text = await readFile5(file, "utf-8");
+    issues.push(
+      ...validateSpecContent(
+        text,
+        file,
+        config.validation.require.specSections
+      )
+    );
+  }
+  return issues;
+}
+function validateSpecContent(text, file, requiredSections) {
+  const issues = [];
+  const invalidIds = extractInvalidIds(text, [
+    "SPEC",
+    "BR",
+    "SC",
+    "UI",
+    "API",
+    "DATA"
+  ]);
+  if (invalidIds.length > 0) {
+    issues.push(
+      issue3(
+        "QFAI_ID_INVALID_FORMAT",
+        `ID \u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u304C\u4E0D\u6B63\u3067\u3059: ${invalidIds.join(", ")}`,
+        "error",
+        file,
+        "id.format",
+        invalidIds
+      )
+    );
+  }
+  const specIds = extractIds(text, "SPEC");
+  if (specIds.length === 0) {
+    issues.push(
+      issue3(
+        "QFAI-SPEC-001",
+        "SPEC ID \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "error",
+        file,
+        "spec.id"
+      )
+    );
+  }
+  const brIds = extractIds(text, "BR");
+  if (brIds.length === 0) {
+    issues.push(
+      issue3(
+        "QFAI-SPEC-002",
+        "BR ID \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "error",
+        file,
+        "spec.br"
+      )
+    );
+  }
+  const scIds = extractIds(text, "SC");
+  if (scIds.length > 0) {
+    issues.push(
+      issue3(
+        "QFAI-SPEC-003",
+        "Spec \u306F SC \u3092\u53C2\u7167\u3057\u306A\u3044\u30EB\u30FC\u30EB\u3067\u3059\u3002",
+        "warning",
+        file,
+        "spec.noSc",
+        scIds
+      )
+    );
+  }
+  for (const section of requiredSections) {
+    if (!text.includes(section)) {
+      issues.push(
+        issue3(
+          "QFAI-SPEC-004",
+          `\u5FC5\u9808\u30BB\u30AF\u30B7\u30E7\u30F3\u304C\u4E0D\u8DB3\u3057\u3066\u3044\u307E\u3059: ${section}`,
+          "error",
+          file,
+          "spec.requiredSection"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function issue3(code, message, severity, file, rule, refs) {
+  const issue5 = {
+    code,
+    severity,
+    message
+  };
+  if (file) {
+    issue5.file = file;
+  }
+  if (rule) {
+    issue5.rule = rule;
+  }
+  if (refs && refs.length > 0) {
+    issue5.refs = refs;
+  }
+  return issue5;
+}
+
+// src/core/validators/traceability.ts
+import { readFile as readFile6 } from "fs/promises";
+async function validateTraceability(root, config) {
+  const issues = [];
+  const specsRoot = resolvePath(root, config, "specDir");
+  const decisionsRoot = resolvePath(root, config, "decisionsDir");
+  const scenariosRoot = resolvePath(root, config, "scenariosDir");
+  const srcRoot = resolvePath(root, config, "srcDir");
+  const testsRoot = resolvePath(root, config, "testsDir");
+  const specFiles = await collectSpecFiles(specsRoot);
+  const decisionFiles = await collectFiles(decisionsRoot, {
+    extensions: [".md"]
+  });
+  const scenarioFiles = await collectFiles(scenariosRoot, {
+    extensions: [".feature"]
+  });
+  const upstreamIds = /* @__PURE__ */ new Set();
+  const brIdsInSpecs = /* @__PURE__ */ new Set();
+  const brIdsInScenarios = /* @__PURE__ */ new Set();
+  const scIdsInScenarios = /* @__PURE__ */ new Set();
+  const scenarioContractIds = /* @__PURE__ */ new Set();
+  const scWithContracts = /* @__PURE__ */ new Set();
+  for (const file of [...specFiles, ...decisionFiles]) {
+    const text = await readFile6(file, "utf-8");
+    extractAllIds(text).forEach((id) => upstreamIds.add(id));
+    extractIds(text, "BR").forEach((id) => brIdsInSpecs.add(id));
+  }
+  for (const file of scenarioFiles) {
+    const text = await readFile6(file, "utf-8");
+    extractAllIds(text).forEach((id) => upstreamIds.add(id));
+    const brIds = extractIds(text, "BR");
+    brIds.forEach((id) => brIdsInScenarios.add(id));
+    const scIds = extractIds(text, "SC");
+    scIds.forEach((id) => scIdsInScenarios.add(id));
+    const contractIds = [
+      ...extractIds(text, "UI"),
+      ...extractIds(text, "API"),
+      ...extractIds(text, "DATA")
+    ];
+    contractIds.forEach((id) => scenarioContractIds.add(id));
+    if (contractIds.length > 0) {
+      scIds.forEach((id) => scWithContracts.add(id));
+    }
+  }
+  if (upstreamIds.size === 0) {
+    return [
+      issue4(
+        "QFAI-TRACE-000",
+        "\u4E0A\u6D41 ID \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        specsRoot,
+        "traceability.upstream"
+      )
+    ];
+  }
+  if (config.validation.traceability.brMustHaveSc && brIdsInSpecs.size > 0) {
+    const orphanBrIds = Array.from(brIdsInSpecs).filter(
+      (id) => !brIdsInScenarios.has(id)
+    );
+    if (orphanBrIds.length > 0) {
+      issues.push(
+        issue4(
+          "QFAI_TRACE_BR_ORPHAN",
+          `BR \u304C SC \u306B\u7D10\u3065\u3044\u3066\u3044\u307E\u305B\u3093: ${orphanBrIds.join(", ")}`,
+          "error",
+          specsRoot,
+          "traceability.brMustHaveSc",
+          orphanBrIds
+        )
+      );
+    }
+  }
+  if (config.validation.traceability.scMustTouchContracts && scIdsInScenarios.size > 0) {
+    const scWithoutContracts = Array.from(scIdsInScenarios).filter(
+      (id) => !scWithContracts.has(id)
+    );
+    if (scWithoutContracts.length > 0) {
+      issues.push(
+        issue4(
+          "QFAI_TRACE_SC_NO_CONTRACT",
+          `SC \u304C\u5951\u7D04(UI/API/DATA)\u306B\u63A5\u7D9A\u3057\u3066\u3044\u307E\u305B\u3093: ${scWithoutContracts.join(
+            ", "
+          )}`,
+          "error",
+          scenariosRoot,
+          "traceability.scMustTouchContracts",
+          scWithoutContracts
+        )
+      );
+    }
+  }
+  if (!config.validation.traceability.allowOrphanContracts) {
+    const contractIds = await collectContractIds(root, config);
+    if (contractIds.size > 0) {
+      const orphanContracts = Array.from(contractIds).filter(
+        (id) => !scenarioContractIds.has(id)
+      );
+      if (orphanContracts.length > 0) {
+        issues.push(
+          issue4(
+            "QFAI_CONTRACT_ORPHAN",
+            `\u5951\u7D04\u304C SC \u304B\u3089\u53C2\u7167\u3055\u308C\u3066\u3044\u307E\u305B\u3093: ${orphanContracts.join(", ")}`,
+            "error",
+            scenariosRoot,
+            "traceability.allowOrphanContracts",
+            orphanContracts
+          )
+        );
+      }
+    }
+  }
+  issues.push(
+    ...await validateCodeReferences(upstreamIds, srcRoot, testsRoot)
+  );
+  return issues;
+}
+async function collectContractIds(root, config) {
+  const contractIds = /* @__PURE__ */ new Set();
+  const uiRoot = resolvePath(root, config, "uiContractsDir");
+  const apiRoot = resolvePath(root, config, "apiContractsDir");
+  const dataRoot = resolvePath(root, config, "dataContractsDir");
+  const uiFiles = await collectUiContractFiles(uiRoot);
+  const apiFiles = await collectApiContractFiles(apiRoot);
+  const dataFiles = await collectDataContractFiles(dataRoot);
+  await collectIdsFromFiles(uiFiles, ["UI"], contractIds);
+  await collectIdsFromFiles(apiFiles, ["API"], contractIds);
+  await collectIdsFromFiles(dataFiles, ["DATA"], contractIds);
+  return contractIds;
+}
+async function collectIdsFromFiles(files, prefixes, out) {
+  for (const file of files) {
+    const text = await readFile6(file, "utf-8");
+    for (const prefix of prefixes) {
+      extractIds(text, prefix).forEach((id) => out.add(id));
+    }
+  }
+}
+async function validateCodeReferences(upstreamIds, srcRoot, testsRoot) {
+  const issues = [];
+  const codeFiles = await collectFiles(srcRoot, {
+    extensions: [".ts", ".tsx", ".js", ".jsx"]
+  });
+  const testFiles = await collectFiles(testsRoot, {
+    extensions: [".ts", ".tsx", ".js", ".jsx"]
+  });
+  const targetFiles = [...codeFiles, ...testFiles];
+  if (targetFiles.length === 0) {
+    issues.push(
+      issue4(
+        "QFAI-TRACE-001",
+        "\u53C2\u7167\u5BFE\u8C61\u306E\u30B3\u30FC\u30C9/\u30C6\u30B9\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002",
+        "info",
+        srcRoot,
+        "traceability.codeReferences"
+      )
+    );
+    return issues;
+  }
+  const pattern = buildIdPattern(Array.from(upstreamIds));
+  let found = false;
+  for (const file of targetFiles) {
+    const text = await readFile6(file, "utf-8");
+    if (pattern.test(text)) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    issues.push(
+      issue4(
+        "QFAI-TRACE-002",
+        "\u4E0A\u6D41 ID \u304C\u30B3\u30FC\u30C9/\u30C6\u30B9\u30C8\u306B\u53C2\u7167\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002",
+        "warning",
+        srcRoot,
+        "traceability.codeReferences"
+      )
+    );
+  }
+  return issues;
+}
+function buildIdPattern(ids) {
+  const escaped = ids.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`\\b(${escaped.join("|")})\\b`);
+}
+function issue4(code, message, severity, file, rule, refs) {
+  const issue5 = {
+    code,
+    severity,
+    message
+  };
+  if (file) {
+    issue5.file = file;
+  }
+  if (rule) {
+    issue5.rule = rule;
+  }
+  if (refs && refs.length > 0) {
+    issue5.refs = refs;
+  }
+  return issue5;
+}
+
+// src/core/validate.ts
+async function validateProject(root, configResult) {
+  const resolved = configResult ?? await loadConfig(root);
+  const { config, issues: configIssues } = resolved;
+  const issues = [
+    ...configIssues,
+    ...await validateSpecs(root, config),
+    ...await validateScenarios(root, config),
+    ...await validateContracts(root, config),
+    ...await validateTraceability(root, config)
+  ];
+  const toolVersion = await resolveToolVersion();
+  return {
+    schemaVersion: VALIDATION_SCHEMA_VERSION,
+    toolVersion,
+    issues,
+    counts: countIssues(issues)
+  };
+}
+function countIssues(issues) {
+  return issues.reduce(
+    (acc, issue5) => {
+      acc[issue5.severity] += 1;
+      return acc;
+    },
+    { info: 0, warning: 0, error: 0 }
+  );
+}
+
+// src/core/report.ts
+var ID_PREFIXES = ["SPEC", "BR", "SC", "UI", "API", "DATA"];
+async function createReportData(root, validation, configResult) {
+  const resolved = configResult ?? await loadConfig(root);
+  const config = resolved.config;
+  const configPath = resolved.configPath;
+  const specRoot = resolvePath(root, config, "specDir");
+  const decisionsRoot = resolvePath(root, config, "decisionsDir");
+  const scenariosRoot = resolvePath(root, config, "scenariosDir");
+  const rulesRoot = resolvePath(root, config, "rulesDir");
+  const apiRoot = resolvePath(root, config, "apiContractsDir");
+  const uiRoot = resolvePath(root, config, "uiContractsDir");
+  const dbRoot = resolvePath(root, config, "dataContractsDir");
+  const srcRoot = resolvePath(root, config, "srcDir");
+  const testsRoot = resolvePath(root, config, "testsDir");
+  const specFiles = await collectSpecFiles(specRoot);
+  const scenarioFiles = await collectFiles(scenariosRoot, {
+    extensions: [".feature"]
+  });
+  const decisionFiles = await collectFiles(decisionsRoot, {
+    extensions: [".md"]
+  });
+  const ruleFiles = await collectFiles(rulesRoot, { extensions: [".md"] });
+  const {
+    api: apiFiles,
+    ui: uiFiles,
+    db: dbFiles
+  } = await collectContractFiles(uiRoot, apiRoot, dbRoot);
+  const idsByPrefix = await collectIds([
+    ...specFiles,
+    ...scenarioFiles,
+    ...decisionFiles,
+    ...ruleFiles,
+    ...apiFiles,
+    ...uiFiles,
+    ...dbFiles
+  ]);
+  const upstreamIds = await collectUpstreamIds([
+    ...specFiles,
+    ...scenarioFiles
+  ]);
+  const traceability = await evaluateTraceability(
+    upstreamIds,
+    srcRoot,
+    testsRoot
+  );
+  const resolvedValidation = validation ?? await validateProject(root, resolved);
+  const version = await resolveToolVersion();
+  return {
+    tool: "qfai",
+    version,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    root,
+    configPath,
+    summary: {
+      specs: specFiles.length,
+      scenarios: scenarioFiles.length,
+      decisions: decisionFiles.length,
+      rules: ruleFiles.length,
+      contracts: {
+        api: apiFiles.length,
+        ui: uiFiles.length,
+        db: dbFiles.length
+      },
+      counts: resolvedValidation.counts
+    },
+    ids: {
+      spec: idsByPrefix.SPEC,
+      br: idsByPrefix.BR,
+      sc: idsByPrefix.SC,
+      ui: idsByPrefix.UI,
+      api: idsByPrefix.API,
+      data: idsByPrefix.DATA
+    },
+    traceability: {
+      upstreamIdsFound: upstreamIds.size,
+      referencedInCodeOrTests: traceability
+    },
+    issues: resolvedValidation.issues
+  };
+}
+function formatReportMarkdown(data) {
+  const lines = [];
+  lines.push("# QFAI Report");
+  lines.push(`- \u751F\u6210\u65E5\u6642: ${data.generatedAt}`);
+  lines.push(`- \u30EB\u30FC\u30C8: ${data.root}`);
+  lines.push(`- \u8A2D\u5B9A: ${data.configPath}`);
+  lines.push(`- \u7248: ${data.version}`);
+  lines.push("");
+  lines.push("## \u6982\u8981");
+  lines.push(`- specs: ${data.summary.specs}`);
+  lines.push(`- scenarios: ${data.summary.scenarios}`);
+  lines.push(`- decisions: ${data.summary.decisions}`);
+  lines.push(`- rules: ${data.summary.rules}`);
+  lines.push(
+    `- contracts: api ${data.summary.contracts.api} / ui ${data.summary.contracts.ui} / db ${data.summary.contracts.db}`
+  );
+  lines.push(
+    `- issues: info ${data.summary.counts.info} / warning ${data.summary.counts.warning} / error ${data.summary.counts.error}`
+  );
+  lines.push("");
+  lines.push("## ID\u96C6\u8A08");
+  lines.push(formatIdLine("SPEC", data.ids.spec));
+  lines.push(formatIdLine("BR", data.ids.br));
+  lines.push(formatIdLine("SC", data.ids.sc));
+  lines.push(formatIdLine("UI", data.ids.ui));
+  lines.push(formatIdLine("API", data.ids.api));
+  lines.push(formatIdLine("DATA", data.ids.data));
+  lines.push("");
+  lines.push("## \u30C8\u30EC\u30FC\u30B5\u30D3\u30EA\u30C6\u30A3");
+  lines.push(`- \u4E0A\u6D41ID\u691C\u51FA\u6570: ${data.traceability.upstreamIdsFound}`);
+  lines.push(
+    `- \u30B3\u30FC\u30C9/\u30C6\u30B9\u30C8\u53C2\u7167: ${data.traceability.referencedInCodeOrTests ? "\u3042\u308A" : "\u306A\u3057"}`
+  );
+  lines.push("");
+  lines.push("## Hotspots");
+  const hotspots = buildHotspots(data.issues);
+  if (hotspots.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const spot of hotspots) {
+      lines.push(
+        `- ${spot.file}: total ${spot.total} (error ${spot.error} / warning ${spot.warning} / info ${spot.info})`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## \u30C8\u30EC\u30FC\u30B5\u30D3\u30EA\u30C6\u30A3\uFF08\u691C\u8A3C\uFF09");
+  const traceIssues = data.issues.filter(
+    (item) => item.rule?.startsWith("traceability.") || item.code.startsWith("QFAI_TRACE") || item.code === "QFAI_CONTRACT_ORPHAN"
+  );
+  if (traceIssues.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const item of traceIssues) {
+      const location = item.file ? ` (${item.file})` : "";
+      lines.push(
+        `- ${item.severity.toUpperCase()} [${item.code}] ${item.message}${location}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## \u691C\u8A3C\u7D50\u679C");
+  if (data.issues.length === 0) {
+    lines.push("- (none)");
+  } else {
+    for (const item of data.issues) {
+      const location = item.file ? ` (${item.file})` : "";
+      const refs = item.refs && item.refs.length > 0 ? ` refs=${item.refs.join(",")}` : "";
+      lines.push(
+        `- ${item.severity.toUpperCase()} [${item.code}] ${item.message}${location}${refs}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function formatReportJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+async function collectIds(files) {
+  const result = {
+    SPEC: /* @__PURE__ */ new Set(),
+    BR: /* @__PURE__ */ new Set(),
+    SC: /* @__PURE__ */ new Set(),
+    UI: /* @__PURE__ */ new Set(),
+    API: /* @__PURE__ */ new Set(),
+    DATA: /* @__PURE__ */ new Set()
+  };
+  for (const file of files) {
+    const text = await readFile7(file, "utf-8");
+    for (const prefix of ID_PREFIXES) {
+      const ids = extractIds(text, prefix);
+      ids.forEach((id) => result[prefix].add(id));
+    }
+  }
+  return {
+    SPEC: toSortedArray(result.SPEC),
+    BR: toSortedArray(result.BR),
+    SC: toSortedArray(result.SC),
+    UI: toSortedArray(result.UI),
+    API: toSortedArray(result.API),
+    DATA: toSortedArray(result.DATA)
+  };
+}
+async function collectUpstreamIds(files) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const text = await readFile7(file, "utf-8");
+    extractAllIds(text).forEach((id) => ids.add(id));
+  }
+  return ids;
+}
+async function evaluateTraceability(upstreamIds, srcRoot, testsRoot) {
+  if (upstreamIds.size === 0) {
+    return false;
+  }
+  const codeFiles = await collectFiles(srcRoot, {
+    extensions: [".ts", ".tsx", ".js", ".jsx"]
+  });
+  const testFiles = await collectFiles(testsRoot, {
+    extensions: [".ts", ".tsx", ".js", ".jsx"]
+  });
+  const targetFiles = [...codeFiles, ...testFiles];
+  if (targetFiles.length === 0) {
+    return false;
+  }
+  const pattern = buildIdPattern2(Array.from(upstreamIds));
+  for (const file of targetFiles) {
+    const text = await readFile7(file, "utf-8");
+    if (pattern.test(text)) {
+      return true;
+    }
+  }
+  return false;
+}
+function buildIdPattern2(ids) {
+  const escaped = ids.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`\\b(${escaped.join("|")})\\b`);
+}
+function formatIdLine(label, values) {
+  if (values.length === 0) {
+    return `- ${label}: (none)`;
+  }
+  return `- ${label}: ${values.join(", ")}`;
+}
+function toSortedArray(values) {
+  return Array.from(values).sort((a, b) => a.localeCompare(b));
+}
+function buildHotspots(issues) {
+  const map = /* @__PURE__ */ new Map();
+  for (const issue5 of issues) {
+    if (!issue5.file) {
+      continue;
+    }
+    const current = map.get(issue5.file) ?? {
+      file: issue5.file,
+      total: 0,
+      error: 0,
+      warning: 0,
+      info: 0
+    };
+    current.total += 1;
+    current[issue5.severity] += 1;
+    map.set(issue5.file, current);
+  }
+  return Array.from(map.values()).sort(
+    (a, b) => b.total !== a.total ? b.total - a.total : a.file.localeCompare(b.file)
+  );
+}
+export {
+  VALIDATION_SCHEMA_VERSION,
+  createReportData,
+  defaultConfig,
+  extractAllIds,
+  extractIds,
+  extractInvalidIds,
+  formatReportJson,
+  formatReportMarkdown,
+  getConfigPath,
+  lintSql,
+  loadConfig,
+  resolvePath,
+  resolveToolVersion,
+  validateContracts,
+  validateProject,
+  validateScenarioContent,
+  validateScenarios,
+  validateSpecContent,
+  validateSpecs,
+  validateTraceability
+};
+//# sourceMappingURL=index.mjs.map