viberails 0.6.10 → 0.6.12

package/dist/index.cjs

@@ -34,7 +34,7 @@ __export(index_exports, {
   VERSION: () => VERSION
 });
 module.exports = __toCommonJS(index_exports);
-var import_chalk18 = __toESM(require("chalk"), 1);
+var import_chalk20 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
 
 // src/commands/boundaries.ts
@@ -99,8 +99,8 @@ var FILE_NAMING_OPTIONS = [
   { value: "snake_case", label: "snake_case" }
 ];
 var COMPONENT_NAMING_OPTIONS = [
-  { value: "PascalCase", label: "PascalCase", hint: "MyComponent.tsx" },
-  { value: "camelCase", label: "camelCase", hint: "myComponent.tsx" }
+  { value: "PascalCase", label: "PascalCase", hint: "e.g. MyComponent, UserProfile" },
+  { value: "camelCase", label: "camelCase", hint: "e.g. myComponent, userProfile" }
 ];
 var HOOK_NAMING_OPTIONS = [
   { value: "useXxx", label: "useXxx", hint: "useAuth, useFormData" },
@@ -162,12 +162,12 @@ async function promptNamingMenu(state) {
       },
       {
         value: "componentNaming",
-        label: `${state.componentNaming ? ok : unset} Component naming`,
+        label: `${state.componentNaming ? ok : unset} Component exports`,
         hint: state.componentNaming ?? HINT_NOT_SET
       },
       {
         value: "hookNaming",
-        label: `${state.hookNaming ? ok : unset} Hook naming`,
+        label: `${state.hookNaming ? ok : unset} Hook exports`,
         hint: state.hookNaming ?? HINT_NOT_SET
       },
       {
@@ -204,7 +204,7 @@ async function promptNamingMenu(state) {
     }
     if (choice === "componentNaming") {
       const selected = await clack.select({
-        message: "Component naming convention",
+        message: "Component export naming (e.g. UserProfile)",
         options: [
           ...COMPONENT_NAMING_OPTIONS,
           { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
@@ -216,7 +216,7 @@ async function promptNamingMenu(state) {
     }
     if (choice === "hookNaming") {
       const selected = await clack.select({
-        message: "Hook naming convention",
+        message: "Hook export naming (e.g. useAuth)",
         options: [
           ...HOOK_NAMING_OPTIONS,
           { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
@@ -1452,9 +1452,9 @@ async function checkCommand(options, cwd) {
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
-  const log9 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(import_chalk5.default.dim(msg)) : () => {
+  const log10 = options.format !== "json" && !options.hook && !options.quiet ? (msg) => process.stderr.write(import_chalk5.default.dim(msg)) : () => {
   };
-  log9("  Checking files...");
+  log10("  Checking files...");
   for (const file of filesToCheck) {
     const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
     const relPath = path7.relative(projectRoot, absPath);
@@ -1487,9 +1487,9 @@ async function checkCommand(options, cwd) {
       }
     }
   }
-  log9(" done\n");
+  log10(" done\n");
   if (!options.files) {
-    log9("  Checking missing tests...");
+    log10("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
     if (options.staged) {
       const stagedSet = new Set(filesToCheck);
@@ -1502,14 +1502,14 @@ async function checkCommand(options, cwd) {
     } else {
       violations.push(...testViolations);
     }
-    log9(" done\n");
+    log10(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
-    log9("  Running test coverage...\n");
+    log10("  Running test coverage...\n");
     const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
       staged: options.staged,
       enforce: options.enforce,
-      onProgress: (pkg) => log9(`    Coverage: ${pkg}...
+      onProgress: (pkg) => log10(`    Coverage: ${pkg}...
 `)
     });
     violations.push(...coverageViolations);
@@ -1534,7 +1534,7 @@ async function checkCommand(options, cwd) {
         severity
       });
     }
-    log9(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
+    log10(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
 `);
   }
   if (options.format === "json") {
@@ -2816,10 +2816,10 @@ ${import_chalk10.default.yellow("!")} No safe fixes to apply. Resolve aliased im
 // src/commands/init.ts
 var fs21 = __toESM(require("fs"), 1);
 var path21 = __toESM(require("path"), 1);
-var clack13 = __toESM(require("@clack/prompts"), 1);
+var clack14 = __toESM(require("@clack/prompts"), 1);
 var import_config9 = require("@viberails/config");
 var import_scanner3 = require("@viberails/scanner");
-var import_chalk16 = __toESM(require("chalk"), 1);
+var import_chalk18 = __toESM(require("chalk"), 1);
 
 // src/utils/check-prerequisites.ts
 var fs14 = __toESM(require("fs"), 1);
@@ -2926,15 +2926,7 @@ async function executeDeferredInstalls(projectRoot, installs) {
   return successCount;
 }
 
-// src/utils/prompt-main-menu.ts
-var clack11 = __toESM(require("@clack/prompts"), 1);
-
-// src/utils/prompt-main-menu-handlers.ts
-var clack10 = __toESM(require("@clack/prompts"), 1);
-
 // src/utils/prompt-integrations.ts
-var fs15 = __toESM(require("fs"), 1);
-var path15 = __toESM(require("path"), 1);
 var clack9 = __toESM(require("@clack/prompts"), 1);
 function buildLefthookInstallCommand(pm, isWorkspace) {
   if (pm === "yarn") return "yarn add -D lefthook";
@@ -2942,26 +2934,24 @@ function buildLefthookInstallCommand(pm, isWorkspace) {
   if (pm === "npm") return "npm install -D lefthook";
   return `${pm} add -D lefthook`;
 }
-async function promptIntegrationsDeferred(hookManager, tools, packageManager, isWorkspace, projectRoot) {
+async function promptIntegrationsDeferred(hookManager, tools) {
+  const hasHookManager = !!hookManager;
   const options = [];
-  const needsLefthook = !hookManager;
-  if (needsLefthook) {
-    const pm = packageManager ?? "npm";
-    options.push({
-      value: "installLefthook",
-      label: "Install Lefthook",
-      hint: `after final confirmation \u2014 ${buildLefthookInstallCommand(pm, isWorkspace)}`
-    });
-  }
-  const hookLabel = hookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook";
-  const hookHint = needsLefthook ? "uses Lefthook if installed above, otherwise local git hook" : "runs viberails checks when you commit";
+  const hookLabel = hasHookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook";
+  const hookHint = hasHookManager ? "runs viberails checks when you commit" : "local hook only \u2014 use lefthook or husky to commit hooks to repo";
   options.push({ value: "preCommit", label: hookLabel, hint: hookHint });
-  if (tools?.isTypeScript) {
+  if (tools?.typecheckLabel) {
     options.push({
       value: "typecheck",
-      label: "Typecheck (tsc --noEmit)",
+      label: `Typecheck (${tools.typecheckLabel})`,
       hint: "pre-commit hook + CI check"
     });
+  } else if (tools?.isTypeScript) {
+    options.push({
+      value: "typecheck",
+      label: "Typecheck",
+      hint: "needs root tsconfig.json, typecheck script, or turbo task"
+    });
   }
   if (tools?.linter) {
     const linterName = tools.linter === "biome" ? "Biome" : "ESLint";
@@ -2988,7 +2978,12 @@ async function promptIntegrationsDeferred(hookManager, tools, packageManager, is
       hint: "blocks PRs that fail viberails check"
     }
   );
-  const initialValues = options.map((o) => o.value);
+  const hasTypecheck = !!tools?.typecheckLabel;
+  const initialValues = options.filter((o) => {
+    if (o.value === "preCommit" && !hasHookManager) return false;
+    if (o.value === "typecheck" && !hasTypecheck) return false;
+    return true;
+  }).map((o) => o.value);
   const result = await clack9.multiselect({
     message: "Integrations",
     options,
@@ -2996,20 +2991,6 @@ async function promptIntegrationsDeferred(hookManager, tools, packageManager, is
     required: false
   });
   assertNotCancelled(result);
-  let lefthookInstall;
-  if (needsLefthook && result.includes("installLefthook")) {
-    const pm = packageManager ?? "npm";
-    lefthookInstall = {
-      label: "Lefthook",
-      command: buildLefthookInstallCommand(pm, isWorkspace),
-      onSuccess: projectRoot ? () => {
-        const ymlPath = path15.join(projectRoot, "lefthook.yml");
-        if (!fs15.existsSync(ymlPath)) {
-          fs15.writeFileSync(ymlPath, "# Generated by viberails\n");
-        }
-      } : void 0
-    };
-  }
   return {
     choice: {
       preCommitHook: result.includes("preCommit"),
@@ -3018,39 +2999,178 @@ async function promptIntegrationsDeferred(hookManager, tools, packageManager, is
       githubAction: result.includes("githubAction"),
       typecheckHook: result.includes("typecheck"),
       lintHook: result.includes("lint")
-    },
-    lefthookInstall
+    }
   };
 }
 
+// src/utils/prompt-main-menu.ts
+var clack11 = __toESM(require("@clack/prompts"), 1);
+
 // src/utils/prompt-main-menu-handlers.ts
-async function handleAdvancedNaming(config) {
+var clack10 = __toESM(require("@clack/prompts"), 1);
+var import_chalk13 = __toESM(require("chalk"), 1);
+
+// src/utils/prompt-main-menu-hints.ts
+var import_chalk12 = __toESM(require("chalk"), 1);
+function fileLimitsHint(config) {
+  const max = config.rules.maxFileLines;
+  const test = config.rules.maxTestFileLines;
+  return test > 0 ? `${max} lines, tests ${test}` : `${max} lines`;
+}
+function getEffectiveFileNaming(config) {
   const rootPkg = getRootPackage(config.packages);
-  const state = {
-    maxFileLines: config.rules.maxFileLines,
-    maxTestFileLines: config.rules.maxTestFileLines,
-    testCoverage: config.rules.testCoverage,
-    enforceMissingTests: config.rules.enforceMissingTests,
-    enforceNaming: config.rules.enforceNaming,
-    fileNamingValue: rootPkg.conventions?.fileNaming,
-    componentNaming: rootPkg.conventions?.componentNaming,
-    hookNaming: rootPkg.conventions?.hookNaming,
-    importAlias: rootPkg.conventions?.importAlias,
-    coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
-    coverageCommand: config.defaults?.coverage?.command
-  };
-  await promptNamingMenu(state);
-  rootPkg.conventions = rootPkg.conventions ?? {};
-  config.rules.enforceNaming = state.enforceNaming;
-  if (state.fileNamingValue) {
-    rootPkg.conventions.fileNaming = state.fileNamingValue;
-  } else {
-    delete rootPkg.conventions.fileNaming;
+  if (rootPkg.conventions?.fileNaming) {
+    return { naming: rootPkg.conventions.fileNaming, source: "root" };
+  }
+  if (config.packages.length > 1) {
+    const namingValues = config.packages.map((p) => p.conventions?.fileNaming).filter((n) => !!n);
+    if (namingValues.length > 0 && new Set(namingValues).size === 1) {
+      return { naming: namingValues[0], source: "consensus" };
+    }
+  }
+  return void 0;
+}
+function fileNamingHint(config, scanResult) {
+  if (!config.rules.enforceNaming) return "not enforced";
+  const effective = getEffectiveFileNaming(config);
+  if (effective) {
+    const detected = scanResult.packages.some(
+      (p) => p.conventions.fileNaming?.value === effective.naming && p.conventions.fileNaming.confidence !== "low"
+    );
+    return detected ? `${effective.naming} (detected)` : effective.naming;
+  }
+  return "not set \u2014 select to configure";
+}
+function fileNamingStatus(config) {
+  if (!config.rules.enforceNaming) return "unconfigured";
+  return getEffectiveFileNaming(config) ? "ok" : "needs-input";
+}
+function missingTestsHint(config) {
+  if (!config.rules.enforceMissingTests) return "not enforced";
+  const rootPkg = getRootPackage(config.packages);
+  const pattern = rootPkg.structure?.testPattern;
+  return pattern ? `enforced (${pattern})` : "enforced";
+}
+function coverageHint(config, hasTestRunner) {
+  if (config.rules.testCoverage === 0) return "disabled";
+  if (!hasTestRunner)
+    return `${config.rules.testCoverage}% target (inactive \u2014 no test runner)`;
+  const isMonorepo = config.packages.length > 1;
+  if (isMonorepo) {
+    const withCov = config.packages.filter(
+      (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
+    );
+    const exempt = config.packages.length - withCov.length;
+    return exempt > 0 ? `${config.rules.testCoverage}% (${withCov.length}/${config.packages.length} packages, ${exempt} exempt)` : `${config.rules.testCoverage}%`;
+  }
+  return `${config.rules.testCoverage}%`;
+}
+function aiContextHint(config) {
+  const rootPkg = getRootPackage(config.packages);
+  const count = [
+    rootPkg.conventions?.componentNaming,
+    rootPkg.conventions?.hookNaming,
+    rootPkg.conventions?.importAlias
+  ].filter(Boolean).length;
+  if (count === 3) return "all set";
+  if (count > 0) return `${count} of 3 conventions`;
+  return "none set \u2014 optional AI guidelines";
+}
+function aiContextStatus(config) {
+  const rootPkg = getRootPackage(config.packages);
+  const count = [
+    rootPkg.conventions?.componentNaming,
+    rootPkg.conventions?.hookNaming,
+    rootPkg.conventions?.importAlias
+  ].filter(Boolean).length;
+  if (count === 3) return "ok";
+  if (count > 0) return "partial";
+  return "unconfigured";
+}
+function packageOverridesHint(config) {
+  const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
+  const editable = config.packages.filter((p) => p.path !== ".");
+  const customized = editable.filter(
+    (p) => p.rules || p.coverage || p.conventions?.fileNaming !== void 0 && p.conventions.fileNaming !== rootNaming
+  ).length;
+  return customized > 0 ? `${editable.length} packages (${customized} customized)` : `${editable.length} packages`;
+}
+function boundariesHint(config, state) {
+  if (!state.visited.boundaries || !config.rules.enforceBoundaries) return "not enabled";
+  const deny = config.boundaries?.deny;
+  if (!deny) return "enabled";
+  const ruleCount = Object.values(deny).reduce((s, a) => s + a.length, 0);
+  const pkgCount = Object.keys(deny).length;
+  return `${ruleCount} rules across ${pkgCount} packages`;
+}
+function packageOverridesStatus(config) {
+  const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
+  const editable = config.packages.filter((p) => p.path !== ".");
+  const customized = editable.some(
+    (p) => p.rules || p.coverage || p.conventions?.fileNaming !== void 0 && p.conventions.fileNaming !== rootNaming
+  );
+  return customized ? "ok" : "unconfigured";
+}
+function statusIcon(status) {
+  if (status === "ok") return import_chalk12.default.green("\u2713");
+  if (status === "needs-input") return import_chalk12.default.yellow("?");
+  if (status === "unconfigured") return import_chalk12.default.dim("-");
+  return import_chalk12.default.yellow("~");
+}
+function buildMainMenuOptions(config, scanResult, state) {
+  const namingStatus = fileNamingStatus(config);
+  const coverageStatus = config.rules.testCoverage === 0 ? "unconfigured" : !state.hasTestRunner ? "partial" : "ok";
+  const missingTestsStatus = config.rules.enforceMissingTests ? "ok" : "unconfigured";
+  const options = [
+    {
+      value: "fileLimits",
+      label: `${statusIcon("ok")} Max file size`,
+      hint: fileLimitsHint(config)
+    },
+    {
+      value: "fileNaming",
+      label: `${statusIcon(namingStatus)} File naming`,
+      hint: fileNamingHint(config, scanResult)
+    },
+    {
+      value: "missingTests",
+      label: `${statusIcon(missingTestsStatus)} Missing tests`,
+      hint: missingTestsHint(config)
+    },
+    {
+      value: "coverage",
+      label: `${statusIcon(coverageStatus)} Coverage`,
+      hint: coverageHint(config, state.hasTestRunner)
+    },
+    {
+      value: "aiContext",
+      label: `${statusIcon(aiContextStatus(config))} AI context`,
+      hint: aiContextHint(config)
+    }
+  ];
+  if (config.packages.length > 1) {
+    const bIcon = statusIcon(
+      state.visited.boundaries && config.rules.enforceBoundaries ? "ok" : "unconfigured"
+    );
+    const poIcon = statusIcon(packageOverridesStatus(config));
+    options.push(
+      {
+        value: "packageOverrides",
+        label: `${poIcon} Per-package overrides`,
+        hint: packageOverridesHint(config)
+      },
+      { value: "boundaries", label: `${bIcon} Boundaries`, hint: boundariesHint(config, state) }
+    );
   }
-  rootPkg.conventions.componentNaming = state.componentNaming || void 0;
-  rootPkg.conventions.hookNaming = state.hookNaming || void 0;
-  rootPkg.conventions.importAlias = state.importAlias || void 0;
+  options.push(
+    { value: "reset", label: "  Reset all to defaults" },
+    { value: "review", label: "  Review scan details", hint: "detected stack & conventions" },
+    { value: "done", label: "  Done \u2014 write config" }
+  );
+  return options;
 }
+
+// src/utils/prompt-main-menu-handlers.ts
 async function handleFileNaming(config, scanResult) {
   const isMonorepo = config.packages.length > 1;
   if (isMonorepo) {
@@ -3074,10 +3194,11 @@ async function handleFileNaming(config, scanResult) {
     return { value: opt.value, label: opt.label };
   });
   const rootPkg = getRootPackage(config.packages);
+  const effective = getEffectiveFileNaming(config);
   const selected = await clack10.select({
     message: isMonorepo ? "Default file naming convention" : "File naming convention",
     options: [...namingOptions, { value: SENTINEL_SKIP, label: "Don't enforce" }],
-    initialValue: rootPkg.conventions?.fileNaming ?? SENTINEL_SKIP
+    initialValue: effective?.naming ?? SENTINEL_SKIP
   });
   if (isCancelled(selected)) return;
   if (selected === SENTINEL_SKIP) {
@@ -3190,192 +3311,98 @@ async function handleBoundaries(config, state, opts) {
     clack10.log.warn(`Boundary inference failed: ${err instanceof Error ? err.message : err}`);
   }
 }
-async function handleIntegrations(state, opts) {
-  const result = await promptIntegrationsDeferred(
-    state.hookManager,
-    opts.tools,
-    opts.tools.packageManager,
-    opts.tools.isWorkspace,
-    opts.projectRoot
-  );
-  state.visited.integrations = true;
-  state.integrations = result.choice;
-  state.deferredInstalls = state.deferredInstalls.filter((d) => !d.command.includes("lefthook"));
-  if (result.lefthookInstall) {
-    state.deferredInstalls.push(result.lefthookInstall);
-  }
-}
-
-// src/utils/prompt-main-menu-hints.ts
-var import_chalk12 = __toESM(require("chalk"), 1);
-function fileLimitsHint(config) {
-  const max = config.rules.maxFileLines;
-  const test = config.rules.maxTestFileLines;
-  return test > 0 ? `${max} lines, tests ${test}` : `${max} lines`;
-}
-function fileNamingHint(config, scanResult) {
-  const rootPkg = getRootPackage(config.packages);
-  const naming = rootPkg.conventions?.fileNaming;
-  if (!config.rules.enforceNaming) return "not enforced";
-  if (naming) {
-    const detected = scanResult.packages.some(
-      (p) => p.conventions.fileNaming?.value === naming && p.conventions.fileNaming.confidence === "high"
-    );
-    return detected ? `${naming} (detected)` : naming;
-  }
-  return "mixed \u2014 will not enforce if skipped";
-}
-function fileNamingStatus(config) {
-  if (!config.rules.enforceNaming) return "unconfigured";
-  const rootPkg = getRootPackage(config.packages);
-  return rootPkg.conventions?.fileNaming ? "ok" : "needs-input";
-}
-function missingTestsHint(config) {
-  if (!config.rules.enforceMissingTests) return "not enforced";
-  const rootPkg = getRootPackage(config.packages);
-  const pattern = rootPkg.structure?.testPattern;
-  return pattern ? `enforced (${pattern})` : "enforced";
-}
-function coverageHint(config, hasTestRunner) {
-  if (config.rules.testCoverage === 0) return "disabled";
-  if (!hasTestRunner)
-    return `${config.rules.testCoverage}% target (inactive \u2014 no test runner)`;
-  const isMonorepo = config.packages.length > 1;
-  if (isMonorepo) {
-    const withCov = config.packages.filter(
-      (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
-    );
-    const exempt = config.packages.length - withCov.length;
-    return exempt > 0 ? `${config.rules.testCoverage}% (${withCov.length}/${config.packages.length} packages, ${exempt} exempt)` : `${config.rules.testCoverage}%`;
-  }
-  return `${config.rules.testCoverage}%`;
-}
-function advancedNamingHint(config) {
-  const rootPkg = getRootPackage(config.packages);
-  if (!config.rules.enforceNaming) return "not enforced";
-  const ok = import_chalk12.default.green("\u2713");
-  const no = import_chalk12.default.dim("\u2717");
-  const parts = [
-    `${rootPkg.conventions?.fileNaming ? ok : no} file naming`,
-    `${rootPkg.conventions?.componentNaming ? ok : no} components`,
-    `${rootPkg.conventions?.hookNaming ? ok : no} hooks`,
-    `${rootPkg.conventions?.importAlias ? ok : no} alias`
-  ];
-  return parts.join(import_chalk12.default.dim(", "));
-}
-function integrationsHint(state) {
-  if (!state.visited.integrations || !state.integrations)
-    return "not configured \u2014 select to set up";
-  const items = [];
-  if (state.integrations.preCommitHook) items.push(import_chalk12.default.green("pre-commit"));
-  if (state.integrations.typecheckHook) items.push(import_chalk12.default.green("typecheck"));
-  if (state.integrations.lintHook) items.push(import_chalk12.default.green("lint"));
-  if (state.integrations.claudeCodeHook) items.push(import_chalk12.default.green("Claude"));
-  if (state.integrations.claudeMdRef) items.push(import_chalk12.default.green("CLAUDE.md"));
-  if (state.integrations.githubAction) items.push(import_chalk12.default.green("CI"));
-  return items.length > 0 ? items.join(import_chalk12.default.dim(" \xB7 ")) : "none selected";
-}
-function packageOverridesHint(config) {
-  const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
-  const editable = config.packages.filter((p) => p.path !== ".");
-  const customized = editable.filter(
-    (p) => p.rules || p.coverage || p.conventions?.fileNaming !== void 0 && p.conventions.fileNaming !== rootNaming
-  ).length;
-  return customized > 0 ? `${editable.length} packages (${customized} customized)` : `${editable.length} packages`;
-}
-function boundariesHint(config, state) {
-  if (!state.visited.boundaries || !config.rules.enforceBoundaries) return "not enabled";
-  const deny = config.boundaries?.deny;
-  if (!deny) return "enabled";
-  const ruleCount = Object.values(deny).reduce((s, a) => s + a.length, 0);
-  const pkgCount = Object.keys(deny).length;
-  return `${ruleCount} rules across ${pkgCount} packages`;
-}
-function advancedNamingStatus(config) {
-  if (!config.rules.enforceNaming) return "unconfigured";
+async function handleAiContext(config) {
   const rootPkg = getRootPackage(config.packages);
-  const hasFile = !!rootPkg.conventions?.fileNaming;
-  const hasComp = !!rootPkg.conventions?.componentNaming;
-  const hasHook = !!rootPkg.conventions?.hookNaming;
-  const hasAlias = !!rootPkg.conventions?.importAlias;
-  if (hasFile && hasComp && hasHook && hasAlias) return "ok";
-  if (hasFile || hasComp || hasHook || hasAlias) return "partial";
-  return "unconfigured";
-}
-function packageOverridesStatus(config) {
-  const rootNaming = getRootPackage(config.packages).conventions?.fileNaming;
-  const editable = config.packages.filter((p) => p.path !== ".");
-  const customized = editable.some(
-    (p) => p.rules || p.coverage || p.conventions?.fileNaming !== void 0 && p.conventions.fileNaming !== rootNaming
-  );
-  return customized ? "ok" : "unconfigured";
-}
-function statusIcon(status) {
-  if (status === "ok") return import_chalk12.default.green("\u2713");
-  if (status === "needs-input") return import_chalk12.default.yellow("?");
-  if (status === "unconfigured") return import_chalk12.default.dim("-");
-  return import_chalk12.default.yellow("~");
-}
-function buildMainMenuOptions(config, scanResult, state) {
-  const namingStatus = fileNamingStatus(config);
-  const coverageStatus = config.rules.testCoverage === 0 ? "unconfigured" : !state.hasTestRunner ? "partial" : "ok";
-  const missingTestsStatus = config.rules.enforceMissingTests ? "ok" : "unconfigured";
-  const options = [
-    {
-      value: "fileLimits",
-      label: `${statusIcon("ok")} Max file size`,
-      hint: fileLimitsHint(config)
-    },
-    {
-      value: "fileNaming",
-      label: `${statusIcon(namingStatus)} Default file naming`,
-      hint: fileNamingHint(config, scanResult)
-    },
-    {
-      value: "missingTests",
-      label: `${statusIcon(missingTestsStatus)} Missing tests`,
-      hint: missingTestsHint(config)
-    },
-    {
-      value: "coverage",
-      label: `${statusIcon(coverageStatus)} Coverage`,
-      hint: coverageHint(config, state.hasTestRunner)
-    },
-    {
-      value: "advancedNaming",
-      label: `${statusIcon(advancedNamingStatus(config))} Advanced naming`,
-      hint: advancedNamingHint(config)
-    }
-  ];
-  if (config.packages.length > 1) {
-    const bIcon = statusIcon(
-      state.visited.boundaries && config.rules.enforceBoundaries ? "ok" : "unconfigured"
-    );
-    const poIcon = statusIcon(packageOverridesStatus(config));
-    options.push(
+  rootPkg.conventions = rootPkg.conventions ?? {};
+  while (true) {
+    const ok = import_chalk13.default.green("\u2713");
+    const unset = import_chalk13.default.dim("-");
+    const options = [
       {
-        value: "packageOverrides",
-        label: `${poIcon} Per-package overrides`,
-        hint: packageOverridesHint(config)
+        value: "componentNaming",
+        label: `${rootPkg.conventions.componentNaming ? ok : unset} Component exports`,
+        hint: rootPkg.conventions.componentNaming ?? "not set"
       },
-      { value: "boundaries", label: `${bIcon} Boundaries`, hint: boundariesHint(config, state) }
-    );
+      {
+        value: "hookNaming",
+        label: `${rootPkg.conventions.hookNaming ? ok : unset} Hook exports`,
+        hint: rootPkg.conventions.hookNaming ?? "not set"
+      },
+      {
+        value: "importAlias",
+        label: `${rootPkg.conventions.importAlias ? ok : unset} Import alias`,
+        hint: rootPkg.conventions.importAlias ?? "not set"
+      },
+      { value: "back", label: "  Back" }
+    ];
+    const choice = await clack10.select({
+      message: "AI context \u2014 conventions written to context.md for AI tools",
+      options
+    });
+    if (isCancelled(choice) || choice === "back") return;
+    if (choice === "componentNaming") {
+      const selected = await clack10.select({
+        message: "Component export naming (e.g. UserProfile)",
+        options: [
+          ...COMPONENT_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: rootPkg.conventions.componentNaming ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      rootPkg.conventions.componentNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "hookNaming") {
+      const selected = await clack10.select({
+        message: "Hook export naming (e.g. useAuth)",
+        options: [
+          ...HOOK_NAMING_OPTIONS,
+          { value: SENTINEL_CLEAR, label: "Clear (no convention)" }
+        ],
+        initialValue: rootPkg.conventions.hookNaming ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      rootPkg.conventions.hookNaming = selected === SENTINEL_CLEAR ? void 0 : selected;
+    }
+    if (choice === "importAlias") {
+      const selected = await clack10.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: rootPkg.conventions.importAlias ?? SENTINEL_CLEAR
+      });
+      if (isCancelled(selected)) continue;
+      if (selected === SENTINEL_CLEAR) {
+        rootPkg.conventions.importAlias = void 0;
+      } else if (selected === SENTINEL_CUSTOM) {
+        const result = await clack10.text({
+          message: "Custom import alias (e.g. #/*)?",
+          initialValue: rootPkg.conventions.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/*";
+          }
+        });
+        if (isCancelled(result)) continue;
+        rootPkg.conventions.importAlias = result.trim();
+      } else {
+        rootPkg.conventions.importAlias = selected;
+      }
+    }
   }
-  const iIcon = state.visited.integrations ? statusIcon("ok") : statusIcon("unconfigured");
-  options.push(
-    { value: "integrations", label: `${iIcon} Integrations`, hint: integrationsHint(state) },
-    { value: "reset", label: "  Reset all to defaults" },
-    { value: "review", label: "  Review scan details", hint: "detected stack & conventions" },
-    { value: "done", label: "  Done \u2014 write config" }
-  );
-  return options;
 }
 
 // src/utils/prompt-main-menu.ts
 async function promptMainMenu(config, scanResult, opts) {
   const originalConfig = structuredClone(config);
   const state = {
-    visited: { integrations: false, boundaries: false },
+    visited: { boundaries: false },
     deferredInstalls: [],
     hasTestRunner: opts.hasTestRunner,
     hookManager: opts.hookManager
@@ -3402,10 +3429,9 @@ async function promptMainMenu(config, scanResult, opts) {
     if (choice === "fileNaming") await handleFileNaming(config, scanResult);
     if (choice === "missingTests") await handleMissingTests(config);
     if (choice === "coverage") await handleCoverage(config, state, opts);
-    if (choice === "advancedNaming") await handleAdvancedNaming(config);
+    if (choice === "aiContext") await handleAiContext(config);
     if (choice === "packageOverrides") await handlePackageOverrides(config);
     if (choice === "boundaries") await handleBoundaries(config, state, opts);
-    if (choice === "integrations") await handleIntegrations(state, opts);
     if (choice === "review") clack11.note(formatScanResultsText(scanResult), "Scan details");
     if (choice === "reset") {
       const confirmed = await clack11.confirm({
@@ -3416,8 +3442,7 @@ async function promptMainMenu(config, scanResult, opts) {
       if (confirmed) {
         Object.assign(config, structuredClone(originalConfig));
         state.deferredInstalls = [];
-        state.visited = { integrations: false, boundaries: false };
-        state.integrations = void 0;
+        state.visited = { boundaries: false };
         clack11.log.info("Reset all settings to scan-detected defaults.");
       }
     }
@@ -3425,37 +3450,26 @@ async function promptMainMenu(config, scanResult, opts) {
   return state;
 }
 
-// src/utils/update-gitignore.ts
-var fs16 = __toESM(require("fs"), 1);
-var path16 = __toESM(require("path"), 1);
-function updateGitignore(projectRoot) {
-  const gitignorePath = path16.join(projectRoot, ".gitignore");
-  let content = "";
-  if (fs16.existsSync(gitignorePath)) {
-    content = fs16.readFileSync(gitignorePath, "utf-8");
-  }
-  if (!content.includes(".viberails/scan-result.json")) {
-    const block = "\n# viberails\n.viberails/scan-result.json\n";
-    const prefix = content.length === 0 ? "" : `${content.trimEnd()}
-`;
-    fs16.writeFileSync(gitignorePath, `${prefix}${block}`);
-  }
-}
+// src/utils/prompt-prereqs.ts
+var fs17 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
+var clack12 = __toESM(require("@clack/prompts"), 1);
+var import_chalk15 = __toESM(require("chalk"), 1);
 
 // src/commands/init-hooks.ts
-var fs18 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
-var import_chalk13 = __toESM(require("chalk"), 1);
+var fs16 = __toESM(require("fs"), 1);
+var path16 = __toESM(require("path"), 1);
+var import_chalk14 = __toESM(require("chalk"), 1);
 var import_yaml = require("yaml");
 
 // src/commands/resolve-typecheck.ts
-var fs17 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs"), 1);
+var path15 = __toESM(require("path"), 1);
 function hasTurboTask(projectRoot, taskName) {
-  const turboPath = path17.join(projectRoot, "turbo.json");
-  if (!fs17.existsSync(turboPath)) return false;
+  const turboPath = path15.join(projectRoot, "turbo.json");
+  if (!fs15.existsSync(turboPath)) return false;
   try {
-    const turbo = JSON.parse(fs17.readFileSync(turboPath, "utf-8"));
+    const turbo = JSON.parse(fs15.readFileSync(turboPath, "utf-8"));
     const tasks = turbo.tasks ?? turbo.pipeline ?? {};
     return taskName in tasks;
   } catch {
@@ -3466,10 +3480,10 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
   if (hasTurboTask(projectRoot, "typecheck")) {
     return { command: "npx turbo typecheck", label: "turbo typecheck" };
   }
-  const pkgJsonPath = path17.join(projectRoot, "package.json");
-  if (fs17.existsSync(pkgJsonPath)) {
+  const pkgJsonPath = path15.join(projectRoot, "package.json");
+  if (fs15.existsSync(pkgJsonPath)) {
     try {
-      const pkg = JSON.parse(fs17.readFileSync(pkgJsonPath, "utf-8"));
+      const pkg = JSON.parse(fs15.readFileSync(pkgJsonPath, "utf-8"));
       if (pkg.scripts?.typecheck) {
         const pm = packageManager ?? "npm";
         return { command: `${pm} run typecheck`, label: `${pm} run typecheck` };
@@ -3477,7 +3491,7 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
     } catch {
     }
   }
-  if (fs17.existsSync(path17.join(projectRoot, "tsconfig.json"))) {
+  if (fs15.existsSync(path15.join(projectRoot, "tsconfig.json"))) {
     return { command: "npx tsc --noEmit", label: "tsc --noEmit" };
   }
   return {
@@ -3487,36 +3501,36 @@ function resolveTypecheckCommand(projectRoot, packageManager) {
 
 // src/commands/init-hooks.ts
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path18.join(projectRoot, "lefthook.yml");
-  if (fs18.existsSync(lefthookPath)) {
+  const lefthookPath = path16.join(projectRoot, "lefthook.yml");
+  if (fs16.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${import_chalk13.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${import_chalk14.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return "lefthook.yml";
   }
-  const huskyDir = path18.join(projectRoot, ".husky");
-  if (fs18.existsSync(huskyDir)) {
+  const huskyDir = path16.join(projectRoot, ".husky");
+  if (fs16.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${import_chalk13.default.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${import_chalk14.default.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return ".husky/pre-commit";
   }
-  const gitDir = path18.join(projectRoot, ".git");
-  if (fs18.existsSync(gitDir)) {
-    const hooksDir = path18.join(gitDir, "hooks");
-    if (!fs18.existsSync(hooksDir)) {
-      fs18.mkdirSync(hooksDir, { recursive: true });
+  const gitDir = path16.join(projectRoot, ".git");
+  if (fs16.existsSync(gitDir)) {
+    const hooksDir = path16.join(gitDir, "hooks");
+    if (!fs16.existsSync(hooksDir)) {
+      fs16.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${import_chalk13.default.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${import_chalk14.default.green("\u2713")} .git/hooks/pre-commit`);
     return ".git/hooks/pre-commit";
   }
   return void 0;
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path18.join(hooksDir, "pre-commit");
-  if (fs18.existsSync(hookPath)) {
-    const existing = fs18.readFileSync(hookPath, "utf-8");
+  const hookPath = path16.join(hooksDir, "pre-commit");
+  if (fs16.existsSync(hookPath)) {
+    const existing = fs16.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs18.writeFileSync(
+    fs16.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -3533,10 +3547,10 @@ if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails chec
     "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi",
     ""
   ].join("\n");
-  fs18.writeFileSync(hookPath, script, { mode: 493 });
+  fs16.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs18.readFileSync(lefthookPath, "utf-8");
+  const content = fs16.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
   const doc = (0, import_yaml.parse)(content) ?? {};
   if (!doc["pre-commit"]) {
@@ -3548,28 +3562,28 @@ function addLefthookPreCommit(lefthookPath) {
   doc["pre-commit"].commands.viberails = {
     run: "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi"
   };
-  fs18.writeFileSync(lefthookPath, (0, import_yaml.stringify)(doc));
+  fs16.writeFileSync(lefthookPath, (0, import_yaml.stringify)(doc));
 }
 function detectHookManager(projectRoot) {
-  if (fs18.existsSync(path18.join(projectRoot, "lefthook.yml"))) return "Lefthook";
-  if (fs18.existsSync(path18.join(projectRoot, ".husky"))) return "Husky";
+  if (fs16.existsSync(path16.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs16.existsSync(path16.join(projectRoot, ".husky"))) return "Husky";
   return void 0;
 }
 function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path18.join(projectRoot, ".claude");
-  if (!fs18.existsSync(claudeDir)) {
-    fs18.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path16.join(projectRoot, ".claude");
+  if (!fs16.existsSync(claudeDir)) {
+    fs16.mkdirSync(claudeDir, { recursive: true });
   }
-  const settingsPath = path18.join(claudeDir, "settings.json");
+  const settingsPath = path16.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs18.existsSync(settingsPath)) {
+  if (fs16.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${import_chalk13.default.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
+        `  ${import_chalk14.default.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      console.warn(`  Fix the JSON manually, then re-run ${import_chalk13.default.cyan("viberails init --force")}`);
+      console.warn(`  Fix the JSON manually, then re-run ${import_chalk14.default.cyan("viberails init --force")}`);
       return;
     }
   }
@@ -3590,30 +3604,30 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs18.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs16.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
-  console.log(`  ${import_chalk13.default.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+  console.log(`  ${import_chalk14.default.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
-  const claudeMdPath = path18.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path16.join(projectRoot, "CLAUDE.md");
   let content = "";
-  if (fs18.existsSync(claudeMdPath)) {
-    content = fs18.readFileSync(claudeMdPath, "utf-8");
+  if (fs16.existsSync(claudeMdPath)) {
+    content = fs16.readFileSync(claudeMdPath, "utf-8");
   }
   if (content.includes("@.viberails/context.md")) return;
   const ref = "\n@.viberails/context.md\n";
   const prefix = content.length === 0 ? "" : content.trimEnd();
-  fs18.writeFileSync(claudeMdPath, prefix + ref);
-  console.log(`  ${import_chalk13.default.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+  fs16.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${import_chalk14.default.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
 }
 function setupGithubAction(projectRoot, packageManager, options) {
-  const workflowDir = path18.join(projectRoot, ".github", "workflows");
-  const workflowPath = path18.join(workflowDir, "viberails.yml");
-  if (fs18.existsSync(workflowPath)) {
-    const existing = fs18.readFileSync(workflowPath, "utf-8");
+  const workflowDir = path16.join(projectRoot, ".github", "workflows");
+  const workflowPath = path16.join(workflowDir, "viberails.yml");
+  if (fs16.existsSync(workflowPath)) {
+    const existing = fs16.readFileSync(workflowPath, "utf-8");
     if (existing.includes("viberails")) return void 0;
   }
-  fs18.mkdirSync(workflowDir, { recursive: true });
+  fs16.mkdirSync(workflowDir, { recursive: true });
   const pm = packageManager || "npm";
   const installCmd = pm === "yarn" ? "yarn install --frozen-lockfile" : pm === "pnpm" ? "pnpm install --frozen-lockfile" : "npm ci";
   const runPrefix = pm === "npm" ? "npx" : `${pm} exec`;
@@ -3667,30 +3681,212 @@ function setupGithubAction(projectRoot, packageManager, options) {
     ""
   );
   const content = lines.filter((l) => l !== void 0).join("\n");
-  fs18.writeFileSync(workflowPath, content);
+  fs16.writeFileSync(workflowPath, content);
   return ".github/workflows/viberails.yml";
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path18.join(huskyDir, "pre-commit");
+  const hookPath = path16.join(huskyDir, "pre-commit");
   const cmd = "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --staged; else npx viberails check --staged; fi";
-  if (fs18.existsSync(hookPath)) {
-    const existing = fs18.readFileSync(hookPath, "utf-8");
+  if (fs16.existsSync(hookPath)) {
+    const existing = fs16.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs18.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
 ${cmd}
 `);
     }
     return;
   }
-  fs18.writeFileSync(hookPath, `#!/bin/sh
+  fs16.writeFileSync(hookPath, `#!/bin/sh
 ${cmd}
 `, { mode: 493 });
 }
 
+// src/utils/prompt-prereqs.ts
+function buildVitestInstallCommand(pm, isWorkspace) {
+  if (pm === "yarn") return "yarn add -D vitest";
+  if (pm === "npm") return "npm install -D vitest";
+  return isWorkspace ? "pnpm add -D -w vitest" : "pnpm add -D vitest";
+}
+function statusIcon2(status) {
+  if (status === "ok") return import_chalk15.default.green("\u2713");
+  if (status === "missing") return import_chalk15.default.yellow("!");
+  if (status === "skipped") return import_chalk15.default.dim("\u2717");
+  return import_chalk15.default.dim("-");
+}
+function buildReadinessNote(state) {
+  const lines = [];
+  const tr = state.testRunner;
+  lines.push(
+    `${statusIcon2(tr.status)} Test runner     ${tr.label ?? (tr.status === "skipped" ? "skipped" : "not detected")}`
+  );
+  const hm = state.hookManager;
+  lines.push(
+    `${statusIcon2(hm.status)} Hook manager    ${hm.label ?? (hm.status === "skipped" ? "skipped" : "not detected")}`
+  );
+  const li = state.linter;
+  lines.push(`${statusIcon2(li.status)} Linter          ${li.label ?? "none"}`);
+  const tc = state.typecheck;
+  if (tc.status === "ok") {
+    lines.push(`${statusIcon2("ok")} Typecheck       ${tc.label}`);
+  } else if (tc.status === "skipped") {
+    lines.push(`${statusIcon2("skipped")} Typecheck       skipped`);
+  } else {
+    lines.push(
+      `${statusIcon2("missing")} Typecheck       needs root tsconfig.json, typecheck script, or turbo task`
+    );
+  }
+  return lines.join("\n");
+}
+function hasMissing(state) {
+  return state.testRunner.status === "missing" || state.hookManager.status === "missing" || state.typecheck.status === "missing";
+}
+async function promptPrereqs(projectRoot, scanResult, hookManager, packageManager, isWorkspace) {
+  let hasTestRunner = !!scanResult.stack.testRunner;
+  let currentHookManager = hookManager;
+  let skipCoverage = false;
+  let skipHooks = false;
+  const linterName = scanResult.stack.linter?.name;
+  const linterLabel = linterName === "biome" ? "Biome" : linterName === "eslint" ? "ESLint" : linterName;
+  const typecheckResolved = resolveTypecheckCommand(projectRoot, packageManager);
+  const state = {
+    testRunner: hasTestRunner ? { status: "ok", label: scanResult.stack.testRunner?.name } : { status: "missing" },
+    hookManager: currentHookManager ? { status: "ok", label: currentHookManager } : { status: "missing" },
+    linter: linterName ? { status: "ok", label: linterLabel } : { status: "none" },
+    typecheck: typecheckResolved.label ? { status: "ok", label: typecheckResolved.label } : { status: "missing", reason: typecheckResolved.reason }
+  };
+  if (!hasMissing(state)) {
+    return {
+      hasTestRunner,
+      hookManager: currentHookManager,
+      skipCoverage,
+      skipHooks,
+      typecheckLabel: typecheckResolved.label
+    };
+  }
+  if (state.testRunner.status === "missing") {
+    clack12.note(buildReadinessNote(state), "Project readiness");
+    const cmd = buildVitestInstallCommand(packageManager, isWorkspace);
+    const choice = await clack12.select({
+      message: "No test runner detected. Coverage checks require one.",
+      options: [
+        { value: "install", label: "Install vitest", hint: cmd },
+        { value: "skip", label: "Skip \u2014 disable coverage checks" },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "install") {
+      const s = clack12.spinner();
+      s.start("Installing vitest...");
+      const result = await spawnAsync(cmd, projectRoot);
+      if (result.status === 0) {
+        s.stop("Installed vitest");
+        hasTestRunner = true;
+        state.testRunner = { status: "ok", label: "vitest" };
+      } else {
+        s.stop("Failed to install vitest");
+        clack12.log.warn(`Install manually: ${cmd}`);
+        skipCoverage = true;
+        state.testRunner = { status: "skipped" };
+      }
+    } else if (choice === "skip") {
+      skipCoverage = true;
+      state.testRunner = { status: "skipped" };
+    } else {
+      clack12.outro("Aborted.");
+      process.exit(0);
+    }
+  }
+  if (state.hookManager.status === "missing") {
+    clack12.note(buildReadinessNote(state), "Project readiness");
+    const cmd = buildLefthookInstallCommand(packageManager, isWorkspace);
+    const choice = await clack12.select({
+      message: "No git hook manager detected. Pre-commit integration requires one.",
+      options: [
+        { value: "install", label: "Install lefthook", hint: cmd },
+        { value: "skip", label: "Skip \u2014 no pre-commit integration" },
+        { value: "exit", label: "Exit" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "install") {
+      const s = clack12.spinner();
+      s.start("Installing lefthook...");
+      const result = await spawnAsync(cmd, projectRoot);
+      if (result.status === 0) {
+        s.stop("Installed lefthook");
+        const ymlPath = path17.join(projectRoot, "lefthook.yml");
+        if (!fs17.existsSync(ymlPath)) {
+          fs17.writeFileSync(ymlPath, "# Managed by viberails\npre-commit:\n  commands: {}\n");
+        }
+        currentHookManager = detectHookManager(projectRoot);
+        state.hookManager = { status: "ok", label: currentHookManager ?? "lefthook" };
+      } else {
+        s.stop("Failed to install lefthook");
+        clack12.log.warn(`Install manually: ${cmd}`);
+        skipHooks = true;
+        state.hookManager = { status: "skipped" };
+      }
+    } else if (choice === "skip") {
+      skipHooks = true;
+      state.hookManager = { status: "skipped" };
+    } else {
+      clack12.outro("Aborted.");
+      process.exit(0);
+    }
+  }
+  if (state.typecheck.status === "missing") {
+    clack12.note(buildReadinessNote(state), "Project readiness");
+    const choice = await clack12.select({
+      message: "No typecheck command found. Without this, pre-commit and CI typecheck hooks will be unavailable.",
+      options: [
+        {
+          value: "continue",
+          label: "Continue without typecheck",
+          hint: "add a root tsconfig.json or typecheck script later, then re-run viberails"
+        },
+        { value: "exit", label: "Exit \u2014 fix this first" }
+      ]
+    });
+    assertNotCancelled(choice);
+    if (choice === "exit") {
+      clack12.outro(
+        "Add a root tsconfig.json, a typecheck script, or a turbo typecheck task, then re-run viberails."
+      );
+      process.exit(0);
+    }
+    state.typecheck = { status: "skipped" };
+  }
+  return {
+    hasTestRunner,
+    hookManager: currentHookManager,
+    skipCoverage,
+    skipHooks,
+    typecheckLabel: typecheckResolved.label
+  };
+}
+
+// src/utils/update-gitignore.ts
+var fs18 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
+function updateGitignore(projectRoot) {
+  const gitignorePath = path18.join(projectRoot, ".gitignore");
+  let content = "";
+  if (fs18.existsSync(gitignorePath)) {
+    content = fs18.readFileSync(gitignorePath, "utf-8");
+  }
+  if (!content.includes(".viberails/scan-result.json")) {
+    const block = "\n# viberails\n.viberails/scan-result.json\n";
+    const prefix = content.length === 0 ? "" : `${content.trimEnd()}
+`;
+    fs18.writeFileSync(gitignorePath, `${prefix}${block}`);
+  }
+}
+
 // src/commands/init-hooks-extra.ts
 var fs19 = __toESM(require("fs"), 1);
 var path19 = __toESM(require("path"), 1);
-var import_chalk14 = __toESM(require("chalk"), 1);
+var import_chalk16 = __toESM(require("chalk"), 1);
 var import_yaml2 = require("yaml");
 function addPreCommitStep(projectRoot, name, command, marker, lefthookExtra) {
   const lefthookPath = path19.join(projectRoot, "lefthook.yml");
@@ -3750,12 +3946,12 @@ ${command}
 function setupTypecheckHook(projectRoot, packageManager) {
   const resolved = resolveTypecheckCommand(projectRoot, packageManager);
   if (!resolved.command) {
-    console.log(`  ${import_chalk14.default.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
+    console.log(`  ${import_chalk16.default.yellow("!")} Skipped typecheck hook: ${resolved.reason}`);
     return void 0;
   }
   const target = addPreCommitStep(projectRoot, "typecheck", resolved.command, "typecheck");
   if (target) {
-    console.log(`  ${import_chalk14.default.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
+    console.log(`  ${import_chalk16.default.green("\u2713")} ${target} \u2014 added typecheck (${resolved.label})`);
   }
   return target;
 }
@@ -3777,7 +3973,7 @@ function setupLintHook(projectRoot, linter) {
   }
   const target = addPreCommitStep(projectRoot, "lint", command, linter, lefthookExtra);
   if (target) {
-    console.log(`  ${import_chalk14.default.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
+    console.log(`  ${import_chalk16.default.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
   }
   return target;
 }
@@ -3786,7 +3982,7 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
   if (integrations.preCommitHook) {
     const t = setupPreCommitHook(projectRoot);
     if (t && opts.lefthookExpected && !t.includes("lefthook")) {
-      console.log(`  ${import_chalk14.default.yellow("!")} Lefthook install failed \u2014 fell back to ${t}`);
+      console.log(`  ${import_chalk16.default.yellow("!")} Lefthook install failed \u2014 fell back to ${t}`);
     }
     created.push(t ? `${t} \u2014 added viberails pre-commit` : "pre-commit hook skipped");
   }
@@ -3819,10 +4015,10 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
 // src/commands/init-non-interactive.ts
 var fs20 = __toESM(require("fs"), 1);
 var path20 = __toESM(require("path"), 1);
-var clack12 = __toESM(require("@clack/prompts"), 1);
+var clack13 = __toESM(require("@clack/prompts"), 1);
 var import_config8 = require("@viberails/config");
 var import_scanner2 = require("@viberails/scanner");
-var import_chalk15 = __toESM(require("chalk"), 1);
+var import_chalk17 = __toESM(require("chalk"), 1);
 
 // src/utils/filter-confidence.ts
 function filterHighConfidence(conventions, meta) {
@@ -3843,7 +4039,7 @@ function getExemptedPackages(config) {
   return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
 async function initNonInteractive(projectRoot, configPath) {
-  const s = clack12.spinner();
+  const s = clack13.spinner();
   s.start("Scanning project...");
   const scanResult = await (0, import_scanner2.scan)(projectRoot);
   const config = (0, import_config8.generateConfig)(scanResult);
@@ -3858,11 +4054,11 @@ async function initNonInteractive(projectRoot, configPath) {
   const exempted = getExemptedPackages(config);
   if (exempted.length > 0) {
     console.log(
-      `  ${import_chalk15.default.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${import_chalk15.default.dim("(types-only)")}`
+      `  ${import_chalk17.default.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${import_chalk17.default.dim("(types-only)")}`
     );
   }
   if (config.packages.length > 1) {
-    const bs = clack12.spinner();
+    const bs = clack13.spinner();
     bs.start("Building import graph...");
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -3895,14 +4091,14 @@ async function initNonInteractive(projectRoot, configPath) {
   const hookManager = detectHookManager(projectRoot);
   const hasHookManager = hookManager === "Lefthook" || hookManager === "Husky";
   const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
-  const ok = import_chalk15.default.green("\u2713");
+  const ok = import_chalk17.default.green("\u2713");
   const created = [
     `${ok} ${path20.basename(configPath)}`,
     `${ok} .viberails/context.md`,
     `${ok} .viberails/scan-result.json`,
     `${ok} .claude/settings.json \u2014 added viberails hook`,
     `${ok} CLAUDE.md \u2014 added @.viberails/context.md reference`,
-    preCommitTarget ? `${ok} ${preCommitTarget}` : `${import_chalk15.default.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
+    preCommitTarget ? `${ok} ${preCommitTarget}` : `${import_chalk17.default.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
     actionTarget ? `${ok} ${actionTarget} \u2014 blocks PRs on violations` : ""
   ].filter(Boolean);
   if (hasHookManager && isTypeScript) setupTypecheckHook(projectRoot, rootPkgPm);
@@ -3927,8 +4123,8 @@ async function initCommand(options, cwd) {
       return initInteractive(projectRoot, configPath, options);
     }
     console.log(
-      `${import_chalk16.default.yellow("!")} viberails is already initialized.
-  Run ${import_chalk16.default.cyan("viberails")} to review or edit the existing setup, ${import_chalk16.default.cyan("viberails sync")} to update generated files, or ${import_chalk16.default.cyan("viberails init --force")} to replace it.`
+      `${import_chalk18.default.yellow("!")} viberails is already initialized.
+  Run ${import_chalk18.default.cyan("viberails")} to review or edit the existing setup, ${import_chalk18.default.cyan("viberails sync")} to update generated files, or ${import_chalk18.default.cyan("viberails init --force")} to replace it.`
     );
     return;
   }
@@ -3936,11 +4132,11 @@ async function initCommand(options, cwd) {
   await initInteractive(projectRoot, configPath, options);
 }
 async function initInteractive(projectRoot, configPath, options) {
-  clack13.intro("viberails");
+  clack14.intro("viberails");
   if (fs21.existsSync(configPath) && !options.force) {
     const action = await promptExistingConfigAction(path21.basename(configPath));
     if (action === "cancel") {
-      clack13.outro("Aborted. No files were written.");
+      clack14.outro("Aborted. No files were written.");
       return;
     }
     if (action === "edit") {
@@ -3954,45 +4150,60 @@ async function initInteractive(projectRoot, configPath, options) {
       `${path21.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
-      clack13.outro("Aborted. No files were written.");
+      clack14.outro("Aborted. No files were written.");
       return;
     }
   }
-  const s = clack13.spinner();
+  const s = clack14.spinner();
   s.start("Scanning project...");
   const scanResult = await (0, import_scanner3.scan)(projectRoot);
   const config = (0, import_config9.generateConfig)(scanResult);
   s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    clack13.log.warn(
+    clack14.log.warn(
       "No source files detected. Try running from the project root,\nor check that source files exist. Run viberails sync after adding files."
     );
   }
-  const hasTestRunner = !!scanResult.stack.testRunner;
-  const hookManager = detectHookManager(projectRoot);
-  const coveragePrereqs = checkCoveragePrereqs(projectRoot, scanResult);
   const rootPkgStack = (config.packages.find((p) => p.path === ".") ?? config.packages[0])?.stack;
+  const packageManager = rootPkgStack?.packageManager?.split("@")[0] ?? "npm";
+  const isWorkspace = config.packages.length > 1;
+  const prereqs = await promptPrereqs(
+    projectRoot,
+    scanResult,
+    detectHookManager(projectRoot),
+    packageManager,
+    isWorkspace
+  );
+  if (prereqs.skipCoverage) config.rules.testCoverage = 0;
+  const coveragePrereqs = prereqs.hasTestRunner ? checkCoveragePrereqs(projectRoot, scanResult) : [];
   const state = await promptMainMenu(config, scanResult, {
-    hasTestRunner,
-    hookManager,
+    hasTestRunner: prereqs.hasTestRunner,
+    hookManager: prereqs.hookManager,
     coveragePrereqs,
     projectRoot,
     tools: {
       isTypeScript: rootPkgStack?.language?.split("@")[0] === "typescript",
       linter: rootPkgStack?.linter?.split("@")[0],
-      packageManager: rootPkgStack?.packageManager?.split("@")[0],
-      isWorkspace: config.packages.length > 1
+      packageManager,
+      isWorkspace
     }
   });
   const shouldWrite = await confirm3("Apply this setup?");
   if (!shouldWrite) {
-    clack13.outro("Aborted. No files were written.");
+    clack14.outro("Aborted. No files were written.");
     return;
   }
+  const integrations = await promptIntegrationsDeferred(prereqs.hookManager, {
+    isTypeScript: rootPkgStack?.language?.split("@")[0] === "typescript",
+    typecheckLabel: prereqs.typecheckLabel,
+    linter: rootPkgStack?.linter?.split("@")[0],
+    packageManager,
+    isWorkspace
+  });
   if (state.deferredInstalls.length > 0) {
     await executeDeferredInstalls(projectRoot, state.deferredInstalls);
   }
-  const ws = clack13.spinner();
+  const ws = clack14.spinner();
   ws.start("Writing configuration...");
   const compacted = (0, import_config9.compactConfig)(config);
   fs21.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
@@ -4000,31 +4211,28 @@ async function initInteractive(projectRoot, configPath, options) {
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   ws.stop("Configuration written");
-  const ok = import_chalk16.default.green("\u2713");
-  clack13.log.step(`${ok} ${path21.basename(configPath)}`);
-  clack13.log.step(`${ok} .viberails/context.md`);
-  clack13.log.step(`${ok} .viberails/scan-result.json`);
-  if (state.visited.integrations && state.integrations) {
-    const lefthookExpected = state.deferredInstalls.some((d) => d.command.includes("lefthook"));
-    setupSelectedIntegrations(projectRoot, state.integrations, {
-      linter: rootPkgStack?.linter?.split("@")[0],
-      packageManager: rootPkgStack?.packageManager?.split("@")[0],
-      lefthookExpected
-    });
-  }
-  clack13.outro(
+  const ok = import_chalk18.default.green("\u2713");
+  clack14.log.step(`${ok} ${path21.basename(configPath)}`);
+  clack14.log.step(`${ok} .viberails/context.md`);
+  clack14.log.step(`${ok} .viberails/scan-result.json`);
+  setupSelectedIntegrations(projectRoot, integrations.choice, {
+    linter: rootPkgStack?.linter?.split("@")[0],
+    packageManager,
+    lefthookExpected: prereqs.hookManager === "lefthook"
+  });
+  clack14.outro(
     `Done! Next: review viberails.config.json, then run viberails check
-  ${import_chalk16.default.dim("Tip: use")} ${import_chalk16.default.cyan("viberails check --enforce")} ${import_chalk16.default.dim("in CI to block PRs on violations.")}`
+  ${import_chalk18.default.dim("Tip: use")} ${import_chalk18.default.cyan("viberails check --enforce")} ${import_chalk18.default.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
 var fs22 = __toESM(require("fs"), 1);
 var path22 = __toESM(require("path"), 1);
-var clack14 = __toESM(require("@clack/prompts"), 1);
+var clack15 = __toESM(require("@clack/prompts"), 1);
 var import_config11 = require("@viberails/config");
 var import_scanner4 = require("@viberails/scanner");
-var import_chalk17 = __toESM(require("chalk"), 1);
+var import_chalk19 = __toESM(require("chalk"), 1);
 var CONFIG_FILE6 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
@@ -4050,7 +4258,7 @@ async function syncCommand(options, cwd) {
   const configPath = path22.join(projectRoot, CONFIG_FILE6);
   const existing = await (0, import_config11.loadConfig)(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  const s = clack14.spinner();
+  const s = clack15.spinner();
   s.start("Scanning project...");
   const scanResult = await (0, import_scanner4.scan)(projectRoot);
   s.stop("Scan complete");
@@ -4065,19 +4273,19 @@ async function syncCommand(options, cwd) {
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${import_chalk17.default.bold("Changes:")}`);
+${import_chalk19.default.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? import_chalk17.default.red("-") : import_chalk17.default.green("+");
+      const icon = change.type === "removed" ? import_chalk19.default.red("-") : import_chalk19.default.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${import_chalk17.default.dim(statsDelta)}`);
+      console.log(`  ${import_chalk19.default.dim(statsDelta)}`);
     }
   }
   if (options?.interactive) {
-    clack14.intro("viberails sync (interactive)");
-    clack14.note(formatRulesText(merged).join("\n"), "Rules after sync");
-    const decision = await clack14.select({
+    clack15.intro("viberails sync (interactive)");
+    clack15.note(formatRulesText(merged).join("\n"), "Rules after sync");
+    const decision = await clack15.select({
       message: "How would you like to proceed?",
       options: [
         { value: "accept", label: "Accept changes" },
@@ -4087,7 +4295,7 @@ ${import_chalk17.default.bold("Changes:")}`);
     });
     assertNotCancelled(decision);
     if (decision === "cancel") {
-      clack14.outro("Sync cancelled. No files were written.");
+      clack15.outro("Sync cancelled. No files were written.");
       return;
     }
     if (decision === "customize") {
@@ -4111,8 +4319,8 @@ ${import_chalk17.default.bold("Changes:")}`);
       fs22.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
-      clack14.log.success("Updated config with your customizations.");
-      clack14.outro("Done! Run viberails check to verify.");
+      clack15.log.success("Updated config with your customizations.");
+      clack15.outro("Done! Run viberails check to verify.");
       return;
     }
   }
@@ -4120,18 +4328,18 @@ ${import_chalk17.default.bold("Changes:")}`);
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${import_chalk17.default.bold("Synced:")}`);
+${import_chalk19.default.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${import_chalk17.default.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
+    console.log(`  ${import_chalk19.default.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${import_chalk17.default.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
+    console.log(`  ${import_chalk19.default.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
   }
-  console.log(`  ${import_chalk17.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${import_chalk17.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${import_chalk19.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${import_chalk19.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.6.10";
+var VERSION = "0.6.12";
 var program = new import_commander.Command();
 program.name("viberails").description("Guardrails for vibe coding").version(VERSION);
 program.command("init", { isDefault: true }).description("Scan your project and set up enforcement guardrails").option("-y, --yes", "Non-interactive mode (use defaults, high-confidence only)").option("-f, --force", "Re-initialize, replacing existing config").action(async (options) => {
@@ -4139,7 +4347,7 @@ program.command("init", { isDefault: true }).description("Scan your project and
     await initCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk18.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk20.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4148,7 +4356,7 @@ program.command("sync").description("Re-scan and update generated files").option
     await syncCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk18.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk20.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4157,7 +4365,7 @@ program.command("config").description("Interactively edit existing config rules"
     await configCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk18.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk20.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4178,7 +4386,7 @@ program.command("check").description("Check files against enforced rules").optio
       process.exit(exitCode);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(`${import_chalk18.default.red("Error:")} ${message}`);
+      console.error(`${import_chalk20.default.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -4189,7 +4397,7 @@ program.command("fix").description("Auto-fix file naming violations and generate
     process.exit(exitCode);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk18.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk20.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -4198,7 +4406,7 @@ program.command("boundaries").description("Display, infer, or inspect import bou
     await boundariesCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk18.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk20.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });