ralph-gate 0.1.1

package/dist/cli.js

@@ -0,0 +1,866 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import path3 from "path";
+
+// src/config.ts
+import { promises as fs } from "fs";
+import path from "path";
+var CONFIG_FILES = ["gate.config.json", ".gaterc.json", ".gaterc"];
+function normalizeGate(gate) {
+  const order = typeof gate.order === "number" ? gate.order : 100;
+  const enabled = typeof gate.enabled === "boolean" ? gate.enabled : true;
+  const blocking = typeof gate.blocking === "boolean" ? gate.blocking : true;
+  return {
+    ...gate,
+    order,
+    enabled,
+    blocking,
+    description: typeof gate.description === "string" ? gate.description : void 0,
+    name: gate.name,
+    command: gate.command
+  };
+}
+function validateGate(gate) {
+  if (!gate || typeof gate !== "object") {
+    return "Gate entries must be objects.";
+  }
+  const maybeGate = gate;
+  if (typeof maybeGate.name !== "string" || maybeGate.name.trim() === "") {
+    return "Gate is missing required field: name.";
+  }
+  if (typeof maybeGate.command !== "string" || maybeGate.command.trim() === "") {
+    return `Gate '${maybeGate.name}' is missing required field: command.`;
+  }
+  return null;
+}
+function sortGates(gates) {
+  const withIndex = gates.map((gate, index) => ({ gate, index }));
+  withIndex.sort((a, b) => {
+    const orderA = typeof a.gate.order === "number" ? a.gate.order : 100;
+    const orderB = typeof b.gate.order === "number" ? b.gate.order : 100;
+    if (orderA !== orderB) {
+      return orderA - orderB;
+    }
+    return a.index - b.index;
+  });
+  return withIndex.map((entry) => entry.gate);
+}
+async function loadConfig(cwd = process.cwd()) {
+  for (const filename of CONFIG_FILES) {
+    const filePath = path.join(cwd, filename);
+    try {
+      await fs.access(filePath);
+    } catch {
+      continue;
+    }
+    let raw;
+    try {
+      raw = await fs.readFile(filePath, "utf8");
+    } catch (error) {
+      return {
+        config: null,
+        configPath: filePath,
+        error: `Invalid config: unable to read ${filename}: ${error.message}`
+      };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      return {
+        config: null,
+        configPath: filePath,
+        error: `Invalid config: malformed JSON in ${filename}: ${error.message}`
+      };
+    }
+    if (!parsed || typeof parsed !== "object") {
+      return {
+        config: null,
+        configPath: filePath,
+        error: `Invalid config: expected object in ${filename}.`
+      };
+    }
+    const config = parsed;
+    if (!Array.isArray(config.gates)) {
+      return {
+        config: null,
+        configPath: filePath,
+        error: `Invalid config: missing required 'gates' array in ${filename}.`
+      };
+    }
+    const normalized = [];
+    for (const gate of config.gates) {
+      const gateError = validateGate(gate);
+      if (gateError) {
+        return {
+          config: null,
+          configPath: filePath,
+          error: `Invalid config: ${gateError}`
+        };
+      }
+      const normalizedGate = normalizeGate(gate);
+      if (normalizedGate.enabled === false) {
+        continue;
+      }
+      normalized.push(normalizedGate);
+    }
+    const failFast = typeof config.failFast === "boolean" ? config.failFast : true;
+    const outputPath = typeof config.outputPath === "string" ? config.outputPath : void 0;
+    const sorted = sortGates(normalized);
+    return {
+      config: {
+        gates: sorted,
+        failFast,
+        outputPath
+      },
+      configPath: filePath
+    };
+  }
+  return { config: null };
+}
+
+// src/init.ts
+import { promises as fs2 } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+var DEFAULT_CONFIG_FILENAME = "gate.config.json";
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(cwd) {
+  if (await fileExists(path2.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fileExists(path2.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function runScriptCommand(packageManager, scriptName) {
+  switch (packageManager) {
+    case "yarn":
+      return `yarn ${scriptName}`;
+    case "pnpm":
+      return `pnpm run ${scriptName}`;
+    default:
+      return `npm run ${scriptName}`;
+  }
+}
+async function readJsonFile(filePath) {
+  const raw = await fs2.readFile(filePath, "utf8");
+  return JSON.parse(raw);
+}
+function extractRequirementName(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("#")) {
+    return null;
+  }
+  const noEnvMarker = trimmed.split(";", 1)[0]?.trim() ?? "";
+  if (noEnvMarker.length === 0) {
+    return null;
+  }
+  const name = noEnvMarker.split(/[<>=\[]/, 1)[0]?.trim();
+  if (!name) {
+    return null;
+  }
+  return name.toLowerCase();
+}
+async function detectProject(cwd) {
+  const packageJsonPath = path2.join(cwd, "package.json");
+  if (await fileExists(packageJsonPath)) {
+    const pm = await detectPackageManager(cwd);
+    const parsed = await readJsonFile(packageJsonPath);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("package.json is not a JSON object.");
+    }
+    return {
+      kind: "node",
+      packageManager: pm,
+      packageJson: parsed
+    };
+  }
+  const requirementsPath = path2.join(cwd, "requirements.txt");
+  const pyprojectPath = path2.join(cwd, "pyproject.toml");
+  if (await fileExists(requirementsPath) || await fileExists(pyprojectPath)) {
+    const requirements = /* @__PURE__ */ new Set();
+    if (await fileExists(requirementsPath)) {
+      const raw = await fs2.readFile(requirementsPath, "utf8");
+      for (const line of raw.split(/\r?\n/)) {
+        const name = extractRequirementName(line);
+        if (name) {
+          requirements.add(name);
+        }
+      }
+    }
+    return { kind: "python", requirements };
+  }
+  return { kind: "unknown" };
+}
+function getPackageJsonScripts(packageJson) {
+  const scripts = packageJson.scripts;
+  if (!scripts || typeof scripts !== "object") {
+    return {};
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(
+    scripts
+  )) {
+    if (typeof value === "string") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function getPackageJsonDeps(packageJson) {
+  const deps = /* @__PURE__ */ new Set();
+  const sections = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ];
+  for (const section of sections) {
+    const values = packageJson[section];
+    if (!values || typeof values !== "object") {
+      continue;
+    }
+    for (const name of Object.keys(values)) {
+      deps.add(name);
+    }
+  }
+  return deps;
+}
+async function inferNodeGates(cwd, packageManager, packageJson, warnings) {
+  const gates = [];
+  const scripts = getPackageJsonScripts(packageJson);
+  const deps = getPackageJsonDeps(packageJson);
+  const addIfScript = (name, order) => {
+    if (!scripts[name]) {
+      return;
+    }
+    gates.push({
+      name,
+      order,
+      command: runScriptCommand(packageManager, name)
+    });
+  };
+  addIfScript("lint", 10);
+  addIfScript("typecheck", 20);
+  addIfScript("test", 30);
+  addIfScript("build", 40);
+  const tsconfigPath = path2.join(cwd, "tsconfig.json");
+  const hasTypescript = deps.has("typescript");
+  if (hasTypescript && await fileExists(tsconfigPath) && !scripts.typecheck) {
+    warnings.push(
+      "No 'typecheck' script found; generating a default tsc gate."
+    );
+    gates.splice(1, 0, {
+      name: "typecheck",
+      order: 20,
+      command: "npx tsc -p tsconfig.json --noEmit"
+    });
+  }
+  return gates;
+}
+function inferPythonGates(requirements, warnings) {
+  const gates = [];
+  if (requirements.has("ruff")) {
+    gates.push({ name: "lint", order: 10, command: "python -m ruff check ." });
+  }
+  if (requirements.has("mypy")) {
+    gates.push({ name: "typecheck", order: 20, command: "python -m mypy ." });
+  }
+  if (requirements.has("pytest")) {
+    gates.push({ name: "test", order: 30, command: "python -m pytest -q" });
+  } else {
+    warnings.push(
+      "pytest not detected in requirements; no test gate generated."
+    );
+  }
+  return gates;
+}
+async function updateGitignore(cwd) {
+  const gitignorePath = path2.join(cwd, ".gitignore");
+  const pattern = "gate-results-*.json";
+  try {
+    execSync("git check-ignore -q gate-results-test.json", {
+      cwd,
+      stdio: "ignore"
+    });
+    return false;
+  } catch {
+  }
+  try {
+    const exists = await fileExists(gitignorePath);
+    const content = exists ? await fs2.readFile(gitignorePath, "utf8") : "";
+    const newline = content && !content.endsWith("\n") ? "\n" : "";
+    await fs2.appendFile(gitignorePath, `${newline}${pattern}
+`, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function generateGateConfig(cwd) {
+  const warnings = [];
+  const detected = await detectProject(cwd);
+  let gates = [];
+  if (detected.kind === "node") {
+    gates = await inferNodeGates(
+      cwd,
+      detected.packageManager,
+      detected.packageJson,
+      warnings
+    );
+  } else if (detected.kind === "python") {
+    gates = inferPythonGates(detected.requirements, warnings);
+  } else {
+    warnings.push(
+      "No supported project markers found; creating an empty gate config."
+    );
+  }
+  return {
+    config: {
+      gates,
+      failFast: true
+    },
+    projectKind: detected.kind,
+    warnings
+  };
+}
+async function initConfigFile(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const filename = options.filename ?? DEFAULT_CONFIG_FILENAME;
+  const configPath = path2.join(cwd, filename);
+  const { config, projectKind, warnings } = await generateGateConfig(cwd);
+  if (options.print) {
+    return {
+      config,
+      configPath,
+      created: false,
+      projectKind,
+      warnings
+    };
+  }
+  const writeFlag = options.force ? "w" : "wx";
+  try {
+    await fs2.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", {
+      encoding: "utf8",
+      flag: writeFlag
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error?.code;
+    if (!options.force && code === "EEXIST") {
+      return {
+        config,
+        configPath,
+        created: false,
+        projectKind,
+        warnings,
+        error: `Config already exists at ${configPath}. Use --force to overwrite.`
+      };
+    }
+    return {
+      config,
+      configPath,
+      created: false,
+      projectKind,
+      warnings,
+      error: `Unable to write config at ${configPath}: ${message}`
+    };
+  }
+  const gitignoreUpdated = await updateGitignore(cwd);
+  return {
+    config,
+    configPath,
+    created: true,
+    projectKind,
+    warnings,
+    gitignoreUpdated
+  };
+}
+
+// src/runner.ts
+import { spawn } from "child_process";
+function resolveShell(shell) {
+  if (typeof shell === "string" && shell.length > 0) {
+    return shell;
+  }
+  const envShell = process.env.SHELL;
+  return envShell && envShell.length > 0 ? envShell : true;
+}
+async function runGate(gate, options) {
+  const start = Date.now();
+  const shell = resolveShell(options.shell);
+  const env = process.env;
+  return new Promise((resolve) => {
+    options.onGateStart?.(gate);
+    const child = spawn(gate.command, {
+      shell,
+      env,
+      cwd: options.cwd
+    });
+    let stdout = "";
+    let stderr = "";
+    let exitCode = null;
+    let resolved = false;
+    const finalize = () => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      const durationMs = Date.now() - start;
+      const result = {
+        name: gate.name,
+        passed: exitCode === 0,
+        exitCode,
+        stdout,
+        stderr,
+        durationMs,
+        skipped: false,
+        blocking: gate.blocking !== false,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      options.onGateComplete?.(result);
+      resolve(result);
+    };
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout += text;
+      if (options.verbose) {
+        process.stdout.write(text);
+      }
+      options.onGateOutput?.(gate, "stdout", text);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      if (options.verbose) {
+        process.stderr.write(text);
+      }
+      options.onGateOutput?.(gate, "stderr", text);
+    });
+    child.on("error", (error) => {
+      stderr += error.message;
+      exitCode = null;
+      finalize();
+    });
+    child.on("close", (code) => {
+      exitCode = code;
+      finalize();
+    });
+  });
+}
+async function runGates(gates, options = {}) {
+  const results = [];
+  const warnings = [];
+  const start = Date.now();
+  let firstFailure = null;
+  for (const gate of gates) {
+    const isBlocking = gate.blocking !== false;
+    const shouldSkip = options.failFast !== false && firstFailure !== null && isBlocking;
+    if (shouldSkip) {
+      const skippedResult = {
+        name: gate.name,
+        passed: true,
+        exitCode: null,
+        stdout: "",
+        stderr: "",
+        durationMs: 0,
+        skipped: true,
+        blocking: isBlocking,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      results.push(skippedResult);
+      options.onGateComplete?.(skippedResult);
+      continue;
+    }
+    const result = await runGate(gate, options);
+    results.push(result);
+    if (!result.passed) {
+      if (result.blocking) {
+        if (!firstFailure) {
+          firstFailure = result;
+        }
+      } else {
+        warnings.push(result.name);
+      }
+    }
+  }
+  const totalDurationMs = Date.now() - start;
+  const passed = firstFailure === null;
+  return {
+    passed,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalDurationMs,
+    results,
+    firstFailure,
+    warnings
+  };
+}
+
+// src/output.ts
+import { promises as fs3 } from "fs";
+var MAX_FAILURE_CHARS = 4e3;
+var HEAD_RATIO = 0.6;
+function truncateOutput(text, maxChars) {
+  const trimmed = text.trimEnd();
+  if (maxChars <= 0 || trimmed.length === 0) {
+    return "";
+  }
+  if (trimmed.length <= maxChars) {
+    return trimmed;
+  }
+  const headChars = Math.max(1, Math.floor(maxChars * HEAD_RATIO));
+  const tailChars = Math.max(0, maxChars - headChars);
+  const omitted = trimmed.length - maxChars;
+  const marker = `
+...<${omitted} chars omitted>...
+`;
+  const head = trimmed.slice(0, headChars);
+  const tail = tailChars > 0 ? trimmed.slice(-tailChars) : "";
+  return `${head}${marker}${tail}`;
+}
+function splitBudget(stdoutLen, stderrLen) {
+  if (stdoutLen === 0 && stderrLen === 0) {
+    return { stdout: 0, stderr: 0 };
+  }
+  if (stdoutLen === 0) {
+    return { stdout: 0, stderr: MAX_FAILURE_CHARS };
+  }
+  if (stderrLen === 0) {
+    return { stdout: MAX_FAILURE_CHARS, stderr: 0 };
+  }
+  const base = Math.floor(MAX_FAILURE_CHARS / 2);
+  let stdout = Math.min(stdoutLen, base);
+  let stderr = Math.min(stderrLen, base);
+  let remaining = MAX_FAILURE_CHARS - stdout - stderr;
+  if (remaining > 0) {
+    const stdoutRemaining = stdoutLen - stdout;
+    const stderrRemaining = stderrLen - stderr;
+    if (stdoutRemaining === 0) {
+      stderr += remaining;
+    } else if (stderrRemaining === 0) {
+      stdout += remaining;
+    } else {
+      const totalRemaining = stdoutRemaining + stderrRemaining;
+      const stdoutExtra = Math.round(
+        stdoutRemaining / totalRemaining * remaining
+      );
+      stdout += stdoutExtra;
+      stderr += remaining - stdoutExtra;
+    }
+  }
+  return { stdout, stderr };
+}
+function colorize(text, code, enabled) {
+  if (!enabled) {
+    return text;
+  }
+  return `\x1B[${code}m${text}\x1B[0m`;
+}
+function formatResultLine(result, color) {
+  const statusSymbol = result.skipped ? "\u2298" : result.passed ? "\u2713" : "\u2717";
+  let symbolColor = "32";
+  if (result.skipped) {
+    symbolColor = "90";
+  } else if (!result.passed) {
+    symbolColor = "31";
+  }
+  const parts = [];
+  if (result.skipped) {
+    parts.push("skipped");
+  } else if (!result.passed) {
+    parts.push(`exit ${result.exitCode ?? "null"}`);
+  }
+  parts.push(`${result.durationMs}ms`);
+  const details = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+  const coloredSymbol = colorize(statusSymbol, symbolColor, color);
+  return `${coloredSymbol} ${result.name}${details}`;
+}
+function formatFailureContext(stderr, stdout = "") {
+  const trimmedStderr = stderr.trimEnd();
+  const trimmedStdout = stdout.trimEnd();
+  if (trimmedStderr.length === 0 && trimmedStdout.length === 0) {
+    return "No output captured.";
+  }
+  if (trimmedStderr.length > 0 && trimmedStdout.length > 0) {
+    const budget = splitBudget(trimmedStdout.length, trimmedStderr.length);
+    const stderrSection = truncateOutput(trimmedStderr, budget.stderr);
+    const stdoutSection = truncateOutput(trimmedStdout, budget.stdout);
+    return `STDERR:
+${stderrSection}
+
+STDOUT:
+${stdoutSection}`;
+  }
+  if (trimmedStderr.length > 0) {
+    return truncateOutput(trimmedStderr, MAX_FAILURE_CHARS);
+  }
+  return truncateOutput(trimmedStdout, MAX_FAILURE_CHARS);
+}
+function formatConsoleOutput(summary) {
+  const color = Boolean(process.stdout.isTTY);
+  const lines = [];
+  for (const result of summary.results) {
+    lines.push(formatResultLine(result, color));
+  }
+  if (summary.warnings.length > 0) {
+    const warningLine = `Warnings: ${summary.warnings.join(", ")}`;
+    lines.push(colorize(warningLine, "33", color));
+  }
+  const finalLine = summary.passed ? colorize("All blocking gates passed.", "32", color) : colorize("Blocking gate failed.", "31", color);
+  lines.push(finalLine);
+  return lines.join("\n");
+}
+async function writeResultsFile(summary, outputPath) {
+  const data = JSON.stringify(summary, null, 2);
+  await fs3.writeFile(outputPath, data, "utf8");
+}
+
+// src/hook.ts
+function generateHookResponse(summary) {
+  const warnings = summary.warnings.length > 0 ? summary.warnings : void 0;
+  if (summary.passed) {
+    return warnings ? { warnings } : {};
+  }
+  const failure = summary.firstFailure;
+  if (failure) {
+    const reason2 = `Gate '${failure.name}' failed (exit ${failure.exitCode ?? "null"}):
+${formatFailureContext(failure.stderr, failure.stdout)}`;
+    return warnings ? { decision: "block", reason: reason2, warnings } : { decision: "block", reason: reason2 };
+  }
+  const reason = "Gate run failed without a blocking gate result.";
+  return warnings ? { decision: "block", reason, warnings } : { decision: "block", reason };
+}
+function outputHookResponse(output) {
+  process.stdout.write(`${JSON.stringify(output)}
+`);
+}
+
+// src/cli.ts
+function parseArgs(args) {
+  const options = {
+    hook: false,
+    dryRun: false,
+    verbose: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    switch (arg) {
+      case "--hook":
+        options.hook = true;
+        break;
+      case "--dry-run":
+        options.dryRun = true;
+        break;
+      case "--verbose":
+        options.verbose = true;
+        break;
+      case "--only": {
+        const value = args[i + 1];
+        if (!value) {
+          return { options, error: "Missing value for --only." };
+        }
+        options.only = value;
+        i += 1;
+        break;
+      }
+      default:
+        return { options, error: `Unknown argument: ${arg}` };
+    }
+  }
+  return { options };
+}
+function parseInitArgs(args) {
+  const options = {
+    force: false,
+    print: false
+  };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    switch (arg) {
+      case "--force":
+        options.force = true;
+        break;
+      case "--print":
+        options.print = true;
+        break;
+      default:
+        return { options, error: `Unknown argument: ${arg}` };
+    }
+  }
+  return { options };
+}
+function defaultOutputPath() {
+  return `gate-results-${process.pid}.json`;
+}
+function createEmptySummary(passed) {
+  return {
+    passed,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    totalDurationMs: 0,
+    results: [],
+    firstFailure: null,
+    warnings: []
+  };
+}
+function formatDryRun(gates, shell) {
+  const lines = [`SHELL: ${shell}`];
+  if (gates.length === 0) {
+    lines.push("No gates to run.");
+    return lines.join("\n");
+  }
+  for (const gate of gates) {
+    const order = typeof gate.order === "number" ? gate.order : 100;
+    lines.push(`- ${gate.name} (order ${order}): ${gate.command}`);
+  }
+  return lines.join("\n");
+}
+function createHookProgressReporter(enabled) {
+  if (!enabled) {
+    return {};
+  }
+  const prefix = "[ralph-gate]";
+  const writeLine = (line) => {
+    process.stderr.write(`${prefix} ${line}
+`);
+  };
+  return {
+    onGateStart: (gate) => {
+      writeLine(`running ${gate.name}: ${gate.command}`);
+    },
+    onGateOutput: (_gate, _stream, text) => {
+      process.stderr.write(text);
+    },
+    onGateComplete: (result) => {
+      if (result.skipped) {
+        writeLine(`${result.name} skipped`);
+        return;
+      }
+      const status = result.passed ? `passed in ${result.durationMs}ms` : `failed (exit ${result.exitCode ?? "null"}) in ${result.durationMs}ms`;
+      writeLine(`${result.name} ${status}`);
+    }
+  };
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "init") {
+    const { options: options2, error: error2 } = parseInitArgs(argv.slice(1));
+    if (error2) {
+      console.error(error2);
+      process.exitCode = 1;
+      return;
+    }
+    const result = await initConfigFile({
+      force: options2.force,
+      print: options2.print
+    });
+    if (result.error) {
+      console.error(result.error);
+      process.exitCode = 1;
+      return;
+    }
+    for (const warning of result.warnings) {
+      console.error(`Warning: ${warning}`);
+    }
+    if (options2.print) {
+      console.log(JSON.stringify(result.config, null, 2));
+      return;
+    }
+    console.log(
+      `Created ${path3.basename(result.configPath)} with ${result.config.gates.length} gate(s).`
+    );
+    if (result.gitignoreUpdated) {
+      console.log("Updated .gitignore to exclude gate-results-*.json files.");
+    }
+    return;
+  }
+  const { options, error } = parseArgs(argv);
+  if (error) {
+    console.error(error);
+    process.exitCode = 1;
+    return;
+  }
+  const configResult = await loadConfig();
+  if (configResult.error) {
+    const summary2 = createEmptySummary(false);
+    const outputPath2 = defaultOutputPath();
+    await writeResultsFile(summary2, outputPath2);
+    if (options.hook) {
+      outputHookResponse({ decision: "block", reason: configResult.error });
+      process.exitCode = 0;
+      return;
+    }
+    console.error(configResult.error);
+    process.exitCode = 1;
+    return;
+  }
+  if (!configResult.config) {
+    if (options.dryRun) {
+      const shellLabel2 = process.env.SHELL ?? "(default)";
+      console.log(formatDryRun([], shellLabel2));
+    }
+    if (options.hook) {
+      outputHookResponse({});
+      process.exitCode = 0;
+    }
+    return;
+  }
+  const config = configResult.config;
+  const shellLabel = process.env.SHELL ?? "(default)";
+  if (options.dryRun) {
+    console.log(formatDryRun(config.gates, shellLabel));
+    return;
+  }
+  let gates = config.gates;
+  if (options.only) {
+    const match = gates.find((gate) => gate.name === options.only);
+    if (!match) {
+      console.error(`Gate not found: ${options.only}`);
+      process.exitCode = 1;
+      return;
+    }
+    gates = [match];
+  }
+  const outputPath = config.outputPath ?? defaultOutputPath();
+  if (gates.length === 0) {
+    const summary2 = createEmptySummary(true);
+    await writeResultsFile(summary2, outputPath);
+    if (options.hook) {
+      outputHookResponse({});
+      process.exitCode = 0;
+      return;
+    }
+    console.log(formatConsoleOutput(summary2));
+    return;
+  }
+  const hookProgress = createHookProgressReporter(options.hook);
+  const summary = await runGates(gates, {
+    failFast: config.failFast,
+    verbose: options.verbose && !options.hook,
+    ...hookProgress
+  });
+  await writeResultsFile(summary, outputPath);
+  if (options.hook) {
+    outputHookResponse(generateHookResponse(summary));
+    process.exitCode = 0;
+    return;
+  }
+  console.log(formatConsoleOutput(summary));
+  if (!summary.passed) {
+    process.exitCode = 1;
+  }
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map