workflow-agent-cli 2.2.2 → 2.3.0

package/dist/chunk-YI3LBZ7I.js

@@ -0,0 +1,1425 @@
+// src/utils/check-runner.ts
+import { execa } from "execa";
+import chalk from "chalk";
+var QUALITY_CHECKS = [
+  {
+    name: "typecheck",
+    displayName: "Type Check",
+    command: "pnpm",
+    args: ["typecheck"],
+    canAutoFix: false
+    // TypeScript errors need manual/LLM fix
+  },
+  {
+    name: "lint",
+    displayName: "Lint",
+    command: "pnpm",
+    args: ["lint"],
+    fixCommand: "pnpm",
+    fixArgs: ["lint", "--fix"],
+    canAutoFix: true
+  },
+  {
+    name: "format",
+    displayName: "Format",
+    command: "pnpm",
+    args: ["format", "--check"],
+    fixCommand: "pnpm",
+    fixArgs: ["format"],
+    canAutoFix: true
+  },
+  {
+    name: "test",
+    displayName: "Tests",
+    command: "pnpm",
+    args: ["test"],
+    canAutoFix: false
+    // Tests need manual/LLM fix
+  },
+  {
+    name: "build",
+    displayName: "Build",
+    command: "pnpm",
+    args: ["build"],
+    canAutoFix: false
+    // Build errors need manual/LLM fix
+  }
+];
+async function runCheck(check, cwd) {
+  const startTime = Date.now();
+  try {
+    const result = await execa(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 {
+      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 execa(check.fixCommand, check.fixArgs || [], {
+      cwd,
+      reject: false,
+      all: true
+    });
+    return {
+      success: result.exitCode === 0,
+      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 runAllChecks(cwd, options = {}) {
+  const {
+    maxRetries = 10,
+    autoFix = true,
+    dryRun = false,
+    onProgress
+  } = 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 pendingFixes = [];
+  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 < QUALITY_CHECKS.length; i++) {
+      const check = QUALITY_CHECKS[i];
+      const stepNum = i + 1;
+      const totalSteps = QUALITY_CHECKS.length;
+      log(`\u{1F4CB} Step ${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 {
+        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) {
+            log(`\u2728 Auto-fix applied for ${check.displayName}`, "success");
+            fixesApplied++;
+            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
+            };
+          }
+        } 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
+            };
+          }
+        }
+      }
+    }
+    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,
+        pendingFixes
+      };
+    }
+    if (allPassed) {
+      return {
+        success: true,
+        results,
+        totalAttempts: attempt,
+        fixesApplied
+      };
+    }
+    if (!fixAppliedThisCycle) {
+      return {
+        success: false,
+        results,
+        totalAttempts: attempt,
+        fixesApplied
+      };
+    }
+  }
+  log(`
+\u274C Maximum retries (${maxRetries}) exceeded`, "error");
+  return {
+    success: false,
+    results: [],
+    totalAttempts: attempt,
+    fixesApplied
+  };
+}
+async function hasUncommittedChanges(cwd) {
+  try {
+    const result = await execa("git", ["status", "--porcelain"], { cwd });
+    return result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function stageAllChanges(cwd) {
+  try {
+    await execa("git", ["add", "-A"], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/auto-setup.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { join as join2 } from "path";
+import { execa as execa3 } from "execa";
+
+// src/utils/git-repo.ts
+import { execa as execa2 } from "execa";
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+async function detectPackageManager(projectPath = process.cwd()) {
+  if (existsSync(join(projectPath, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(projectPath, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync(join(projectPath, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync(join(projectPath, "package-lock.json"))) {
+    return "npm";
+  }
+  try {
+    const pkgPath = join(projectPath, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      if (pkg.packageManager) {
+        if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
+        if (pkg.packageManager.startsWith("yarn")) return "yarn";
+        if (pkg.packageManager.startsWith("bun")) return "bun";
+      }
+    }
+  } catch {
+  }
+  return "npm";
+}
+async function isMonorepo(projectPath = process.cwd()) {
+  if (existsSync(join(projectPath, "pnpm-workspace.yaml"))) {
+    return true;
+  }
+  try {
+    const pkgPath = join(projectPath, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  if (existsSync(join(projectPath, "lerna.json"))) {
+    return true;
+  }
+  if (existsSync(join(projectPath, "nx.json"))) {
+    return true;
+  }
+  if (existsSync(join(projectPath, "turbo.json"))) {
+    return true;
+  }
+  return false;
+}
+async function getPackageScripts(projectPath = process.cwd()) {
+  try {
+    const pkgPath = join(projectPath, "package.json");
+    if (!existsSync(pkgPath)) {
+      return {};
+    }
+    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    return pkg.scripts || {};
+  } catch {
+    return {};
+  }
+}
+
+// src/utils/auto-setup.ts
+async function analyzeProject(projectPath = process.cwd()) {
+  const packageManager = await detectPackageManager(projectPath);
+  const mono = await isMonorepo(projectPath);
+  const scripts = await getPackageScripts(projectPath);
+  const isTypeScript = existsSync2(join2(projectPath, "tsconfig.json")) || existsSync2(join2(projectPath, "src/index.ts")) || existsSync2(join2(projectPath, "index.ts"));
+  const framework = await detectFramework(projectPath);
+  const existing = {
+    typescript: existsSync2(join2(projectPath, "tsconfig.json")),
+    eslint: existsSync2(join2(projectPath, "eslint.config.js")) || existsSync2(join2(projectPath, "eslint.config.mjs")) || existsSync2(join2(projectPath, ".eslintrc.js")) || existsSync2(join2(projectPath, ".eslintrc.json")) || existsSync2(join2(projectPath, ".eslintrc")),
+    eslintFlat: existsSync2(join2(projectPath, "eslint.config.js")) || existsSync2(join2(projectPath, "eslint.config.mjs")),
+    prettier: existsSync2(join2(projectPath, ".prettierrc")) || existsSync2(join2(projectPath, ".prettierrc.json")) || existsSync2(join2(projectPath, "prettier.config.js")) || existsSync2(join2(projectPath, "prettier.config.mjs")),
+    vitest: existsSync2(join2(projectPath, "vitest.config.ts")) || existsSync2(join2(projectPath, "vitest.config.js")),
+    jest: existsSync2(join2(projectPath, "jest.config.js")) || existsSync2(join2(projectPath, "jest.config.ts")),
+    husky: existsSync2(join2(projectPath, ".husky")),
+    simpleGitHooks: existsSync2(join2(projectPath, ".git/hooks/pre-commit")) || await hasSimpleGitHooksConfig(projectPath),
+    githubActions: existsSync2(join2(projectPath, ".github/workflows"))
+  };
+  const existingScripts = {
+    build: !!scripts.build,
+    test: !!scripts.test,
+    lint: !!scripts.lint,
+    format: !!scripts.format,
+    typecheck: !!scripts.typecheck,
+    verify: !!scripts.verify
+  };
+  const setupPlans = await generateSetupPlans(
+    projectPath,
+    packageManager,
+    isTypeScript,
+    framework,
+    existing,
+    existingScripts,
+    mono
+  );
+  return {
+    packageManager,
+    isMonorepo: mono,
+    isTypeScript,
+    framework,
+    existing,
+    scripts: existingScripts,
+    setupPlans
+  };
+}
+async function hasSimpleGitHooksConfig(projectPath) {
+  try {
+    const pkgPath = join2(projectPath, "package.json");
+    if (!existsSync2(pkgPath)) return false;
+    const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+    return !!pkg["simple-git-hooks"];
+  } catch {
+    return false;
+  }
+}
+async function detectFramework(projectPath) {
+  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";
+    }
+    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";
+  } catch {
+    return "unknown";
+  }
+}
+async function generateSetupPlans(projectPath, packageManager, isTypeScript, framework, existing, scripts, isMonorepo2) {
+  const plans = [];
+  if (isTypeScript) {
+    plans.push(
+      await planTypeScriptSetup(
+        projectPath,
+        framework,
+        existing.typescript,
+        isMonorepo2
+      )
+    );
+  }
+  plans.push(
+    await planESLintSetup(projectPath, isTypeScript, framework, existing)
+  );
+  plans.push(await planPrettierSetup(projectPath, existing.prettier));
+  plans.push(
+    await planTestingSetup(projectPath, isTypeScript, framework, existing)
+  );
+  if (isTypeScript && !["nextjs", "remix", "nuxt"].includes(framework)) {
+    plans.push(await planBuildSetup(projectPath, scripts.build));
+  }
+  plans.push(
+    await planScriptsSetup(projectPath, isTypeScript, framework, scripts)
+  );
+  plans.push(await planHooksSetup(projectPath, existing));
+  plans.push(
+    await planCISetup(
+      projectPath,
+      packageManager,
+      isTypeScript,
+      framework,
+      existing.githubActions,
+      isMonorepo2
+    )
+  );
+  return plans;
+}
+async function planTypeScriptSetup(projectPath, _framework, hasExisting, isMonorepo2) {
+  const changes = [];
+  const devDeps = [];
+  const pkg = await readPackageJson(projectPath);
+  const deps = pkg.dependencies || {};
+  const devDepsPkg = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDepsPkg };
+  if (!allDeps.typescript) {
+    devDeps.push("typescript");
+  }
+  if (hasExisting) {
+    const tsconfig = await readTSConfig(join2(projectPath, "tsconfig.json"));
+    const opts = tsconfig.compilerOptions || {};
+    if (!opts.strict) {
+      changes.push({
+        type: "modify",
+        file: "tsconfig.json",
+        key: "compilerOptions.strict",
+        oldValue: opts.strict,
+        newValue: true,
+        description: "Enable strict type checking"
+      });
+    }
+    if (!opts.skipLibCheck) {
+      changes.push({
+        type: "modify",
+        file: "tsconfig.json",
+        key: "compilerOptions.skipLibCheck",
+        oldValue: opts.skipLibCheck,
+        newValue: true,
+        description: "Skip type checking of declaration files for faster builds"
+      });
+    }
+    if (opts.target !== "ES2022" && opts.target !== "ESNext") {
+      changes.push({
+        type: "modify",
+        file: "tsconfig.json",
+        key: "compilerOptions.target",
+        oldValue: opts.target,
+        newValue: "ES2022",
+        description: "Use modern JavaScript target"
+      });
+    }
+  } else {
+    changes.push({
+      type: "add",
+      file: isMonorepo2 ? "tsconfig.base.json" : "tsconfig.json",
+      description: `Create TypeScript configuration${isMonorepo2 ? " (shared base for monorepo)" : ""}`
+    });
+  }
+  return {
+    name: "typescript",
+    description: hasExisting ? "Improve TypeScript configuration" : "Set up TypeScript configuration",
+    priority: "high",
+    changes,
+    dependencies: [],
+    devDependencies: devDeps
+  };
+}
+async function planESLintSetup(projectPath, isTypeScript, framework, existing) {
+  const changes = [];
+  const devDeps = [];
+  const pkg = await readPackageJson(projectPath);
+  const deps = pkg.dependencies || {};
+  const devDepsPkg = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDepsPkg };
+  if (!allDeps.eslint) {
+    devDeps.push("eslint");
+  }
+  if (isTypeScript) {
+    if (!allDeps["@typescript-eslint/eslint-plugin"]) {
+      devDeps.push("@typescript-eslint/eslint-plugin");
+    }
+    if (!allDeps["@typescript-eslint/parser"]) {
+      devDeps.push("@typescript-eslint/parser");
+    }
+    if (!allDeps["typescript-eslint"]) {
+      devDeps.push("typescript-eslint");
+    }
+  }
+  if (framework === "react" || framework === "nextjs") {
+    if (!allDeps["eslint-plugin-react"]) devDeps.push("eslint-plugin-react");
+    if (!allDeps["eslint-plugin-react-hooks"])
+      devDeps.push("eslint-plugin-react-hooks");
+  }
+  if (existing.eslint) {
+    if (!existing.eslintFlat) {
+      changes.push({
+        type: "modify",
+        file: "eslint.config.mjs",
+        description: "Migrate to ESLint 9 flat config format (recommended)"
+      });
+    } else {
+      changes.push({
+        type: "unchanged",
+        file: "eslint.config.mjs",
+        description: "ESLint flat config already exists"
+      });
+    }
+  } else {
+    changes.push({
+      type: "add",
+      file: "eslint.config.mjs",
+      description: "Create ESLint configuration with TypeScript support"
+    });
+  }
+  return {
+    name: "eslint",
+    description: existing.eslint ? "Audit ESLint configuration and dependencies" : "Set up ESLint for code linting",
+    priority: "high",
+    changes,
+    dependencies: [],
+    devDependencies: devDeps
+  };
+}
+async function planPrettierSetup(projectPath, hasExisting) {
+  const changes = [];
+  const devDeps = [];
+  const pkg = await readPackageJson(projectPath);
+  const deps = pkg.dependencies || {};
+  const devDepsPkg = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDepsPkg };
+  if (!allDeps.prettier) {
+    devDeps.push("prettier");
+  }
+  if (hasExisting) {
+    const prettierConfig = await readPrettierConfig(projectPath);
+    if (prettierConfig.printWidth === void 0) {
+      changes.push({
+        type: "modify",
+        file: ".prettierrc",
+        key: "printWidth",
+        newValue: 100,
+        description: "Add printWidth setting"
+      });
+    }
+    if (prettierConfig.trailingComma === void 0) {
+      changes.push({
+        type: "modify",
+        file: ".prettierrc",
+        key: "trailingComma",
+        newValue: "es5",
+        description: "Add trailing comma setting"
+      });
+    }
+    if (changes.length === 0) {
+      changes.push({
+        type: "unchanged",
+        file: ".prettierrc",
+        description: "Prettier configuration is complete"
+      });
+    }
+  } else {
+    changes.push({
+      type: "add",
+      file: ".prettierrc",
+      description: "Create Prettier configuration"
+    });
+    changes.push({
+      type: "add",
+      file: ".prettierignore",
+      description: "Create Prettier ignore file"
+    });
+  }
+  return {
+    name: "prettier",
+    description: hasExisting ? "Audit Prettier configuration" : "Set up Prettier for code formatting",
+    priority: "high",
+    changes,
+    dependencies: [],
+    devDependencies: devDeps
+  };
+}
+async function planTestingSetup(projectPath, isTypeScript, framework, existing) {
+  const changes = [];
+  const devDeps = [];
+  const pkg = await readPackageJson(projectPath);
+  const deps = pkg.dependencies || {};
+  const devDepsPkg = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDepsPkg };
+  if (existing.jest) {
+    changes.push({
+      type: "unchanged",
+      file: "jest.config.*",
+      description: "Jest configuration exists (preserving existing setup)"
+    });
+    return {
+      name: "testing",
+      description: "Jest testing already configured",
+      priority: "high",
+      changes,
+      dependencies: [],
+      devDependencies: []
+    };
+  }
+  if (!allDeps.vitest) {
+    devDeps.push("vitest");
+  }
+  if (!allDeps["@vitest/coverage-v8"]) {
+    devDeps.push("@vitest/coverage-v8");
+  }
+  if (["react", "nextjs", "vue", "nuxt", "svelte"].includes(framework)) {
+    if (!allDeps.jsdom) devDeps.push("jsdom");
+    if (framework === "react" || framework === "nextjs") {
+      if (!allDeps["@testing-library/react"])
+        devDeps.push("@testing-library/react");
+    }
+  }
+  if (existing.vitest) {
+    changes.push({
+      type: "unchanged",
+      file: `vitest.config.${isTypeScript ? "ts" : "js"}`,
+      description: "Vitest configuration already exists"
+    });
+  } else {
+    changes.push({
+      type: "add",
+      file: `vitest.config.${isTypeScript ? "ts" : "js"}`,
+      description: "Create Vitest configuration"
+    });
+  }
+  return {
+    name: "testing",
+    description: existing.vitest ? "Audit Vitest dependencies" : "Set up Vitest for testing",
+    priority: "high",
+    changes,
+    dependencies: [],
+    devDependencies: devDeps
+  };
+}
+async function planBuildSetup(projectPath, hasBuildScript) {
+  const changes = [];
+  const devDeps = [];
+  const pkg = await readPackageJson(projectPath);
+  const deps = pkg.dependencies || {};
+  const devDepsPkg = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDepsPkg };
+  if (hasBuildScript) {
+    changes.push({
+      type: "unchanged",
+      file: "package.json",
+      key: "scripts.build",
+      description: "Build script already configured"
+    });
+  } else {
+    if (!allDeps.tsup) {
+      devDeps.push("tsup");
+    }
+    changes.push({
+      type: "add",
+      file: "tsup.config.ts",
+      description: "Create tsup build configuration"
+    });
+  }
+  return {
+    name: "build",
+    description: hasBuildScript ? "Build configuration exists" : "Set up tsup for TypeScript builds",
+    priority: "medium",
+    changes,
+    dependencies: [],
+    devDependencies: devDeps
+  };
+}
+async function planScriptsSetup(_projectPath, isTypeScript, _framework, scripts) {
+  const changes = [];
+  const scriptsToAdd = {};
+  if (!scripts.lint) {
+    scriptsToAdd.lint = "eslint src";
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "scripts.lint",
+      newValue: "eslint src",
+      description: "Add lint script"
+    });
+  }
+  if (!scripts.format) {
+    scriptsToAdd.format = 'prettier --write "src/**/*.{ts,tsx,js,jsx,json}"';
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "scripts.format",
+      newValue: scriptsToAdd.format,
+      description: "Add format script"
+    });
+  }
+  if (isTypeScript && !scripts.typecheck) {
+    scriptsToAdd.typecheck = "tsc --noEmit";
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "scripts.typecheck",
+      newValue: "tsc --noEmit",
+      description: "Add typecheck script"
+    });
+  }
+  if (!scripts.test) {
+    scriptsToAdd.test = "vitest run";
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "scripts.test",
+      newValue: "vitest run",
+      description: "Add test script"
+    });
+  }
+  if (!scripts.verify) {
+    scriptsToAdd.verify = "workflow-agent verify";
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "scripts.verify",
+      newValue: "workflow-agent verify",
+      description: "Add verify script"
+    });
+  }
+  if (Object.keys(scriptsToAdd).length === 0) {
+    changes.push({
+      type: "unchanged",
+      file: "package.json",
+      description: "All standard scripts already configured"
+    });
+  }
+  return {
+    name: "scripts",
+    description: "Configure npm scripts",
+    priority: "medium",
+    changes,
+    dependencies: [],
+    devDependencies: []
+  };
+}
+async function planHooksSetup(projectPath, existing) {
+  const changes = [];
+  const devDeps = [];
+  const pkg = await readPackageJson(projectPath);
+  const deps = pkg.dependencies || {};
+  const devDepsPkg = pkg.devDependencies || {};
+  const allDeps = { ...deps, ...devDepsPkg };
+  if (!allDeps["simple-git-hooks"]) {
+    devDeps.push("simple-git-hooks");
+  }
+  if (!allDeps["lint-staged"]) {
+    devDeps.push("lint-staged");
+  }
+  if (existing.husky || existing.simpleGitHooks) {
+    changes.push({
+      type: "modify",
+      file: "package.json",
+      key: "simple-git-hooks",
+      description: "Ensure pre-commit hook configuration"
+    });
+  } else {
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "simple-git-hooks",
+      newValue: { "pre-commit": "npx lint-staged" },
+      description: "Add pre-commit hook configuration"
+    });
+    changes.push({
+      type: "add",
+      file: "package.json",
+      key: "lint-staged",
+      description: "Add lint-staged configuration"
+    });
+  }
+  return {
+    name: "hooks",
+    description: existing.husky || existing.simpleGitHooks ? "Audit pre-commit hooks" : "Set up pre-commit hooks",
+    priority: "medium",
+    changes,
+    dependencies: [],
+    devDependencies: devDeps
+  };
+}
+async function planCISetup(projectPath, _packageManager, _isTypeScript, _framework, hasExisting, _isMonorepo) {
+  const changes = [];
+  if (hasExisting) {
+    if (existsSync2(join2(projectPath, ".github/workflows/ci.yml"))) {
+      changes.push({
+        type: "unchanged",
+        file: ".github/workflows/ci.yml",
+        description: "CI workflow already exists"
+      });
+    } else {
+      changes.push({
+        type: "add",
+        file: ".github/workflows/ci.yml",
+        description: "Add CI workflow (other workflows exist)"
+      });
+    }
+  } else {
+    changes.push({
+      type: "add",
+      file: ".github/workflows/ci.yml",
+      description: "Create GitHub Actions CI workflow"
+    });
+  }
+  return {
+    name: "ci",
+    description: hasExisting ? "Audit CI configuration" : "Set up GitHub Actions CI",
+    priority: "low",
+    changes,
+    dependencies: [],
+    devDependencies: []
+  };
+}
+async function generateAuditReport(projectPath = process.cwd()) {
+  const analysis = await analyzeProject(projectPath);
+  const allDeps = /* @__PURE__ */ new Set();
+  const allDevDeps = /* @__PURE__ */ new Set();
+  for (const plan of analysis.setupPlans) {
+    plan.dependencies.forEach((d) => allDeps.add(d));
+    plan.devDependencies.forEach((d) => allDevDeps.add(d));
+  }
+  const totalChanges = analysis.setupPlans.reduce(
+    (sum, plan) => sum + plan.changes.filter((c) => c.type !== "unchanged").length,
+    0
+  );
+  return {
+    analysis,
+    totalChanges,
+    allDependencies: Array.from(allDeps),
+    allDevDependencies: Array.from(allDevDeps),
+    plans: analysis.setupPlans
+  };
+}
+function formatAuditReport(report) {
+  const lines = [];
+  lines.push("\u{1F4CB} Auto-Setup Audit Report\n");
+  lines.push(`Framework: ${report.analysis.framework}`);
+  lines.push(`Package Manager: ${report.analysis.packageManager}`);
+  lines.push(`TypeScript: ${report.analysis.isTypeScript ? "Yes" : "No"}`);
+  lines.push(`Monorepo: ${report.analysis.isMonorepo ? "Yes" : "No"}
+`);
+  for (const plan of report.plans) {
+    const hasChanges = plan.changes.some((c) => c.type !== "unchanged");
+    const icon = hasChanges ? "\u{1F527}" : "\u2713";
+    lines.push(
+      `${icon} ${plan.name.charAt(0).toUpperCase() + plan.name.slice(1)}`
+    );
+    for (const change of plan.changes) {
+      const symbol = change.type === "add" ? "+" : change.type === "modify" ? "~" : "=";
+      let line = `  ${symbol} ${change.description}`;
+      if (change.key && change.oldValue !== void 0 && change.newValue !== void 0) {
+        line += ` (${String(change.oldValue)} \u2192 ${String(change.newValue)})`;
+      }
+      lines.push(line);
+    }
+    if (plan.devDependencies.length > 0) {
+      lines.push(`  \u{1F4E6} Install: ${plan.devDependencies.join(", ")}`);
+    }
+    lines.push("");
+  }
+  if (report.allDevDependencies.length > 0) {
+    lines.push("Dependencies to install (batched):");
+    const pm = report.analysis.packageManager;
+    const cmd = pm === "npm" ? "npm install" : pm === "yarn" ? "yarn add" : `${pm} add`;
+    lines.push(`  ${cmd} -D ${report.allDevDependencies.join(" ")}`);
+    lines.push("");
+  }
+  lines.push(`Total changes: ${report.totalChanges}`);
+  return lines.join("\n");
+}
+async function runAllSetups(projectPath = process.cwd(), onProgress) {
+  const report = await generateAuditReport(projectPath);
+  const results = [];
+  const filesCreated = [];
+  const filesUpdated = [];
+  if (report.allDevDependencies.length > 0) {
+    onProgress?.("Installing dependencies", "start");
+    try {
+      await installDependencies(
+        projectPath,
+        report.analysis.packageManager,
+        report.allDevDependencies
+      );
+      onProgress?.("Installing dependencies", "done");
+    } catch (error) {
+      onProgress?.("Installing dependencies", "error");
+      results.push({
+        success: false,
+        name: "dependencies",
+        message: `Failed to install: ${error instanceof Error ? error.message : String(error)}`,
+        filesCreated: [],
+        filesUpdated: [],
+        packagesInstalled: []
+      });
+      return results;
+    }
+  }
+  for (const plan of report.plans) {
+    const hasChanges = plan.changes.some((c) => c.type !== "unchanged");
+    if (!hasChanges && plan.devDependencies.length === 0) continue;
+    onProgress?.(`Setting up ${plan.name}`, "start");
+    try {
+      const result = await applySetupPlan(projectPath, plan, report.analysis);
+      results.push(result);
+      filesCreated.push(...result.filesCreated);
+      filesUpdated.push(...result.filesUpdated);
+      onProgress?.(`Setting up ${plan.name}`, "done");
+    } catch (error) {
+      onProgress?.(`Setting up ${plan.name}`, "error");
+      results.push({
+        success: false,
+        name: plan.name,
+        message: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+        filesCreated: [],
+        filesUpdated: [],
+        packagesInstalled: []
+      });
+    }
+  }
+  onProgress?.("Initializing git hooks", "start");
+  try {
+    await execa3("npx", ["simple-git-hooks"], {
+      cwd: projectPath,
+      stdio: "pipe"
+    });
+    onProgress?.("Initializing git hooks", "done");
+  } catch {
+    onProgress?.("Initializing git hooks", "error");
+  }
+  return results;
+}
+async function installDependencies(projectPath, packageManager, packages) {
+  if (packages.length === 0) return;
+  const commands = {
+    npm: { cmd: "npm", args: ["install", "--save-dev"] },
+    pnpm: { cmd: "pnpm", args: ["add", "-D"] },
+    yarn: { cmd: "yarn", args: ["add", "-D"] },
+    bun: { cmd: "bun", args: ["add", "-D"] }
+  };
+  const { cmd, args } = commands[packageManager];
+  await execa3(cmd, [...args, ...packages], {
+    cwd: projectPath,
+    stdio: "pipe"
+  });
+}
+async function applySetupPlan(projectPath, plan, analysis) {
+  const filesCreated = [];
+  const filesUpdated = [];
+  switch (plan.name) {
+    case "typescript":
+      await applyTypeScriptSetup(
+        projectPath,
+        analysis,
+        filesCreated,
+        filesUpdated
+      );
+      break;
+    case "eslint":
+      await applyESLintSetup(projectPath, analysis, filesCreated, filesUpdated);
+      break;
+    case "prettier":
+      await applyPrettierSetup(projectPath, filesCreated, filesUpdated);
+      break;
+    case "testing":
+      await applyTestingSetup(
+        projectPath,
+        analysis,
+        filesCreated,
+        filesUpdated
+      );
+      break;
+    case "build":
+      await applyBuildSetup(projectPath, filesCreated, filesUpdated);
+      break;
+    case "scripts":
+      await applyScriptsSetup(projectPath, analysis, filesUpdated);
+      break;
+    case "hooks":
+      await applyHooksSetup(projectPath, filesUpdated);
+      break;
+    case "ci":
+      await applyCISetup(projectPath, analysis, filesCreated, filesUpdated);
+      break;
+  }
+  return {
+    success: true,
+    name: plan.name,
+    message: `${plan.name} configured successfully`,
+    filesCreated,
+    filesUpdated,
+    packagesInstalled: plan.devDependencies
+  };
+}
+async function applyTypeScriptSetup(projectPath, analysis, filesCreated, filesUpdated) {
+  const configName = analysis.isMonorepo ? "tsconfig.base.json" : "tsconfig.json";
+  const configPath = join2(projectPath, configName);
+  let tsconfig = {};
+  if (existsSync2(configPath)) {
+    tsconfig = await readJsonFile(configPath);
+    filesUpdated.push(configName);
+  } else {
+    filesCreated.push(configName);
+  }
+  if (!tsconfig.compilerOptions) {
+    tsconfig.compilerOptions = {};
+  }
+  const opts = tsconfig.compilerOptions;
+  const improvements = {
+    target: opts.target || "ES2022",
+    module: opts.module || "ESNext",
+    moduleResolution: opts.moduleResolution || "bundler",
+    esModuleInterop: opts.esModuleInterop ?? true,
+    strict: opts.strict ?? true,
+    skipLibCheck: opts.skipLibCheck ?? true,
+    resolveJsonModule: opts.resolveJsonModule ?? true,
+    isolatedModules: opts.isolatedModules ?? true,
+    declaration: opts.declaration ?? true,
+    declarationMap: opts.declarationMap ?? true,
+    sourceMap: opts.sourceMap ?? true
+  };
+  const frameworkOpts = getFrameworkTsOptions(analysis.framework);
+  tsconfig.compilerOptions = { ...opts, ...improvements, ...frameworkOpts };
+  if (!tsconfig.include) {
+    tsconfig.include = ["src/**/*"];
+  }
+  if (!tsconfig.exclude) {
+    tsconfig.exclude = ["node_modules", "dist", "coverage"];
+  }
+  await writeFile(configPath, JSON.stringify(tsconfig, null, 2) + "\n");
+}
+function getFrameworkTsOptions(framework) {
+  switch (framework) {
+    case "nextjs":
+      return {
+        lib: ["dom", "dom.iterable", "esnext"],
+        jsx: "preserve",
+        incremental: true,
+        plugins: [{ name: "next" }]
+      };
+    case "react":
+    case "remix":
+      return {
+        lib: ["dom", "dom.iterable", "esnext"],
+        jsx: "react-jsx"
+      };
+    case "vue":
+    case "nuxt":
+      return {
+        lib: ["esnext", "dom"],
+        jsx: "preserve"
+      };
+    default:
+      return {};
+  }
+}
+async function applyESLintSetup(projectPath, analysis, filesCreated, _filesUpdated) {
+  if (analysis.existing.eslintFlat) {
+    return;
+  }
+  const configPath = join2(projectPath, "eslint.config.mjs");
+  const config = generateESLintFlatConfig(
+    analysis.isTypeScript,
+    analysis.framework
+  );
+  await writeFile(configPath, config);
+  filesCreated.push("eslint.config.mjs");
+}
+function generateESLintFlatConfig(isTypeScript, framework) {
+  const imports = [];
+  const configs = [];
+  if (isTypeScript) {
+    imports.push(`import tseslint from "typescript-eslint";`);
+  }
+  if (framework === "react" || framework === "nextjs") {
+    imports.push(`import react from "eslint-plugin-react";`);
+    imports.push(`import reactHooks from "eslint-plugin-react-hooks";`);
+  }
+  if (isTypeScript) {
+    configs.push(`  ...tseslint.configs.recommended`);
+  }
+  configs.push(`  {
+    files: ["**/*.${isTypeScript ? "{ts,tsx}" : "{js,jsx}"}"],
+    rules: {
+      ${isTypeScript ? `"@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],` : ""}
+      "no-console": "warn",
+    },
+  }`);
+  configs.push(`  {
+    ignores: ["dist/", "node_modules/", "coverage/", ".next/", "build/"],
+  }`);
+  return `${imports.join("\n")}
+
+export default [
+${configs.join(",\n")}
+];
+`;
+}
+async function applyPrettierSetup(projectPath, filesCreated, filesUpdated) {
+  const prettierPath = join2(projectPath, ".prettierrc");
+  let config = {
+    semi: true,
+    singleQuote: false,
+    tabWidth: 2,
+    trailingComma: "es5",
+    printWidth: 100,
+    bracketSpacing: true
+  };
+  if (existsSync2(prettierPath)) {
+    const existing = await readPrettierConfig(projectPath);
+    config = { ...config, ...existing };
+    filesUpdated.push(".prettierrc");
+  } else {
+    filesCreated.push(".prettierrc");
+  }
+  await writeFile(prettierPath, JSON.stringify(config, null, 2) + "\n");
+  const ignorePath = join2(projectPath, ".prettierignore");
+  if (!existsSync2(ignorePath)) {
+    const ignoreContent = `dist/
+node_modules/
+coverage/
+.next/
+build/
+*.min.js
+pnpm-lock.yaml
+package-lock.json
+yarn.lock
+`;
+    await writeFile(ignorePath, ignoreContent);
+    filesCreated.push(".prettierignore");
+  }
+}
+async function applyTestingSetup(projectPath, analysis, filesCreated, _filesUpdated) {
+  if (analysis.existing.jest || analysis.existing.vitest) {
+    return;
+  }
+  const ext = analysis.isTypeScript ? "ts" : "js";
+  const configPath = join2(projectPath, `vitest.config.${ext}`);
+  const environment = ["react", "nextjs", "vue", "nuxt", "svelte"].includes(
+    analysis.framework
+  ) ? "jsdom" : "node";
+  const config = `import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "${environment}",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "dist/", "**/*.test.${ext}"],
+    },
+    include: ["src/**/*.test.${ext}", "tests/**/*.test.${ext}"],
+  },
+});
+`;
+  await writeFile(configPath, config);
+  filesCreated.push(`vitest.config.${ext}`);
+}
+async function applyBuildSetup(projectPath, filesCreated, _filesUpdated) {
+  const configPath = join2(projectPath, "tsup.config.ts");
+  if (existsSync2(configPath)) {
+    return;
+  }
+  const config = `import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm"],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});
+`;
+  await writeFile(configPath, config);
+  filesCreated.push("tsup.config.ts");
+}
+async function applyScriptsSetup(projectPath, analysis, filesUpdated) {
+  const pkgPath = join2(projectPath, "package.json");
+  const pkg = await readPackageJson(projectPath);
+  const scripts = pkg.scripts || {};
+  const scriptsToAdd = {
+    lint: "eslint src",
+    "lint:fix": "eslint src --fix",
+    format: 'prettier --write "src/**/*.{ts,tsx,js,jsx,json}"',
+    "format:check": 'prettier --check "src/**/*.{ts,tsx,js,jsx,json}"',
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    verify: "workflow-agent verify",
+    "verify:fix": "workflow-agent verify --fix",
+    "pre-commit": "workflow-agent verify --fix"
+  };
+  if (analysis.isTypeScript) {
+    scriptsToAdd.typecheck = "tsc --noEmit";
+  }
+  let added = false;
+  for (const [name, cmd] of Object.entries(scriptsToAdd)) {
+    if (!scripts[name]) {
+      scripts[name] = cmd;
+      added = true;
+    }
+  }
+  if (added) {
+    pkg.scripts = scripts;
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+    filesUpdated.push("package.json");
+  }
+}
+async function applyHooksSetup(projectPath, filesUpdated) {
+  const pkgPath = join2(projectPath, "package.json");
+  const pkg = await readPackageJson(projectPath);
+  if (!pkg["simple-git-hooks"]) {
+    pkg["simple-git-hooks"] = {
+      "pre-commit": "npx lint-staged"
+    };
+  }
+  if (!pkg["lint-staged"]) {
+    pkg["lint-staged"] = {
+      "*.{ts,tsx,js,jsx}": ["eslint --fix", "prettier --write"],
+      "*.{json,md,yml,yaml}": ["prettier --write"]
+    };
+  }
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  filesUpdated.push("package.json");
+}
+async function applyCISetup(projectPath, analysis, filesCreated, _filesUpdated) {
+  const workflowsDir = join2(projectPath, ".github/workflows");
+  await mkdir(workflowsDir, { recursive: true });
+  const ciPath = join2(workflowsDir, "ci.yml");
+  if (existsSync2(ciPath)) {
+    return;
+  }
+  const workflow = generateCIWorkflow(
+    analysis.packageManager,
+    analysis.isTypeScript,
+    analysis.framework,
+    analysis.isMonorepo
+  );
+  await writeFile(ciPath, workflow);
+  filesCreated.push(".github/workflows/ci.yml");
+}
+function generateCIWorkflow(packageManager, isTypeScript, framework, _isMonorepo) {
+  const runCmd = packageManager === "npm" ? "npm run" : packageManager === "yarn" ? "yarn" : packageManager;
+  const isPnpm = packageManager === "pnpm";
+  return `name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+${isPnpm ? `
+      - name: Install pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+` : ""}
+      - name: Install dependencies
+        run: ${packageManager} install
+
+${isTypeScript ? `      - name: Type check
+        run: ${runCmd} typecheck
+
+` : ""}      - name: Lint
+        run: ${runCmd} lint
+
+      - name: Format check
+        run: ${runCmd} format:check || true
+
+      - name: Test
+        run: ${runCmd} test
+${isTypeScript && !["nextjs", "remix", "nuxt"].includes(framework) ? `
+      - name: Build
+        run: ${runCmd} build
+` : ""}`;
+}
+async function readPackageJson(projectPath) {
+  const pkgPath = join2(projectPath, "package.json");
+  if (!existsSync2(pkgPath)) {
+    return {};
+  }
+  return JSON.parse(await readFile2(pkgPath, "utf-8"));
+}
+async function readTSConfig(filePath) {
+  if (!existsSync2(filePath)) {
+    return {};
+  }
+  return JSON.parse(await readFile2(filePath, "utf-8"));
+}
+async function readJsonFile(filePath) {
+  if (!existsSync2(filePath)) {
+    return {};
+  }
+  return JSON.parse(await readFile2(filePath, "utf-8"));
+}
+async function readPrettierConfig(projectPath) {
+  const files = [".prettierrc", ".prettierrc.json", "prettier.config.js"];
+  for (const file of files) {
+    const filePath = join2(projectPath, file);
+    if (existsSync2(filePath)) {
+      if (file.endsWith(".js")) {
+        return {};
+      }
+      try {
+        return JSON.parse(await readFile2(filePath, "utf-8"));
+      } catch {
+        return {};
+      }
+    }
+  }
+  return {};
+}
+
+export {
+  QUALITY_CHECKS,
+  runCheck,
+  applyFix,
+  runAllChecks,
+  hasUncommittedChanges,
+  stageAllChanges,
+  analyzeProject,
+  generateAuditReport,
+  formatAuditReport,
+  runAllSetups
+};
+//# sourceMappingURL=chunk-YI3LBZ7I.js.map