workflow-agent-cli 2.23.0 → 2.23.2

package/dist/{chunk-XGS2VFBP.js → chunk-MBRMT5ZG.js}

@@ -130,26 +130,86 @@ async function hasSimpleGitHooksConfig(projectPath) {
   }
 }
 async function detectFramework(projectPath) {
+  const result = await detectAllPlatforms(projectPath);
+  return result.primary;
+}
+async function detectAllPlatforms(projectPath) {
+  const detected = [];
   try {
     const pkgPath = join2(projectPath, "package.json");
-    if (!existsSync2(pkgPath)) return "unknown";
-    const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
-    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    if (existsSync2(join2(projectPath, "shopify.theme.toml")) || existsSync2(join2(projectPath, "config/settings_schema.json")) || deps["@shopify/cli"] || deps["@shopify/theme"]) {
-      return "shopify";
+    const hasPkgJson = existsSync2(pkgPath);
+    let deps = {};
+    let composerDeps = {};
+    if (hasPkgJson) {
+      const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+      deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    const composerPath = join2(projectPath, "composer.json");
+    if (existsSync2(composerPath)) {
+      try {
+        const composer = JSON.parse(await readFile2(composerPath, "utf-8"));
+        composerDeps = { ...composer.require, ...composer["require-dev"] };
+      } catch {
+      }
+    }
+    if (deps["@shopify/hydrogen"] || deps["@shopify/remix-oxygen"] || existsSync2(join2(projectPath, "hydrogen.config.ts")) || existsSync2(join2(projectPath, "hydrogen.config.js"))) {
+      detected.push("shopify-hydrogen");
+    }
+    if (existsSync2(join2(projectPath, "shopify.theme.toml")) || existsSync2(join2(projectPath, "config/settings_schema.json")) || deps["@shopify/theme"] || await hasLiquidFiles(projectPath)) {
+      detected.push("shopify-theme");
+    }
+    const hasWooCommerce = Object.keys(composerDeps).some(
+      (dep) => dep.toLowerCase().includes("woocommerce")
+    ) || existsSync2(join2(projectPath, "wp-content/plugins/woocommerce"));
+    const isWordPress = existsSync2(join2(projectPath, "wp-content")) || existsSync2(join2(projectPath, "functions.php")) || await hasWordPressThemeHeader(projectPath) || Object.keys(composerDeps).some(
+      (dep) => dep.includes("wordpress") || dep.includes("johnpbloch/wordpress")
+    );
+    if (hasWooCommerce && isWordPress) {
+      detected.push("woocommerce");
+    } else if (isWordPress) {
+      detected.push("wordpress");
+    }
+    if (existsSync2(join2(projectPath, "app/etc/env.php")) || existsSync2(join2(projectPath, "bin/magento")) || Object.keys(composerDeps).some((dep) => dep.startsWith("magento/"))) {
+      detected.push("magento");
+    }
+    if (deps.next) detected.push("nextjs");
+    if (deps["@remix-run/react"] && !detected.includes("shopify-hydrogen")) {
+      detected.push("remix");
     }
-    if (deps.next) return "nextjs";
-    if (deps["@remix-run/react"]) return "remix";
-    if (deps.nuxt) return "nuxt";
-    if (deps.vue) return "vue";
-    if (deps.svelte || deps["@sveltejs/kit"]) return "svelte";
-    if (deps.react && !deps.next) return "react";
-    if (deps.hono) return "hono";
-    if (deps.express) return "express";
-    if (deps["@types/node"] || pkg.type === "module") return "node";
-    return "unknown";
+    if (deps.nuxt) detected.push("nuxt");
+    if (deps.vue && !deps.nuxt) detected.push("vue");
+    if (deps.svelte || deps["@sveltejs/kit"]) detected.push("svelte");
+    if (deps.react && !deps.next && !detected.includes("shopify-hydrogen")) {
+      detected.push("react");
+    }
+    if (deps.hono) detected.push("hono");
+    if (deps.express) detected.push("express");
+    if ((deps["@types/node"] || hasPkgJson && existsSync2(pkgPath)) && detected.length === 0) {
+      detected.push("node");
+    }
+    const primary = detected.length > 0 ? detected[0] : "unknown";
+    return { primary, detected };
   } catch {
-    return "unknown";
+    return { primary: "unknown", detected: [] };
+  }
+}
+async function hasLiquidFiles(projectPath) {
+  try {
+    const { readdir } = await import("fs/promises");
+    const entries = await readdir(projectPath);
+    return entries.some((entry) => entry.endsWith(".liquid"));
+  } catch {
+    return false;
+  }
+}
+async function hasWordPressThemeHeader(projectPath) {
+  try {
+    const stylePath = join2(projectPath, "style.css");
+    if (!existsSync2(stylePath)) return false;
+    const content = await readFile2(stylePath, "utf-8");
+    return content.includes("Theme Name:");
+  } catch {
+    return false;
   }
 }
 async function generateSetupPlans(projectPath, packageManager, isTypeScript, framework, existing, scripts, isMonorepo2) {
@@ -1111,12 +1171,799 @@ async function readPrettierConfig(projectPath) {
   return {};
 }
 
+// src/utils/check-runner.ts
+import { execa as execa3 } from "execa";
+import chalk from "chalk";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join3 } from "path";
+import * as p from "@clack/prompts";
+var QUALITY_CHECKS = [
+  {
+    name: "typecheck",
+    displayName: "Type Check",
+    command: "pnpm",
+    args: ["typecheck"],
+    canAutoFix: false,
+    // TypeScript errors need manual/LLM fix
+    requiredScript: "typecheck",
+    fallbackCommand: ["tsc", "--noEmit"]
+  },
+  {
+    name: "lint",
+    displayName: "Lint",
+    command: "pnpm",
+    args: ["lint"],
+    fixCommand: "pnpm",
+    fixArgs: ["lint", "--fix"],
+    canAutoFix: true,
+    requiredScript: "lint"
+  },
+  {
+    name: "format",
+    displayName: "Format",
+    command: "pnpm",
+    args: ["format", "--check"],
+    fixCommand: "pnpm",
+    fixArgs: ["format"],
+    canAutoFix: true,
+    requiredScript: "format"
+  },
+  {
+    name: "test",
+    displayName: "Tests",
+    command: "pnpm",
+    args: ["test"],
+    canAutoFix: false,
+    // Tests need manual/LLM fix
+    requiredScript: "test"
+  },
+  {
+    name: "build",
+    displayName: "Build",
+    command: "pnpm",
+    args: ["build"],
+    canAutoFix: false,
+    // Build errors need manual/LLM fix
+    requiredScript: "build"
+  }
+];
+var PLATFORM_CLI_INSTALL = {
+  "shopify-theme": {
+    cli: "shopify",
+    install: "npm install -g @shopify/cli @shopify/theme",
+    requiresComposer: false,
+    displayName: "Shopify Theme"
+  },
+  "shopify-hydrogen": {
+    cli: "shopify",
+    install: "npm install -g @shopify/cli",
+    requiresComposer: false,
+    displayName: "Shopify Hydrogen"
+  },
+  wordpress: {
+    cli: "phpcs",
+    install: "composer global require squizlabs/php_codesniffer wp-coding-standards/wpcs && phpcs --config-set installed_paths $(composer global config home)/vendor/wp-coding-standards/wpcs",
+    requiresComposer: true,
+    displayName: "WordPress"
+  },
+  magento: {
+    cli: "phpcs",
+    install: "composer global require squizlabs/php_codesniffer magento/magento-coding-standard && phpcs --config-set installed_paths $(composer global config home)/vendor/magento/magento-coding-standard",
+    requiresComposer: true,
+    displayName: "Magento"
+  },
+  woocommerce: {
+    cli: "phpcs",
+    install: "composer global require squizlabs/php_codesniffer automattic/woocommerce-sniffs && phpcs --config-set installed_paths $(composer global config home)/vendor/automattic/woocommerce-sniffs",
+    requiresComposer: true,
+    displayName: "WooCommerce"
+  }
+};
+var PLATFORM_CHECKS = [
+  {
+    platform: "shopify-theme",
+    name: "shopify-theme-check",
+    displayName: "Shopify Theme Check",
+    command: "shopify",
+    args: ["theme", "check"],
+    canAutoFix: false
+  },
+  {
+    platform: "shopify-hydrogen",
+    name: "shopify-hydrogen-check",
+    displayName: "Shopify Hydrogen Check",
+    command: "shopify",
+    args: ["hydrogen", "check"],
+    canAutoFix: false
+  },
+  {
+    platform: "wordpress",
+    name: "wordpress-phpcs",
+    displayName: "WordPress Coding Standards",
+    command: "phpcs",
+    args: ["--standard=WordPress", "."],
+    fixCommand: "phpcbf",
+    fixArgs: ["--standard=WordPress", "."],
+    canAutoFix: true
+  },
+  {
+    platform: "magento",
+    name: "magento-phpcs",
+    displayName: "Magento Coding Standards",
+    command: "phpcs",
+    args: ["--standard=Magento2", "."],
+    fixCommand: "phpcbf",
+    fixArgs: ["--standard=Magento2", "."],
+    canAutoFix: true
+  },
+  {
+    platform: "woocommerce",
+    name: "woocommerce-phpcs",
+    displayName: "WooCommerce Coding Standards",
+    command: "phpcs",
+    args: ["--standard=WooCommerce-Core", "."],
+    fixCommand: "phpcbf",
+    fixArgs: ["--standard=WooCommerce-Core", "."],
+    canAutoFix: true
+  }
+];
+function getAvailableScripts(cwd) {
+  const packageJsonPath = join3(cwd, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return /* @__PURE__ */ new Set();
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return new Set(Object.keys(packageJson.scripts || {}));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function commandExists(cmd) {
+  try {
+    await execa3("which", [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getApplicableChecks(cwd) {
+  const availableScripts = getAvailableScripts(cwd);
+  const applicableChecks = [];
+  for (const check of QUALITY_CHECKS) {
+    if (!check.requiredScript) {
+      applicableChecks.push(check);
+      continue;
+    }
+    if (availableScripts.has(check.requiredScript)) {
+      applicableChecks.push(check);
+      continue;
+    }
+    if (check.fallbackCommand && check.fallbackCommand.length > 0) {
+      const fallbackCmd = check.fallbackCommand[0];
+      if (await commandExists(fallbackCmd)) {
+        applicableChecks.push({
+          ...check,
+          command: fallbackCmd,
+          args: check.fallbackCommand.slice(1)
+        });
+        continue;
+      }
+    }
+  }
+  return applicableChecks;
+}
+async function ensureComposer() {
+  const hasComposer = await commandExists("composer");
+  if (!hasComposer) {
+    console.log(chalk.red("\n\u274C Composer is required but not installed.\n"));
+    console.log(chalk.yellow("Please install Composer for your platform:\n"));
+    const platform = process.platform;
+    if (platform === "darwin") {
+      console.log(chalk.cyan("  macOS (Homebrew):"));
+      console.log(chalk.dim("    brew install composer\n"));
+    } else if (platform === "linux") {
+      console.log(chalk.cyan("  Ubuntu/Debian:"));
+      console.log(chalk.dim("    sudo apt install composer\n"));
+      console.log(chalk.cyan("  Fedora/CentOS:"));
+      console.log(chalk.dim("    sudo dnf install composer\n"));
+      console.log(chalk.cyan("  Arch Linux:"));
+      console.log(chalk.dim("    sudo pacman -S composer\n"));
+    } else if (platform === "win32") {
+      console.log(chalk.cyan("  Windows (Scoop):"));
+      console.log(chalk.dim("    scoop install composer\n"));
+      console.log(chalk.cyan("  Windows (Chocolatey):"));
+      console.log(chalk.dim("    choco install composer\n"));
+    }
+    console.log(chalk.cyan("  Or download from:"));
+    console.log(chalk.dim("    https://getcomposer.org/download/\n"));
+    process.exit(1);
+  }
+}
+async function promptPlatformChoice(detected) {
+  const platformTypes = detected.filter(
+    (d) => Object.keys(PLATFORM_CLI_INSTALL).includes(d)
+  );
+  if (platformTypes.length === 0) {
+    return detected[0] || "unknown";
+  }
+  if (platformTypes.length === 1) {
+    return platformTypes[0];
+  }
+  console.log(
+    chalk.yellow("\n\u{1F50D} Multiple platforms detected in this project:\n")
+  );
+  const options = platformTypes.map((pt) => ({
+    value: pt,
+    label: PLATFORM_CLI_INSTALL[pt].displayName
+  }));
+  const choice = await p.select({
+    message: "Which platform would you like to run checks for?",
+    options
+  });
+  if (p.isCancel(choice)) {
+    console.log(chalk.yellow("\n\u26A0\uFE0F  Platform check cancelled."));
+    process.exit(0);
+  }
+  return choice;
+}
+async function ensurePlatformCLI(platform) {
+  const config = PLATFORM_CLI_INSTALL[platform];
+  if (config.requiresComposer) {
+    await ensureComposer();
+  }
+  const hasCLI = await commandExists(config.cli);
+  if (!hasCLI) {
+    console.log(
+      chalk.yellow(
+        `
+\u{1F4E6} ${config.displayName} CLI (${config.cli}) not found. Installing...
+`
+      )
+    );
+    console.log(chalk.dim(`  Running: ${config.install}
+`));
+    try {
+      await execa3("sh", ["-c", config.install], {
+        stdio: "inherit"
+      });
+      const nowHasCLI = await commandExists(config.cli);
+      if (!nowHasCLI) {
+        console.log(
+          chalk.red(
+            `
+\u274C Failed to install ${config.cli}. Please install manually:
+`
+          )
+        );
+        console.log(chalk.dim(`  ${config.install}
+`));
+        process.exit(1);
+      }
+      console.log(
+        chalk.green(`
+\u2705 ${config.displayName} CLI installed successfully.
+`)
+      );
+    } catch (error) {
+      console.log(chalk.red(`
+\u274C Failed to install ${config.cli}:
+`));
+      console.log(chalk.dim(`  ${error.message}
+`));
+      console.log(chalk.yellow("Please install manually:\n"));
+      console.log(chalk.dim(`  ${config.install}
+`));
+      process.exit(1);
+    }
+  }
+}
+async function getPlatformChecks(cwd) {
+  const detection = await detectAllPlatforms(cwd);
+  const platformsWithChecks = detection.detected.filter(
+    (d) => Object.keys(PLATFORM_CLI_INSTALL).includes(d)
+  );
+  if (platformsWithChecks.length === 0) {
+    return [];
+  }
+  let selectedPlatform;
+  if (platformsWithChecks.length === 1) {
+    selectedPlatform = platformsWithChecks[0];
+  } else {
+    const choice = await promptPlatformChoice(detection.detected);
+    if (!Object.keys(PLATFORM_CLI_INSTALL).includes(choice)) {
+      return [];
+    }
+    selectedPlatform = choice;
+  }
+  await ensurePlatformCLI(selectedPlatform);
+  return PLATFORM_CHECKS.filter((check) => check.platform === selectedPlatform);
+}
+var SKIPPABLE_ERROR_PATTERNS = [
+  {
+    pattern: /No files matching the pattern .* were found/i,
+    reason: "No files found matching the lint pattern"
+  },
+  {
+    pattern: /No files matching .* were found/i,
+    reason: "No files found matching the pattern"
+  },
+  {
+    pattern: /No inputs were found in config file/i,
+    reason: "No TypeScript files found"
+  },
+  {
+    pattern: /No files matching the pattern .* are present/i,
+    reason: "No files present matching the pattern"
+  }
+];
+function isSkippableError(output) {
+  for (const { pattern, reason } of SKIPPABLE_ERROR_PATTERNS) {
+    if (pattern.test(output)) {
+      return reason;
+    }
+  }
+  return void 0;
+}
+async function runCheck(check, cwd) {
+  const startTime = Date.now();
+  try {
+    const result = await execa3(check.command, check.args, {
+      cwd,
+      reject: false,
+      all: true
+    });
+    const duration = Date.now() - startTime;
+    if (result.exitCode === 0) {
+      return {
+        check,
+        success: true,
+        output: result.all || "",
+        duration
+      };
+    } else {
+      const combinedOutput = result.all || result.stderr || "";
+      const skipReason = isSkippableError(combinedOutput);
+      if (skipReason) {
+        return {
+          check,
+          success: true,
+          // Treat as success since it's not a real failure
+          output: result.all || "",
+          duration,
+          skipped: true,
+          skipReason
+        };
+      }
+      return {
+        check,
+        success: false,
+        output: result.all || "",
+        error: result.stderr || result.all || "Check failed",
+        duration
+      };
+    }
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const execaError = error;
+    return {
+      check,
+      success: false,
+      output: execaError.all?.toString() || execaError.message || "",
+      error: execaError.message,
+      duration
+    };
+  }
+}
+async function applyFix(check, cwd) {
+  if (!check.canAutoFix || !check.fixCommand) {
+    return { success: false, output: "Check does not support auto-fix" };
+  }
+  try {
+    const result = await execa3(check.fixCommand, check.fixArgs || [], {
+      cwd,
+      reject: false,
+      all: true
+    });
+    if (result.exitCode === 0) {
+      return {
+        success: true,
+        output: result.all || ""
+      };
+    }
+    const combinedOutput = result.all || result.stderr || "";
+    const skipReason = isSkippableError(combinedOutput);
+    if (skipReason) {
+      return {
+        success: true,
+        // Treat as success since it's not a real failure
+        output: result.all || "",
+        skipped: true,
+        skipReason
+      };
+    }
+    return {
+      success: false,
+      output: result.all || ""
+    };
+  } catch (error) {
+    const execaError = error;
+    return {
+      success: false,
+      output: execaError.message
+    };
+  }
+}
+function formatFixCommand(check) {
+  if (!check.fixCommand) return "";
+  return `${check.fixCommand} ${(check.fixArgs || []).join(" ")}`;
+}
+async function runPlatformChecks(cwd, log, autoFix, dryRun) {
+  const results = [];
+  try {
+    const platformChecks = await getPlatformChecks(cwd);
+    if (platformChecks.length === 0) {
+      return results;
+    }
+    log(`
+${"\u2501".repeat(50)}`, "info");
+    log(`\u{1F527} Platform-Specific Checks`, "info");
+    log(`${"\u2501".repeat(50)}
+`, "info");
+    for (let i = 0; i < platformChecks.length; i++) {
+      const check = platformChecks[i];
+      const stepNum = i + 1;
+      const totalSteps = platformChecks.length;
+      log(
+        `\u{1F4CB} Platform ${stepNum}/${totalSteps}: ${check.displayName}...`,
+        "info"
+      );
+      const result = await runCheck(check, cwd);
+      results.push(result);
+      if (result.success) {
+        log(`\u2705 ${check.displayName} passed (${result.duration}ms)`, "success");
+      } else {
+        log(`\u274C ${check.displayName} failed`, "error");
+        if (autoFix && check.canAutoFix && check.fixCommand) {
+          if (dryRun) {
+            log(
+              `\u{1F527} [DRY-RUN] Would run: ${formatFixCommand(check)}`,
+              "warning"
+            );
+            continue;
+          }
+          log(`\u{1F527} Attempting auto-fix for ${check.displayName}...`, "warning");
+          const fixResult = await applyFix(check, cwd);
+          if (fixResult.success) {
+            log(`\u2728 Auto-fix applied for ${check.displayName}`, "success");
+            const reResult = await runCheck(check, cwd);
+            results[results.length - 1] = reResult;
+            if (reResult.success) {
+              log(`\u2705 ${check.displayName} now passes`, "success");
+            } else {
+              log(`\u26A0\uFE0F  ${check.displayName} still failing after fix`, "error");
+            }
+          } else {
+            log(`\u26A0\uFE0F  Auto-fix failed for ${check.displayName}`, "error");
+          }
+        } else if (!check.canAutoFix) {
+          log(`\u26A0\uFE0F  ${check.displayName} requires manual fix`, "error");
+        }
+        if (result.error) {
+          const errorPreview = result.error.slice(0, 500);
+          log(`
+${chalk.dim(errorPreview)}`, "error");
+          if (result.error.length > 500) {
+            log(
+              chalk.dim(`... (${result.error.length - 500} more characters)`),
+              "error"
+            );
+          }
+        }
+      }
+    }
+  } catch (error) {
+    log(`
+\u26A0\uFE0F  Platform check error: ${error.message}`, "warning");
+  }
+  return results;
+}
+async function runAllChecks(cwd, options = {}) {
+  const {
+    maxRetries = 10,
+    autoFix = true,
+    dryRun = false,
+    onProgress,
+    includePlatformChecks = true
+  } = options;
+  const log = (message, type = "info") => {
+    if (onProgress) {
+      onProgress(message, type);
+    } else {
+      switch (type) {
+        case "success":
+          console.log(chalk.green(message));
+          break;
+        case "error":
+          console.log(chalk.red(message));
+          break;
+        case "warning":
+          console.log(chalk.yellow(message));
+          break;
+        default:
+          console.log(message);
+      }
+    }
+  };
+  let attempt = 0;
+  let fixesApplied = 0;
+  const appliedFixes = [];
+  const pendingFixes = [];
+  const applicableChecks = await getApplicableChecks(cwd);
+  const skippedChecks = QUALITY_CHECKS.filter(
+    (qc) => !applicableChecks.some((ac) => ac.name === qc.name)
+  );
+  if (skippedChecks.length > 0) {
+    log(
+      `
+\u23ED\uFE0F  Skipping checks (scripts not found): ${skippedChecks.map((c) => c.displayName).join(", ")}`,
+      "warning"
+    );
+  }
+  if (applicableChecks.length === 0) {
+    log(
+      `
+\u26A0\uFE0F  No applicable checks found. Add scripts to package.json: typecheck, lint, format, test, build`,
+      "warning"
+    );
+    return {
+      success: true,
+      results: [],
+      totalAttempts: 0,
+      fixesApplied: 0,
+      appliedFixes: []
+    };
+  }
+  while (attempt < maxRetries) {
+    attempt++;
+    log(`
+${"\u2501".repeat(50)}`, "info");
+    log(`\u{1F504} Validation Cycle ${attempt}/${maxRetries}`, "info");
+    log(`${"\u2501".repeat(50)}
+`, "info");
+    const results = [];
+    let allPassed = true;
+    let fixAppliedThisCycle = false;
+    for (let i = 0; i < applicableChecks.length; i++) {
+      const check = applicableChecks[i];
+      const stepNum = i + 1;
+      const totalSteps = applicableChecks.length;
+      log(`\u{1F4CB} Step ${stepNum}/${totalSteps}: ${check.displayName}...`, "info");
+      const result = await runCheck(check, cwd);
+      results.push(result);
+      if (result.success) {
+        if (result.skipped) {
+          log(
+            `\u23ED\uFE0F  ${check.displayName} skipped: ${result.skipReason} (${result.duration}ms)`,
+            "warning"
+          );
+        } else {
+          log(
+            `\u2705 ${check.displayName} passed (${result.duration}ms)`,
+            "success"
+          );
+        }
+      } else {
+        allPassed = false;
+        log(`\u274C ${check.displayName} failed`, "error");
+        if (autoFix && check.canAutoFix && check.fixCommand) {
+          if (dryRun) {
+            log(
+              `\u{1F527} [DRY-RUN] Would run: ${formatFixCommand(check)}`,
+              "warning"
+            );
+            pendingFixes.push({ check, command: formatFixCommand(check) });
+            continue;
+          }
+          log(`\u{1F527} Attempting auto-fix for ${check.displayName}...`, "warning");
+          const fixResult = await applyFix(check, cwd);
+          if (fixResult.success) {
+            if (fixResult.skipped) {
+              log(
+                `\u23ED\uFE0F  ${check.displayName} skipped: ${fixResult.skipReason}`,
+                "warning"
+              );
+              results[results.length - 1] = {
+                ...results[results.length - 1],
+                success: true,
+                skipped: true,
+                skipReason: fixResult.skipReason
+              };
+              allPassed = true;
+              continue;
+            }
+            log(`\u2728 Auto-fix applied for ${check.displayName}`, "success");
+            fixesApplied++;
+            appliedFixes.push({
+              checkName: check.name,
+              displayName: check.displayName,
+              command: formatFixCommand(check),
+              timestamp: /* @__PURE__ */ new Date()
+            });
+            fixAppliedThisCycle = true;
+            log(
+              `
+\u{1F504} Fix applied - restarting all checks to verify...`,
+              "warning"
+            );
+            break;
+          } else {
+            log(`\u26A0\uFE0F  Auto-fix failed for ${check.displayName}`, "error");
+            log(`   Manual intervention required`, "error");
+            if (result.error) {
+              const errorPreview = result.error.slice(0, 500);
+              log(`
+${chalk.dim(errorPreview)}`, "error");
+              if (result.error.length > 500) {
+                log(
+                  chalk.dim(
+                    `... (${result.error.length - 500} more characters)`
+                  ),
+                  "error"
+                );
+              }
+            }
+            return {
+              success: false,
+              results,
+              totalAttempts: attempt,
+              fixesApplied,
+              appliedFixes
+            };
+          }
+        } else {
+          if (check.canAutoFix) {
+            log(
+              `\u26A0\uFE0F  ${check.displayName} can be fixed with: ${formatFixCommand(check)}`,
+              "warning"
+            );
+          } else {
+            log(`\u26A0\uFE0F  ${check.displayName} requires manual fix`, "error");
+          }
+          if (result.error) {
+            const errorPreview = result.error.slice(0, 500);
+            log(`
+${chalk.dim(errorPreview)}`, "error");
+            if (result.error.length > 500) {
+              log(
+                chalk.dim(`... (${result.error.length - 500} more characters)`),
+                "error"
+              );
+            }
+          }
+          if (!dryRun) {
+            return {
+              success: false,
+              results,
+              totalAttempts: attempt,
+              fixesApplied,
+              appliedFixes
+            };
+          }
+        }
+      }
+    }
+    if (dryRun && pendingFixes.length > 0) {
+      log(`
+${"\u2501".repeat(50)}`, "info");
+      log(`\u{1F4CB} DRY-RUN SUMMARY`, "info");
+      log(`${"\u2501".repeat(50)}`, "info");
+      log(`
+The following fixes would be applied:`, "warning");
+      for (const fix of pendingFixes) {
+        log(`  \u2022 ${fix.check.displayName}: ${fix.command}`, "info");
+      }
+      log(`
+Run without --dry-run to apply fixes.`, "info");
+      return {
+        success: false,
+        results,
+        totalAttempts: attempt,
+        fixesApplied: 0,
+        appliedFixes: [],
+        pendingFixes
+      };
+    }
+    if (allPassed) {
+      if (includePlatformChecks) {
+        const platformCheckResults = await runPlatformChecks(
+          cwd,
+          log,
+          autoFix,
+          dryRun
+        );
+        if (platformCheckResults.length > 0) {
+          const platformFailed = platformCheckResults.some((r) => !r.success);
+          if (platformFailed) {
+            return {
+              success: false,
+              results: [...results, ...platformCheckResults],
+              totalAttempts: attempt,
+              fixesApplied,
+              appliedFixes
+            };
+          }
+          results.push(...platformCheckResults);
+        }
+      }
+      return {
+        success: true,
+        results,
+        totalAttempts: attempt,
+        fixesApplied,
+        appliedFixes
+      };
+    }
+    if (!fixAppliedThisCycle) {
+      return {
+        success: false,
+        results,
+        totalAttempts: attempt,
+        fixesApplied,
+        appliedFixes
+      };
+    }
+  }
+  log(`
+\u274C Maximum retries (${maxRetries}) exceeded`, "error");
+  return {
+    success: false,
+    results: [],
+    totalAttempts: attempt,
+    fixesApplied,
+    appliedFixes
+  };
+}
+async function hasUncommittedChanges(cwd) {
+  try {
+    const result = await execa3("git", ["status", "--porcelain"], { cwd });
+    return result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function stageAllChanges(cwd) {
+  try {
+    await execa3("git", ["add", "-A"], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export {
   detectPackageManager,
   isMonorepo,
   analyzeProject,
+  detectAllPlatforms,
   generateAuditReport,
   formatAuditReport,
-  runAllSetups
+  runAllSetups,
+  QUALITY_CHECKS,
+  PLATFORM_CLI_INSTALL,
+  PLATFORM_CHECKS,
+  getAvailableScripts,
+  getApplicableChecks,
+  ensureComposer,
+  promptPlatformChoice,
+  ensurePlatformCLI,
+  getPlatformChecks,
+  SKIPPABLE_ERROR_PATTERNS,
+  isSkippableError,
+  runCheck,
+  applyFix,
+  runAllChecks,
+  hasUncommittedChanges,
+  stageAllChanges
 };
-//# sourceMappingURL=chunk-XGS2VFBP.js.map
+//# sourceMappingURL=chunk-MBRMT5ZG.js.map