ai-quality-gate 0.0.1

package/dist/server.js

@@ -0,0 +1,3007 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z2 from 'zod/v4';
+import { parseArgs } from 'util';
+import path13 from 'path';
+import { z } from 'zod';
+import * as fs8 from 'fs';
+import fs8__default from 'fs';
+import { parse, stringify } from 'yaml';
+import { SyntaxKind, Project } from 'ts-morph';
+import * as fs4 from 'fs/promises';
+import { readFile } from 'fs/promises';
+import { spawn } from 'child_process';
+import { setTimeout } from 'timers/promises';
+import axios from 'axios';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+
+var CLI_OPTION = {
+  CHECK: "check",
+  FIX: "fix",
+  PHASE1_ONLY: "phase1-only",
+  PHASE2_ONLY: "phase2-only",
+  CONFIG: "config",
+  HELP: "help",
+  SETUP: "setup",
+  VERSION: "version"
+};
+var CLI_ENTRY_FLAGS = /* @__PURE__ */ new Set([
+  "-h",
+  `--${CLI_OPTION.HELP}`,
+  `--${CLI_OPTION.VERSION}`,
+  `--${CLI_OPTION.SETUP}`,
+  `--${CLI_OPTION.CHECK}`,
+  `--${CLI_OPTION.FIX}`,
+  `--${CLI_OPTION.PHASE1_ONLY}`,
+  `--${CLI_OPTION.PHASE2_ONLY}`,
+  `--${CLI_OPTION.CONFIG}`
+]);
+function shouldUseCliMode(argv) {
+  for (const arg of argv.slice(2)) {
+    if (CLI_ENTRY_FLAGS.has(arg)) return true;
+    if (arg.startsWith("--config=")) return true;
+  }
+  return false;
+}
+function buildQualityGateOptions(values) {
+  const { check, fix, phase1Only, phase2Only } = values;
+  if (phase1Only && phase2Only) return null;
+  if (phase2Only) {
+    return { phases: "phase2" };
+  }
+  if (check && fix) return null;
+  if (!check && !fix) return null;
+  const phase1Mode = check ? "check" : "fix";
+  if (phase1Only) {
+    return { phase1Mode, phases: "phase1" };
+  }
+  return { phase1Mode, phases: "all" };
+}
+function readCliParseArgs(args) {
+  const { positionals, values } = parseArgs({
+    args,
+    options: {
+      [CLI_OPTION.CHECK]: { type: "boolean" },
+      [CLI_OPTION.FIX]: { type: "boolean" },
+      [CLI_OPTION.PHASE1_ONLY]: { type: "boolean" },
+      [CLI_OPTION.PHASE2_ONLY]: { type: "boolean" },
+      [CLI_OPTION.CONFIG]: { type: "string" },
+      [CLI_OPTION.HELP]: { type: "boolean", short: "h" },
+      [CLI_OPTION.SETUP]: { type: "boolean" },
+      [CLI_OPTION.VERSION]: { type: "boolean" }
+    },
+    allowPositionals: true,
+    strict: true
+  });
+  return { positionals, values };
+}
+function parseCliRunOrError(values, positionals) {
+  const configRaw = values[CLI_OPTION.CONFIG];
+  const configPath = typeof configRaw === "string" && configRaw.length > 0 ? configRaw : void 0;
+  const gateOpts = buildQualityGateOptions({
+    check: values[CLI_OPTION.CHECK] === true,
+    fix: values[CLI_OPTION.FIX] === true,
+    phase1Only: values[CLI_OPTION.PHASE1_ONLY] === true,
+    phase2Only: values[CLI_OPTION.PHASE2_ONLY] === true
+  });
+  if (gateOpts === null) {
+    return {
+      error: "Invalid flags: use --check or --fix when Phase 1 runs; do not combine --check with --fix; do not combine --phase1-only with --phase2-only.",
+      ok: false
+    };
+  }
+  if (positionals.length === 0) {
+    return { error: "Specify at least one file path.", ok: false };
+  }
+  return {
+    kind: "run",
+    ok: true,
+    payload: {
+      configPath,
+      files: positionals,
+      qualityGateOptions: gateOpts
+    }
+  };
+}
+function parseSetupCliResult(values, positionals) {
+  if (values[CLI_OPTION.SETUP] !== true) return null;
+  const conflicting = values[CLI_OPTION.CHECK] === true || values[CLI_OPTION.FIX] === true || values[CLI_OPTION.PHASE1_ONLY] === true || values[CLI_OPTION.PHASE2_ONLY] === true;
+  if (conflicting) {
+    return {
+      error: "Do not combine --setup with --check, --fix, --phase1-only, or --phase2-only.",
+      ok: false
+    };
+  }
+  if (positionals.length > 0) {
+    return { error: "Do not pass file paths with --setup.", ok: false };
+  }
+  return { kind: "setup", ok: true };
+}
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  if (args.length === 0) {
+    return { error: "CLI parser invoked with no arguments.", ok: false };
+  }
+  let parsed;
+  try {
+    parsed = readCliParseArgs(args);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { error: message, ok: false };
+  }
+  const { positionals, values } = parsed;
+  if (values[CLI_OPTION.HELP] === true) {
+    return { kind: "help", ok: true };
+  }
+  if (values[CLI_OPTION.VERSION] === true) {
+    return { kind: "version", ok: true };
+  }
+  const setupResult = parseSetupCliResult(values, positionals);
+  if (setupResult !== null) return setupResult;
+  return parseCliRunOrError(values, positionals);
+}
+var ENV_KEYS = {
+  /** Optional absolute or relative path to `.quality-gate.yaml` / `.quality-gate.json` (skips discovery) */
+  QUALITY_GATE_CONFIG: "QUALITY_GATE_CONFIG",
+  /** Optional override; when unset, project root is inferred (walk up from cwd for `package.json` / `tsconfig.json`) */
+  PROJECT_ROOT: "PROJECT_ROOT",
+  SONAR_HOST_URL: "SONAR_HOST_URL",
+  SONAR_TOKEN: "SONAR_TOKEN",
+  SONAR_PROJECT_KEY: "SONAR_PROJECT_KEY",
+  SONAR_SCANNER_PATH: "SONAR_SCANNER_PATH",
+  PHASE1_TIMEOUT: "PHASE1_TIMEOUT",
+  PHASE2_TIMEOUT: "PHASE2_TIMEOUT",
+  // Feature flags
+  ENABLE_I18N_RULES: "ENABLE_I18N_RULES"
+};
+var CONFIG_DEFAULTS = {
+  /** Phase 1 timeout (TypeScript + ESLint) - 30 seconds */
+  PHASE1_TIMEOUT: 3e4,
+  /** Phase 2 timeout (SonarQube) - 5 minutes for large monorepos */
+  PHASE2_TIMEOUT: 3e5
+};
+var FixerConfigPartialSchema = z.object({
+  curlyBraces: z.boolean().optional(),
+  eslint: z.boolean().optional(),
+  jsonValidator: z.boolean().optional(),
+  prettier: z.boolean().optional(),
+  singleLineArrow: z.boolean().optional()
+});
+var FixerConfigSchema = FixerConfigPartialSchema.default({}).transform((p) => ({
+  curlyBraces: p.curlyBraces ?? true,
+  eslint: p.eslint ?? true,
+  jsonValidator: p.jsonValidator ?? true,
+  prettier: p.prettier ?? true,
+  singleLineArrow: p.singleLineArrow ?? true
+}));
+var CustomRuleSchema = z.object({
+  id: z.string().min(1),
+  message: z.string().min(1),
+  pattern: z.string().min(1),
+  severity: z.enum(["error", "info", "warning"])
+});
+var ConfigSchema = z.object({
+  /** Set by merge + `ConfigManager.ensureProjectRoot` before parse (file, env, or `findProjectRoot`) */
+  projectRoot: z.string().min(1),
+  // Optional (Phase 2 - SonarQube Server)
+  sonarHostUrl: z.url().optional(),
+  sonarToken: z.string().min(1).optional(),
+  sonarProjectKey: z.string().min(1).optional(),
+  sonarScannerPath: z.string().optional(),
+  // Timeouts with defaults
+  phase1Timeout: z.number().positive().default(CONFIG_DEFAULTS.PHASE1_TIMEOUT),
+  phase2Timeout: z.number().positive().default(CONFIG_DEFAULTS.PHASE2_TIMEOUT),
+  // Feature flags
+  /** Enable i18n rules (no-literal-string) - default false for non-i18n projects */
+  enableI18nRules: z.boolean().default(false),
+  /** Phase 1 tool toggles (defaults: all enabled) */
+  fixers: FixerConfigSchema,
+  /** Optional regex-based rules (rule id appears as `custom:<id>` in issues) */
+  customRules: z.array(CustomRuleSchema).optional()
+});
+
+// src/constants/project-root.ts
+var PROJECT_ROOT_MARKER_FILES = ["package.json", "tsconfig.json"];
+
+// src/utils/findProjectRoot.ts
+function hasProjectMarker(dir) {
+  for (const name of PROJECT_ROOT_MARKER_FILES) {
+    if (fs8__default.existsSync(path13.join(dir, name))) return true;
+  }
+  return false;
+}
+function findProjectRoot(startDir) {
+  let current = path13.resolve(startDir);
+  while (true) {
+    if (hasProjectMarker(current)) return current;
+    const parent = path13.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return path13.resolve(startDir);
+}
+
+// src/constants/config-files.ts
+var CONFIG_FILE_NAMES = {
+  YAML: ".quality-gate.yaml",
+  JSON: ".quality-gate.json"
+};
+
+// src/config/configFile.ts
+var discoverConfigFilePath = (startDir) => {
+  let current = path13.resolve(startDir);
+  while (true) {
+    const yamlPath = path13.join(current, CONFIG_FILE_NAMES.YAML);
+    if (fs8__default.existsSync(yamlPath)) return yamlPath;
+    const jsonPath = path13.join(current, CONFIG_FILE_NAMES.JSON);
+    if (fs8__default.existsSync(jsonPath)) return jsonPath;
+    const parent = path13.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+};
+var resolveExplicitConfigPath = (explicitPath) => {
+  const resolved = path13.resolve(explicitPath);
+  if (!fs8__default.existsSync(resolved)) throw new Error(`Config file not found: ${resolved}`);
+  return resolved;
+};
+var loadConfigFile = (absolutePath) => {
+  const text = fs8__default.readFileSync(absolutePath, "utf8");
+  const ext = path13.extname(absolutePath).toLowerCase();
+  if (ext === ".json") {
+    const parsed2 = JSON.parse(text);
+    return parsed2 !== null && typeof parsed2 === "object" && !Array.isArray(parsed2) ? parsed2 : {};
+  }
+  const parsed = parse(text);
+  if (parsed === null || parsed === void 0) return {};
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new TypeError(`Invalid YAML config (expected object): ${absolutePath}`);
+  }
+  return parsed;
+};
+var normalizeRawConfig = (raw) => {
+  const out = { ...raw };
+  const sonar = out["sonar"];
+  if (sonar !== null && typeof sonar === "object" && !Array.isArray(sonar)) {
+    const s = sonar;
+    if (s.hostUrl !== void 0) out["sonarHostUrl"] = s.hostUrl;
+    if (s.token !== void 0) out["sonarToken"] = s.token;
+    if (s.projectKey !== void 0) out["sonarProjectKey"] = s.projectKey;
+    if (s.scannerPath !== void 0) out["sonarScannerPath"] = s.scannerPath;
+    Reflect.deleteProperty(out, "sonar");
+  }
+  coerceConfigFields(out);
+  return out;
+};
+var coerceConfigFields = (raw) => {
+  const timeoutKeys = ["phase1Timeout", "phase2Timeout"];
+  for (const k of timeoutKeys) {
+    const v = raw[k];
+    if (typeof v === "string" && /^\d+$/.test(v.trim())) raw[k] = Number.parseInt(v.trim(), 10);
+  }
+  const e = raw["enableI18nRules"];
+  if (typeof e === "string") {
+    const lower = e.toLowerCase();
+    if (lower === "true") raw["enableI18nRules"] = true;
+    else if (lower === "false") raw["enableI18nRules"] = false;
+  }
+  coerceFixersBooleanStrings(raw);
+};
+var coerceFixersBooleanStrings = (raw) => {
+  const fixersRaw = raw["fixers"];
+  if (fixersRaw === null || typeof fixersRaw !== "object" || Array.isArray(fixersRaw)) return;
+  const fx = fixersRaw;
+  const keys = ["eslint", "curlyBraces", "singleLineArrow", "prettier", "jsonValidator"];
+  for (const k of keys) {
+    const v = fx[k];
+    if (typeof v === "string") {
+      const lower = v.toLowerCase();
+      if (lower === "true") fx[k] = true;
+      else if (lower === "false") fx[k] = false;
+    }
+  }
+};
+var resolveProjectRootAgainstConfigFile = (raw, configFilePath) => {
+  const pr = raw["projectRoot"];
+  if (typeof pr !== "string" || pr.length === 0) return;
+  if (path13.isAbsolute(pr)) return;
+  const configDir = path13.dirname(configFilePath);
+  raw["projectRoot"] = path13.resolve(configDir, pr);
+};
+var mergeConfigFileWithEnv = (filePartial, envPartial) => {
+  const merged = { ...filePartial };
+  for (const [key, value] of Object.entries(envPartial)) {
+    if (value !== void 0) merged[key] = value;
+  }
+  return merged;
+};
+
+// src/config/ConfigManager.ts
+function formatConfigInvalidMessage(issues) {
+  const parts = issues.map((issue) => {
+    const pathStr = issue.path.length === 0 ? "(root)" : issue.path.map(String).join(".");
+    return `'${pathStr}' ${issue.message}`;
+  });
+  return `Config: ${parts.join("; ")}`;
+}
+var ConfigManager = class {
+  config = null;
+  /**
+   * Load and validate configuration (optional YAML/JSON file + environment variables)
+   * @throws Error if validation fails
+   */
+  load() {
+    if (this.config !== null) return this.config;
+    const merged = this.loadMergedRaw();
+    const result = ConfigSchema.safeParse(merged);
+    if (!result.success) throw new Error(formatConfigInvalidMessage(result.error.issues));
+    this.config = result.data;
+    return this.config;
+  }
+  /**
+   * Merge config file (if any) with ENV; file first, then ENV overwrites defined keys.
+   */
+  loadMergedRaw() {
+    const envRaw = this.readFromEnv();
+    const explicit = process.env[ENV_KEYS.QUALITY_GATE_CONFIG]?.trim();
+    const projectRootEnv = process.env[ENV_KEYS.PROJECT_ROOT]?.trim();
+    const configDiscoveryStartDir = projectRootEnv ? path13.resolve(projectRootEnv) : findProjectRoot(process.cwd());
+    let fileRaw = {};
+    if (explicit && explicit.length > 0) {
+      const configPath = resolveExplicitConfigPath(explicit);
+      fileRaw = loadConfigFile(configPath);
+      fileRaw = normalizeRawConfig(fileRaw);
+      resolveProjectRootAgainstConfigFile(fileRaw, configPath);
+    } else {
+      const discovered = discoverConfigFilePath(configDiscoveryStartDir);
+      if (discovered) {
+        fileRaw = loadConfigFile(discovered);
+        fileRaw = normalizeRawConfig(fileRaw);
+        resolveProjectRootAgainstConfigFile(fileRaw, discovered);
+      }
+    }
+    const merged = mergeConfigFileWithEnv(fileRaw, envRaw);
+    this.ensureProjectRoot(merged);
+    return merged;
+  }
+  /**
+   * Ensure `projectRoot` is set: env `PROJECT_ROOT`, then config merge, else walk up from cwd.
+   */
+  ensureProjectRoot(merged) {
+    const m = merged;
+    const existing = m.projectRoot;
+    if (typeof existing === "string" && existing.trim().length > 0) return;
+    const fromEnv = process.env[ENV_KEYS.PROJECT_ROOT]?.trim();
+    m.projectRoot = fromEnv && fromEnv.length > 0 ? path13.resolve(fromEnv) : findProjectRoot(process.cwd());
+  }
+  /**
+   * Check if Phase 2 (SonarQube Server) is configured
+   */
+  isPhase2Configured() {
+    const config = this.load();
+    return Boolean(config.sonarHostUrl && config.sonarToken && config.sonarProjectKey);
+  }
+  /**
+   * Reset cached config (useful for testing)
+   */
+  reset() {
+    this.config = null;
+  }
+  /**
+   * Read raw values from environment variables
+   */
+  readFromEnv() {
+    const { env } = process;
+    return {
+      projectRoot: env[ENV_KEYS.PROJECT_ROOT],
+      sonarHostUrl: env[ENV_KEYS.SONAR_HOST_URL],
+      sonarToken: env[ENV_KEYS.SONAR_TOKEN],
+      sonarProjectKey: env[ENV_KEYS.SONAR_PROJECT_KEY],
+      sonarScannerPath: env[ENV_KEYS.SONAR_SCANNER_PATH],
+      phase1Timeout: this.parseNumber(env[ENV_KEYS.PHASE1_TIMEOUT]),
+      phase2Timeout: this.parseNumber(env[ENV_KEYS.PHASE2_TIMEOUT]),
+      enableI18nRules: this.parseBoolean(env[ENV_KEYS.ENABLE_I18N_RULES])
+    };
+  }
+  /**
+   * Parse string to boolean, return undefined if invalid
+   */
+  parseBoolean(value) {
+    if (value === void 0) return void 0;
+    return value.toLowerCase() === "true";
+  }
+  /**
+   * Parse string to number, return undefined if invalid
+   */
+  parseNumber(value) {
+    if (value === void 0) return void 0;
+    const num = Number.parseInt(value, 10);
+    return Number.isNaN(num) ? void 0 : num;
+  }
+};
+var configManager = new ConfigManager();
+
+// src/constants/severity.ts
+var SEVERITY = {
+  ERROR: "error",
+  WARNING: "warning",
+  INFO: "info"
+};
+
+// src/constants/phases.ts
+var PHASE = {
+  /** Local analysis - TypeScript + ESLint + AST fixers (~2-3s) */
+  LOCAL: "local",
+  /** Server analysis - SonarQube deep scan (~30-60s) */
+  SERVER: "server",
+  /** All phases completed successfully */
+  COMPLETE: "complete"
+};
+
+// src/constants/fixers.ts
+var FIXER_TYPE = {
+  /** Remove unnecessary curly braces from single-statement if blocks */
+  CURLY_BRACES: "curlyBraces",
+  /** Convert multi-line single-statement arrow functions to single line */
+  SINGLE_LINE_ARROW: "singleLineArrow"
+};
+
+// src/constants/sonarqube.ts
+var SONAR_SEVERITY = {
+  BLOCKER: "BLOCKER",
+  CRITICAL: "CRITICAL",
+  MAJOR: "MAJOR"};
+var SONAR_TASK_STATUS = {
+  PENDING: "PENDING",
+  IN_PROGRESS: "IN_PROGRESS",
+  SUCCESS: "SUCCESS",
+  FAILED: "FAILED",
+  CANCELED: "CANCELED"
+};
+
+// src/constants/extensions.ts
+var SUPPORTED_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  // ═══════════════════════════════════════════════════════════════════════════
+  // JavaScript/TypeScript (Primary Focus)
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Frontend Frameworks
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".vue",
+  ".svelte",
+  ".astro",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Python
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".py",
+  ".pyw",
+  ".pyx",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Go
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".go",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Rust
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".rs",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Java/Kotlin
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".java",
+  ".kt",
+  ".kts",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // C/C++
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".h",
+  ".hpp",
+  ".hxx",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // C#
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".cs",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Ruby
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".rb",
+  ".rake",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PHP
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".php",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Swift
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".swift",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Scala
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".scala",
+  ".sc",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Elixir/Erlang
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".ex",
+  ".exs",
+  ".erl",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Haskell
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".hs",
+  ".lhs",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Lua
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".lua",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // R
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".r",
+  ".R",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Shell
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".sh",
+  ".bash",
+  ".zsh",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Dart
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".dart",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Zig
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".zig",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Nim
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".nim",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Crystal
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".cr",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Julia
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".jl",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Clojure
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".clj",
+  ".cljs",
+  ".cljc",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // F#
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".fs",
+  ".fsx",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // OCaml
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".ml",
+  ".mli",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Perl
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".pl",
+  ".pm",
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Groovy
+  // ═══════════════════════════════════════════════════════════════════════════
+  ".groovy",
+  ".gvy"
+]);
+var LINTABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+var isLintableFile = (filePath) => LINTABLE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+var JSON_EXTENSIONS = [".json"];
+var isJsonFile = (filePath) => JSON_EXTENSIONS.some((ext) => filePath.endsWith(ext));
+var I18N_LOCALE_PATTERNS = [
+  /\/locales\/[a-z]{2}\.json$/i,
+  // /locales/en.json, /locales/tr.json
+  /\/i18n\/.*\/[a-z]{2}\.json$/i,
+  // /i18n/locales/en.json
+  /\/translations\/[a-z]{2}\.json$/i,
+  // /translations/en.json
+  /\.[a-z]{2}\.json$/i
+  // file.en.json, file.tr.json
+];
+var isI18nLocaleFile = (filePath) => I18N_LOCALE_PATTERNS.some((pattern) => pattern.test(filePath));
+
+// src/constants/patterns.ts
+var DEPRECATED_PATTERN = /deprecated/i;
+var TYPESCRIPT_ERROR_PATTERN = /error TS/;
+
+// src/constants/rules.ts
+var RULE_NAMES = {
+  TYPESCRIPT: "typescript",
+  TYPESCRIPT_DEPRECATED: "typescript:deprecated",
+  ESLINT: "eslint"
+};
+var CUSTOM_RULE_PREFIX = "custom:";
+function formatCustomRuleId(ruleId) {
+  return `${CUSTOM_RULE_PREFIX}${ruleId}`;
+}
+
+// src/constants/eslintConfigFilenames.ts
+var ESLINT_PROJECT_ROOT_CONFIG_FILENAMES = [
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  ".eslintrc.cjs",
+  ".eslintrc.js",
+  ".eslintrc.json",
+  ".eslintrc.yaml",
+  ".eslintrc.yml"
+];
+
+// src/constants/exit-codes.ts
+var EXIT_CODE = {
+  /** Quality checks passed */
+  SUCCESS: 0,
+  /** Quality checks failed (issues found or verification failed) */
+  QUALITY_FAILED: 1,
+  /** Configuration error, unexpected exception, or invalid CLI usage */
+  ERROR: 2
+};
+var transactionFileSync = {
+  readFileSync: fs8.readFileSync.bind(fs8),
+  writeFileSync: fs8.writeFileSync.bind(fs8),
+  existsSync: fs8.existsSync.bind(fs8),
+  unlinkSync: fs8.unlinkSync.bind(fs8)
+};
+
+// src/core/TransactionManager.ts
+var TransactionImpl = class {
+  backups = /* @__PURE__ */ new Map();
+  committed = false;
+  rolledBack = false;
+  /**
+   * Record file content before modification
+   * Only records once per file (first call wins)
+   */
+  recordChange(file) {
+    if (this.committed || this.rolledBack) throw new Error("Transaction already finalized");
+    const absolutePath = path13.resolve(file);
+    if (!this.backups.has(absolutePath)) {
+      try {
+        const content = transactionFileSync.readFileSync(absolutePath, "utf8");
+        this.backups.set(absolutePath, content);
+      } catch {
+        this.backups.set(absolutePath, "");
+      }
+    }
+  }
+  /**
+   * Commit transaction - clear backups, changes are permanent
+   */
+  commit() {
+    if (this.committed) return Promise.reject(new Error("Transaction already committed"));
+    if (this.rolledBack) return Promise.reject(new Error("Transaction already rolled back"));
+    this.backups.clear();
+    this.committed = true;
+    return Promise.resolve();
+  }
+  /**
+   * Rollback transaction - restore all files to original state
+   */
+  rollback() {
+    if (this.committed) return Promise.reject(new Error("Transaction already committed"));
+    if (this.rolledBack) return Promise.reject(new Error("Transaction already rolled back"));
+    const errors = [];
+    for (const [filePath, originalContent] of this.backups) {
+      try {
+        if (originalContent === "") {
+          if (transactionFileSync.existsSync(filePath)) transactionFileSync.unlinkSync(filePath);
+        } else transactionFileSync.writeFileSync(filePath, originalContent, "utf8");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`Failed to restore ${filePath}: ${message}`);
+      }
+    }
+    this.backups.clear();
+    this.rolledBack = true;
+    if (errors.length > 0) return Promise.reject(new Error(`Rollback partially failed: ${errors.join("; ")}`));
+    return Promise.resolve();
+  }
+  /**
+   * Get count of backed up files
+   */
+  getBackupCount() {
+    return this.backups.size;
+  }
+  /**
+   * Check if file is backed up
+   */
+  isBackedUp(file) {
+    return this.backups.has(path13.resolve(file));
+  }
+};
+var TransactionManager = class {
+  /**
+   * Begin a new transaction
+   */
+  begin() {
+    return new TransactionImpl();
+  }
+};
+var BaseFixer = class {
+  project;
+  constructor() {
+    this.project = new Project({
+      useInMemoryFileSystem: false,
+      skipAddingFilesFromTsConfig: true
+    });
+  }
+  /**
+   * Get or add source file to project
+   * Handles the case where file might already be added
+   */
+  getSourceFile(filePath) {
+    try {
+      return this.project.addSourceFileAtPath(filePath);
+    } catch {
+      return this.project.getSourceFileOrThrow(filePath);
+    }
+  }
+  /**
+   * Cleanup: Remove source file from project to avoid memory leaks
+   */
+  cleanupSourceFile(sourceFile) {
+    this.project.removeSourceFile(sourceFile);
+  }
+};
+
+// src/types/config.ts
+var DEFAULT_FIXER_CONFIG = {
+  eslint: true,
+  curlyBraces: true,
+  singleLineArrow: true,
+  prettier: true,
+  jsonValidator: true
+};
+var MAX_LINE_LENGTH = 120;
+var CurlyBracesFixer = class extends BaseFixer {
+  name = FIXER_TYPE.CURLY_BRACES;
+  /**
+   * Scan file for if statements with unnecessary braces
+   */
+  async scanAndFix(filePath, transaction) {
+    const fixes = [];
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const ifStatements = this.findIfStatements(sourceFile);
+      const sortedStatements = [...ifStatements].sort((a, b) => b.getStart() - a.getStart());
+      for (const ifStmt of sortedStatements) {
+        if (!this.isSafeToTransform(ifStmt)) continue;
+        const lineNumber = ifStmt.getStartLineNumber();
+        transaction.recordChange(filePath);
+        const result = this.transform(ifStmt);
+        if (result.success) {
+          fixes.push({
+            file: filePath,
+            line: lineNumber,
+            type: FIXER_TYPE.CURLY_BRACES,
+            description: "Removed unnecessary curly braces from single-statement if"
+          });
+        }
+      }
+      if (fixes.length > 0) await sourceFile.save();
+      this.cleanupSourceFile(sourceFile);
+    } catch (error) {
+      console.error(`CurlyBracesFixer error in ${filePath}:`, error);
+    }
+    return fixes;
+  }
+  findIfStatements(sourceFile) {
+    return sourceFile.getDescendantsOfKind(SyntaxKind.IfStatement);
+  }
+  /**
+   * Check if if statement is safe to transform (remove braces)
+   */
+  isSafeToTransform(ifStmt) {
+    if (ifStmt.getElseStatement()) return false;
+    const thenStmt = ifStmt.getThenStatement();
+    if (thenStmt.getKind() !== SyntaxKind.Block) return false;
+    const block = thenStmt;
+    const statements = block.getStatements();
+    if (statements.length !== 1) return false;
+    const singleStatement = statements[0];
+    if (!singleStatement) return false;
+    if (singleStatement.getKind() === SyntaxKind.IfStatement) return false;
+    const blockText = block.getText();
+    if (blockText.includes("//") || blockText.includes("/*")) return false;
+    const statementText = singleStatement.getText().replace(/;$/, "");
+    if (this.containsObjectLiteralReturn(statementText)) return false;
+    const conditionText = ifStmt.getExpression().getText();
+    const combinedLine = `if (${conditionText}) ${statementText}`;
+    const indent = this.getIndentation(ifStmt);
+    if (indent.length + combinedLine.length > MAX_LINE_LENGTH) return false;
+    return true;
+  }
+  getIndentation(ifStmt) {
+    const fullText = ifStmt.getFullText();
+    const leadingWhitespace = /^[\t ]*/.exec(fullText)?.[0] || "";
+    return leadingWhitespace.replaceAll("\n", "");
+  }
+  /**
+   * Check if statement returns an object literal
+   * Prettier wraps object literals to multiple lines based on various heuristics
+   * (not just printWidth), which causes ESLint curly: multi-line errors
+   *
+   * Skip ANY return statement with object literal to be safe
+   */
+  containsObjectLiteralReturn(statementText) {
+    return /^return\s+\{/.test(statementText.trim());
+  }
+  /**
+   * Transform if statement to single line without braces
+   */
+  transform(ifStmt) {
+    try {
+      const conditionText = ifStmt.getExpression().getText();
+      const block = ifStmt.getThenStatement();
+      const singleStatement = block.getStatements()[0];
+      if (!singleStatement) return { success: false, error: "No statement found" };
+      const statementText = singleStatement.getText().replace(/;$/, "");
+      const newText = `if (${conditionText}) ${statementText}`;
+      ifStmt.replaceWithText(newText);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+var MAX_LINE_LENGTH2 = 120;
+var ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([
+  SyntaxKind.EqualsToken,
+  SyntaxKind.PlusEqualsToken,
+  SyntaxKind.MinusEqualsToken,
+  SyntaxKind.AsteriskEqualsToken,
+  SyntaxKind.SlashEqualsToken,
+  SyntaxKind.PercentEqualsToken,
+  SyntaxKind.AmpersandEqualsToken,
+  SyntaxKind.BarEqualsToken,
+  SyntaxKind.CaretEqualsToken,
+  SyntaxKind.LessThanLessThanEqualsToken,
+  SyntaxKind.GreaterThanGreaterThanEqualsToken,
+  SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+  SyntaxKind.AsteriskAsteriskEqualsToken,
+  SyntaxKind.BarBarEqualsToken,
+  SyntaxKind.AmpersandAmpersandEqualsToken,
+  SyntaxKind.QuestionQuestionEqualsToken
+]);
+var SingleLineArrowFixer = class extends BaseFixer {
+  name = FIXER_TYPE.SINGLE_LINE_ARROW;
+  /**
+   * Scan file for arrow functions with unnecessary braces
+   */
+  async scanAndFix(filePath, transaction) {
+    const fixes = [];
+    if (filePath.endsWith(".vue")) return fixes;
+    try {
+      const sourceFile = this.getSourceFile(filePath);
+      const arrowFunctions = this.findArrowFunctions(sourceFile);
+      const sortedFunctions = [...arrowFunctions].sort((a, b) => b.getStart() - a.getStart());
+      for (const arrowFn of sortedFunctions) {
+        const result = this.processArrowFunction(arrowFn, filePath, transaction);
+        if (result) fixes.push(result);
+      }
+      if (fixes.length > 0) await sourceFile.save();
+      this.cleanupSourceFile(sourceFile);
+    } catch (error) {
+      console.error(`SingleLineArrowFixer error in ${filePath}:`, error);
+    }
+    return fixes;
+  }
+  findArrowFunctions(sourceFile) {
+    return sourceFile.getDescendantsOfKind(SyntaxKind.ArrowFunction);
+  }
+  /**
+   * Process single arrow function
+   */
+  processArrowFunction(arrowFn, filePath, transaction) {
+    if (!this.hasBlockBody(arrowFn)) return null;
+    const block = arrowFn.getBody();
+    const statement = this.getSingleStatement(block);
+    if (!statement) return null;
+    if (this.hasComments(block)) return null;
+    const newBody = this.extractNewBody(statement);
+    if (!newBody) return null;
+    if (this.wouldExceedLineLength(arrowFn, newBody)) return null;
+    const lineNumber = arrowFn.getStartLineNumber();
+    transaction.recordChange(filePath);
+    const result = this.transformArrowFunction(arrowFn, newBody);
+    if (!result.success) return null;
+    return {
+      file: filePath,
+      line: lineNumber,
+      type: FIXER_TYPE.SINGLE_LINE_ARROW,
+      description: "Converted multi-line arrow function to single line"
+    };
+  }
+  /**
+   * Check if arrow function has block body (with braces)
+   */
+  hasBlockBody(arrowFn) {
+    return arrowFn.getBody().getKind() === SyntaxKind.Block;
+  }
+  /**
+   * Get single statement from block, or null if not exactly one
+   */
+  getSingleStatement(block) {
+    const statements = block.getStatements();
+    if (statements.length !== 1) return null;
+    const stmt = statements[0];
+    if (!stmt) return null;
+    const kind = stmt.getKind();
+    if (kind !== SyntaxKind.ReturnStatement && kind !== SyntaxKind.ExpressionStatement) return null;
+    return stmt;
+  }
+  /**
+   * Check if block has comments
+   */
+  hasComments(block) {
+    const text = block.getText();
+    return text.includes("//") || text.includes("/*");
+  }
+  /**
+   * Extract new body from statement
+   */
+  extractNewBody(statement) {
+    const kind = statement.getKind();
+    if (kind === SyntaxKind.ReturnStatement) return this.extractFromReturn(statement);
+    if (kind === SyntaxKind.ExpressionStatement) return this.extractFromExpression(statement);
+    return null;
+  }
+  /**
+   * Extract body from return statement
+   */
+  extractFromReturn(returnStmt) {
+    const expr = returnStmt.getExpression();
+    if (!expr) return "undefined";
+    const exprText = expr.getText();
+    if (expr.getKind() === SyntaxKind.ObjectLiteralExpression) return `(${exprText})`;
+    return exprText;
+  }
+  /**
+   * Extract body from expression statement
+   */
+  extractFromExpression(exprStmt) {
+    const expr = exprStmt.getExpression();
+    const exprText = expr.getText().replace(/;$/, "");
+    if (expr.getKind() === SyntaxKind.BinaryExpression) {
+      const binaryExpr = expr;
+      const operatorKind = binaryExpr.getOperatorToken().getKind();
+      if (ASSIGNMENT_OPERATORS.has(operatorKind)) return `(${exprText})`;
+    }
+    return exprText;
+  }
+  /**
+   * Check if transformed line would exceed max length
+   */
+  wouldExceedLineLength(arrowFn, newBody) {
+    const params = arrowFn.getParameters().map((p) => p.getText()).join(", ");
+    const asyncKeyword = arrowFn.isAsync() ? "async " : "";
+    const needsParens = arrowFn.getParameters().length !== 1 || arrowFn.getParameters()[0]?.getTypeNode() !== void 0;
+    const paramsText = needsParens ? `(${params})` : params;
+    const combinedLine = `${asyncKeyword}${paramsText} => ${newBody}`;
+    const parent = arrowFn.getParent();
+    let prefix = "";
+    if (parent.getKind() === SyntaxKind.VariableDeclaration) {
+      const firstChild = parent.getChildAtIndex(0);
+      const varName = firstChild.getText();
+      prefix = `const ${varName} = `;
+    }
+    const indent = this.getIndentation(arrowFn);
+    return indent.length + prefix.length + combinedLine.length > MAX_LINE_LENGTH2;
+  }
+  /**
+   * Get indentation of arrow function
+   */
+  getIndentation(arrowFn) {
+    let current = arrowFn.getParent();
+    while (current !== void 0) {
+      if (current.getKind() === SyntaxKind.VariableStatement) {
+        const fullText = current.getFullText();
+        const match = /^[\t ]*/.exec(fullText);
+        const whitespace = match?.[0] ?? "";
+        return whitespace.replaceAll("\n", "");
+      }
+      current = current.getParent();
+    }
+    return "";
+  }
+  /**
+   * Transform arrow function to single line
+   */
+  transformArrowFunction(arrowFn, newBody) {
+    try {
+      const params = arrowFn.getParameters().map((p) => p.getText()).join(", ");
+      const asyncKeyword = arrowFn.isAsync() ? "async " : "";
+      const needsParens = arrowFn.getParameters().length !== 1 || arrowFn.getParameters()[0]?.getTypeNode() !== void 0;
+      const paramsText = needsParens ? `(${params})` : params;
+      const newText = `${asyncKeyword}${paramsText} => ${newBody}`;
+      arrowFn.replaceWithText(newText);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/fixers/AutoFixer.ts
+var AutoFixer = class {
+  fixers;
+  constructor(fixerConfig = DEFAULT_FIXER_CONFIG) {
+    this.fixers = [];
+    if (fixerConfig.curlyBraces) this.fixers.push(new CurlyBracesFixer());
+    if (fixerConfig.singleLineArrow) this.fixers.push(new SingleLineArrowFixer());
+  }
+  /**
+   * Scan all files and apply fixes
+   *
+   * @param files - Array of file paths to scan
+   * @param transaction - Transaction for rollback support
+   * @returns Summary of fixes applied
+   */
+  async scanAndFix(files, transaction) {
+    const summary = {
+      eslint: 0,
+      curlyBraces: 0,
+      singleLineArrow: 0,
+      prettier: 0,
+      json: 0
+    };
+    const eligibleFiles = this.filterEligibleFiles(files);
+    for (const file of eligibleFiles) {
+      await this.processFileWithFixers(file, transaction, summary);
+    }
+    return summary;
+  }
+  /**
+   * Filter to TypeScript/JavaScript files only
+   */
+  filterEligibleFiles(files) {
+    const extensions = [".ts", ".tsx", ".js", ".jsx"];
+    return files.filter((file) => extensions.some((ext) => file.endsWith(ext)));
+  }
+  /**
+   * Process single file with all fixers
+   */
+  async processFileWithFixers(file, transaction, summary) {
+    for (const fixer of this.fixers) {
+      await this.runFixer(fixer, file, transaction, summary);
+    }
+  }
+  /**
+   * Run single fixer on file
+   */
+  async runFixer(fixer, file, transaction, summary) {
+    try {
+      const fixes = await fixer.scanAndFix(file, transaction);
+      this.updateSummary(summary, fixer.name, fixes.length);
+      if (fixes.length > 0) console.error(`[AutoFixer] ${fixer.name}: ${fixes.length} fixes in ${file}`);
+    } catch (error) {
+      console.error(`[AutoFixer] Error in ${fixer.name} for ${file}:`, error);
+    }
+  }
+  /**
+   * Update summary based on fixer type
+   */
+  updateSummary(summary, fixerName, count) {
+    if (fixerName === FIXER_TYPE.CURLY_BRACES) summary.curlyBraces += count;
+    if (fixerName === FIXER_TYPE.SINGLE_LINE_ARROW) summary.singleLineArrow += count;
+  }
+  /**
+   * Get list of registered fixers
+   */
+  getFixerNames() {
+    return this.fixers.map((f) => f.name);
+  }
+};
+new AutoFixer(DEFAULT_FIXER_CONFIG);
+function compileRulePattern(pattern, ruleId) {
+  try {
+    return new RegExp(pattern, "g");
+  } catch {
+    console.error(`[ai-quality-gate] Invalid custom rule pattern (skipped): id=${ruleId}, pattern=${pattern}`);
+    return null;
+  }
+}
+function pushMatchesOnLine(issues, line, lineIndex0, regex, ctx) {
+  regex.lastIndex = 0;
+  let match;
+  while ((match = regex.exec(line)) !== null) {
+    issues.push({
+      rule: formatCustomRuleId(ctx.rule.id),
+      file: ctx.normalizedFile,
+      line: lineIndex0 + 1,
+      column: match.index + 1,
+      message: ctx.rule.message,
+      severity: ctx.rule.severity
+    });
+    if (match[0].length === 0) {
+      if (regex.lastIndex === match.index) regex.lastIndex += 1;
+      break;
+    }
+  }
+}
+async function scanFileWithRule(rule, regex, file) {
+  let content;
+  try {
+    content = await readFile(file, "utf8");
+  } catch (error) {
+    console.error(`[ai-quality-gate] Could not read file for custom rules: ${file}`, error);
+    return [];
+  }
+  const lines = content.split(/\r?\n/);
+  const normalizedPath = path13.normalize(file);
+  const ctx = { rule, normalizedFile: normalizedPath };
+  const issues = [];
+  for (const [lineIndex, line] of lines.entries()) {
+    pushMatchesOnLine(issues, line, lineIndex, regex, ctx);
+  }
+  return issues;
+}
+var CustomRulesValidator = class {
+  async validate(rules, files) {
+    if (rules.length === 0 || files.length === 0) return [];
+    const issues = [];
+    for (const rule of rules) {
+      const regex = compileRulePattern(rule.pattern, rule.id);
+      if (regex === null) continue;
+      for (const file of files) {
+        const fileIssues = await scanFileWithRule(rule, regex, file);
+        issues.push(...fileIssues);
+      }
+    }
+    return issues;
+  }
+};
+var BOM_CODE_POINT = 65279;
+var MIN_LOCALE_FILES_FOR_CONSISTENCY = 2;
+var JsonValidator = class {
+  /**
+   * Validate JSON files
+   *
+   * @param files - Array of file paths to validate
+   * @returns Validation result. `passed` reflects blocking issues only (`issues`). Locale key consistency
+   *   is listed separately in `i18nIssues` and does not flip `passed` to `false`.
+   */
+  async validate(files) {
+    const issues = [];
+    const i18nIssues = [];
+    let validCount = 0;
+    const i18nGroups = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      const result = await this.validateSingleFile(file);
+      if (result.passed) {
+        validCount++;
+        this.trackI18nFile(file, i18nGroups);
+      } else if (result.error) issues.push(this.toIssue(result.error));
+    }
+    const consistencyIssues = await this.checkAllI18nGroups(i18nGroups);
+    i18nIssues.push(...consistencyIssues);
+    return {
+      passed: issues.length === 0,
+      validCount,
+      issues,
+      i18nIssues
+    };
+  }
+  /**
+   * Track i18n file for consistency checking
+   */
+  trackI18nFile(file, groups) {
+    if (!isI18nLocaleFile(file)) return;
+    const dir = path13.dirname(file);
+    const group = groups.get(dir) ?? [];
+    group.push(file);
+    groups.set(dir, group);
+  }
+  /**
+   * Check i18n consistency for all groups
+   */
+  async checkAllI18nGroups(groups) {
+    const allIssues = [];
+    for (const [, localeFiles] of groups) {
+      if (localeFiles.length >= MIN_LOCALE_FILES_FOR_CONSISTENCY) {
+        const issues = await this.checkI18nConsistency(localeFiles);
+        allIssues.push(...issues);
+      }
+    }
+    return allIssues;
+  }
+  /**
+   * Validate a single JSON file
+   */
+  async validateSingleFile(filePath) {
+    try {
+      const content = await fs4.readFile(filePath, "utf8");
+      if (this.hasBom(content)) {
+        return {
+          passed: false,
+          error: {
+            file: filePath,
+            line: 1,
+            column: 1,
+            message: "File contains BOM (Byte Order Mark). Remove it for clean JSON."
+          }
+        };
+      }
+      this.parseJson(content);
+      return { passed: true };
+    } catch (error) {
+      return {
+        passed: false,
+        error: this.extractParseError(error, filePath)
+      };
+    }
+  }
+  /**
+   * Check if content has BOM
+   */
+  hasBom(content) {
+    return content.codePointAt(0) === BOM_CODE_POINT;
+  }
+  /**
+   * Parse JSON content
+   */
+  parseJson(content) {
+    return JSON.parse(content);
+  }
+  /**
+   * Extract detailed error information from JSON parse error
+   */
+  extractParseError(error, filePath) {
+    const message = error instanceof Error ? error.message : String(error);
+    const { line, column } = this.extractLineColumn(message);
+    return {
+      file: filePath,
+      line,
+      column,
+      message: this.friendlyErrorMessage(message)
+    };
+  }
+  /**
+   * Extract line and column from error message
+   */
+  extractLineColumn(message) {
+    let line = 1;
+    let column = 1;
+    const positionMatch = /at position (\d+)/.exec(message);
+    if (positionMatch?.[1]) column = Number.parseInt(positionMatch[1], 10);
+    const lineMatch = /line (\d+)/.exec(message);
+    const columnMatch = /column (\d+)/.exec(message);
+    if (lineMatch?.[1]) line = Number.parseInt(lineMatch[1], 10);
+    if (columnMatch?.[1]) column = Number.parseInt(columnMatch[1], 10);
+    return { line, column };
+  }
+  /**
+   * Convert JSON parse error to user-friendly message
+   */
+  friendlyErrorMessage(message) {
+    if (message.includes("Unexpected token")) return this.friendlyUnexpectedTokenMessage(message);
+    if (message.includes("Unexpected end")) return "Incomplete JSON - missing closing bracket or brace";
+    if (message.includes("Duplicate keys")) return message;
+    return `JSON parse error: ${message}`;
+  }
+  /**
+   * Get friendly message for unexpected token errors
+   */
+  friendlyUnexpectedTokenMessage(message) {
+    if (message.includes(",")) return "Trailing comma or extra comma in JSON (not allowed in strict JSON)";
+    if (message.includes("}")) return "Unexpected closing brace - check for missing values or extra commas";
+    if (message.includes("]")) return "Unexpected closing bracket - check for missing values or extra commas";
+    return "Invalid JSON syntax - check for typos or missing quotes";
+  }
+  /**
+   * Check i18n consistency across locale files
+   * Ensures all locale files have the same keys
+   */
+  async checkI18nConsistency(localeFiles) {
+    const localeData = await this.parseLocaleFiles(localeFiles);
+    if (localeData.size < MIN_LOCALE_FILES_FOR_CONSISTENCY) return [];
+    return this.compareLocaleKeys(localeData);
+  }
+  /**
+   * Parse all locale files and extract keys
+   */
+  async parseLocaleFiles(localeFiles) {
+    const localeData = /* @__PURE__ */ new Map();
+    for (const file of localeFiles) {
+      const keys = await this.extractKeysFromFile(file);
+      if (keys) localeData.set(file, keys);
+    }
+    return localeData;
+  }
+  /**
+   * Extract keys from a single locale file
+   */
+  async extractKeysFromFile(file) {
+    try {
+      const content = await fs4.readFile(file, "utf8");
+      const parsed = JSON.parse(content);
+      const keys = this.extractAllKeys(parsed);
+      return new Set(keys);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Compare keys across all locale files
+   */
+  compareLocaleKeys(localeData) {
+    const entries = [...localeData.entries()];
+    const firstEntry = entries[0];
+    if (!firstEntry) return [];
+    const [referenceFile, referenceKeys] = firstEntry;
+    const issues = [];
+    for (const [file, keys] of entries.slice(1)) {
+      const missingKeys = this.findMissingKeys(file, keys, referenceFile, referenceKeys);
+      const extraKeys = this.findExtraKeys(file, keys, referenceFile, referenceKeys);
+      issues.push(...missingKeys, ...extraKeys);
+    }
+    return issues;
+  }
+  /**
+   * Find keys missing in target file
+   */
+  findMissingKeys(file, keys, referenceFile, referenceKeys) {
+    const issues = [];
+    for (const key of referenceKeys) {
+      if (!keys.has(key)) issues.push({ file, type: "missing_key", key, referenceFile });
+    }
+    return issues;
+  }
+  /**
+   * Find extra keys in target file
+   */
+  findExtraKeys(file, keys, referenceFile, referenceKeys) {
+    const issues = [];
+    for (const key of keys) {
+      if (!referenceKeys.has(key)) issues.push({ file, type: "extra_key", key, referenceFile });
+    }
+    return issues;
+  }
+  /**
+   * Extract all keys from nested object (dot notation)
+   */
+  extractAllKeys(obj, prefix = "") {
+    const keys = [];
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        keys.push(...this.extractAllKeys(value, fullKey));
+      } else {
+        keys.push(fullKey);
+      }
+    }
+    return keys;
+  }
+  /**
+   * Convert JsonParseError to Issue format
+   */
+  toIssue(error) {
+    return {
+      rule: "json/parse-error",
+      file: error.file,
+      line: error.line,
+      column: error.column,
+      message: error.message,
+      severity: "error"
+    };
+  }
+};
+
+// src/phases/Phase1Local.ts
+var MAX_I18N_ISSUES_TO_DISPLAY = 5;
+var Phase1Local = class {
+  config;
+  verifier;
+  autoFixer;
+  jsonValidator;
+  customRulesValidator;
+  constructor(config) {
+    this.config = config;
+    this.verifier = new Verifier(config);
+    this.autoFixer = new AutoFixer(config.fixers);
+    this.jsonValidator = new JsonValidator();
+    this.customRulesValidator = new CustomRulesValidator();
+  }
+  /**
+   * Run Phase 1 local analysis
+   * @param options.phase1Mode `check` = typecheck + lint verify only (no file mutations). Default `fix`.
+   *
+   * **i18n locale key consistency** (JSON validator): extra/missing keys across locale files are reported
+   * via stderr warnings only; they do **not** set `passed: false` for Phase 1.
+   */
+  async run(files, transaction, options) {
+    const fixSummary = this.createEmptyFixSummary();
+    const { jsonFiles, codeFiles } = this.categorizeFiles(files);
+    const phase1Mode = options?.phase1Mode ?? "fix";
+    const jsonResult = await this.runJsonValidation(jsonFiles, fixSummary);
+    if (jsonResult) return jsonResult;
+    if (codeFiles.length === 0) {
+      return { passed: true, fixed: fixSummary, issues: [] };
+    }
+    if (phase1Mode === "check") return this.runCodeAnalysisCheck(codeFiles, fixSummary);
+    return this.runCodeAnalysis(codeFiles, transaction, fixSummary);
+  }
+  /**
+   * Create empty fix summary
+   */
+  createEmptyFixSummary() {
+    return {
+      eslint: 0,
+      curlyBraces: 0,
+      singleLineArrow: 0,
+      prettier: 0,
+      json: 0
+    };
+  }
+  /**
+   * Categorize files by type
+   */
+  categorizeFiles(files) {
+    return {
+      jsonFiles: files.filter((f) => isJsonFile(f)),
+      codeFiles: files.filter((f) => isLintableFile(f))
+    };
+  }
+  /**
+   * Run JSON validation and return early if parse/BOM (or other blocking) issues exist.
+   * i18n key mismatches never return early here — they are logged in {@link logI18nIssues} only.
+   */
+  async runJsonValidation(jsonFiles, fixSummary) {
+    if (jsonFiles.length === 0) return null;
+    if (!this.config.fixers.jsonValidator) return null;
+    const jsonResult = await this.jsonValidator.validate(jsonFiles);
+    fixSummary.json = jsonResult.validCount;
+    if (!jsonResult.passed) {
+      return { passed: false, fixed: fixSummary, issues: jsonResult.issues };
+    }
+    this.logI18nIssues(jsonResult);
+    return null;
+  }
+  /**
+   * Run regex custom rules from config (optional).
+   */
+  runCustomRulesPhase(codeFiles) {
+    const rules = this.config.customRules;
+    if (!rules?.length) return Promise.resolve([]);
+    return this.customRulesValidator.validate(rules, codeFiles);
+  }
+  /**
+   * Log i18n locale key mismatches to stderr. Does not affect Phase 1 success — informational only.
+   */
+  logI18nIssues(jsonResult) {
+    if (jsonResult.i18nIssues.length === 0) return;
+    console.warn(`\u26A0\uFE0F i18n consistency issues found: ${jsonResult.i18nIssues.length}`);
+    for (const issue of jsonResult.i18nIssues.slice(0, MAX_I18N_ISSUES_TO_DISPLAY)) {
+      console.warn(`  - ${issue.file}: ${issue.type} "${issue.key}"`);
+    }
+    if (jsonResult.i18nIssues.length > MAX_I18N_ISSUES_TO_DISPLAY) {
+      const remaining = jsonResult.i18nIssues.length - MAX_I18N_ISSUES_TO_DISPLAY;
+      console.warn(`  ... and ${remaining} more`);
+    }
+  }
+  /**
+   * Run code analysis (TypeScript, AST fixers, ESLint, Prettier)
+   */
+  async runCodeAnalysis(codeFiles, transaction, fixSummary) {
+    const typecheck = await this.verifier.runTypeCheck(codeFiles);
+    if (!typecheck.passed) {
+      return { passed: false, fixed: fixSummary, issues: typecheck.errors };
+    }
+    const customIssuesEarly = await this.runCustomRulesPhase(codeFiles);
+    if (customIssuesEarly.length > 0) {
+      return { passed: false, fixed: fixSummary, issues: customIssuesEarly };
+    }
+    this.ensureTransactionPrimedForMutablePhase(codeFiles, transaction);
+    const { fixers } = this.config;
+    if (fixers.curlyBraces || fixers.singleLineArrow) await this.runAstFixers(codeFiles, transaction, fixSummary);
+    if (fixers.eslint) {
+      const lintFix = await this.verifier.runLintFix(codeFiles);
+      fixSummary.eslint = lintFix.fixedCount;
+    }
+    if (fixers.prettier) {
+      const prettierResult = await this.verifier.runPrettier(codeFiles);
+      fixSummary.prettier = prettierResult.formattedCount;
+    }
+    if (fixers.eslint) {
+      const lintFixAfterPrettier = await this.verifier.runLintFix(codeFiles);
+      fixSummary.eslint += lintFixAfterPrettier.fixedCount;
+    }
+    return this.verifyAfterFixes(codeFiles, fixSummary);
+  }
+  /**
+   * Read-only Phase 1: typecheck + lint check only (no AST / ESLint --fix / Prettier writes).
+   */
+  async runCodeAnalysisCheck(codeFiles, fixSummary) {
+    const typecheck = await this.verifier.runTypeCheck(codeFiles);
+    if (!typecheck.passed) {
+      return { passed: false, fixed: fixSummary, issues: typecheck.errors };
+    }
+    const customIssuesEarly = await this.runCustomRulesPhase(codeFiles);
+    if (customIssuesEarly.length > 0) {
+      return { passed: false, fixed: fixSummary, issues: customIssuesEarly };
+    }
+    if (!this.config.fixers.eslint) {
+      return { passed: true, fixed: fixSummary, issues: [] };
+    }
+    const lintCheck = await this.verifier.runLintCheck(codeFiles);
+    if (!lintCheck.passed) {
+      return { passed: false, fixed: fixSummary, issues: lintCheck.errors };
+    }
+    return { passed: true, fixed: fixSummary, issues: [] };
+  }
+  /**
+   * Backup every code file before any mutating step (AST, ESLint --fix, Prettier).
+   * AST fixers call recordChange as well; first snapshot wins so we keep the pre-run content for rollback.
+   */
+  ensureTransactionPrimedForMutablePhase(codeFiles, transaction) {
+    for (const file of codeFiles) {
+      transaction.recordChange(file);
+    }
+  }
+  /**
+   * Run AST fixers and update summary
+   */
+  async runAstFixers(codeFiles, transaction, fixSummary) {
+    const astFixes = await this.autoFixer.scanAndFix(codeFiles, transaction);
+    fixSummary.curlyBraces = astFixes.curlyBraces;
+    fixSummary.singleLineArrow = astFixes.singleLineArrow;
+  }
+  /**
+   * Re-verify after all fixes
+   */
+  async verifyAfterFixes(codeFiles, fixSummary) {
+    const recheckType = await this.verifier.runTypeCheck(codeFiles);
+    if (!recheckType.passed) {
+      return { passed: false, fixed: fixSummary, issues: recheckType.errors };
+    }
+    const customIssues = await this.runCustomRulesPhase(codeFiles);
+    if (customIssues.length > 0) {
+      return { passed: false, fixed: fixSummary, issues: customIssues };
+    }
+    if (this.config.fixers.eslint) {
+      const recheckLint = await this.verifier.runLintCheck(codeFiles);
+      if (!recheckLint.passed) {
+        return { passed: false, fixed: fixSummary, issues: recheckLint.errors };
+      }
+    }
+    return { passed: true, fixed: fixSummary, issues: [] };
+  }
+};
+var isFileRelevantToPaths = (filePath, relevantFiles) => {
+  const normalizedFile = path13.normalize(filePath);
+  return relevantFiles.some((f) => {
+    const normalizedF = path13.normalize(f);
+    if (process.platform === "win32") {
+      const fLower = normalizedF.toLowerCase();
+      const fileLower = normalizedFile.toLowerCase();
+      return fLower.endsWith(fileLower) || fileLower.endsWith(fLower);
+    }
+    return normalizedF.endsWith(normalizedFile) || normalizedFile.endsWith(normalizedF);
+  });
+};
+
+// src/phases/Phase2Server.ts
+var MIN_HTTP_STATUS_CLIENT_ERROR = 400;
+var tryClassifyAxiosSonarError = (error) => {
+  const isAxios = typeof axios.isAxiosError === "function" ? axios.isAxiosError(error) : false;
+  if (!isAxios) return void 0;
+  const ax = error;
+  if (ax.code === "ECONNABORTED") return "SONAR_TIMEOUT";
+  if (ax.code === "ECONNREFUSED" || ax.code === "ENOTFOUND" || ax.code === "ETIMEDOUT") return "SONAR_CONNECTION_FAILED";
+  const status = ax.response?.status;
+  if (status !== void 0 && status >= MIN_HTTP_STATUS_CLIENT_ERROR) return "SONAR_API_ERROR";
+  return void 0;
+};
+var classifySonarFailure = (error) => {
+  const fromAxios = tryClassifyAxiosSonarError(error);
+  if (fromAxios !== void 0) return fromAxios;
+  if (error instanceof Error) {
+    const msg = error.message;
+    if (/ECONNREFUSED|ENOTFOUND|ETIMEDOUT|ECONNRESET|ECONNABORTED/i.test(msg)) return "SONAR_CONNECTION_FAILED";
+    if (/SonarQube analysis timeout/i.test(msg)) return "SONAR_TIMEOUT";
+    if (/exited with code/i.test(msg)) return "SONAR_API_ERROR";
+  }
+  return "SONAR_API_ERROR";
+};
+var ALLOWED_SCANNERS = /* @__PURE__ */ new Set(["sonar-scanner", "npx"]);
+var validateScannerPath = (scannerPath) => {
+  const commandName = scannerPath.split(/[/\\]/).pop() ?? scannerPath;
+  if (ALLOWED_SCANNERS.has(commandName)) return;
+  throw new Error(`Security: Scanner '${commandName}' is not in the allowed list`);
+};
+var Phase2Server = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Run Phase 2 SonarQube analysis
+   */
+  async run(files) {
+    console.error("[Phase2] Starting SonarQube analysis");
+    if (!this.isConfigured()) {
+      console.error("[Phase2] Not configured, skipping");
+      return { passed: true, issues: [] };
+    }
+    try {
+      console.error("[Phase2] Running sonar-scanner");
+      await this.runScanner();
+      console.error("[Phase2] Waiting for analysis");
+      await this.waitForAnalysis();
+      console.error("[Phase2] Fetching issues");
+      const issues = await this.fetchIssues(files);
+      console.error(`[Phase2] Found ${issues.length} issues`);
+      return {
+        passed: issues.length === 0,
+        issues
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = classifySonarFailure(error);
+      console.error("[Phase2] Error:", message);
+      return {
+        passed: false,
+        issues: [
+          {
+            rule: "sonarqube",
+            file: "",
+            line: 0,
+            message: `SonarQube analysis failed: ${message}`,
+            severity: SEVERITY.ERROR
+          }
+        ],
+        phaseError: { code, message }
+      };
+    }
+  }
+  /**
+   * Check if Phase 2 is configured
+   */
+  isConfigured() {
+    return Boolean(this.config.sonarHostUrl && this.config.sonarToken && this.config.sonarProjectKey);
+  }
+  /**
+   * Run sonar-scanner CLI
+   */
+  runScanner() {
+    const scannerPath = this.config.sonarScannerPath ?? "sonar-scanner";
+    validateScannerPath(scannerPath);
+    const hostUrl = this.config.sonarHostUrl ?? "";
+    const token = this.config.sonarToken ?? "";
+    const projectKey = this.config.sonarProjectKey ?? "";
+    const args = [
+      `-Dsonar.host.url=${hostUrl}`,
+      `-Dsonar.token=${token}`,
+      `-Dsonar.projectKey=${projectKey}`,
+      // Skip Quality Gate wait - we handle it ourselves via API
+      `-Dsonar.qualitygate.wait=false`,
+      // Disable SCM to analyze working directory (not just committed code)
+      // This allows catching issues BEFORE commit
+      `-Dsonar.scm.disabled=true`
+    ];
+    return new Promise((resolve, reject) => {
+      const proc = spawn(scannerPath, args, {
+        cwd: this.config.projectRoot,
+        shell: true,
+        timeout: this.config.phase2Timeout
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => stdout += data.toString());
+      proc.stderr.on("data", (data) => stderr += data.toString());
+      proc.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`sonar-scanner exited with code ${String(code ?? "unknown")}: ${stderr || stdout}`));
+      });
+      proc.on("error", (error) => reject(error));
+    });
+  }
+  /**
+   * Wait for SonarQube analysis to complete
+   * Uses polling with issues API as CE API may require admin permissions
+   */
+  async waitForAnalysis() {
+    const maxWait = 6e4;
+    const fallbackWait = 15e3;
+    const projectDoesNotExistWaitTime = 1e4;
+    const pollInterval = 3e3;
+    const startTime = Date.now();
+    const ceApiWorks = await this.checkCeApiAccess();
+    if (ceApiWorks) {
+      while (Date.now() - startTime < maxWait) {
+        const status = await this.getTaskStatus();
+        if (status === SONAR_TASK_STATUS.SUCCESS) return;
+        if (status === SONAR_TASK_STATUS.FAILED || status === SONAR_TASK_STATUS.CANCELED) {
+          throw new Error(`SonarQube analysis ${status.toLowerCase()}`);
+        }
+        await this.sleep(pollInterval);
+      }
+    } else {
+      await this.sleep(fallbackWait);
+      const projectExists = await this.checkProjectAnalyzed();
+      if (!projectExists) await this.sleep(projectDoesNotExistWaitTime);
+      return;
+    }
+    throw new Error("SonarQube analysis timeout");
+  }
+  /**
+   * Check if status is OK
+   */
+  isStatusOk(status) {
+    const statusOkCode = 200;
+    return status === statusOkCode;
+  }
+  /**
+   * Check if CE API is accessible
+   */
+  async checkCeApiAccess() {
+    const hostUrl = this.config.sonarHostUrl ?? "";
+    const token = this.config.sonarToken ?? "";
+    const timeout = 5e3;
+    try {
+      const response = await axios.get(`${hostUrl}/api/ce/activity`, {
+        params: { ps: 1 },
+        headers: { Authorization: `Bearer ${token}` },
+        timeout
+      });
+      return this.isStatusOk(response.status);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if project has been analyzed (has measures)
+   */
+  async checkProjectAnalyzed() {
+    const hostUrl = this.config.sonarHostUrl ?? "";
+    const token = this.config.sonarToken ?? "";
+    const component = this.config.sonarProjectKey ?? "";
+    const timeout = 5e3;
+    const metricKeys = "ncloc";
+    try {
+      const response = await axios.get(`${hostUrl}/api/measures/component`, {
+        params: {
+          component,
+          metricKeys
+        },
+        headers: { Authorization: `Bearer ${token}` },
+        timeout
+      });
+      return this.isStatusOk(response.status);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get latest analysis task status
+   */
+  async getTaskStatus() {
+    const hostUrl = this.config.sonarHostUrl ?? "";
+    const token = this.config.sonarToken ?? "";
+    const projectKey = this.config.sonarProjectKey ?? "";
+    const timeout = 1e4;
+    try {
+      const response = await axios.get(`${hostUrl}/api/ce/activity`, {
+        params: {
+          component: projectKey,
+          ps: 1
+        },
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        timeout
+      });
+      const tasks = response.data.tasks ?? [];
+      const firstTask = tasks[0];
+      if (firstTask) return firstTask.status ?? SONAR_TASK_STATUS.PENDING;
+      return SONAR_TASK_STATUS.PENDING;
+    } catch {
+      return SONAR_TASK_STATUS.PENDING;
+    }
+  }
+  /**
+   * Fetch issues from SonarQube API
+   */
+  async fetchIssues(files) {
+    const hostUrl = this.config.sonarHostUrl ?? "";
+    const token = this.config.sonarToken ?? "";
+    const projectKey = this.config.sonarProjectKey ?? "";
+    const timeout = 3e4;
+    try {
+      const response = await axios.get(`${hostUrl}/api/issues/search`, {
+        params: {
+          componentKeys: projectKey,
+          resolved: "false",
+          ps: 500
+        },
+        headers: {
+          Authorization: `Bearer ${token}`
+        },
+        timeout
+      });
+      const sonarIssues = response.data.issues ?? [];
+      return sonarIssues.filter((issue) => this.isRelevantFile(issue.component, files)).map((issue) => this.convertIssue(issue));
+    } catch (error) {
+      console.error("[Phase2] Failed to fetch issues:", error);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`SonarQube issues API failed: ${message}`);
+    }
+  }
+  /**
+   * Check if issue's component matches any of the relevant files
+   */
+  isRelevantFile(component, files) {
+    const colonIndex = component.indexOf(":");
+    const rawPath = colonIndex === -1 ? component : component.slice(colonIndex + 1);
+    const sonarPath = path13.normalize(rawPath);
+    return isFileRelevantToPaths(sonarPath, files);
+  }
+  /**
+   * Convert SonarQube issue to our Issue type
+   */
+  convertIssue(sonarIssue) {
+    const colonIndex = sonarIssue.component.indexOf(":");
+    const file = colonIndex === -1 ? sonarIssue.component : sonarIssue.component.slice(colonIndex + 1);
+    return {
+      rule: sonarIssue.rule,
+      file,
+      line: sonarIssue.line ?? 0,
+      message: sonarIssue.message,
+      severity: this.mapSeverity(sonarIssue.severity)
+    };
+  }
+  /**
+   * Map SonarQube severity to our severity
+   */
+  mapSeverity(sonarSeverity) {
+    const upperSeverity = sonarSeverity.toUpperCase();
+    if (upperSeverity === SONAR_SEVERITY.BLOCKER || upperSeverity === SONAR_SEVERITY.CRITICAL) return SEVERITY.ERROR;
+    if (upperSeverity === SONAR_SEVERITY.MAJOR) return SEVERITY.WARNING;
+    return SEVERITY.INFO;
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return setTimeout(ms);
+  }
+};
+
+// src/core/QualityGate.ts
+var QualityGate = class {
+  config;
+  transactionManager;
+  phase1;
+  phase2;
+  constructor(config, deps) {
+    this.config = config;
+    this.transactionManager = deps?.transactionManager ?? new TransactionManager();
+    this.phase1 = deps?.phase1 ?? new Phase1Local(config);
+    this.phase2 = deps?.phase2 ?? new Phase2Server(config);
+  }
+  /**
+   * Run quality gate on specified files
+   * @param options.phases `phase1` | `phase2` | `all` (default). `phase1Mode` defaults to `fix`.
+   */
+  async run(files, options) {
+    const ctx = this.createContext(files);
+    try {
+      return await this.executePhases(ctx, options);
+    } catch (error) {
+      return this.handleError(error, ctx);
+    }
+  }
+  createContext(files) {
+    return {
+      startTime: Date.now(),
+      phase1Time: 0,
+      phase2Time: 0,
+      transaction: this.transactionManager.begin(),
+      absoluteFiles: files.map((file) => path13.isAbsolute(file) ? file : path13.resolve(this.config.projectRoot, file))
+    };
+  }
+  executePhases(ctx, options) {
+    const phases = options?.phases ?? "all";
+    const phase1Mode = options?.phase1Mode ?? "fix";
+    const phase1Opts = { phase1Mode };
+    if (phases === "phase2") return this.runPhase2OnlyPipeline(ctx);
+    return this.runPhase1Pipeline(ctx, phase1Opts, phases);
+  }
+  emptyPhaseResult(passed) {
+    return {
+      passed,
+      fixed: this.createEmptyFixSummary(),
+      issues: []
+    };
+  }
+  /**
+   * Human-readable summary for MCP/CLI when Phase 1 fails (e.g. "TypeScript: 2 issues in src/index.ts").
+   */
+  summarizePhase1Failure(issues) {
+    if (issues.length === 0) return "Local analysis found issues. Fix these first.";
+    const root = this.config.projectRoot;
+    const segments = [];
+    const tsIssues = issues.filter((i) => this.isPhase1TypeScriptIssue(i));
+    const customIssues = issues.filter((i) => i.rule.startsWith(CUSTOM_RULE_PREFIX));
+    const jsonIssues = issues.filter((i) => i.rule.startsWith("json/"));
+    const eslintIssues = issues.filter(
+      (i) => !this.isPhase1TypeScriptIssue(i) && !i.rule.startsWith(CUSTOM_RULE_PREFIX) && !i.rule.startsWith("json/")
+    );
+    if (tsIssues.length > 0) segments.push(this.formatPhase1IssueGroup("TypeScript", tsIssues, root));
+    if (eslintIssues.length > 0) segments.push(this.formatPhase1IssueGroup("ESLint", eslintIssues, root));
+    if (customIssues.length > 0) segments.push(this.formatPhase1IssueGroup("Custom rules", customIssues, root));
+    if (jsonIssues.length > 0) segments.push(this.formatPhase1IssueGroup("JSON", jsonIssues, root));
+    return segments.length > 0 ? segments.join("; ") : "Local analysis found issues. Fix these first.";
+  }
+  isPhase1TypeScriptIssue(issue) {
+    return issue.rule === RULE_NAMES.TYPESCRIPT || issue.rule === RULE_NAMES.TYPESCRIPT_DEPRECATED;
+  }
+  formatPhase1IssueGroup(label, issues, projectRoot) {
+    const n = issues.length;
+    const issueWord = n === 1 ? "issue" : "issues";
+    const first = issues[0];
+    const file = first?.file;
+    let where;
+    if (file === void 0 || file === "unknown" || file.length === 0) {
+      where = "multiple files";
+    } else {
+      const resolved = path13.isAbsolute(file) ? file : path13.resolve(projectRoot, file);
+      const rel = path13.relative(projectRoot, resolved);
+      where = rel.length > 0 && !rel.startsWith("..") ? rel : file;
+    }
+    return `${label}: ${n} ${issueWord} in ${where}`;
+  }
+  async runPhase2OnlyPipeline(ctx) {
+    if (!this.phase2.isConfigured()) {
+      return this.buildConfigurationFailureResponse(ctx, "Phase 2 is not configured (SonarQube env or config missing).");
+    }
+    const phase2Start = Date.now();
+    const serverResult = await this.phase2.run(ctx.absoluteFiles);
+    ctx.phase2Time = Date.now() - phase2Start;
+    if (!serverResult.passed) {
+      const rollbackResponse = await this.tryRollback(ctx);
+      if (rollbackResponse) return rollbackResponse;
+      return this.buildFailResponse(
+        ctx,
+        PHASE.SERVER,
+        this.phase2FailureMessage(serverResult),
+        this.emptyPhaseResult(false),
+        this.phase2FailResponseOptions(serverResult)
+      );
+    }
+    await ctx.transaction.commit();
+    return this.buildSuccessResponse(
+      ctx,
+      PHASE.COMPLETE,
+      "\u2705 Phase 2 (SonarQube) checks passed.",
+      this.emptyPhaseResult(true)
+    );
+  }
+  async runPhase1Pipeline(ctx, phase1Opts, phases) {
+    const phase1Start = Date.now();
+    const localResult = await this.phase1.run(ctx.absoluteFiles, ctx.transaction, phase1Opts);
+    ctx.phase1Time = Date.now() - phase1Start;
+    if (!localResult.passed) {
+      const rollbackResponse = await this.tryRollback(ctx);
+      if (rollbackResponse) return rollbackResponse;
+      return this.buildFailResponse(ctx, PHASE.LOCAL, this.summarizePhase1Failure(localResult.issues), localResult);
+    }
+    if (phases === "phase1") {
+      await ctx.transaction.commit();
+      return this.buildSuccessResponse(ctx, PHASE.LOCAL, "\u2705 Phase 1 complete (Phase 2 skipped).", localResult);
+    }
+    if (!this.phase2.isConfigured()) {
+      await ctx.transaction.commit();
+      return this.buildSuccessResponse(ctx, PHASE.LOCAL, "\u2705 Local checks passed (Phase 2 not configured)", localResult);
+    }
+    return this.runPhase2WithLocal(ctx, localResult);
+  }
+  async runPhase2WithLocal(ctx, localResult) {
+    const phase2Start = Date.now();
+    const serverResult = await this.phase2.run(ctx.absoluteFiles);
+    ctx.phase2Time = Date.now() - phase2Start;
+    if (!serverResult.passed) {
+      const rollbackResponse = await this.tryRollback(ctx);
+      if (rollbackResponse) return rollbackResponse;
+      return this.buildFailResponse(
+        ctx,
+        PHASE.SERVER,
+        this.phase2FailureMessage(serverResult),
+        localResult,
+        this.phase2FailResponseOptions(serverResult)
+      );
+    }
+    await ctx.transaction.commit();
+    return this.buildSuccessResponse(ctx, PHASE.COMPLETE, "\u2705 All quality checks passed!", localResult);
+  }
+  phase2FailureMessage(serverResult) {
+    if (serverResult.phaseError !== void 0) return "Phase 2 (SonarQube) failed due to a server or network error.";
+    return "SonarQube found additional issues.";
+  }
+  phase2FailResponseOptions(serverResult) {
+    const qe = serverResult.phaseError;
+    if (qe === void 0) return { remaining: serverResult.issues };
+    return { remaining: serverResult.issues, qualityError: qe };
+  }
+  buildFailResponse(ctx, phase, message, result, options) {
+    const remaining = options?.remaining ?? result.issues;
+    const params = {
+      phase,
+      success: false,
+      message,
+      fixed: result.fixed,
+      remaining,
+      phase1Time: ctx.phase1Time,
+      totalTime: Date.now() - ctx.startTime
+    };
+    if (ctx.phase2Time > 0) params.phase2Time = ctx.phase2Time;
+    const response = this.buildResponse(params);
+    if (options?.qualityError !== void 0) return { ...response, error: options.qualityError };
+    return response;
+  }
+  buildSuccessResponse(ctx, phase, message, result) {
+    const params = {
+      phase,
+      success: true,
+      message,
+      fixed: result.fixed,
+      remaining: [],
+      phase1Time: ctx.phase1Time,
+      totalTime: Date.now() - ctx.startTime
+    };
+    if (ctx.phase2Time > 0) params.phase2Time = ctx.phase2Time;
+    return this.buildResponse(params);
+  }
+  /**
+   * Roll back file changes after a failed phase so disk matches pre-run state.
+   * @returns Error response if rollback failed; otherwise `null` to continue building the failure response.
+   */
+  async tryRollback(ctx) {
+    try {
+      await ctx.transaction.rollback();
+      return null;
+    } catch (rollbackError) {
+      console.error("[QualityGate] Rollback failed after phase failure:", rollbackError);
+      return this.buildErrorResponse(ctx, "ROLLBACK_FAILED", rollbackError);
+    }
+  }
+  async handleError(error, ctx) {
+    try {
+      await ctx.transaction.rollback();
+    } catch (rollbackError) {
+      console.error("[QualityGate] Rollback failed:", rollbackError);
+      return this.buildErrorResponse(ctx, "ROLLBACK_FAILED", rollbackError);
+    }
+    return this.buildErrorResponse(ctx, "UNEXPECTED_ERROR", error);
+  }
+  /**
+   * Create empty FixSummary with all properties set to 0
+   * Used for error responses when no fixes were applied
+   */
+  createEmptyFixSummary() {
+    return {
+      eslint: 0,
+      curlyBraces: 0,
+      singleLineArrow: 0,
+      prettier: 0,
+      json: 0
+    };
+  }
+  buildErrorResponse(ctx, code, error) {
+    const emptyFixed = this.createEmptyFixSummary();
+    return {
+      phase: PHASE.LOCAL,
+      success: false,
+      message: code === "ROLLBACK_FAILED" ? "Critical error: rollback failed" : "An error occurred during quality checks",
+      fixed: emptyFixed,
+      remaining: [],
+      timing: {
+        phase1: this.formatTime(ctx.phase1Time),
+        total: this.formatTime(Date.now() - ctx.startTime)
+      },
+      totalIssues: 0,
+      remainingCount: 0,
+      fixedCount: 0,
+      error: {
+        code,
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  /** Configuration / prerequisite failure (e.g. Phase 2 requested but Sonar not configured) */
+  buildConfigurationFailureResponse(ctx, message) {
+    const emptyFixed = this.createEmptyFixSummary();
+    return {
+      phase: PHASE.LOCAL,
+      success: false,
+      message,
+      fixed: emptyFixed,
+      remaining: [],
+      timing: {
+        phase1: this.formatTime(ctx.phase1Time),
+        total: this.formatTime(Date.now() - ctx.startTime)
+      },
+      totalIssues: 0,
+      remainingCount: 0,
+      fixedCount: 0,
+      error: {
+        code: "CONFIG_INVALID",
+        message
+      }
+    };
+  }
+  /**
+   * Calculate total fixed count by summing all numeric values in FixSummary
+   * Dynamic approach - automatically includes new fix types without code changes
+   */
+  calculateFixedCount(fixed) {
+    const values = Object.values(fixed);
+    return values.reduce((sum, count) => sum + count, 0);
+  }
+  buildResponse(params) {
+    const fixedCount = this.calculateFixedCount(params.fixed);
+    const remainingCount = params.remaining.length;
+    const totalIssues = fixedCount + remainingCount;
+    const response = {
+      phase: params.phase,
+      success: params.success,
+      message: params.message,
+      totalIssues,
+      remainingCount,
+      fixedCount,
+      fixed: params.fixed,
+      remaining: params.remaining,
+      timing: {
+        phase1: this.formatTime(params.phase1Time),
+        total: this.formatTime(params.totalTime)
+      }
+    };
+    if (params.phase2Time) response.timing.phase2 = this.formatTime(params.phase2Time);
+    return response;
+  }
+  formatTime(ms) {
+    return ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+  }
+};
+var normalizePath = (p) => {
+  const normalized = path13.normalize(p);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+};
+var isPathUnder = (childPath, parentPath) => {
+  const normalizedChild = normalizePath(childPath);
+  const normalizedParent = normalizePath(parentPath);
+  const parentWithSep = normalizedParent.endsWith(path13.sep) ? normalizedParent : `${normalizedParent}${path13.sep}`;
+  return normalizedChild.startsWith(parentWithSep) || normalizedChild === normalizedParent;
+};
+var findTsConfig = (filePath, projectRoot) => {
+  const absoluteFile = path13.resolve(filePath);
+  const absoluteRoot = path13.resolve(projectRoot);
+  let currentDir = path13.dirname(absoluteFile);
+  while (isPathUnder(currentDir, absoluteRoot)) {
+    const tsConfigPath = path13.join(currentDir, "tsconfig.json");
+    if (fs8__default.existsSync(tsConfigPath)) return tsConfigPath;
+    const parentDir = path13.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  const rootTsConfig = path13.join(absoluteRoot, "tsconfig.json");
+  if (fs8__default.existsSync(rootTsConfig)) return rootTsConfig;
+  throw new Error(`tsconfig.json not found for ${filePath}`);
+};
+var groupFilesByTsConfig = (files, projectRoot) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    try {
+      const tsConfig = findTsConfig(file, projectRoot);
+      const existing = groups.get(tsConfig) ?? [];
+      existing.push(file);
+      groups.set(tsConfig, existing);
+    } catch {
+      const noTsConfig = "__no_tsconfig__";
+      const existing = groups.get(noTsConfig) ?? [];
+      existing.push(file);
+      groups.set(noTsConfig, existing);
+    }
+  }
+  return groups;
+};
+var ESLINT_CONFIG_REL = path13.join("eslint", "config.mjs");
+var EMBEDDED_ESLINT_CONFIG_MAX_WALK_DEPTH = 8;
+var walkUpForEslintConfig = (startDir) => {
+  let current = path13.resolve(startDir);
+  for (let depth = 0; depth < EMBEDDED_ESLINT_CONFIG_MAX_WALK_DEPTH; depth += 1) {
+    const candidate = path13.join(current, ESLINT_CONFIG_REL);
+    if (fs8__default.existsSync(candidate)) return candidate;
+    const parent = path13.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return void 0;
+};
+var resolveEmbeddedEslintConfigPath = () => {
+  const moduleDir = path13.dirname(fileURLToPath(import.meta.url));
+  const found = walkUpForEslintConfig(moduleDir);
+  if (found) return found;
+  return path13.resolve(moduleDir, ESLINT_CONFIG_REL);
+};
+var findProjectEslintConfigFile = (projectRoot) => {
+  const root = path13.resolve(projectRoot);
+  for (const name of ESLINT_PROJECT_ROOT_CONFIG_FILENAMES) {
+    const full = path13.join(root, name);
+    if (fs8__default.existsSync(full)) return full;
+  }
+  return void 0;
+};
+
+// src/core/Verifier.ts
+var ALLOWED_COMMANDS = /* @__PURE__ */ new Set(["npx", "eslint", "tsc", "yarn", "prettier"]);
+var validateCommand = (command) => {
+  if (ALLOWED_COMMANDS.has(command)) return;
+  if (command.includes("node_modules") && command.includes(".bin")) return;
+  throw new Error(`Security: Command '${command}' is not in the allowed list`);
+};
+var findTscCommand = (projectDir) => {
+  const localTsc = path13.join(projectDir, "node_modules", ".bin", "tsc");
+  const localTscWin = `${localTsc}.cmd`;
+  if (process.platform === "win32" && fs8.existsSync(localTscWin)) return { command: localTscWin, args: [] };
+  if (fs8.existsSync(localTsc)) return { command: localTsc, args: [] };
+  return { command: "yarn", args: ["tsc"] };
+};
+var findEslintCommand = (projectDir) => {
+  const mcpPackageDir = path13.join(projectDir, "ai-quality-gate");
+  const mcpEslint = path13.join(mcpPackageDir, "node_modules", ".bin", "eslint");
+  const mcpEslintWin = `${mcpEslint}.cmd`;
+  if (process.platform === "win32" && fs8.existsSync(mcpEslintWin)) return { command: mcpEslintWin, found: true };
+  if (fs8.existsSync(mcpEslint)) return { command: mcpEslint, found: true };
+  const projectEslint = path13.join(projectDir, "node_modules", ".bin", "eslint");
+  const projectEslintWin = `${projectEslint}.cmd`;
+  if (process.platform === "win32" && fs8.existsSync(projectEslintWin)) return { command: projectEslintWin, found: true };
+  if (fs8.existsSync(projectEslint)) return { command: projectEslint, found: true };
+  return { command: "npx", found: false };
+};
+var findPrettierCommand = (projectDir) => {
+  const projectPrettier = path13.join(projectDir, "node_modules", ".bin", "prettier");
+  const projectPrettierWin = `${projectPrettier}.cmd`;
+  if (process.platform === "win32" && fs8.existsSync(projectPrettierWin)) {
+    return { command: projectPrettierWin, found: true };
+  }
+  if (fs8.existsSync(projectPrettier)) return { command: projectPrettier, found: true };
+  return { command: "npx", found: false };
+};
+var Verifier = class {
+  config;
+  embeddedEslintConfig;
+  constructor(config) {
+    this.config = config;
+    this.embeddedEslintConfig = resolveEmbeddedEslintConfigPath();
+  }
+  /**
+   * Prefer bundled strict config when present; otherwise root-level project ESLint config; else ESLint auto-discovery.
+   */
+  resolveEslintCliConfigArgs() {
+    if (fs8.existsSync(this.embeddedEslintConfig)) return ["--config", this.embeddedEslintConfig];
+    const projectConfig = findProjectEslintConfigFile(this.config.projectRoot);
+    if (projectConfig !== void 0) return ["--config", projectConfig];
+    return [];
+  }
+  /**
+   * Report files without tsconfig as errors
+   */
+  reportMissingTsConfig(groupFiles) {
+    return groupFiles.map((file) => ({
+      rule: RULE_NAMES.TYPESCRIPT,
+      file,
+      line: 0,
+      message: "No tsconfig.json found for this file",
+      severity: SEVERITY.ERROR
+    }));
+  }
+  /**
+   * Run TypeScript typecheck for a single tsconfig group
+   */
+  async runTypeCheckForGroup(tsConfigPath, groupFiles) {
+    const projectDir = path13.dirname(tsConfigPath);
+    try {
+      const tscCmd = findTscCommand(projectDir);
+      const result = await this.execCommand(
+        tscCmd.command,
+        [...tscCmd.args, "--noEmit", "--pretty", "false", "--project", tsConfigPath],
+        {
+          cwd: projectDir,
+          timeout: this.config.phase1Timeout
+        }
+      );
+      const output = result.stdout || result.stderr;
+      if (!result.success || TYPESCRIPT_ERROR_PATTERN.test(output) || DEPRECATED_PATTERN.test(output)) {
+        return this.parseTypeCheckErrors(output, groupFiles);
+      }
+      return [];
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      return [
+        {
+          rule: RULE_NAMES.TYPESCRIPT,
+          file: tsConfigPath,
+          line: 0,
+          message: `TypeScript: typecheck could not run \u2014 ${detail}`,
+          severity: SEVERITY.ERROR
+        }
+      ];
+    }
+  }
+  /**
+   * Run TypeScript type check on files
+   * Groups files by tsconfig for accurate checking
+   */
+  async runTypeCheck(files) {
+    const tsFiles = files.filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+    if (tsFiles.length === 0) return { passed: true, errors: [] };
+    const groups = groupFilesByTsConfig(tsFiles, this.config.projectRoot);
+    const allErrors = [];
+    for (const [tsConfigPath, groupFiles] of groups) {
+      if (tsConfigPath === "__no_tsconfig__") {
+        allErrors.push(...this.reportMissingTsConfig(groupFiles));
+        continue;
+      }
+      const errors = await this.runTypeCheckForGroup(tsConfigPath, groupFiles);
+      allErrors.push(...errors);
+    }
+    return {
+      passed: allErrors.length === 0,
+      errors: allErrors
+    };
+  }
+  /**
+   * Run ESLint with embedded config and auto-fix
+   */
+  runLintFix(files) {
+    return this.runLint(files, true);
+  }
+  /**
+   * Run lint without fix (for verification)
+   */
+  runLintCheck(files) {
+    return this.runLint(files, false);
+  }
+  /**
+   * Run Prettier to format files after ESLint fix
+   * This ensures consistent formatting (e.g., single-line if statements)
+   * Runs Prettier from each file's app directory to pick up correct config
+   */
+  async runPrettier(files) {
+    const formattableFiles = files.filter((f) => /\.(?:ts|tsx|js|jsx|vue|json)$/.test(f));
+    if (formattableFiles.length === 0) return { success: true, formattedCount: 0 };
+    const filesByAppDir = this.groupFilesByAppDir(formattableFiles);
+    let totalFormatted = 0;
+    for (const [appDir, appFiles] of Object.entries(filesByAppDir)) {
+      const prettierCmd = findPrettierCommand(appDir);
+      const args = prettierCmd.found ? ["--write", ...appFiles] : ["prettier", "--write", ...appFiles];
+      try {
+        await this.execCommand(prettierCmd.command, args, {
+          cwd: appDir,
+          timeout: this.config.phase1Timeout
+        });
+        totalFormatted += appFiles.length;
+      } catch {
+      }
+    }
+    return { success: totalFormatted > 0, formattedCount: totalFormatted };
+  }
+  /**
+   * Group files by their app directory (api, admin, frontend, etc.)
+   * Finds the nearest directory containing package.json
+   */
+  groupFilesByAppDir(files) {
+    const result = {};
+    for (const file of files) {
+      const appDir = this.findAppDir(file);
+      result[appDir] ??= [];
+      result[appDir].push(file);
+    }
+    return result;
+  }
+  /**
+   * Find the app directory for a file (nearest parent with package.json)
+   */
+  findAppDir(filePath) {
+    let dir = path13.dirname(filePath);
+    while (dir !== path13.dirname(dir)) {
+      if (fs8.existsSync(path13.join(dir, "package.json"))) return dir;
+      dir = path13.dirname(dir);
+    }
+    return this.config.projectRoot;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Private Methods
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Core lint execution - DRY: shared between runLintFix and runLintCheck
+   */
+  async runLint(files, autoFix) {
+    const lintableFiles = files.filter((f) => isLintableFile(f));
+    if (lintableFiles.length === 0) return { passed: true, hasErrors: false, fixedCount: 0, errors: [] };
+    const configArg = this.resolveEslintCliConfigArgs();
+    const eslintCmd = findEslintCommand(this.config.projectRoot);
+    const fixArg = autoFix ? ["--fix"] : [];
+    const args = eslintCmd.found ? [...configArg, ...fixArg, "--format", "json", ...lintableFiles] : ["eslint", ...configArg, ...fixArg, "--format", "json", ...lintableFiles];
+    try {
+      const result = await this.execCommand(eslintCmd.command, args, {
+        cwd: this.config.projectRoot,
+        timeout: this.config.phase1Timeout
+      });
+      const output = result.stdout || "[]";
+      return this.parseLintResult(output, lintableFiles);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      return {
+        passed: false,
+        hasErrors: true,
+        fixedCount: 0,
+        errors: [
+          {
+            rule: RULE_NAMES.ESLINT,
+            file: this.config.projectRoot,
+            line: 0,
+            message: `ESLint: command failed \u2014 ${detail}`,
+            severity: SEVERITY.ERROR
+          }
+        ]
+      };
+    }
+  }
+  execCommand(command, args, options) {
+    validateCommand(command);
+    return new Promise((resolve) => {
+      const proc = spawn(command, args, {
+        cwd: options.cwd,
+        shell: true,
+        timeout: options.timeout
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => stdout += data.toString());
+      proc.stderr.on("data", (data) => stderr += data.toString());
+      proc.on(
+        "close",
+        (code) => resolve({
+          success: code === 0,
+          stdout,
+          stderr
+        })
+      );
+      proc.on(
+        "error",
+        (error) => resolve({
+          success: false,
+          stdout,
+          stderr: error.message
+        })
+      );
+    });
+  }
+  /**
+   * Parse a single TypeScript error line into an Issue
+   */
+  parseErrorLine(line, relevantFiles) {
+    const trimmedLine = line.trim();
+    const errorRegex = /^([^(]+)\((\d+),(\d+)\): error TS\d+: (.+)$/;
+    const match = errorRegex.exec(trimmedLine);
+    if (!match) return null;
+    const [, file, lineNum, col, message] = match;
+    if (!file || !lineNum || !message) return null;
+    const normalizedFile = path13.normalize(file);
+    if (!isFileRelevantToPaths(normalizedFile, relevantFiles)) return null;
+    const trimmedMessage = message.trim();
+    const isDeprecated = DEPRECATED_PATTERN.test(trimmedMessage);
+    return {
+      rule: isDeprecated ? RULE_NAMES.TYPESCRIPT_DEPRECATED : RULE_NAMES.TYPESCRIPT,
+      file: normalizedFile,
+      line: Number.parseInt(lineNum, 10),
+      column: col ? Number.parseInt(col, 10) : void 0,
+      message: trimmedMessage,
+      severity: isDeprecated ? SEVERITY.WARNING : SEVERITY.ERROR
+    };
+  }
+  parseTypeCheckErrors(output, relevantFiles) {
+    const errors = [];
+    const lines = output.split(/\r?\n/);
+    for (const line of lines) {
+      const issue = this.parseErrorLine(line, relevantFiles);
+      if (issue) errors.push(issue);
+    }
+    return errors;
+  }
+  parseLintResult(jsonOutput, relevantFiles) {
+    try {
+      const results = JSON.parse(jsonOutput);
+      return this.processLintResults(results, relevantFiles);
+    } catch (parseError) {
+      return this.createParseErrorResult(parseError);
+    }
+  }
+  processLintResults(results, relevantFiles) {
+    const errors = [];
+    let fixedCount = 0;
+    for (const result of results) {
+      const isRelevant = isFileRelevantToPaths(result.filePath, relevantFiles);
+      if (!isRelevant) continue;
+      if (result.output !== void 0) fixedCount++;
+      errors.push(...this.extractMessages(result));
+    }
+    return { passed: errors.length === 0, hasErrors: errors.length > 0, fixedCount, errors };
+  }
+  extractMessages(result) {
+    return result.messages.filter((msg) => msg.severity >= 1).map((msg) => ({
+      rule: msg.ruleId ?? RULE_NAMES.ESLINT,
+      file: result.filePath,
+      line: msg.line,
+      column: msg.column,
+      message: msg.message,
+      severity: msg.severity === 2 ? SEVERITY.ERROR : SEVERITY.WARNING
+    }));
+  }
+  createParseErrorResult(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      passed: false,
+      hasErrors: true,
+      fixedCount: 0,
+      errors: [
+        {
+          rule: RULE_NAMES.ESLINT,
+          file: "unknown",
+          line: 0,
+          message: `ESLint: could not parse JSON output \u2014 ${detail}`,
+          severity: SEVERITY.ERROR
+        }
+      ]
+    };
+  }
+};
+function filterCodeFiles(files) {
+  const codeFiles = [];
+  const skippedFiles = [];
+  for (const file of files) {
+    const ext = path13.extname(file).toLowerCase();
+    if (SUPPORTED_CODE_EXTENSIONS.has(ext)) codeFiles.push(file);
+    else skippedFiles.push(file);
+  }
+  return { codeFiles, skippedFiles };
+}
+function getPackageVersion() {
+  const moduleDir = path13.dirname(fileURLToPath(import.meta.url));
+  const candidates = [path13.join(moduleDir, "..", "package.json"), path13.join(moduleDir, "..", "..", "package.json")];
+  for (const packageJsonPath of candidates) {
+    try {
+      const raw = fs8__default.readFileSync(packageJsonPath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.version === "string") return parsed.version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var SETUP_FIXER_VALUES = {
+  CURLY_BRACES: "curlyBraces",
+  ESLINT: "eslint",
+  JSON_VALIDATOR: "jsonValidator",
+  PRETTIER: "prettier",
+  SINGLE_LINE_ARROW: "singleLineArrow"
+};
+function fixersFromSelection(selected) {
+  const set = new Set(selected);
+  return {
+    curlyBraces: set.has(SETUP_FIXER_VALUES.CURLY_BRACES),
+    eslint: set.has(SETUP_FIXER_VALUES.ESLINT),
+    jsonValidator: set.has(SETUP_FIXER_VALUES.JSON_VALIDATOR),
+    prettier: set.has(SETUP_FIXER_VALUES.PRETTIER),
+    singleLineArrow: set.has(SETUP_FIXER_VALUES.SINGLE_LINE_ARROW)
+  };
+}
+function buildQualityGateYamlFromModel(model) {
+  const doc = {
+    enableI18nRules: model.enableI18nRules,
+    fixers: model.fixers,
+    phase1Timeout: model.phase1Timeout,
+    phase2Timeout: model.phase2Timeout,
+    projectRoot: model.projectRoot
+  };
+  if (model.sonar !== void 0) {
+    doc.sonar = {
+      hostUrl: model.sonar.hostUrl,
+      projectKey: model.sonar.projectKey
+    };
+  }
+  const header = "# AI Quality Gate \u2014 generated by `ai-quality-gate --setup`\n# SonarQube: set SONAR_TOKEN in the environment (do not commit secrets).\n\n";
+  return `${header}${stringify(doc, { lineWidth: 100 })}`;
+}
+function assertValidHttpUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value.trim());
+  } catch {
+    throw new TypeError(`Invalid URL: ${value}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new TypeError("URL must use http: or https:");
+}
+function formatValidationError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validateRequiredField(input, emptyMessage) {
+  return input.trim().length > 0 ? true : emptyMessage;
+}
+function validateFixerKeysSelection(selected) {
+  return Array.isArray(selected) && selected.length > 0 ? true : "Select at least one tool";
+}
+function validateSonarHostInput(input) {
+  try {
+    assertValidHttpUrl(input);
+    return true;
+  } catch (error) {
+    return formatValidationError(error);
+  }
+}
+function parsePositiveInt(raw, label) {
+  const n = Number.parseInt(raw.trim(), 10);
+  if (!Number.isFinite(n) || n <= 0) throw new TypeError(`${label} must be a positive integer`);
+  return n;
+}
+async function promptSonarBlock() {
+  const sonarAnswers = await inquirer.prompt([
+    {
+      message: "SonarQube host URL",
+      name: "hostUrl",
+      type: "input",
+      validate: (input) => validateSonarHostInput(input)
+    },
+    {
+      message: "SonarQube project key",
+      name: "projectKey",
+      type: "input",
+      validate: (input) => validateRequiredField(input, "Project key is required")
+    },
+    {
+      message: "SonarQube token (not saved to file). Optional \u2014 set SONAR_TOKEN in env; press Enter to skip",
+      name: "_tokenHint",
+      type: "password"
+    }
+  ]);
+  const tokenHint = sonarAnswers._tokenHint ?? "";
+  if (tokenHint.length > 0) console.log('\nToken not written to disk. Example:\n  export SONAR_TOKEN="<your-token>"\n');
+  return {
+    hostUrl: sonarAnswers.hostUrl.trim(),
+    projectKey: sonarAnswers.projectKey.trim()
+  };
+}
+function validateTimeoutInput(input, label) {
+  try {
+    parsePositiveInt(input, label);
+    return true;
+  } catch (error) {
+    return formatValidationError(error);
+  }
+}
+function promptFixerCheckbox() {
+  return inquirer.prompt([
+    {
+      choices: [
+        { checked: true, name: "ESLint (auto-fix)", value: SETUP_FIXER_VALUES.ESLINT },
+        { checked: true, name: "Curly braces (AST)", value: SETUP_FIXER_VALUES.CURLY_BRACES },
+        { checked: true, name: "Single-line arrow (AST)", value: SETUP_FIXER_VALUES.SINGLE_LINE_ARROW },
+        { checked: true, name: "Prettier", value: SETUP_FIXER_VALUES.PRETTIER },
+        { checked: true, name: "JSON validator", value: SETUP_FIXER_VALUES.JSON_VALIDATOR }
+      ],
+      message: "Which Phase 1 tools should run?",
+      name: "fixerKeys",
+      type: "checkbox",
+      validate: (selected) => validateFixerKeysSelection(selected)
+    }
+  ]);
+}
+function promptTimeoutsI18nOutput() {
+  return inquirer.prompt([
+    {
+      default: String(CONFIG_DEFAULTS.PHASE1_TIMEOUT),
+      message: "Phase 1 timeout (ms)",
+      name: "phase1TimeoutRaw",
+      type: "input",
+      validate: (input) => validateTimeoutInput(input, "Phase 1 timeout")
+    },
+    {
+      default: String(CONFIG_DEFAULTS.PHASE2_TIMEOUT),
+      message: "Phase 2 timeout (ms)",
+      name: "phase2TimeoutRaw",
+      type: "input",
+      validate: (input) => validateTimeoutInput(input, "Phase 2 timeout")
+    },
+    {
+      default: false,
+      message: "Enable i18n ESLint rules (no-literal-string in JSX text)?",
+      name: "enableI18nRules",
+      type: "confirm"
+    },
+    {
+      default: path13.join(process.cwd(), CONFIG_FILE_NAMES.YAML),
+      message: "Path for the new config file",
+      name: "outputPath",
+      type: "input",
+      validate: (input) => validateRequiredField(input, "Path is required")
+    }
+  ]);
+}
+async function promptFixersTimeoutsOutput() {
+  const chk = await promptFixerCheckbox();
+  const rest = await promptTimeoutsI18nOutput();
+  return { ...chk, ...rest };
+}
+async function confirmOverwrite(outputPath) {
+  const { overwrite } = await inquirer.prompt([
+    {
+      default: false,
+      message: `File exists: ${outputPath}. Overwrite?`,
+      name: "overwrite",
+      type: "confirm"
+    }
+  ]);
+  return overwrite;
+}
+function promptStep1() {
+  return inquirer.prompt([
+    {
+      default: "./",
+      message: "Project root (relative to the config file directory, or absolute)",
+      name: "projectRoot",
+      type: "input",
+      validate: (input) => validateRequiredField(input, "Project root is required")
+    },
+    {
+      default: false,
+      message: "Enable SonarQube (Phase 2)?",
+      name: "useSonar",
+      type: "confirm"
+    }
+  ]);
+}
+async function promptSetupWizardModel() {
+  const step1 = await promptStep1();
+  let sonar;
+  if (step1.useSonar) sonar = await promptSonarBlock();
+  const step2 = await promptFixersTimeoutsOutput();
+  const outputPath = path13.resolve(step2.outputPath.trim());
+  if (fs8__default.existsSync(outputPath)) {
+    const ok = await confirmOverwrite(outputPath);
+    if (!ok) return "aborted";
+  }
+  const fixers = fixersFromSelection(step2.fixerKeys);
+  const phase1Timeout = parsePositiveInt(step2.phase1TimeoutRaw, "Phase 1 timeout");
+  const phase2Timeout = parsePositiveInt(step2.phase2TimeoutRaw, "Phase 2 timeout");
+  const model = {
+    enableI18nRules: step2.enableI18nRules,
+    fixers,
+    outputPath,
+    phase1Timeout,
+    phase2Timeout,
+    projectRoot: step1.projectRoot.trim()
+  };
+  if (sonar !== void 0) model.sonar = sonar;
+  return model;
+}
+
+// src/cli/setup.ts
+async function runSetup() {
+  try {
+    const result = await promptSetupWizardModel();
+    if (result === "aborted") {
+      console.log("Aborted.");
+      return EXIT_CODE.ERROR;
+    }
+    const yaml = buildQualityGateYamlFromModel(result);
+    fs8__default.writeFileSync(result.outputPath, yaml, "utf8");
+    console.log(`
+Wrote ${result.outputPath}
+`);
+    return EXIT_CODE.SUCCESS;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Setup failed: ${message}`);
+    return EXIT_CODE.ERROR;
+  }
+}
+
+// src/cli/run.ts
+function printHelp() {
+  const lines = [
+    "Usage: ai-quality-gate [options] <file ...>",
+    "",
+    "Options:",
+    `  --${CLI_OPTION.CHECK}              Read-only: typecheck + lint (no auto-fix)`,
+    `  --${CLI_OPTION.FIX}                Apply fixes (ESLint --fix, Prettier, AST)`,
+    `  --${CLI_OPTION.PHASE1_ONLY}        Run Phase 1 only`,
+    `  --${CLI_OPTION.PHASE2_ONLY}        Run Phase 2 (SonarQube) only`,
+    `  --${CLI_OPTION.CONFIG} <path>      Path to .quality-gate.yaml / .quality-gate.json`,
+    `  --${CLI_OPTION.SETUP}             Interactive wizard to create .quality-gate.yaml`,
+    `  -h, --${CLI_OPTION.HELP}          Show help`,
+    `  --${CLI_OPTION.VERSION}           Print version`,
+    "",
+    "Exit codes:",
+    `  ${String(EXIT_CODE.SUCCESS)}  Success`,
+    `  ${String(EXIT_CODE.QUALITY_FAILED)}  Quality checks failed`,
+    `  ${String(EXIT_CODE.ERROR)}  Configuration or runtime error`,
+    ""
+  ];
+  console.log(lines.join("\n"));
+}
+function printVersion() {
+  console.log(getPackageVersion());
+}
+function mapExitCode(result) {
+  if (result.error !== void 0) return EXIT_CODE.ERROR;
+  if (!result.success) return EXIT_CODE.QUALITY_FAILED;
+  return EXIT_CODE.SUCCESS;
+}
+function buildEmptyCliResponse(skippedCount, skippedList) {
+  return {
+    phase: PHASE.COMPLETE,
+    success: true,
+    message: `No code files to check. Skipped ${String(skippedCount)} non-code file(s): ${skippedList}`,
+    fixed: { eslint: 0, curlyBraces: 0, singleLineArrow: 0, prettier: 0, json: 0 },
+    remaining: [],
+    timing: { phase1: "0ms", total: "0ms" }
+  };
+}
+function buildExecutionErrorResponse(message) {
+  return {
+    phase: PHASE.LOCAL,
+    success: false,
+    message: "Execution error",
+    fixed: { eslint: 0, curlyBraces: 0, singleLineArrow: 0, prettier: 0, json: 0 },
+    remaining: [],
+    timing: { phase1: "0ms", total: "0ms" },
+    error: { code: "UNEXPECTED_ERROR", message }
+  };
+}
+async function runQualityPayload(payload) {
+  if (payload.configPath !== void 0) process.env[ENV_KEYS.QUALITY_GATE_CONFIG] = path13.resolve(payload.configPath);
+  const config = configManager.load();
+  const { codeFiles, skippedFiles } = filterCodeFiles(payload.files);
+  if (codeFiles.length === 0) {
+    const empty = buildEmptyCliResponse(skippedFiles.length, skippedFiles.join(", "));
+    console.log(JSON.stringify(empty, null, 2));
+    return mapExitCode(empty);
+  }
+  const qualityGate = new QualityGate(config);
+  const result = await qualityGate.run(codeFiles, payload.qualityGateOptions);
+  if (skippedFiles.length > 0) result.message += ` (Skipped ${String(skippedFiles.length)} non-code file(s))`;
+  console.log(JSON.stringify(result, null, 2));
+  return mapExitCode(result);
+}
+async function runCli(argv) {
+  const parsed = parseCliArgs(argv);
+  if (!parsed.ok) {
+    console.error(parsed.error);
+    return EXIT_CODE.ERROR;
+  }
+  if (parsed.kind === "help") {
+    printHelp();
+    return EXIT_CODE.SUCCESS;
+  }
+  if (parsed.kind === "version") {
+    printVersion();
+    return EXIT_CODE.SUCCESS;
+  }
+  if (parsed.kind === "setup") return runSetup();
+  try {
+    return await runQualityPayload(parsed.payload);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const response = buildExecutionErrorResponse(message);
+    console.log(JSON.stringify(response, null, 2));
+    return EXIT_CODE.ERROR;
+  }
+}
+
+// src/server/qualityFixHandlers.ts
+var toToolResponse = (response) => ({
+  content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+});
+var buildEmptyResponse = (skippedCount, skippedList) => ({
+  phase: PHASE.COMPLETE,
+  success: true,
+  message: `\u2705 No code files to check. Skipped ${skippedCount} non-code file(s): ${skippedList}`,
+  fixed: { eslint: 0, curlyBraces: 0, singleLineArrow: 0, prettier: 0, json: 0 },
+  remaining: [],
+  timing: { phase1: "0ms", total: "0ms" }
+});
+var buildErrorResponse = (errorMessage) => ({
+  phase: PHASE.LOCAL,
+  success: false,
+  message: "Configuration or execution error",
+  fixed: { eslint: 0, curlyBraces: 0, singleLineArrow: 0, prettier: 0, json: 0 },
+  remaining: [],
+  timing: { phase1: "0ms", total: "0ms" },
+  error: { code: "CONFIG_INVALID", message: errorMessage }
+});
+async function runQualityFixForFiles(files) {
+  try {
+    const { codeFiles, skippedFiles } = filterCodeFiles(files);
+    if (codeFiles.length === 0) return buildEmptyResponse(skippedFiles.length, skippedFiles.join(", "));
+    const config = configManager.load();
+    const qualityGate = new QualityGate(config);
+    const result = await qualityGate.run(codeFiles);
+    if (skippedFiles.length > 0) result.message += ` (Skipped ${skippedFiles.length} non-code file(s))`;
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return buildErrorResponse(errorMessage);
+  }
+}
+
+// src/server.ts
+var PACKAGE_VERSION = getPackageVersion();
+var TOOL_DESCRIPTION = `Run quality checks on code files and auto-fix deterministic issues.
+
+Phase 1 (Local, ~2-3s): TypeScript + ESLint + SonarJS (~60 rules) + AST fixers
+Phase 2 (Server, optional): Deep SonarQube analysis (only if configured)
+
+\u{1F3AF} Phase 1 is comprehensive - most users won't need Phase 2!
+
+Auto-fixes (ESLint + AST):
+- Curly braces on single-statement if (AST)
+- Single-expression arrow bodies where safe (AST)
+
+Code Quality Limits:
+- File: max 400 lines
+- Function: max 50 lines, max 5 params, max 4 depth, max 20 statements
+- Complexity: Cognitive max 15, Cyclomatic max 10
+- Security: no-eval, no-new-func, no-implied-eval
+- Best Practices: eqeqeq, no-throw-literal, prefer-promise-reject-errors`;
+var server = new McpServer({ name: "ai-quality-gate", version: PACKAGE_VERSION });
+server.registerTool(
+  "quality_fix",
+  {
+    description: TOOL_DESCRIPTION,
+    inputSchema: { files: z2.array(z2.string()).min(1).describe("Array of file paths to check") }
+  },
+  async ({ files }) => toToolResponse(await runQualityFixForFiles(files))
+);
+if (shouldUseCliMode(process.argv)) {
+  const code = await runCli(process.argv);
+  process.exit(code);
+}
+try {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[ai-quality-gate] MCP Server started");
+} catch (error) {
+  console.error("[ai-quality-gate] Fatal error:", error);
+  process.exit(1);
+}
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map