viberails 0.6.3 → 0.6.5

package/dist/chunk-XQKOK3FU.js

@@ -0,0 +1,821 @@
+#!/usr/bin/env node
+
+// src/utils/get-root-package.ts
+function getRootPackage(packages) {
+  return packages.find((pkg) => pkg.path === ".") ?? packages[0];
+}
+
+// src/utils/prompt-constants.ts
+var SENTINEL_DONE = "__done__";
+var SENTINEL_CLEAR = "__clear__";
+var SENTINEL_CUSTOM = "__custom__";
+var SENTINEL_NONE = "__none__";
+var SENTINEL_INHERIT = "__inherit__";
+var SENTINEL_SKIP = "__skip__";
+
+// src/utils/prompt-submenus.ts
+import * as clack6 from "@clack/prompts";
+
+// src/utils/prompt.ts
+import * as clack5 from "@clack/prompts";
+
+// src/utils/prompt-integrations.ts
+import * as clack from "@clack/prompts";
+
+// src/utils/spawn-async.ts
+import { spawn } from "child_process";
+function spawnAsync(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, { cwd, shell: true, stdio: "pipe" });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (status) => {
+      resolve({ status, stdout, stderr });
+    });
+    child.on("error", () => {
+      resolve({ status: 1, stdout, stderr });
+    });
+  });
+}
+
+// src/utils/prompt-integrations.ts
+async function promptHookManagerInstall(projectRoot, packageManager, isWorkspace) {
+  const choice = await clack.select({
+    message: "No shared git hook manager detected. Install Lefthook?",
+    options: [
+      {
+        value: "install",
+        label: "Yes, install Lefthook",
+        hint: "recommended \u2014 hooks are committed to the repo and shared with your team"
+      },
+      {
+        value: "skip",
+        label: "No, skip",
+        hint: "pre-commit hooks will be local-only (.git/hooks) and not shared"
+      }
+    ]
+  });
+  assertNotCancelled(choice);
+  if (choice !== "install") return void 0;
+  const pm = packageManager || "npm";
+  const installCmd = pm === "yarn" ? "yarn add -D lefthook" : pm === "pnpm" ? `pnpm add -D${isWorkspace ? " -w" : ""} lefthook` : "npm install -D lefthook";
+  const s = clack.spinner();
+  s.start("Installing Lefthook...");
+  const result = await spawnAsync(installCmd, projectRoot);
+  if (result.status === 0) {
+    const fs = await import("fs");
+    const path = await import("path");
+    const lefthookPath = path.join(projectRoot, "lefthook.yml");
+    if (!fs.existsSync(lefthookPath)) {
+      fs.writeFileSync(lefthookPath, "# Managed by viberails \u2014 https://viberails.sh\n");
+    }
+    s.stop("Installed Lefthook");
+    return "Lefthook";
+  }
+  s.stop("Failed to install Lefthook");
+  clack.log.warn(`Install manually: ${installCmd}`);
+  return void 0;
+}
+async function promptIntegrations(projectRoot, hookManager, tools) {
+  let resolvedHookManager = hookManager;
+  if (!resolvedHookManager) {
+    resolvedHookManager = await promptHookManagerInstall(
+      projectRoot,
+      tools?.packageManager ?? "npm",
+      tools?.isWorkspace
+    );
+  }
+  const isBareHook = !resolvedHookManager;
+  const hookLabel = resolvedHookManager ? `Pre-commit hook (${resolvedHookManager})` : "Pre-commit hook (git hook \u2014 local only)";
+  const hookHint = isBareHook ? "local only \u2014 will NOT be committed or shared with collaborators" : "runs viberails checks when you commit";
+  const options = [
+    {
+      value: "preCommit",
+      label: hookLabel,
+      hint: hookHint
+    }
+  ];
+  if (tools?.isTypeScript) {
+    options.push({
+      value: "typecheck",
+      label: "Typecheck (tsc --noEmit)",
+      hint: "pre-commit hook + CI check"
+    });
+  }
+  if (tools?.linter) {
+    const linterName = tools.linter === "biome" ? "Biome" : "ESLint";
+    options.push({
+      value: "lint",
+      label: `Lint check (${linterName})`,
+      hint: "pre-commit hook + CI check"
+    });
+  }
+  options.push(
+    {
+      value: "claude",
+      label: "Claude Code hook",
+      hint: "checks files when Claude edits them"
+    },
+    {
+      value: "claudeMd",
+      label: "CLAUDE.md reference",
+      hint: "appends @.viberails/context.md so Claude loads rules automatically"
+    },
+    {
+      value: "githubAction",
+      label: "GitHub Actions workflow",
+      hint: "blocks PRs that fail viberails check"
+    }
+  );
+  const initialValues = isBareHook ? options.filter((o) => o.value !== "preCommit").map((o) => o.value) : options.map((o) => o.value);
+  const result = await clack.multiselect({
+    message: "Optional integrations",
+    options,
+    initialValues,
+    required: false
+  });
+  assertNotCancelled(result);
+  return {
+    preCommitHook: result.includes("preCommit"),
+    claudeCodeHook: result.includes("claude"),
+    claudeMdRef: result.includes("claudeMd"),
+    githubAction: result.includes("githubAction"),
+    typecheckHook: result.includes("typecheck"),
+    lintHook: result.includes("lint")
+  };
+}
+
+// src/utils/prompt-rules.ts
+import * as clack4 from "@clack/prompts";
+
+// src/utils/prompt-menu-handlers.ts
+import * as clack3 from "@clack/prompts";
+
+// src/utils/prompt-package-overrides.ts
+import * as clack2 from "@clack/prompts";
+function normalizePackageOverrides(packages) {
+  for (const pkg of packages) {
+    if (pkg.rules && Object.keys(pkg.rules).length === 0) {
+      delete pkg.rules;
+    }
+    if (pkg.coverage && Object.keys(pkg.coverage).length === 0) {
+      delete pkg.coverage;
+    }
+    if (pkg.conventions && Object.keys(pkg.conventions).length === 0) {
+      delete pkg.conventions;
+    }
+  }
+  return packages;
+}
+function packageOverrideHint(pkg, defaults) {
+  const tags = [];
+  if (pkg.conventions?.fileNaming && pkg.conventions.fileNaming !== defaults.fileNamingValue) {
+    tags.push(pkg.conventions.fileNaming);
+  }
+  if (pkg.rules?.maxFileLines !== void 0 && pkg.rules.maxFileLines !== defaults.maxFileLines && pkg.rules.maxFileLines > 0) {
+    tags.push(`${pkg.rules.maxFileLines} lines`);
+  }
+  const coverage = pkg.rules?.testCoverage ?? defaults.testCoverage;
+  const isExempt = coverage === 0;
+  const nameSegments = pkg.name.replace(/^@[^/]+\//, "").split(/[-/]/);
+  const isTypesOnly = isExempt && nameSegments.some((s) => s === "types");
+  if (isExempt) {
+    tags.push(isTypesOnly ? "exempt (types-only)" : "exempt");
+  } else if (pkg.rules?.testCoverage !== void 0 && pkg.rules.testCoverage !== defaults.testCoverage) {
+    tags.push(`${coverage}%`);
+  }
+  const hasSummaryOverride = pkg.coverage?.summaryPath !== void 0 && pkg.coverage.summaryPath !== defaults.coverageSummaryPath;
+  const defaultCommand = defaults.coverageCommand ?? "";
+  const hasCommandOverride = pkg.coverage?.command !== void 0 && pkg.coverage.command !== defaultCommand;
+  if (hasSummaryOverride) tags.push("summary override");
+  if (hasCommandOverride) tags.push("command override");
+  return tags.length > 0 ? tags.join(", ") : "(no overrides)";
+}
+async function promptPackageOverrides(packages, defaults) {
+  const editablePackages = packages.filter((pkg) => pkg.path !== ".");
+  if (editablePackages.length === 0) return packages;
+  while (true) {
+    const selectedPath = await clack2.select({
+      message: "Select package to edit overrides",
+      options: [
+        ...editablePackages.map((pkg) => ({
+          value: pkg.path,
+          label: `${pkg.path} (${pkg.name})`,
+          hint: packageOverrideHint(pkg, defaults)
+        })),
+        { value: SENTINEL_DONE, label: "Done" }
+      ]
+    });
+    assertNotCancelled(selectedPath);
+    if (selectedPath === SENTINEL_DONE) break;
+    const target = editablePackages.find((pkg) => pkg.path === selectedPath);
+    if (!target) continue;
+    await promptSinglePackageOverrides(target, defaults);
+    normalizePackageOverrides(editablePackages);
+  }
+  return normalizePackageOverrides(packages);
+}
+async function promptSinglePackageOverrides(target, defaults) {
+  while (true) {
+    const effectiveNaming = target.conventions?.fileNaming ?? defaults.fileNamingValue;
+    const effectiveMaxLines = target.rules?.maxFileLines ?? defaults.maxFileLines;
+    const effectiveCoverage = target.rules?.testCoverage ?? defaults.testCoverage;
+    const effectiveSummary = target.coverage?.summaryPath ?? defaults.coverageSummaryPath;
+    const effectiveCommand = target.coverage?.command ?? defaults.coverageCommand ?? "(auto-detect)";
+    const hasNamingOverride = target.conventions?.fileNaming !== void 0 && target.conventions.fileNaming !== defaults.fileNamingValue;
+    const hasMaxLinesOverride = target.rules?.maxFileLines !== void 0 && target.rules.maxFileLines !== defaults.maxFileLines;
+    const namingHint = hasNamingOverride ? String(effectiveNaming) : `(inherits: ${effectiveNaming ?? "not set"})`;
+    const maxLinesHint = hasMaxLinesOverride ? String(effectiveMaxLines) : `(inherits: ${effectiveMaxLines})`;
+    const choice = await clack2.select({
+      message: `Edit overrides for ${target.path}`,
+      options: [
+        { value: "fileNaming", label: "File naming", hint: namingHint },
+        { value: "maxFileLines", label: "Max file lines", hint: maxLinesHint },
+        { value: "testCoverage", label: "Test coverage", hint: String(effectiveCoverage) },
+        { value: "summaryPath", label: "Coverage summary path", hint: effectiveSummary },
+        { value: "command", label: "Coverage command", hint: effectiveCommand },
+        { value: "reset", label: "Reset all overrides for this package" },
+        { value: "back", label: "Back to package list" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "back") break;
+    if (choice === "fileNaming") {
+      const selected = await clack2.select({
+        message: `File naming for ${target.path}`,
+        options: [
+          ...FILE_NAMING_OPTIONS,
+          { value: SENTINEL_NONE, label: "(none \u2014 exempt from checks)" },
+          {
+            value: SENTINEL_INHERIT,
+            label: `Inherit default${defaults.fileNamingValue ? ` (${defaults.fileNamingValue})` : ""}`
+          }
+        ],
+        initialValue: target.conventions?.fileNaming ?? SENTINEL_INHERIT
+      });
+      assertNotCancelled(selected);
+      if (selected === SENTINEL_INHERIT) {
+        if (target.conventions) delete target.conventions.fileNaming;
+      } else if (selected === SENTINEL_NONE) {
+        target.conventions = { ...target.conventions ?? {}, fileNaming: "" };
+      } else {
+        target.conventions = { ...target.conventions ?? {}, fileNaming: selected };
+      }
+    }
+    if (choice === "maxFileLines") {
+      const result = await clack2.text({
+        message: `Max file lines for ${target.path} (blank to inherit default)?`,
+        initialValue: target.rules?.maxFileLines !== void 0 ? String(target.rules.maxFileLines) : "",
+        placeholder: String(defaults.maxFileLines)
+      });
+      assertNotCancelled(result);
+      const value = result.trim();
+      if (value.length === 0 || Number.parseInt(value, 10) === defaults.maxFileLines) {
+        if (target.rules) delete target.rules.maxFileLines;
+      } else {
+        target.rules = { ...target.rules ?? {}, maxFileLines: Number.parseInt(value, 10) };
+      }
+    }
+    if (choice === "testCoverage") {
+      const result = await clack2.text({
+        message: "Package testCoverage (0 to exempt package)?",
+        initialValue: String(effectiveCoverage),
+        validate: (v) => {
+          if (typeof v !== "string") return "Enter a number between 0 and 100";
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
+        }
+      });
+      assertNotCancelled(result);
+      const nextCoverage = Number.parseInt(result, 10);
+      if (nextCoverage === defaults.testCoverage) {
+        if (target.rules) delete target.rules.testCoverage;
+      } else {
+        target.rules = { ...target.rules ?? {}, testCoverage: nextCoverage };
+      }
+    }
+    if (choice === "summaryPath") {
+      const result = await clack2.text({
+        message: "Path to coverage summary file (blank to inherit default)?",
+        initialValue: target.coverage?.summaryPath !== void 0 ? target.coverage.summaryPath : "",
+        placeholder: defaults.coverageSummaryPath
+      });
+      assertNotCancelled(result);
+      const value = result.trim();
+      if (value.length === 0 || value === defaults.coverageSummaryPath) {
+        if (target.coverage) delete target.coverage.summaryPath;
+      } else {
+        target.coverage = { ...target.coverage ?? {}, summaryPath: value };
+      }
+    }
+    if (choice === "command") {
+      const result = await clack2.text({
+        message: "Coverage command (blank to auto-detect)?",
+        initialValue: target.coverage?.command !== void 0 ? target.coverage.command : "",
+        placeholder: defaults.coverageCommand ?? "(auto-detect from package.json test runner)"
+      });
+      assertNotCancelled(result);
+      const value = result.trim();
+      const defaultCommand = defaults.coverageCommand ?? "";
+      if (value.length === 0 || value === defaultCommand) {
+        if (target.coverage) delete target.coverage.command;
+      } else {
+        target.coverage = { ...target.coverage ?? {}, command: value };
+      }
+    }
+    if (choice === "reset") {
+      if (target.rules) {
+        delete target.rules.testCoverage;
+        delete target.rules.maxFileLines;
+      }
+      delete target.coverage;
+      delete target.conventions;
+    }
+  }
+}
+
+// src/utils/prompt-menu-handlers.ts
+function getPackageDiffs(pkg, root) {
+  const diffs = [];
+  const convKeys = ["fileNaming", "componentNaming", "hookNaming", "importAlias"];
+  for (const key of convKeys) {
+    if (pkg.conventions?.[key] && pkg.conventions[key] !== root.conventions?.[key]) {
+      diffs.push(`${key}: ${pkg.conventions[key]}`);
+    }
+  }
+  const stackKeys = [
+    "framework",
+    "language",
+    "styling",
+    "backend",
+    "orm",
+    "linter",
+    "formatter",
+    "testRunner",
+    "packageManager"
+  ];
+  for (const key of stackKeys) {
+    if (pkg.stack?.[key] && pkg.stack[key] !== root.stack?.[key]) {
+      diffs.push(`${key}: ${pkg.stack[key]}`);
+    }
+  }
+  if (pkg.rules?.maxFileLines !== void 0 && pkg.rules.maxFileLines !== root.rules?.maxFileLines && pkg.rules.maxFileLines > 0) {
+    diffs.push(`maxFileLines: ${pkg.rules.maxFileLines}`);
+  }
+  if (pkg.rules?.testCoverage !== void 0 && pkg.rules.testCoverage !== root.rules?.testCoverage && pkg.rules.testCoverage >= 0) {
+    diffs.push(`testCoverage: ${pkg.rules.testCoverage}`);
+  }
+  if (pkg.coverage?.summaryPath && pkg.coverage.summaryPath !== root.coverage?.summaryPath) {
+    diffs.push(`coverage.summaryPath: ${pkg.coverage.summaryPath}`);
+  }
+  if (pkg.coverage?.command && pkg.coverage.command !== root.coverage?.command) {
+    diffs.push("coverage.command: (override)");
+  }
+  return diffs;
+}
+function buildMenuOptions(state, packageCount) {
+  const fileLimitsHint = state.maxTestFileLines > 0 ? `max ${state.maxFileLines} lines, tests ${state.maxTestFileLines}` : `max ${state.maxFileLines} lines, test files unlimited`;
+  const namingHint = state.enforceNaming ? `${state.fileNamingValue ?? "not set"} (enforced)` : "not enforced";
+  const testingHint = state.testCoverage > 0 ? `${state.testCoverage}% coverage, missing tests ${state.enforceMissingTests ? "enforced" : "not enforced"}` : `coverage disabled, missing tests ${state.enforceMissingTests ? "enforced" : "not enforced"}`;
+  const options = [
+    { value: "fileLimits", label: "File limits", hint: fileLimitsHint },
+    { value: "naming", label: "Naming & conventions", hint: namingHint },
+    { value: "testing", label: "Testing & coverage", hint: testingHint }
+  ];
+  if (packageCount > 0) {
+    options.push({
+      value: "packageOverrides",
+      label: "Per-package overrides",
+      hint: `${packageCount} package${packageCount > 1 ? "s" : ""} configurable`
+    });
+  }
+  options.push(
+    { value: "reset", label: "Reset all to detected defaults" },
+    { value: "done", label: "Done" }
+  );
+  return options;
+}
+function clonePackages(packages) {
+  return packages ? structuredClone(packages) : void 0;
+}
+async function handleMenuChoice(choice, state, defaults, root) {
+  if (choice === "reset") {
+    state.maxFileLines = defaults.maxFileLines;
+    state.maxTestFileLines = defaults.maxTestFileLines;
+    state.testCoverage = defaults.testCoverage;
+    state.enforceMissingTests = defaults.enforceMissingTests;
+    state.enforceNaming = defaults.enforceNaming;
+    state.fileNamingValue = defaults.fileNamingValue;
+    state.componentNaming = defaults.componentNaming;
+    state.hookNaming = defaults.hookNaming;
+    state.importAlias = defaults.importAlias;
+    state.coverageSummaryPath = defaults.coverageSummaryPath;
+    state.coverageCommand = defaults.coverageCommand;
+    state.packageOverrides = clonePackages(defaults.packageOverrides);
+    clack3.log.info("Reset all rules to detected defaults.");
+    return;
+  }
+  if (choice === "fileLimits") {
+    await promptFileLimitsMenu(state);
+    return;
+  }
+  if (choice === "naming") {
+    await promptNamingMenu(state);
+    return;
+  }
+  if (choice === "testing") {
+    await promptTestingMenu(state);
+    return;
+  }
+  if (choice === "packageOverrides") {
+    if (state.packageOverrides) {
+      const packageDiffs = root ? state.packageOverrides.filter((pkg) => pkg.path !== root.path).map((pkg) => ({ pkg, diffs: getPackageDiffs(pkg, root) })).filter((entry) => entry.diffs.length > 0) : [];
+      state.packageOverrides = await promptPackageOverrides(state.packageOverrides, {
+        fileNamingValue: state.fileNamingValue,
+        maxFileLines: state.maxFileLines,
+        testCoverage: state.testCoverage,
+        coverageSummaryPath: state.coverageSummaryPath,
+        coverageCommand: state.coverageCommand
+      });
+      const lines = packageDiffs.map((entry) => `${entry.pkg.path}
+  ${entry.diffs.join(", ")}`);
+      if (lines.length > 0) {
+        clack3.note(lines.join("\n\n"), "Existing package differences");
+      }
+    }
+    return;
+  }
+}
+
+// src/utils/prompt-rules.ts
+async function promptRuleMenu(defaults) {
+  const state = {
+    ...defaults,
+    packageOverrides: clonePackages(defaults.packageOverrides)
+  };
+  const root = state.packageOverrides && state.packageOverrides.length > 0 ? getRootPackage(state.packageOverrides) : void 0;
+  const packageCount = state.packageOverrides?.filter((pkg) => pkg.path !== ".").length ?? 0;
+  while (true) {
+    const options = buildMenuOptions(state, packageCount);
+    const choice = await clack4.select({ message: "Customize rules", options });
+    assertNotCancelled(choice);
+    if (choice === "done") break;
+    await handleMenuChoice(choice, state, defaults, root);
+  }
+  return {
+    maxFileLines: state.maxFileLines,
+    maxTestFileLines: state.maxTestFileLines,
+    testCoverage: state.testCoverage,
+    enforceMissingTests: state.enforceMissingTests,
+    enforceNaming: state.enforceNaming,
+    fileNamingValue: state.fileNamingValue,
+    componentNaming: state.componentNaming,
+    hookNaming: state.hookNaming,
+    importAlias: state.importAlias,
+    coverageSummaryPath: state.coverageSummaryPath,
+    coverageCommand: state.coverageCommand,
+    packageOverrides: state.packageOverrides
+  };
+}
+
+// src/utils/prompt.ts
+function assertNotCancelled(value) {
+  if (clack5.isCancel(value)) {
+    clack5.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+}
+async function confirm2(message) {
+  const result = await clack5.confirm({ message, initialValue: true });
+  assertNotCancelled(result);
+  return result;
+}
+async function confirmDangerous(message) {
+  const result = await clack5.confirm({ message, initialValue: false });
+  assertNotCancelled(result);
+  return result;
+}
+async function promptExistingConfigAction(configFile) {
+  const result = await clack5.select({
+    message: `${configFile} already exists. What do you want to do?`,
+    options: [
+      {
+        value: "edit",
+        label: "Edit existing config",
+        hint: "open the current rules and save updates in place"
+      },
+      {
+        value: "replace",
+        label: "Replace with a fresh scan",
+        hint: "re-scan the project and overwrite the current config"
+      },
+      {
+        value: "cancel",
+        label: "Cancel",
+        hint: "leave the current setup unchanged"
+      }
+    ]
+  });
+  assertNotCancelled(result);
+  return result;
+}
+async function promptInitDecision() {
+  const result = await clack5.select({
+    message: "How do you want to proceed?",
+    options: [
+      {
+        value: "accept",
+        label: "Accept defaults",
+        hint: "writes the config with these defaults; use --enforce in CI to block"
+      },
+      {
+        value: "customize",
+        label: "Customize rules",
+        hint: "edit limits, naming, test coverage, and package overrides"
+      },
+      {
+        value: "review",
+        label: "Review detected details",
+        hint: "show the full scan report with package and structure details"
+      }
+    ]
+  });
+  assertNotCancelled(result);
+  return result;
+}
+
+// src/utils/prompt-submenus.ts
+var FILE_NAMING_OPTIONS = [
+  { value: "kebab-case", label: "kebab-case" },
+  { value: "camelCase", label: "camelCase" },
+  { value: "PascalCase", label: "PascalCase" },
+  { value: "snake_case", label: "snake_case" }
+];
+var COMPONENT_NAMING_OPTIONS = [
+  { value: "PascalCase", label: "PascalCase", hint: "MyComponent.tsx" },
+  { value: "camelCase", label: "camelCase", hint: "myComponent.tsx" }
+];
+var HOOK_NAMING_OPTIONS = [
+  { value: "useXxx", label: "useXxx", hint: "useAuth, useFormData" },
+  { value: "use-*", label: "use-*", hint: "use-auth, use-form-data" }
+];
+async function promptFileLimitsMenu(state) {
+  while (true) {
+    const choice = await clack6.select({
+      message: "File limits",
+      options: [
+        { value: "maxFileLines", label: "Max file lines", hint: String(state.maxFileLines) },
+        {
+          value: "maxTestFileLines",
+          label: "Max test file lines",
+          hint: state.maxTestFileLines > 0 ? String(state.maxTestFileLines) : "0 (unlimited)"
+        },
+        { value: "back", label: "Back" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "back") return;
+    if (choice === "maxFileLines") {
+      const result = await clack6.text({
+        message: "Maximum lines per source file?",
+        initialValue: String(state.maxFileLines),
+        validate: (v) => {
+          if (typeof v !== "string") return "Enter a positive number";
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 1) return "Enter a positive number";
+        }
+      });
+      assertNotCancelled(result);
+      state.maxFileLines = Number.parseInt(result, 10);
+    }
+    if (choice === "maxTestFileLines") {
+      const result = await clack6.text({
+        message: "Maximum lines per test file (0 to disable)?",
+        initialValue: String(state.maxTestFileLines),
+        validate: (v) => {
+          if (typeof v !== "string") return "Enter a number (0 or positive)";
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 0) return "Enter a number (0 or positive)";
+        }
+      });
+      assertNotCancelled(result);
+      state.maxTestFileLines = Number.parseInt(result, 10);
+    }
+  }
+}
+async function promptNamingMenu(state) {
+  while (true) {
+    const options = [
+      {
+        value: "enforceNaming",
+        label: "Enforce file naming",
+        hint: state.enforceNaming ? "yes" : "no"
+      }
+    ];
+    if (state.enforceNaming) {
+      options.push({
+        value: "fileNaming",
+        label: "File naming convention",
+        hint: state.fileNamingValue ?? "(not set)"
+      });
+    }
+    options.push(
+      {
+        value: "componentNaming",
+        label: "Component naming",
+        hint: state.componentNaming ?? "(not set)"
+      },
+      {
+        value: "hookNaming",
+        label: "Hook naming",
+        hint: state.hookNaming ?? "(not set)"
+      },
+      {
+        value: "importAlias",
+        label: "Import alias",
+        hint: state.importAlias ?? "(not set)"
+      },
+      { value: "back", label: "Back" }
+    );
+    const choice = await clack6.select({ message: "Naming & conventions", options });
+    assertNotCancelled(choice);
+    if (choice === "back") return;
+    if (choice === "enforceNaming") {
+      const result = await clack6.confirm({
+        message: state.fileNamingValue ? `Enforce file naming? (detected: ${state.fileNamingValue})` : "Enforce file naming?",
+        initialValue: state.enforceNaming
+      });
+      assertNotCancelled(result);
+      if (result && !state.fileNamingValue) {
+        const selected = await clack6.select({
+          message: "Which file naming convention should be enforced?",
+          options: [...FILE_NAMING_OPTIONS]
+        });
+        assertNotCancelled(selected);
+        state.fileNamingValue = selected;
+      }
+      state.enforceNaming = result;
+    }
+    if (choice === "fileNaming") {
+      const selected = await clack6.select({
+        message: "Which file naming convention should be enforced?",
+        options: [...FILE_NAMING_OPTIONS],
+        initialValue: state.fileNamingValue
+      });
+      assertNotCancelled(selected);
+      state.fileNamingValue = selected;
+    }
+    if (choice === "componentNaming") {
+      const selected = await clack6.select({
+        message: "Component naming convention",
+        options: [
+          ...COMPONENT_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: state.componentNaming ?? SENTINEL_CLEAR
+      });
+      assertNotCancelled(selected);
+      state.componentNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "hookNaming") {
+      const selected = await clack6.select({
+        message: "Hook naming convention",
+        options: [
+          ...HOOK_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: state.hookNaming ?? SENTINEL_CLEAR
+      });
+      assertNotCancelled(selected);
+      state.hookNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "importAlias") {
+      const selected = await clack6.select({
+        message: "Import alias pattern",
+        options: [
+          { value: "@/*", label: "@/*", hint: "import { x } from '@/utils'" },
+          { value: "~/*", label: "~/*", hint: "import { x } from '~/utils'" },
+          { value: SENTINEL_CUSTOM, label: "Custom..." },
+          { value: SENTINEL_CLEAR, label: "Clear (no alias)" }
+        ],
+        initialValue: state.importAlias ?? SENTINEL_CLEAR
+      });
+      assertNotCancelled(selected);
+      if (selected === SENTINEL_CLEAR) {
+        state.importAlias = void 0;
+      } else if (selected === SENTINEL_CUSTOM) {
+        const result = await clack6.text({
+          message: "Custom import alias (e.g. #/*)?",
+          initialValue: state.importAlias ?? "",
+          placeholder: "e.g. #/*",
+          validate: (v) => {
+            if (typeof v !== "string" || !v.trim()) return "Alias cannot be empty";
+            if (!/^[a-zA-Z@~#$][a-zA-Z0-9@~#$_-]*\/\*$/.test(v.trim()))
+              return "Must match pattern like @/*, ~/*, or #src/*";
+          }
+        });
+        assertNotCancelled(result);
+        state.importAlias = result.trim();
+      } else {
+        state.importAlias = selected;
+      }
+    }
+  }
+}
+async function promptTestingMenu(state) {
+  while (true) {
+    const options = [
+      {
+        value: "enforceMissingTests",
+        label: "Enforce missing tests",
+        hint: state.enforceMissingTests ? "yes" : "no"
+      },
+      {
+        value: "testCoverage",
+        label: "Test coverage target",
+        hint: state.testCoverage === 0 ? "0 (disabled)" : `${state.testCoverage}%`
+      }
+    ];
+    if (state.testCoverage > 0) {
+      options.push(
+        {
+          value: "coverageSummaryPath",
+          label: "Coverage summary path",
+          hint: state.coverageSummaryPath
+        },
+        {
+          value: "coverageCommand",
+          label: "Coverage command",
+          hint: state.coverageCommand ?? "auto-detect from package.json test runner"
+        }
+      );
+    }
+    options.push({ value: "back", label: "Back" });
+    const choice = await clack6.select({ message: "Testing & coverage", options });
+    assertNotCancelled(choice);
+    if (choice === "back") return;
+    if (choice === "enforceMissingTests") {
+      const result = await clack6.confirm({
+        message: "Require every source file to have a corresponding test file?",
+        initialValue: state.enforceMissingTests
+      });
+      assertNotCancelled(result);
+      state.enforceMissingTests = result;
+    }
+    if (choice === "testCoverage") {
+      const result = await clack6.text({
+        message: "Test coverage target (0 disables coverage checks)?",
+        initialValue: String(state.testCoverage),
+        validate: (v) => {
+          if (typeof v !== "string") return "Enter a number between 0 and 100";
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 0 || n > 100) return "Enter a number between 0 and 100";
+        }
+      });
+      assertNotCancelled(result);
+      state.testCoverage = Number.parseInt(result, 10);
+    }
+    if (choice === "coverageSummaryPath") {
+      const result = await clack6.text({
+        message: "Coverage summary path (relative to package root)?",
+        initialValue: state.coverageSummaryPath,
+        validate: (v) => {
+          if (typeof v !== "string" || v.trim().length === 0) return "Path cannot be empty";
+        }
+      });
+      assertNotCancelled(result);
+      state.coverageSummaryPath = result.trim();
+    }
+    if (choice === "coverageCommand") {
+      const result = await clack6.text({
+        message: "Coverage command (blank to auto-detect from package.json)?",
+        initialValue: state.coverageCommand ?? "",
+        placeholder: "(auto-detect from package.json test runner)"
+      });
+      assertNotCancelled(result);
+      const trimmed = result.trim();
+      state.coverageCommand = trimmed.length > 0 ? trimmed : void 0;
+    }
+  }
+}
+
+export {
+  spawnAsync,
+  promptIntegrations,
+  getRootPackage,
+  SENTINEL_SKIP,
+  FILE_NAMING_OPTIONS,
+  promptRuleMenu,
+  assertNotCancelled,
+  confirm2 as confirm,
+  confirmDangerous,
+  promptExistingConfigAction,
+  promptInitDecision
+};
+//# sourceMappingURL=chunk-XQKOK3FU.js.map