viberails 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -34,7 +34,7 @@ __export(index_exports, {
   VERSION: () => VERSION
 });
 module.exports = __toCommonJS(index_exports);
-var import_chalk12 = __toESM(require("chalk"), 1);
+var import_chalk13 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
 
 // src/commands/boundaries.ts
@@ -64,14 +64,66 @@ function findProjectRoot(startDir) {
 var clack5 = __toESM(require("@clack/prompts"), 1);
 
 // src/utils/prompt-integrations.ts
+var import_node_child_process = require("child_process");
 var clack = __toESM(require("@clack/prompts"), 1);
-async function promptIntegrations(hookManager, tools) {
-  const hookLabel = hookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook (git hook)";
+async function promptHookManagerInstall(projectRoot, packageManager) {
+  const choice = await clack.select({
+    message: "No git hook manager detected. Install Lefthook for shareable pre-commit hooks?",
+    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 lefthook" : "npm install -D lefthook";
+  const s = clack.spinner();
+  s.start("Installing Lefthook...");
+  const result = (0, import_node_child_process.spawnSync)(installCmd, {
+    cwd: projectRoot,
+    shell: true,
+    encoding: "utf-8",
+    stdio: "pipe"
+  });
+  if (result.status === 0) {
+    const fs20 = await import("fs");
+    const path20 = await import("path");
+    const lefthookPath = path20.join(projectRoot, "lefthook.yml");
+    if (!fs20.existsSync(lefthookPath)) {
+      fs20.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"
+    );
+  }
+  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: "runs viberails checks when you commit"
+      hint: hookHint
     }
   ];
   if (tools?.isTypeScript) {
@@ -106,7 +158,7 @@ async function promptIntegrations(hookManager, tools) {
       hint: "blocks PRs that fail viberails check"
     }
   );
-  const initialValues = options.map((o) => o.value);
+  const initialValues = isBareHook ? options.filter((o) => o.value !== "preCommit").map((o) => o.value) : options.map((o) => o.value);
   const result = await clack.multiselect({
     message: "Set up integrations?",
     options,
@@ -309,11 +361,10 @@ function buildMenuOptions(state, packageCount) {
       hint: state.fileNamingValue
     });
   }
-  options.push({
-    value: "testCoverage",
-    label: "Test coverage target",
-    hint: state.testCoverage === 0 ? "0 (disabled)" : `${state.testCoverage}%`
-  });
+  const isMonorepo = packageCount > 0;
+  const coverageLabel = isMonorepo ? "Default coverage target" : "Test coverage target";
+  const coverageHint = state.testCoverage === 0 ? "0 (disabled)" : isMonorepo ? `${state.testCoverage}% (per-package default)` : `${state.testCoverage}%`;
+  options.push({ value: "testCoverage", label: coverageLabel, hint: coverageHint });
   options.push({
     value: "enforceMissingTests",
     label: "Enforce missing tests",
@@ -323,16 +374,16 @@ function buildMenuOptions(state, packageCount) {
     options.push(
       {
         value: "coverageSummaryPath",
-        label: "Coverage summary path",
+        label: isMonorepo ? "Default coverage summary path" : "Coverage summary path",
         hint: state.coverageSummaryPath
       },
       {
         value: "coverageCommand",
-        label: "Coverage command",
+        label: isMonorepo ? "Default coverage command" : "Coverage command",
         hint: state.coverageCommand ?? "auto-detect from package.json test runner"
       }
     );
-    if (packageCount > 0) {
+    if (isMonorepo) {
       options.push({
         value: "packageOverrides",
         label: "Per-package coverage overrides",
@@ -678,7 +729,7 @@ ${import_chalk.default.yellow("Cycles detected:")}`);
 // src/commands/check.ts
 var fs7 = __toESM(require("fs"), 1);
 var path7 = __toESM(require("path"), 1);
-var import_config4 = require("@viberails/config");
+var import_config5 = require("@viberails/config");
 var import_chalk2 = __toESM(require("chalk"), 1);
 
 // src/commands/check-config.ts
@@ -723,9 +774,10 @@ function resolveIgnoreForFile(relPath, config) {
 }
 
 // src/commands/check-coverage.ts
-var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
 var fs4 = __toESM(require("fs"), 1);
 var path4 = __toESM(require("path"), 1);
+var import_config3 = require("@viberails/config");
 var DEFAULT_SUMMARY_PATH = "coverage/coverage-summary.json";
 function packageRoot(projectRoot, pkg) {
   return pkg.path === "." ? projectRoot : path4.join(projectRoot, pkg.path);
@@ -765,7 +817,7 @@ function readCoveragePercentage(summaryPath) {
   }
 }
 function runCoverageCommand(pkgRoot, command) {
-  const result = (0, import_node_child_process.spawnSync)(command, {
+  const result = (0, import_node_child_process2.spawnSync)(command, {
     cwd: pkgRoot,
     shell: true,
     encoding: "utf-8",
@@ -806,13 +858,14 @@ function checkCoverage(projectRoot, config, filesToCheck, options) {
   const violations = [];
   for (const target of targets) {
     if (target.rules.testCoverage <= 0) continue;
+    if (!target.pkg.stack?.testRunner) continue;
     const pkgRoot = packageRoot(projectRoot, target.pkg);
     const summaryPath = target.coverage.summaryPath ?? DEFAULT_SUMMARY_PATH;
     const summaryAbs = path4.join(pkgRoot, summaryPath);
     const summaryRel = violationFilePath(projectRoot, pkgRoot, summaryPath);
     let pct = readCoveragePercentage(summaryAbs);
     if (pct === void 0 && !options.staged) {
-      const command = target.coverage.command;
+      const command = target.coverage.command ?? (0, import_config3.inferCoverageCommand)(target.pkg.stack.testRunner);
       if (!command) {
         const pkgLabel = target.pkg.path === "." ? "root package" : target.pkg.path;
         pushViolation(
@@ -823,6 +876,7 @@ function checkCoverage(projectRoot, config, filesToCheck, options) {
         );
         continue;
       }
+      options.onProgress?.(target.pkg.path === "." ? "root" : target.pkg.path);
       const run = runCoverageCommand(pkgRoot, command);
       if (!run.ok) {
         pushViolation(
@@ -857,10 +911,10 @@ function checkCoverage(projectRoot, config, filesToCheck, options) {
 }
 
 // src/commands/check-files.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process3 = require("child_process");
 var fs5 = __toESM(require("fs"), 1);
 var path5 = __toESM(require("path"), 1);
-var import_config3 = require("@viberails/config");
+var import_config4 = require("@viberails/config");
 var import_picomatch = __toESM(require("picomatch"), 1);
 var ALWAYS_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -930,7 +984,7 @@ function checkNaming(relPath, conventions) {
 }
 function getStagedFiles(projectRoot) {
   try {
-    const output = (0, import_node_child_process2.execSync)("git diff --cached --name-only --diff-filter=ACM", {
+    const output = (0, import_node_child_process3.execSync)("git diff --cached --name-only --diff-filter=ACM", {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -942,12 +996,12 @@ function getStagedFiles(projectRoot) {
 }
 function getDiffFiles(projectRoot, base) {
   try {
-    const allOutput = (0, import_node_child_process2.execSync)(`git diff --name-only --diff-filter=ACMR ${base}...HEAD`, {
+    const allOutput = (0, import_node_child_process3.execSync)(`git diff --name-only --diff-filter=ACMR ${base}...HEAD`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const addedOutput = (0, import_node_child_process2.execSync)(`git diff --name-only --diff-filter=A ${base}...HEAD`, {
+    const addedOutput = (0, import_node_child_process3.execSync)(`git diff --name-only --diff-filter=A ${base}...HEAD`, {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -961,7 +1015,7 @@ function getDiffFiles(projectRoot, base) {
   }
 }
 function getAllSourceFiles(projectRoot, config) {
-  const effectiveIgnore = [...import_config3.BUILTIN_IGNORE, ...config.ignore ?? []];
+  const effectiveIgnore = [...import_config4.BUILTIN_IGNORE, ...config.ignore ?? []];
   const files = [];
   const walk = (dir) => {
     let entries;
@@ -1141,7 +1195,7 @@ async function checkCommand(options, cwd) {
     );
     return 1;
   }
-  const config = await (0, import_config4.loadConfig)(configPath);
+  const config = await (0, import_config5.loadConfig)(configPath);
   let filesToCheck;
   let diffAddedFiles = null;
   if (options.staged) {
@@ -1165,6 +1219,9 @@ async function checkCommand(options, cwd) {
   }
   const violations = [];
   const severity = options.enforce ? "error" : "warn";
+  const log7 = options.format !== "json" && !options.hook ? (msg) => process.stderr.write(import_chalk2.default.dim(msg)) : () => {
+  };
+  log7("  Checking files...");
   for (const file of filesToCheck) {
     const absPath = path7.isAbsolute(file) ? file : path7.join(projectRoot, file);
     const relPath = path7.relative(projectRoot, absPath);
@@ -1197,18 +1254,22 @@ async function checkCommand(options, cwd) {
       }
     }
   }
+  log7(" done\n");
   if (!options.staged && !options.files) {
+    log7("  Checking missing tests...");
     const testViolations = checkMissingTests(projectRoot, config, severity);
-    if (diffAddedFiles) {
-      violations.push(...testViolations.filter((v) => diffAddedFiles.has(v.file)));
-    } else {
-      violations.push(...testViolations);
-    }
+    violations.push(
+      ...diffAddedFiles ? testViolations.filter((v) => diffAddedFiles.has(v.file)) : testViolations
+    );
+    log7(" done\n");
   }
   if (!options.files && !options.staged && !options.diffBase) {
+    log7("  Running test coverage...\n");
     const coverageViolations = checkCoverage(projectRoot, config, filesToCheck, {
       staged: options.staged,
-      enforce: options.enforce
+      enforce: options.enforce,
+      onProgress: (pkg) => log7(`    Coverage: ${pkg}...
+`)
     });
     violations.push(...coverageViolations);
   }
@@ -1232,10 +1293,8 @@ async function checkCommand(options, cwd) {
         severity
       });
     }
-    const elapsed = Date.now() - startTime;
-    if (options.format !== "json") {
-      console.log(import_chalk2.default.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
-    }
+    log7(`  Boundary check: ${graph.nodes.length} files in ${Date.now() - startTime}ms
+`);
   }
   if (options.format === "json") {
     console.log(
@@ -1307,431 +1366,367 @@ async function hookCheckCommand(cwd) {
   }
 }
 
-// src/commands/fix.ts
-var fs11 = __toESM(require("fs"), 1);
-var path11 = __toESM(require("path"), 1);
-var import_config5 = require("@viberails/config");
+// src/commands/config.ts
+var fs10 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
+var clack6 = __toESM(require("@clack/prompts"), 1);
+var import_config6 = require("@viberails/config");
+var import_scanner = require("@viberails/scanner");
+var import_chalk5 = __toESM(require("chalk"), 1);
+
+// src/display-text.ts
+var import_types4 = require("@viberails/types");
+
+// src/display.ts
+var import_types3 = require("@viberails/types");
 var import_chalk4 = __toESM(require("chalk"), 1);
 
-// src/commands/fix-helpers.ts
-var import_node_child_process3 = require("child_process");
-var import_chalk3 = __toESM(require("chalk"), 1);
-function printPlan(renames, stubs) {
-  if (renames.length > 0) {
-    console.log(import_chalk3.default.bold("\nFile renames:"));
-    for (const r of renames) {
-      console.log(`  ${import_chalk3.default.red(r.oldPath)} \u2192 ${import_chalk3.default.green(r.newPath)}`);
+// src/display-helpers.ts
+var import_types = require("@viberails/types");
+function groupByRole(directories) {
+  const map = /* @__PURE__ */ new Map();
+  for (const dir of directories) {
+    if (dir.role === "unknown") continue;
+    const existing = map.get(dir.role);
+    if (existing) {
+      existing.dirs.push(dir);
+    } else {
+      map.set(dir.role, { dirs: [dir] });
     }
   }
-  if (stubs.length > 0) {
-    console.log(import_chalk3.default.bold("\nTest stubs to create:"));
-    for (const s of stubs) {
-      console.log(`  ${import_chalk3.default.green("+")} ${s.path}`);
-    }
+  const groups = [];
+  for (const [role, { dirs }] of map) {
+    const label = import_types.ROLE_DESCRIPTIONS[role] ?? role;
+    const totalFiles = dirs.reduce((sum, d) => sum + d.fileCount, 0);
+    groups.push({
+      role,
+      label,
+      dirCount: dirs.length,
+      totalFiles,
+      singlePath: dirs.length === 1 ? dirs[0].path : void 0
+    });
   }
+  return groups;
 }
-function checkGitDirty(projectRoot) {
-  try {
-    const output = (0, import_node_child_process3.execSync)("git status --porcelain", {
-      cwd: projectRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return output.trim().length > 0;
-  } catch {
-    return false;
+function formatSummary(stats, packageCount) {
+  const parts = [];
+  if (packageCount && packageCount > 1) {
+    parts.push(`${packageCount} packages`);
   }
+  parts.push(`${stats.totalFiles.toLocaleString()} source files`);
+  parts.push(`${stats.totalLines.toLocaleString()} lines`);
+  parts.push(`avg ${Math.round(stats.averageFileLines)} lines/file`);
+  return parts.join(" \xB7 ");
 }
-function getConventionValue(convention) {
-  if (typeof convention === "string") return convention;
-  return void 0;
+function formatExtensions(filesByExtension, maxEntries = 4) {
+  return Object.entries(filesByExtension).sort(([, a], [, b]) => b - a).slice(0, maxEntries).map(([ext, count]) => `${ext} ${count}`).join(" \xB7 ");
 }
-
-// src/commands/fix-imports.ts
-var path8 = __toESM(require("path"), 1);
-function stripExtension(filePath) {
-  return filePath.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+function formatRoleGroup(group) {
+  const files = group.totalFiles === 1 ? "1 file" : `${group.totalFiles} files`;
+  if (group.singlePath) {
+    return `${group.label} \u2014 ${group.singlePath} (${files})`;
+  }
+  const dirs = group.dirCount === 1 ? "1 dir" : `${group.dirCount} dirs`;
+  return `${group.label} \u2014 ${dirs} (${files})`;
 }
-function computeNewSpecifier(oldSpecifier, newBare) {
-  const hasJsExt = oldSpecifier.endsWith(".js");
-  const base = hasJsExt ? oldSpecifier.slice(0, -3) : oldSpecifier;
-  const dir = base.lastIndexOf("/");
-  const prefix = dir >= 0 ? base.slice(0, dir + 1) : "";
-  const newSpec = prefix + newBare;
-  return hasJsExt ? `${newSpec}.js` : newSpec;
+
+// src/display-monorepo.ts
+var import_types2 = require("@viberails/types");
+var import_chalk3 = __toESM(require("chalk"), 1);
+function formatPackageSummary(pkg) {
+  const parts = [];
+  if (pkg.stack.framework) {
+    parts.push(formatItem(pkg.stack.framework, import_types2.FRAMEWORK_NAMES));
+  }
+  if (pkg.stack.styling) {
+    parts.push(formatItem(pkg.stack.styling, import_types2.STYLING_NAMES));
+  }
+  const files = `${pkg.statistics.totalFiles} files`;
+  const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
+  return `  ${pkg.relativePath} \u2014 ${detail}`;
 }
-async function updateImportsAfterRenames(renames, projectRoot) {
-  if (renames.length === 0) return [];
-  const { Project, SyntaxKind } = await import("ts-morph");
-  const renameMap = /* @__PURE__ */ new Map();
-  for (const r of renames) {
-    const oldStripped = stripExtension(r.oldAbsPath);
-    const newFilename = path8.basename(r.newPath);
-    const newName = newFilename.slice(0, newFilename.indexOf("."));
-    renameMap.set(oldStripped, { newBare: newName });
+function displayMonorepoResults(scanResult) {
+  const { stack, packages } = scanResult;
+  console.log(`
+${import_chalk3.default.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
+  console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.language)}`);
+  if (stack.packageManager) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
-  const project = new Project({
-    tsConfigFilePath: void 0,
-    skipAddingFilesFromTsConfig: true
-  });
-  project.addSourceFilesAtPaths(path8.join(projectRoot, "**/*.{ts,tsx,js,jsx,mjs,cjs}"));
-  const updates = [];
-  const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
-  for (const sourceFile of project.getSourceFiles()) {
-    const filePath = sourceFile.getFilePath();
-    const segments = filePath.split(path8.sep);
-    if (segments.includes("node_modules") || segments.includes("dist")) continue;
-    const fileDir = path8.dirname(filePath);
-    for (const decl of sourceFile.getImportDeclarations()) {
-      const specifier = decl.getModuleSpecifierValue();
-      if (!specifier.startsWith(".")) continue;
-      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
-      if (!match) continue;
-      const newSpec = computeNewSpecifier(specifier, match.newBare);
-      updates.push({
-        file: filePath,
-        oldSpecifier: specifier,
-        newSpecifier: newSpec,
-        line: decl.getStartLineNumber()
-      });
-      decl.setModuleSpecifier(newSpec);
-    }
-    for (const decl of sourceFile.getExportDeclarations()) {
-      const specifier = decl.getModuleSpecifierValue();
-      if (!specifier || !specifier.startsWith(".")) continue;
-      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
-      if (!match) continue;
-      const newSpec = computeNewSpecifier(specifier, match.newBare);
-      updates.push({
-        file: filePath,
-        oldSpecifier: specifier,
-        newSpecifier: newSpec,
-        line: decl.getStartLineNumber()
-      });
-      decl.setModuleSpecifier(newSpec);
+  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
+  } else {
+    if (stack.linter) {
+      console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.linter)}`);
     }
-    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-      if (call.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
-      const args = call.getArguments();
-      if (args.length === 0) continue;
-      const arg = args[0];
-      if (arg.getKind() !== SyntaxKind.StringLiteral) continue;
-      const specifier = arg.getText().slice(1, -1);
-      if (!specifier.startsWith(".")) continue;
-      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
-      if (!match) continue;
-      const newSpec = computeNewSpecifier(specifier, match.newBare);
-      updates.push({
-        file: filePath,
-        oldSpecifier: specifier,
-        newSpecifier: newSpec,
-        line: call.getStartLineNumber()
-      });
-      const quote = arg.getText()[0];
-      arg.replaceWithText(`${quote}${newSpec}${quote}`);
+    if (stack.formatter) {
+      console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.formatter)}`);
     }
   }
-  if (updates.length > 0) {
-    await project.save();
+  if (stack.testRunner) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
-  return updates;
+  console.log("");
+  for (const pkg of packages) {
+    console.log(formatPackageSummary(pkg));
+  }
+  const packagesWithDirs = packages.filter(
+    (pkg) => pkg.structure.directories.some((d) => d.role !== "unknown")
+  );
+  if (packagesWithDirs.length > 0) {
+    console.log(`
+${import_chalk3.default.bold("Structure:")}`);
+    for (const pkg of packagesWithDirs) {
+      const groups = groupByRole(pkg.structure.directories);
+      if (groups.length === 0) continue;
+      console.log(`  ${pkg.relativePath}:`);
+      for (const group of groups) {
+        console.log(`    ${import_chalk3.default.green("\u2713")} ${formatRoleGroup(group)}`);
+      }
+    }
+  }
+  displayConventions(scanResult);
+  displaySummarySection(scanResult);
+  console.log("");
 }
-function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
-  const cleanSpec = specifier.endsWith(".js") ? specifier.slice(0, -3) : specifier;
-  const resolved = path8.resolve(fromDir, cleanSpec);
-  for (const ext of extensions) {
-    const candidate = resolved + ext;
-    const stripped = stripExtension(candidate);
-    const match = renameMap.get(stripped);
-    if (match) return match;
+function formatPackageSummaryPlain(pkg) {
+  const parts = [];
+  if (pkg.stack.framework) {
+    parts.push(formatItem(pkg.stack.framework, import_types2.FRAMEWORK_NAMES));
   }
-  return void 0;
+  if (pkg.stack.styling) {
+    parts.push(formatItem(pkg.stack.styling, import_types2.STYLING_NAMES));
+  }
+  const files = `${pkg.statistics.totalFiles} files`;
+  const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
+  return `  ${pkg.relativePath} \u2014 ${detail}`;
 }
-
-// src/commands/fix-naming.ts
-var fs9 = __toESM(require("fs"), 1);
-var path9 = __toESM(require("path"), 1);
-
-// src/commands/convert-name.ts
-function splitIntoWords(name) {
-  const parts = name.split(/[-_]/);
-  const words = [];
-  for (const part of parts) {
-    if (part === "") continue;
-    let current = "";
-    for (let i = 0; i < part.length; i++) {
-      const ch = part[i];
-      const isUpper = ch >= "A" && ch <= "Z";
-      if (isUpper && current.length > 0) {
-        const prevIsUpper = current[current.length - 1] >= "A" && current[current.length - 1] <= "Z";
-        const nextIsLower = i + 1 < part.length && part[i + 1] >= "a" && part[i + 1] <= "z";
-        if (!prevIsUpper || nextIsLower) {
-          words.push(current.toLowerCase());
-          current = "";
-        }
+function formatMonorepoResultsText(scanResult) {
+  const lines = [];
+  const { stack, packages } = scanResult;
+  lines.push(`Detected: (monorepo, ${packages.length} packages)`);
+  const sharedParts = [formatItem(stack.language)];
+  if (stack.packageManager) sharedParts.push(formatItem(stack.packageManager));
+  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
+    sharedParts.push(`${formatItem(stack.linter)} (lint + format)`);
+  } else {
+    if (stack.linter) sharedParts.push(formatItem(stack.linter));
+    if (stack.formatter) sharedParts.push(formatItem(stack.formatter));
+  }
+  if (stack.testRunner) sharedParts.push(formatItem(stack.testRunner));
+  lines.push(`  \u2713 ${sharedParts.join(" \xB7 ")}`);
+  lines.push("");
+  for (const pkg of packages) {
+    lines.push(formatPackageSummaryPlain(pkg));
+  }
+  const packagesWithDirs = packages.filter(
+    (pkg) => pkg.structure.directories.some((d) => d.role !== "unknown")
+  );
+  if (packagesWithDirs.length > 0) {
+    lines.push("");
+    lines.push("Structure:");
+    for (const pkg of packagesWithDirs) {
+      const groups = groupByRole(pkg.structure.directories);
+      if (groups.length === 0) continue;
+      lines.push(`  ${pkg.relativePath}:`);
+      for (const group of groups) {
+        lines.push(`    \u2713 ${formatRoleGroup(group)}`);
       }
-      current += ch;
     }
-    if (current) words.push(current.toLowerCase());
   }
-  return words;
-}
-function convertName(bare, target) {
-  const words = splitIntoWords(bare);
-  if (words.length === 0) return bare;
-  switch (target) {
-    case "kebab-case":
-      return words.join("-");
-    case "camelCase":
-      return words[0] + words.slice(1).map(capitalize).join("");
-    case "PascalCase":
-      return words.map(capitalize).join("");
-    case "snake_case":
-      return words.join("_");
-    default:
-      return bare;
+  lines.push(...formatConventionsText(scanResult));
+  const pkgCount = packages.length > 1 ? packages.length : void 0;
+  lines.push("");
+  lines.push(formatSummary(scanResult.statistics, pkgCount));
+  const ext = formatExtensions(scanResult.statistics.filesByExtension);
+  if (ext) {
+    lines.push(ext);
   }
-}
-function capitalize(word) {
-  if (word.length === 0) return word;
-  return word[0].toUpperCase() + word.slice(1);
+  return lines.join("\n");
 }
 
-// src/commands/fix-naming.ts
-function computeRename(relPath, targetConvention, projectRoot) {
-  const filename = path9.basename(relPath);
-  const dir = path9.dirname(relPath);
-  const dotIndex = filename.indexOf(".");
-  if (dotIndex === -1) return null;
-  const bare = filename.slice(0, dotIndex);
-  const suffix = filename.slice(dotIndex);
-  const newBare = convertName(bare, targetConvention);
-  if (newBare === bare) return null;
-  const newFilename = newBare + suffix;
-  const newRelPath = path9.join(dir, newFilename);
-  const oldAbsPath = path9.join(projectRoot, relPath);
-  const newAbsPath = path9.join(projectRoot, newRelPath);
-  if (fs9.existsSync(newAbsPath)) return null;
-  return { oldPath: relPath, newPath: newRelPath, oldAbsPath, newAbsPath };
-}
-function executeRename(rename) {
-  if (fs9.existsSync(rename.newAbsPath)) return false;
-  fs9.renameSync(rename.oldAbsPath, rename.newAbsPath);
-  return true;
+// src/display.ts
+function formatItem(item, nameMap) {
+  const name = nameMap?.[item.name] ?? item.name;
+  return item.version ? `${name} ${item.version}` : name;
 }
-function deduplicateRenames(renames) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const r of renames) {
-    if (seen.has(r.newAbsPath)) continue;
-    seen.add(r.newAbsPath);
-    result.push(r);
+function confidenceLabel(convention) {
+  const pct = Math.round(convention.consistency);
+  if (convention.confidence === "high") {
+    return `${pct}% \u2014 high confidence, will enforce`;
   }
-  return result;
+  return `${pct}% \u2014 medium confidence, suggested only`;
 }
-
-// src/commands/fix-tests.ts
-var fs10 = __toESM(require("fs"), 1);
-var path10 = __toESM(require("path"), 1);
-function generateTestStub(sourceRelPath, config, projectRoot) {
-  const pkg = resolvePackageForFile(sourceRelPath, config);
-  const testPattern = pkg?.structure?.testPattern;
-  if (!testPattern) return null;
-  const basename8 = path10.basename(sourceRelPath);
-  const ext = path10.extname(basename8);
-  if (!ext) return null;
-  const stem = basename8.slice(0, -ext.length);
-  const testSuffix = testPattern.replace("*", "");
-  const testFilename = `${stem}${testSuffix}`;
-  const dir = path10.dirname(path10.join(projectRoot, sourceRelPath));
-  const testAbsPath = path10.join(dir, testFilename);
-  if (fs10.existsSync(testAbsPath)) return null;
-  return {
-    path: path10.relative(projectRoot, testAbsPath),
-    absPath: testAbsPath,
-    moduleName: stem
-  };
+function displayConventions(scanResult) {
+  const conventionEntries = Object.entries(scanResult.conventions);
+  if (conventionEntries.length === 0) return;
+  console.log(`
+${import_chalk4.default.bold("Conventions:")}`);
+  for (const [key, convention] of conventionEntries) {
+    if (convention.confidence === "low") continue;
+    const label = import_types3.CONVENTION_LABELS[key] ?? key;
+    if (scanResult.packages.length > 1) {
+      const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
+      const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
+      if (allSame || pkgValues.length <= 1) {
+        const ind = convention.confidence === "high" ? import_chalk4.default.green("\u2713") : import_chalk4.default.yellow("~");
+        const detail = import_chalk4.default.dim(`(${confidenceLabel(convention)})`);
+        console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+      } else {
+        console.log(`  ${import_chalk4.default.yellow("~")} ${label}: varies by package`);
+        for (const pv of pkgValues) {
+          const pct = Math.round(pv.convention.consistency);
+          console.log(`    ${pv.relativePath}: ${pv.convention.value} (${pct}%)`);
+        }
+      }
+    } else {
+      const ind = convention.confidence === "high" ? import_chalk4.default.green("\u2713") : import_chalk4.default.yellow("~");
+      const detail = import_chalk4.default.dim(`(${confidenceLabel(convention)})`);
+      console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+    }
+  }
 }
-function writeTestStub(stub, config) {
-  const pkg = resolvePackageForFile(stub.path, config);
-  const testRunner = pkg?.stack?.testRunner ?? "";
-  const runner = testRunner.startsWith("jest") ? "jest" : "vitest";
-  const importLine = runner === "jest" ? "" : "import { describe, it, expect } from 'vitest';\n\n";
-  const content = `${importLine}describe('${stub.moduleName}', () => {
-  it.todo('add tests');
-});
-`;
-  fs10.mkdirSync(path10.dirname(stub.absPath), { recursive: true });
-  fs10.writeFileSync(stub.absPath, content);
+function displaySummarySection(scanResult) {
+  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
+  console.log(`
+${import_chalk4.default.bold("Summary:")}`);
+  console.log(`  ${formatSummary(scanResult.statistics, pkgCount)}`);
+  const ext = formatExtensions(scanResult.statistics.filesByExtension);
+  if (ext) {
+    console.log(`  ${ext}`);
+  }
 }
-
-// src/commands/fix.ts
-var CONFIG_FILE3 = "viberails.config.json";
-async function fixCommand(options, cwd) {
-  const startDir = cwd ?? process.cwd();
-  const projectRoot = findProjectRoot(startDir);
-  if (!projectRoot) {
-    console.error(`${import_chalk4.default.red("Error:")} No package.json found. Are you in a JS/TS project?`);
-    return 1;
+function displayScanResults(scanResult) {
+  if (scanResult.packages.length > 1) {
+    displayMonorepoResults(scanResult);
+    return;
   }
-  const configPath = path11.join(projectRoot, CONFIG_FILE3);
-  if (!fs11.existsSync(configPath)) {
-    console.error(
-      `${import_chalk4.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
-    );
-    return 1;
+  const { stack } = scanResult;
+  console.log(`
+${import_chalk4.default.bold("Detected:")}`);
+  if (stack.framework) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.framework, import_types3.FRAMEWORK_NAMES)}`);
   }
-  const config = await (0, import_config5.loadConfig)(configPath);
-  if (!options.dryRun) {
-    const isDirty = checkGitDirty(projectRoot);
-    if (isDirty) {
-      console.log(
-        import_chalk4.default.yellow("Warning: You have uncommitted changes. Consider committing first.")
-      );
-    }
+  console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.language)}`);
+  if (stack.styling) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.styling, import_types3.STYLING_NAMES)}`);
   }
-  const shouldFixNaming = !options.rule || options.rule.includes("file-naming");
-  const shouldFixTests = !options.rule || options.rule.includes("missing-test");
-  const allFiles = getAllSourceFiles(projectRoot, config);
-  const renames = [];
-  if (shouldFixNaming) {
-    for (const file of allFiles) {
-      const resolved = resolveConfigForFile(file, config);
-      if (!resolved.rules.enforceNaming || !resolved.conventions.fileNaming) continue;
-      const violation = checkNaming(file, resolved.conventions);
-      if (!violation) continue;
-      const convention = getConventionValue(resolved.conventions.fileNaming);
-      if (!convention) continue;
-      const rename = computeRename(file, convention, projectRoot);
-      if (rename) renames.push(rename);
-    }
+  if (stack.backend) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.backend, import_types3.FRAMEWORK_NAMES)}`);
   }
-  const dedupedRenames = deduplicateRenames(renames);
-  const testStubs = [];
-  if (shouldFixTests) {
-    const testViolations = checkMissingTests(projectRoot, config, "warn");
-    for (const v of testViolations) {
-      const stub = generateTestStub(v.file, config, projectRoot);
-      if (stub) testStubs.push(stub);
-    }
+  if (stack.orm) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.orm, import_types3.ORM_NAMES)}`);
   }
-  if (dedupedRenames.length === 0 && testStubs.length === 0) {
-    console.log(`${import_chalk4.default.green("\u2713")} No fixable violations found.`);
-    return 0;
+  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
+  } else {
+    if (stack.linter) {
+      console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.linter)}`);
+    }
+    if (stack.formatter) {
+      console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.formatter)}`);
+    }
   }
-  printPlan(dedupedRenames, testStubs);
-  if (options.dryRun) {
-    console.log(import_chalk4.default.dim("\nDry run \u2014 no changes applied."));
-    return 0;
+  if (stack.testRunner) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
-  if (!options.yes) {
-    const confirmed = await confirmDangerous("Apply these fixes?");
-    if (!confirmed) {
-      console.log("Aborted.");
-      return 0;
-    }
+  if (stack.packageManager) {
+    console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
-  let renameCount = 0;
-  for (const rename of dedupedRenames) {
-    if (executeRename(rename)) {
-      renameCount++;
+  if (stack.libraries.length > 0) {
+    for (const lib of stack.libraries) {
+      console.log(`  ${import_chalk4.default.green("\u2713")} ${formatItem(lib, import_types3.LIBRARY_NAMES)}`);
     }
   }
-  let importUpdateCount = 0;
-  if (renameCount > 0) {
-    const appliedRenames = dedupedRenames.filter((r) => fs11.existsSync(r.newAbsPath));
-    const updates = await updateImportsAfterRenames(appliedRenames, projectRoot);
-    importUpdateCount = updates.length;
-  }
-  let stubCount = 0;
-  for (const stub of testStubs) {
-    if (!fs11.existsSync(stub.absPath)) {
-      writeTestStub(stub, config);
-      stubCount++;
+  const groups = groupByRole(scanResult.structure.directories);
+  if (groups.length > 0) {
+    console.log(`
+${import_chalk4.default.bold("Structure:")}`);
+    for (const group of groups) {
+      console.log(`  ${import_chalk4.default.green("\u2713")} ${formatRoleGroup(group)}`);
     }
   }
+  displayConventions(scanResult);
+  displaySummarySection(scanResult);
   console.log("");
-  if (renameCount > 0) {
-    console.log(`${import_chalk4.default.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
-  }
-  if (importUpdateCount > 0) {
-    console.log(
-      `${import_chalk4.default.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
-    );
-  }
-  if (stubCount > 0) {
-    console.log(`${import_chalk4.default.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
+}
+function displayRulesPreview(config) {
+  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  console.log(
+    `${import_chalk4.default.bold("Rules:")} ${import_chalk4.default.dim("(warns on violation; use --enforce in CI to block)")}`
+  );
+  console.log(`  ${import_chalk4.default.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
+  if (config.rules.testCoverage > 0 && root?.structure?.testPattern) {
+    console.log(
+      `  ${import_chalk4.default.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}% (${root.structure.testPattern})`
+    );
+  } else if (config.rules.testCoverage > 0) {
+    console.log(`  ${import_chalk4.default.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}%`);
+  } else {
+    console.log(`  ${import_chalk4.default.dim("\u2022")} Test coverage target: disabled`);
   }
-  return 0;
+  if (config.rules.enforceNaming && root?.conventions?.fileNaming) {
+    console.log(`  ${import_chalk4.default.dim("\u2022")} Enforce file naming: ${root.conventions.fileNaming}`);
+  } else {
+    console.log(`  ${import_chalk4.default.dim("\u2022")} Enforce file naming: no`);
+  }
+  console.log(
+    `  ${import_chalk4.default.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
+  );
+  console.log("");
 }
-
-// src/commands/init.ts
-var fs17 = __toESM(require("fs"), 1);
-var path17 = __toESM(require("path"), 1);
-var clack7 = __toESM(require("@clack/prompts"), 1);
-var import_config6 = require("@viberails/config");
-var import_scanner = require("@viberails/scanner");
-var import_chalk10 = __toESM(require("chalk"), 1);
-
-// src/display.ts
-var import_types4 = require("@viberails/types");
-var import_chalk6 = __toESM(require("chalk"), 1);
-
-// src/display-helpers.ts
-var import_types = require("@viberails/types");
-function groupByRole(directories) {
-  const map = /* @__PURE__ */ new Map();
-  for (const dir of directories) {
-    if (dir.role === "unknown") continue;
-    const existing = map.get(dir.role);
-    if (existing) {
-      existing.dirs.push(dir);
+function displayInitSummary(config, exemptedPackages) {
+  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  const isMonorepo = config.packages.length > 1;
+  const ok = import_chalk4.default.green("\u2713");
+  const off = import_chalk4.default.dim("\u25CB");
+  console.log("");
+  console.log(`  ${import_chalk4.default.bold("Rules to apply:")}`);
+  console.log(`  ${ok} Max file size: ${import_chalk4.default.cyan(`${config.rules.maxFileLines} lines`)}`);
+  if (config.rules.enforceNaming && root?.conventions?.fileNaming) {
+    console.log(`  ${ok} File naming: ${import_chalk4.default.cyan(root.conventions.fileNaming)}`);
+  } else {
+    console.log(`  ${off} File naming: ${import_chalk4.default.dim("not enforced")}`);
+  }
+  if (config.rules.enforceMissingTests && root?.structure?.testPattern) {
+    console.log(`  ${ok} Missing tests: ${import_chalk4.default.cyan(`enforced (${root.structure.testPattern})`)}`);
+  } else if (config.rules.enforceMissingTests) {
+    console.log(`  ${ok} Missing tests: ${import_chalk4.default.cyan("enforced")}`);
+  } else {
+    console.log(`  ${off} Missing tests: ${import_chalk4.default.dim("not enforced")}`);
+  }
+  if (config.rules.testCoverage > 0) {
+    if (isMonorepo) {
+      const withCoverage = config.packages.filter(
+        (p) => (p.rules?.testCoverage ?? config.rules.testCoverage) > 0
+      );
+      console.log(
+        `  ${ok} Coverage: ${import_chalk4.default.cyan(`${config.rules.testCoverage}%`)} default ${import_chalk4.default.dim(`(${withCoverage.length}/${config.packages.length} packages)`)}`
+      );
     } else {
-      map.set(dir.role, { dirs: [dir] });
+      console.log(`  ${ok} Coverage: ${import_chalk4.default.cyan(`${config.rules.testCoverage}%`)}`);
     }
+  } else {
+    console.log(`  ${off} Coverage: ${import_chalk4.default.dim("disabled")}`);
   }
-  const groups = [];
-  for (const [role, { dirs }] of map) {
-    const label = import_types.ROLE_DESCRIPTIONS[role] ?? role;
-    const totalFiles = dirs.reduce((sum, d) => sum + d.fileCount, 0);
-    groups.push({
-      role,
-      label,
-      dirCount: dirs.length,
-      totalFiles,
-      singlePath: dirs.length === 1 ? dirs[0].path : void 0
-    });
-  }
-  return groups;
-}
-function formatSummary(stats, packageCount) {
-  const parts = [];
-  if (packageCount && packageCount > 1) {
-    parts.push(`${packageCount} packages`);
+  if (exemptedPackages.length > 0) {
+    console.log(
+      `  ${import_chalk4.default.dim("  exempted:")} ${import_chalk4.default.dim(exemptedPackages.join(", "))} ${import_chalk4.default.dim("(types-only)")}`
+    );
   }
-  parts.push(`${stats.totalFiles.toLocaleString()} source files`);
-  parts.push(`${stats.totalLines.toLocaleString()} lines`);
-  parts.push(`avg ${Math.round(stats.averageFileLines)} lines/file`);
-  return parts.join(" \xB7 ");
-}
-function formatExtensions(filesByExtension, maxEntries = 4) {
-  return Object.entries(filesByExtension).sort(([, a], [, b]) => b - a).slice(0, maxEntries).map(([ext, count]) => `${ext} ${count}`).join(" \xB7 ");
-}
-function formatRoleGroup(group) {
-  const files = group.totalFiles === 1 ? "1 file" : `${group.totalFiles} files`;
-  if (group.singlePath) {
-    return `${group.label} \u2014 ${group.singlePath} (${files})`;
+  if (isMonorepo) {
+    console.log(
+      `
+  ${import_chalk4.default.dim(`${config.packages.length} packages scanned \xB7 warns on violation \xB7 use --enforce in CI`)}`
+    );
+  } else {
+    console.log(`
+  ${import_chalk4.default.dim("warns on violation \xB7 use --enforce in CI to block")}`);
   }
-  const dirs = group.dirCount === 1 ? "1 dir" : `${group.dirCount} dirs`;
-  return `${group.label} \u2014 ${dirs} (${files})`;
+  console.log("");
 }
 
-// src/display-monorepo.ts
-var import_types3 = require("@viberails/types");
-var import_chalk5 = __toESM(require("chalk"), 1);
-
 // src/display-text.ts
-var import_types2 = require("@viberails/types");
 function plainConfidenceLabel(convention) {
   const pct = Math.round(convention.consistency);
   if (convention.confidence === "high") {
@@ -1747,7 +1742,7 @@ function formatConventionsText(scanResult) {
   lines.push("Conventions:");
   for (const [key, convention] of conventionEntries) {
     if (convention.confidence === "low") continue;
-    const label = import_types2.CONVENTION_LABELS[key] ?? key;
+    const label = import_types4.CONVENTION_LABELS[key] ?? key;
     if (scanResult.packages.length > 1) {
       const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
       const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
@@ -1770,10 +1765,13 @@ function formatConventionsText(scanResult) {
 }
 function formatRulesText(config) {
   const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  const isMonorepo = config.packages.length > 1;
   const lines = [];
   lines.push(`Max file size: ${config.rules.maxFileLines} lines`);
   if (config.rules.testCoverage > 0) {
-    lines.push(`Test coverage target: ${config.rules.testCoverage}%`);
+    const label = isMonorepo ? "Default coverage target" : "Test coverage target";
+    const suffix = isMonorepo ? " (per-package)" : "";
+    lines.push(`${label}: ${config.rules.testCoverage}%${suffix}`);
   } else {
     lines.push("Test coverage target: disabled");
   }
@@ -1798,17 +1796,17 @@ function formatScanResultsText(scanResult) {
   const { stack } = scanResult;
   lines.push("Detected:");
   if (stack.framework) {
-    lines.push(`  \u2713 ${formatItem(stack.framework, import_types2.FRAMEWORK_NAMES)}`);
+    lines.push(`  \u2713 ${formatItem(stack.framework, import_types4.FRAMEWORK_NAMES)}`);
   }
   lines.push(`  \u2713 ${formatItem(stack.language)}`);
   if (stack.styling) {
-    lines.push(`  \u2713 ${formatItem(stack.styling, import_types2.STYLING_NAMES)}`);
+    lines.push(`  \u2713 ${formatItem(stack.styling, import_types4.STYLING_NAMES)}`);
   }
   if (stack.backend) {
-    lines.push(`  \u2713 ${formatItem(stack.backend, import_types2.FRAMEWORK_NAMES)}`);
+    lines.push(`  \u2713 ${formatItem(stack.backend, import_types4.FRAMEWORK_NAMES)}`);
   }
   if (stack.orm) {
-    lines.push(`  \u2713 ${formatItem(stack.orm, import_types2.ORM_NAMES)}`);
+    lines.push(`  \u2713 ${formatItem(stack.orm, import_types4.ORM_NAMES)}`);
   }
   const secondaryParts = [];
   if (stack.packageManager) secondaryParts.push(formatItem(stack.packageManager));
@@ -1820,7 +1818,7 @@ function formatScanResultsText(scanResult) {
   }
   if (stack.libraries.length > 0) {
     for (const lib of stack.libraries) {
-      lines.push(`  \u2713 ${formatItem(lib, import_types2.LIBRARY_NAMES)}`);
+      lines.push(`  \u2713 ${formatItem(lib, import_types4.LIBRARY_NAMES)}`);
     }
   }
   const groups = groupByRole(scanResult.structure.directories);
@@ -1842,256 +1840,652 @@ function formatScanResultsText(scanResult) {
   return lines.join("\n");
 }
 
-// src/display-monorepo.ts
-function formatPackageSummary(pkg) {
-  const parts = [];
-  if (pkg.stack.framework) {
-    parts.push(formatItem(pkg.stack.framework, import_types3.FRAMEWORK_NAMES));
+// src/utils/apply-rule-overrides.ts
+function applyRuleOverrides(config, overrides) {
+  if (overrides.packageOverrides) config.packages = overrides.packageOverrides;
+  config.rules.maxFileLines = overrides.maxFileLines;
+  config.rules.testCoverage = overrides.testCoverage;
+  config.rules.enforceMissingTests = overrides.enforceMissingTests;
+  config.rules.enforceNaming = overrides.enforceNaming;
+  for (const pkg of config.packages) {
+    pkg.coverage = pkg.coverage ?? {};
+    if (pkg.coverage.summaryPath === void 0) {
+      pkg.coverage.summaryPath = overrides.coverageSummaryPath;
+    }
+    if (pkg.coverage.command === void 0 && overrides.coverageCommand) {
+      pkg.coverage.command = overrides.coverageCommand;
+    }
   }
-  if (pkg.stack.styling) {
-    parts.push(formatItem(pkg.stack.styling, import_types3.STYLING_NAMES));
+  if (overrides.fileNamingValue) {
+    const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+    const oldNaming = rootPkg.conventions?.fileNaming;
+    rootPkg.conventions = rootPkg.conventions ?? {};
+    rootPkg.conventions.fileNaming = overrides.fileNamingValue;
+    if (oldNaming && oldNaming !== overrides.fileNamingValue) {
+      for (const pkg of config.packages) {
+        if (pkg.conventions?.fileNaming === oldNaming) {
+          pkg.conventions.fileNaming = overrides.fileNamingValue;
+        }
+      }
+    }
   }
-  const files = `${pkg.statistics.totalFiles} files`;
-  const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
-  return `  ${pkg.relativePath} \u2014 ${detail}`;
 }
-function displayMonorepoResults(scanResult) {
-  const { stack, packages } = scanResult;
-  console.log(`
-${import_chalk5.default.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
-  console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.language)}`);
-  if (stack.packageManager) {
-    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
+
+// src/utils/diff-configs.ts
+var import_types5 = require("@viberails/types");
+function parseStackString(s) {
+  const atIdx = s.indexOf("@");
+  if (atIdx > 0) {
+    return { name: s.slice(0, atIdx), version: s.slice(atIdx + 1) };
   }
-  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
-    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
-  } else {
-    if (stack.linter) {
-      console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.linter)}`);
+  return { name: s };
+}
+function displayStackName(s) {
+  const { name, version } = parseStackString(s);
+  const allMaps = {
+    ...import_types5.FRAMEWORK_NAMES,
+    ...import_types5.STYLING_NAMES,
+    ...import_types5.ORM_NAMES
+  };
+  const display = allMaps[name] ?? name;
+  return version ? `${display} ${version}` : display;
+}
+function isNewlyDetected(config, pkgPath, key) {
+  return config._meta?.packages?.[pkgPath]?.conventions?.[key]?.detected === true;
+}
+var STACK_FIELDS = [
+  "framework",
+  "styling",
+  "backend",
+  "orm",
+  "linter",
+  "formatter",
+  "testRunner"
+];
+var CONVENTION_KEYS = [
+  "fileNaming",
+  "componentNaming",
+  "hookNaming",
+  "importAlias"
+];
+var STRUCTURE_FIELDS = [
+  { key: "srcDir", label: "source directory" },
+  { key: "pages", label: "pages directory" },
+  { key: "components", label: "components directory" },
+  { key: "hooks", label: "hooks directory" },
+  { key: "utils", label: "utilities directory" },
+  { key: "types", label: "types directory" },
+  { key: "tests", label: "tests directory" },
+  { key: "testPattern", label: "test pattern" }
+];
+function diffPackage(existing, merged, mergedConfig) {
+  const changes = [];
+  const pkgPrefix = existing.path === "." ? "" : `${existing.path}: `;
+  for (const field of STACK_FIELDS) {
+    const oldVal = existing.stack?.[field];
+    const newVal = merged.stack?.[field];
+    if (!oldVal && newVal) {
+      changes.push({
+        type: "added",
+        description: `${pkgPrefix}Stack: added ${displayStackName(newVal)}`
+      });
+    } else if (oldVal && newVal && oldVal !== newVal) {
+      changes.push({
+        type: "changed",
+        description: `${pkgPrefix}Stack: ${displayStackName(oldVal)} \u2192 ${displayStackName(newVal)}`
+      });
     }
-    if (stack.formatter) {
-      console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.formatter)}`);
+  }
+  for (const key of CONVENTION_KEYS) {
+    const oldVal = existing.conventions?.[key];
+    const newVal = merged.conventions?.[key];
+    const label = import_types5.CONVENTION_LABELS[key] ?? key;
+    if (!oldVal && newVal) {
+      changes.push({
+        type: "added",
+        description: `${pkgPrefix}New convention: ${label} (${newVal})`
+      });
+    } else if (oldVal && newVal && oldVal !== newVal) {
+      const suffix = isNewlyDetected(mergedConfig, merged.path, key) ? " (newly detected)" : "";
+      changes.push({
+        type: "changed",
+        description: `${pkgPrefix}Convention updated: ${label} (${newVal})${suffix}`
+      });
     }
   }
-  if (stack.testRunner) {
-    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
+  for (const { key, label } of STRUCTURE_FIELDS) {
+    const oldVal = existing.structure?.[key];
+    const newVal = merged.structure?.[key];
+    if (!oldVal && newVal) {
+      changes.push({
+        type: "added",
+        description: `${pkgPrefix}Structure: detected ${label} (${newVal})`
+      });
+    }
   }
-  console.log("");
-  for (const pkg of packages) {
-    console.log(formatPackageSummary(pkg));
+  return changes;
+}
+function diffConfigs(existing, merged) {
+  const changes = [];
+  const existingByPath = new Map(existing.packages.map((p) => [p.path, p]));
+  const mergedByPath = new Map(merged.packages.map((p) => [p.path, p]));
+  for (const existingPkg of existing.packages) {
+    const mergedPkg = mergedByPath.get(existingPkg.path);
+    if (mergedPkg) {
+      changes.push(...diffPackage(existingPkg, mergedPkg, merged));
+    }
   }
-  const packagesWithDirs = packages.filter(
-    (pkg) => pkg.structure.directories.some((d) => d.role !== "unknown")
-  );
-  if (packagesWithDirs.length > 0) {
-    console.log(`
-${import_chalk5.default.bold("Structure:")}`);
-    for (const pkg of packagesWithDirs) {
-      const groups = groupByRole(pkg.structure.directories);
-      if (groups.length === 0) continue;
-      console.log(`  ${pkg.relativePath}:`);
-      for (const group of groups) {
-        console.log(`    ${import_chalk5.default.green("\u2713")} ${formatRoleGroup(group)}`);
-      }
+  for (const mergedPkg of merged.packages) {
+    if (!existingByPath.has(mergedPkg.path)) {
+      changes.push({ type: "added", description: `New package: ${mergedPkg.path}` });
     }
   }
-  displayConventions(scanResult);
-  displaySummarySection(scanResult);
-  console.log("");
+  return changes;
 }
-function formatPackageSummaryPlain(pkg) {
+function formatStatsDelta(oldStats, newStats) {
+  const fileDelta = newStats.totalFiles - oldStats.totalFiles;
+  const lineDelta = newStats.totalLines - oldStats.totalLines;
+  if (fileDelta === 0 && lineDelta === 0) return void 0;
   const parts = [];
-  if (pkg.stack.framework) {
-    parts.push(formatItem(pkg.stack.framework, import_types3.FRAMEWORK_NAMES));
+  if (fileDelta !== 0) {
+    const sign = fileDelta > 0 ? "+" : "";
+    parts.push(`${sign}${fileDelta.toLocaleString()} files`);
   }
-  if (pkg.stack.styling) {
-    parts.push(formatItem(pkg.stack.styling, import_types3.STYLING_NAMES));
+  if (lineDelta !== 0) {
+    const sign = lineDelta > 0 ? "+" : "";
+    parts.push(`${sign}${lineDelta.toLocaleString()} lines`);
   }
-  const files = `${pkg.statistics.totalFiles} files`;
-  const detail = parts.length > 0 ? `${parts.join(", ")} (${files})` : `(${files})`;
-  return `  ${pkg.relativePath} \u2014 ${detail}`;
+  return `${parts.join(", ")} since last sync`;
 }
-function formatMonorepoResultsText(scanResult) {
-  const lines = [];
-  const { stack, packages } = scanResult;
-  lines.push(`Detected: (monorepo, ${packages.length} packages)`);
-  const sharedParts = [formatItem(stack.language)];
-  if (stack.packageManager) sharedParts.push(formatItem(stack.packageManager));
-  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
-    sharedParts.push(`${formatItem(stack.linter)} (lint + format)`);
-  } else {
-    if (stack.linter) sharedParts.push(formatItem(stack.linter));
-    if (stack.formatter) sharedParts.push(formatItem(stack.formatter));
+
+// src/utils/write-generated-files.ts
+var fs9 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+var import_context = require("@viberails/context");
+var CONTEXT_DIR = ".viberails";
+var CONTEXT_FILE = "context.md";
+var SCAN_RESULT_FILE = "scan-result.json";
+function writeGeneratedFiles(projectRoot, config, scanResult) {
+  const contextDir = path8.join(projectRoot, CONTEXT_DIR);
+  try {
+    if (!fs9.existsSync(contextDir)) {
+      fs9.mkdirSync(contextDir, { recursive: true });
+    }
+    const context = (0, import_context.generateContext)(config);
+    fs9.writeFileSync(path8.join(contextDir, CONTEXT_FILE), context);
+    fs9.writeFileSync(
+      path8.join(contextDir, SCAN_RESULT_FILE),
+      `${JSON.stringify(scanResult, null, 2)}
+`
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to write generated files to ${contextDir}: ${message}`);
   }
-  if (stack.testRunner) sharedParts.push(formatItem(stack.testRunner));
-  lines.push(`  \u2713 ${sharedParts.join(" \xB7 ")}`);
-  lines.push("");
-  for (const pkg of packages) {
-    lines.push(formatPackageSummaryPlain(pkg));
+}
+
+// src/commands/config.ts
+var CONFIG_FILE3 = "viberails.config.json";
+async function configCommand(options, cwd) {
+  const projectRoot = findProjectRoot(cwd ?? process.cwd());
+  if (!projectRoot) {
+    throw new Error("No package.json found. Make sure you are inside a JS/TS project.");
   }
-  const packagesWithDirs = packages.filter(
-    (pkg) => pkg.structure.directories.some((d) => d.role !== "unknown")
-  );
-  if (packagesWithDirs.length > 0) {
-    lines.push("");
-    lines.push("Structure:");
-    for (const pkg of packagesWithDirs) {
-      const groups = groupByRole(pkg.structure.directories);
-      if (groups.length === 0) continue;
-      lines.push(`  ${pkg.relativePath}:`);
-      for (const group of groups) {
-        lines.push(`    \u2713 ${formatRoleGroup(group)}`);
+  const configPath = path9.join(projectRoot, CONFIG_FILE3);
+  if (!fs10.existsSync(configPath)) {
+    console.log(`${import_chalk5.default.yellow("!")} No config found. Run ${import_chalk5.default.cyan("viberails init")} first.`);
+    return;
+  }
+  clack6.intro("viberails config");
+  const config = await (0, import_config6.loadConfig)(configPath);
+  let scanResult = options.rescan ? await rescanAndMerge(projectRoot, config) : void 0;
+  clack6.note(formatRulesText(config).join("\n"), "Current rules");
+  const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
+  const overrides = await promptRuleMenu({
+    maxFileLines: config.rules.maxFileLines,
+    testCoverage: config.rules.testCoverage,
+    enforceMissingTests: config.rules.enforceMissingTests,
+    enforceNaming: config.rules.enforceNaming,
+    fileNamingValue: rootPkg.conventions?.fileNaming,
+    coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
+    coverageCommand: config.defaults?.coverage?.command,
+    packageOverrides: config.packages
+  });
+  applyRuleOverrides(config, overrides);
+  if (options.rescan && config.packages.length > 1) {
+    const shouldInfer = await confirm3("Re-infer boundary rules from import patterns?");
+    if (shouldInfer) {
+      const bs = clack6.spinner();
+      bs.start("Building import graph...");
+      const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
+      const packages = resolveWorkspacePackages(projectRoot, config.packages);
+      const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
+      const inferred = inferBoundaries(graph);
+      const denyCount = Object.values(inferred.deny).reduce((sum, arr) => sum + arr.length, 0);
+      if (denyCount > 0) {
+        config.boundaries = inferred;
+        config.rules.enforceBoundaries = true;
+        bs.stop(`Inferred ${denyCount} boundary rules`);
+      } else {
+        bs.stop("No boundary rules inferred");
       }
     }
   }
-  lines.push(...formatConventionsText(scanResult));
-  const pkgCount = packages.length > 1 ? packages.length : void 0;
-  lines.push("");
-  lines.push(formatSummary(scanResult.statistics, pkgCount));
-  const ext = formatExtensions(scanResult.statistics.filesByExtension);
-  if (ext) {
-    lines.push(ext);
+  const shouldWrite = await confirm3("Save updated configuration?");
+  if (!shouldWrite) {
+    clack6.outro("No changes written.");
+    return;
+  }
+  const compacted = (0, import_config6.compactConfig)(config);
+  fs10.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+`);
+  if (!scanResult) {
+    const s = clack6.spinner();
+    s.start("Scanning for context generation...");
+    scanResult = await (0, import_scanner.scan)(projectRoot);
+    s.stop("Scan complete");
+  }
+  writeGeneratedFiles(projectRoot, config, scanResult);
+  clack6.log.success(
+    `Updated:
+  ${CONFIG_FILE3}
+  .viberails/context.md
+  .viberails/scan-result.json`
+  );
+  clack6.outro("Done! Run viberails check to verify.");
+}
+async function rescanAndMerge(projectRoot, config) {
+  const s = clack6.spinner();
+  s.start("Re-scanning project...");
+  const scanResult = await (0, import_scanner.scan)(projectRoot);
+  const merged = (0, import_config6.mergeConfig)(config, scanResult);
+  s.stop("Scan complete");
+  const changes = diffConfigs(config, merged);
+  if (changes.length > 0) {
+    const changeLines = changes.map((c) => {
+      const icon = c.type === "removed" ? "-" : "+";
+      return `${icon} ${c.description}`;
+    }).join("\n");
+    clack6.note(changeLines, "Changes detected");
+  } else {
+    clack6.log.info("No new changes detected from scan.");
+  }
+  Object.assign(config, merged);
+  return scanResult;
+}
+
+// src/commands/fix.ts
+var fs13 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
+var import_config7 = require("@viberails/config");
+var import_chalk7 = __toESM(require("chalk"), 1);
+
+// src/commands/fix-helpers.ts
+var import_node_child_process4 = require("child_process");
+var import_chalk6 = __toESM(require("chalk"), 1);
+function printPlan(renames, stubs) {
+  if (renames.length > 0) {
+    console.log(import_chalk6.default.bold("\nFile renames:"));
+    for (const r of renames) {
+      console.log(`  ${import_chalk6.default.red(r.oldPath)} \u2192 ${import_chalk6.default.green(r.newPath)}`);
+    }
+  }
+  if (stubs.length > 0) {
+    console.log(import_chalk6.default.bold("\nTest stubs to create:"));
+    for (const s of stubs) {
+      console.log(`  ${import_chalk6.default.green("+")} ${s.path}`);
+    }
+  }
+}
+function checkGitDirty(projectRoot) {
+  try {
+    const output = (0, import_node_child_process4.execSync)("git status --porcelain", {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function getConventionValue(convention) {
+  if (typeof convention === "string") return convention;
+  return void 0;
+}
+
+// src/commands/fix-imports.ts
+var path10 = __toESM(require("path"), 1);
+function stripExtension(filePath) {
+  return filePath.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
+}
+function computeNewSpecifier(oldSpecifier, newBare) {
+  const hasJsExt = oldSpecifier.endsWith(".js");
+  const base = hasJsExt ? oldSpecifier.slice(0, -3) : oldSpecifier;
+  const dir = base.lastIndexOf("/");
+  const prefix = dir >= 0 ? base.slice(0, dir + 1) : "";
+  const newSpec = prefix + newBare;
+  return hasJsExt ? `${newSpec}.js` : newSpec;
+}
+async function updateImportsAfterRenames(renames, projectRoot) {
+  if (renames.length === 0) return [];
+  const { Project, SyntaxKind } = await import("ts-morph");
+  const renameMap = /* @__PURE__ */ new Map();
+  for (const r of renames) {
+    const oldStripped = stripExtension(r.oldAbsPath);
+    const newFilename = path10.basename(r.newPath);
+    const newName = newFilename.slice(0, newFilename.indexOf("."));
+    renameMap.set(oldStripped, { newBare: newName });
+  }
+  const project = new Project({
+    tsConfigFilePath: void 0,
+    skipAddingFilesFromTsConfig: true
+  });
+  project.addSourceFilesAtPaths(path10.join(projectRoot, "**/*.{ts,tsx,js,jsx,mjs,cjs}"));
+  const updates = [];
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+  for (const sourceFile of project.getSourceFiles()) {
+    const filePath = sourceFile.getFilePath();
+    const segments = filePath.split(path10.sep);
+    if (segments.includes("node_modules") || segments.includes("dist")) continue;
+    const fileDir = path10.dirname(filePath);
+    for (const decl of sourceFile.getImportDeclarations()) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier.startsWith(".")) continue;
+      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
+      if (!match) continue;
+      const newSpec = computeNewSpecifier(specifier, match.newBare);
+      updates.push({
+        file: filePath,
+        oldSpecifier: specifier,
+        newSpecifier: newSpec,
+        line: decl.getStartLineNumber()
+      });
+      decl.setModuleSpecifier(newSpec);
+    }
+    for (const decl of sourceFile.getExportDeclarations()) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier || !specifier.startsWith(".")) continue;
+      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
+      if (!match) continue;
+      const newSpec = computeNewSpecifier(specifier, match.newBare);
+      updates.push({
+        file: filePath,
+        oldSpecifier: specifier,
+        newSpecifier: newSpec,
+        line: decl.getStartLineNumber()
+      });
+      decl.setModuleSpecifier(newSpec);
+    }
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      if (call.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+      const args = call.getArguments();
+      if (args.length === 0) continue;
+      const arg = args[0];
+      if (arg.getKind() !== SyntaxKind.StringLiteral) continue;
+      const specifier = arg.getText().slice(1, -1);
+      if (!specifier.startsWith(".")) continue;
+      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
+      if (!match) continue;
+      const newSpec = computeNewSpecifier(specifier, match.newBare);
+      updates.push({
+        file: filePath,
+        oldSpecifier: specifier,
+        newSpecifier: newSpec,
+        line: call.getStartLineNumber()
+      });
+      const quote = arg.getText()[0];
+      arg.replaceWithText(`${quote}${newSpec}${quote}`);
+    }
+  }
+  if (updates.length > 0) {
+    await project.save();
   }
-  return lines.join("\n");
-}
-
-// src/display.ts
-function formatItem(item, nameMap) {
-  const name = nameMap?.[item.name] ?? item.name;
-  return item.version ? `${name} ${item.version}` : name;
+  return updates;
 }
-function confidenceLabel(convention) {
-  const pct = Math.round(convention.consistency);
-  if (convention.confidence === "high") {
-    return `${pct}% \u2014 high confidence, will enforce`;
+function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
+  const cleanSpec = specifier.endsWith(".js") ? specifier.slice(0, -3) : specifier;
+  const resolved = path10.resolve(fromDir, cleanSpec);
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    const stripped = stripExtension(candidate);
+    const match = renameMap.get(stripped);
+    if (match) return match;
   }
-  return `${pct}% \u2014 medium confidence, suggested only`;
+  return void 0;
 }
-function displayConventions(scanResult) {
-  const conventionEntries = Object.entries(scanResult.conventions);
-  if (conventionEntries.length === 0) return;
-  console.log(`
-${import_chalk6.default.bold("Conventions:")}`);
-  for (const [key, convention] of conventionEntries) {
-    if (convention.confidence === "low") continue;
-    const label = import_types4.CONVENTION_LABELS[key] ?? key;
-    if (scanResult.packages.length > 1) {
-      const pkgValues = scanResult.packages.filter((pkg) => pkg.conventions[key] && pkg.conventions[key].confidence !== "low").map((pkg) => ({ relativePath: pkg.relativePath, convention: pkg.conventions[key] }));
-      const allSame = pkgValues.every((pv) => pv.convention.value === convention.value);
-      if (allSame || pkgValues.length <= 1) {
-        const ind = convention.confidence === "high" ? import_chalk6.default.green("\u2713") : import_chalk6.default.yellow("~");
-        const detail = import_chalk6.default.dim(`(${confidenceLabel(convention)})`);
-        console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
-      } else {
-        console.log(`  ${import_chalk6.default.yellow("~")} ${label}: varies by package`);
-        for (const pv of pkgValues) {
-          const pct = Math.round(pv.convention.consistency);
-          console.log(`    ${pv.relativePath}: ${pv.convention.value} (${pct}%)`);
+
+// src/commands/fix-naming.ts
+var fs11 = __toESM(require("fs"), 1);
+var path11 = __toESM(require("path"), 1);
+
+// src/commands/convert-name.ts
+function splitIntoWords(name) {
+  const parts = name.split(/[-_]/);
+  const words = [];
+  for (const part of parts) {
+    if (part === "") continue;
+    let current = "";
+    for (let i = 0; i < part.length; i++) {
+      const ch = part[i];
+      const isUpper = ch >= "A" && ch <= "Z";
+      if (isUpper && current.length > 0) {
+        const prevIsUpper = current[current.length - 1] >= "A" && current[current.length - 1] <= "Z";
+        const nextIsLower = i + 1 < part.length && part[i + 1] >= "a" && part[i + 1] <= "z";
+        if (!prevIsUpper || nextIsLower) {
+          words.push(current.toLowerCase());
+          current = "";
         }
       }
-    } else {
-      const ind = convention.confidence === "high" ? import_chalk6.default.green("\u2713") : import_chalk6.default.yellow("~");
-      const detail = import_chalk6.default.dim(`(${confidenceLabel(convention)})`);
-      console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+      current += ch;
     }
+    if (current) words.push(current.toLowerCase());
   }
+  return words;
 }
-function displaySummarySection(scanResult) {
-  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
-  console.log(`
-${import_chalk6.default.bold("Summary:")}`);
-  console.log(`  ${formatSummary(scanResult.statistics, pkgCount)}`);
-  const ext = formatExtensions(scanResult.statistics.filesByExtension);
-  if (ext) {
-    console.log(`  ${ext}`);
+function convertName(bare, target) {
+  const words = splitIntoWords(bare);
+  if (words.length === 0) return bare;
+  switch (target) {
+    case "kebab-case":
+      return words.join("-");
+    case "camelCase":
+      return words[0] + words.slice(1).map(capitalize).join("");
+    case "PascalCase":
+      return words.map(capitalize).join("");
+    case "snake_case":
+      return words.join("_");
+    default:
+      return bare;
   }
 }
-function displayScanResults(scanResult) {
-  if (scanResult.packages.length > 1) {
-    displayMonorepoResults(scanResult);
-    return;
-  }
-  const { stack } = scanResult;
-  console.log(`
-${import_chalk6.default.bold("Detected:")}`);
-  if (stack.framework) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.framework, import_types4.FRAMEWORK_NAMES)}`);
+function capitalize(word) {
+  if (word.length === 0) return word;
+  return word[0].toUpperCase() + word.slice(1);
+}
+
+// src/commands/fix-naming.ts
+function computeRename(relPath, targetConvention, projectRoot) {
+  const filename = path11.basename(relPath);
+  const dir = path11.dirname(relPath);
+  const dotIndex = filename.indexOf(".");
+  if (dotIndex === -1) return null;
+  const bare = filename.slice(0, dotIndex);
+  const suffix = filename.slice(dotIndex);
+  const newBare = convertName(bare, targetConvention);
+  if (newBare === bare) return null;
+  const newFilename = newBare + suffix;
+  const newRelPath = path11.join(dir, newFilename);
+  const oldAbsPath = path11.join(projectRoot, relPath);
+  const newAbsPath = path11.join(projectRoot, newRelPath);
+  if (fs11.existsSync(newAbsPath)) return null;
+  return { oldPath: relPath, newPath: newRelPath, oldAbsPath, newAbsPath };
+}
+function executeRename(rename) {
+  if (fs11.existsSync(rename.newAbsPath)) return false;
+  fs11.renameSync(rename.oldAbsPath, rename.newAbsPath);
+  return true;
+}
+function deduplicateRenames(renames) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const r of renames) {
+    if (seen.has(r.newAbsPath)) continue;
+    seen.add(r.newAbsPath);
+    result.push(r);
   }
-  console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.language)}`);
-  if (stack.styling) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.styling, import_types4.STYLING_NAMES)}`);
+  return result;
+}
+
+// src/commands/fix-tests.ts
+var fs12 = __toESM(require("fs"), 1);
+var path12 = __toESM(require("path"), 1);
+function generateTestStub(sourceRelPath, config, projectRoot) {
+  const pkg = resolvePackageForFile(sourceRelPath, config);
+  const testPattern = pkg?.structure?.testPattern;
+  if (!testPattern) return null;
+  const basename8 = path12.basename(sourceRelPath);
+  const ext = path12.extname(basename8);
+  if (!ext) return null;
+  const stem = basename8.slice(0, -ext.length);
+  const testSuffix = testPattern.replace("*", "");
+  const testFilename = `${stem}${testSuffix}`;
+  const dir = path12.dirname(path12.join(projectRoot, sourceRelPath));
+  const testAbsPath = path12.join(dir, testFilename);
+  if (fs12.existsSync(testAbsPath)) return null;
+  return {
+    path: path12.relative(projectRoot, testAbsPath),
+    absPath: testAbsPath,
+    moduleName: stem
+  };
+}
+function writeTestStub(stub, config) {
+  const pkg = resolvePackageForFile(stub.path, config);
+  const testRunner = pkg?.stack?.testRunner ?? "";
+  const runner = testRunner.startsWith("jest") ? "jest" : "vitest";
+  const importLine = runner === "jest" ? "" : "import { describe, it, expect } from 'vitest';\n\n";
+  const content = `${importLine}describe('${stub.moduleName}', () => {
+  it.todo('add tests');
+});
+`;
+  fs12.mkdirSync(path12.dirname(stub.absPath), { recursive: true });
+  fs12.writeFileSync(stub.absPath, content);
+}
+
+// src/commands/fix.ts
+var CONFIG_FILE4 = "viberails.config.json";
+async function fixCommand(options, cwd) {
+  const startDir = cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(startDir);
+  if (!projectRoot) {
+    console.error(`${import_chalk7.default.red("Error:")} No package.json found. Are you in a JS/TS project?`);
+    return 1;
   }
-  if (stack.backend) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.backend, import_types4.FRAMEWORK_NAMES)}`);
+  const configPath = path13.join(projectRoot, CONFIG_FILE4);
+  if (!fs13.existsSync(configPath)) {
+    console.error(
+      `${import_chalk7.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+    );
+    return 1;
   }
-  if (stack.orm) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.orm, import_types4.ORM_NAMES)}`);
+  const config = await (0, import_config7.loadConfig)(configPath);
+  if (!options.dryRun) {
+    const isDirty = checkGitDirty(projectRoot);
+    if (isDirty) {
+      console.log(
+        import_chalk7.default.yellow("Warning: You have uncommitted changes. Consider committing first.")
+      );
+    }
   }
-  if (stack.linter && stack.formatter && stack.linter.name === stack.formatter.name) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.linter)} (lint + format)`);
-  } else {
-    if (stack.linter) {
-      console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.linter)}`);
+  const shouldFixNaming = !options.rule || options.rule.includes("file-naming");
+  const shouldFixTests = !options.rule || options.rule.includes("missing-test");
+  const allFiles = getAllSourceFiles(projectRoot, config);
+  const renames = [];
+  if (shouldFixNaming) {
+    for (const file of allFiles) {
+      const resolved = resolveConfigForFile(file, config);
+      if (!resolved.rules.enforceNaming || !resolved.conventions.fileNaming) continue;
+      const violation = checkNaming(file, resolved.conventions);
+      if (!violation) continue;
+      const convention = getConventionValue(resolved.conventions.fileNaming);
+      if (!convention) continue;
+      const rename = computeRename(file, convention, projectRoot);
+      if (rename) renames.push(rename);
     }
-    if (stack.formatter) {
-      console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.formatter)}`);
+  }
+  const dedupedRenames = deduplicateRenames(renames);
+  const testStubs = [];
+  if (shouldFixTests) {
+    const testViolations = checkMissingTests(projectRoot, config, "warn");
+    for (const v of testViolations) {
+      const stub = generateTestStub(v.file, config, projectRoot);
+      if (stub) testStubs.push(stub);
     }
   }
-  if (stack.testRunner) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
+  if (dedupedRenames.length === 0 && testStubs.length === 0) {
+    console.log(`${import_chalk7.default.green("\u2713")} No fixable violations found.`);
+    return 0;
   }
-  if (stack.packageManager) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
+  printPlan(dedupedRenames, testStubs);
+  if (options.dryRun) {
+    console.log(import_chalk7.default.dim("\nDry run \u2014 no changes applied."));
+    return 0;
   }
-  if (stack.libraries.length > 0) {
-    for (const lib of stack.libraries) {
-      console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(lib, import_types4.LIBRARY_NAMES)}`);
+  if (!options.yes) {
+    const confirmed = await confirmDangerous("Apply these fixes?");
+    if (!confirmed) {
+      console.log("Aborted.");
+      return 0;
     }
   }
-  const groups = groupByRole(scanResult.structure.directories);
-  if (groups.length > 0) {
-    console.log(`
-${import_chalk6.default.bold("Structure:")}`);
-    for (const group of groups) {
-      console.log(`  ${import_chalk6.default.green("\u2713")} ${formatRoleGroup(group)}`);
+  let renameCount = 0;
+  for (const rename of dedupedRenames) {
+    if (executeRename(rename)) {
+      renameCount++;
     }
   }
-  displayConventions(scanResult);
-  displaySummarySection(scanResult);
-  console.log("");
-}
-function displayRulesPreview(config) {
-  const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
-  console.log(
-    `${import_chalk6.default.bold("Rules:")} ${import_chalk6.default.dim("(warns on violation; use --enforce in CI to block)")}`
-  );
-  console.log(`  ${import_chalk6.default.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
-  if (config.rules.testCoverage > 0 && root?.structure?.testPattern) {
+  let importUpdateCount = 0;
+  if (renameCount > 0) {
+    const appliedRenames = dedupedRenames.filter((r) => fs13.existsSync(r.newAbsPath));
+    const updates = await updateImportsAfterRenames(appliedRenames, projectRoot);
+    importUpdateCount = updates.length;
+  }
+  let stubCount = 0;
+  for (const stub of testStubs) {
+    if (!fs13.existsSync(stub.absPath)) {
+      writeTestStub(stub, config);
+      stubCount++;
+    }
+  }
+  console.log("");
+  if (renameCount > 0) {
+    console.log(`${import_chalk7.default.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
+  }
+  if (importUpdateCount > 0) {
     console.log(
-      `  ${import_chalk6.default.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}% (${root.structure.testPattern})`
+      `${import_chalk7.default.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
     );
-  } else if (config.rules.testCoverage > 0) {
-    console.log(`  ${import_chalk6.default.dim("\u2022")} Test coverage target: ${config.rules.testCoverage}%`);
-  } else {
-    console.log(`  ${import_chalk6.default.dim("\u2022")} Test coverage target: disabled`);
   }
-  if (config.rules.enforceNaming && root?.conventions?.fileNaming) {
-    console.log(`  ${import_chalk6.default.dim("\u2022")} Enforce file naming: ${root.conventions.fileNaming}`);
-  } else {
-    console.log(`  ${import_chalk6.default.dim("\u2022")} Enforce file naming: no`);
+  if (stubCount > 0) {
+    console.log(`${import_chalk7.default.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
   }
-  console.log(
-    `  ${import_chalk6.default.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
-  );
-  console.log("");
+  return 0;
 }
 
+// src/commands/init.ts
+var fs18 = __toESM(require("fs"), 1);
+var path18 = __toESM(require("path"), 1);
+var clack8 = __toESM(require("@clack/prompts"), 1);
+var import_config8 = require("@viberails/config");
+var import_scanner2 = require("@viberails/scanner");
+var import_chalk11 = __toESM(require("chalk"), 1);
+
 // src/utils/check-prerequisites.ts
-var import_node_child_process4 = require("child_process");
-var fs12 = __toESM(require("fs"), 1);
-var path12 = __toESM(require("path"), 1);
-var clack6 = __toESM(require("@clack/prompts"), 1);
-var import_chalk7 = __toESM(require("chalk"), 1);
+var import_node_child_process5 = require("child_process");
+var fs14 = __toESM(require("fs"), 1);
+var path14 = __toESM(require("path"), 1);
+var clack7 = __toESM(require("@clack/prompts"), 1);
+var import_chalk8 = __toESM(require("chalk"), 1);
 function checkCoveragePrereqs(projectRoot, scanResult) {
   const testRunner = scanResult.stack.testRunner;
   if (!testRunner) return [];
@@ -2116,9 +2510,9 @@ function checkCoveragePrereqs(projectRoot, scanResult) {
 function displayMissingPrereqs(prereqs) {
   const missing = prereqs.filter((p) => !p.installed);
   for (const m of missing) {
-    console.log(`  ${import_chalk7.default.yellow("!")} ${m.label} not installed \u2014 ${m.reason}`);
+    console.log(`  ${import_chalk8.default.yellow("!")} ${m.label} not installed \u2014 ${m.reason}`);
     if (m.installCommand) {
-      console.log(`    Install: ${import_chalk7.default.cyan(m.installCommand)}`);
+      console.log(`    Install: ${import_chalk8.default.cyan(m.installCommand)}`);
     }
   }
 }
@@ -2128,11 +2522,11 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
   const prereqLines = prereqs.map(
     (p) => `${p.installed ? "\u2713" : "\u2717"} ${p.label}${p.installed ? "" : ` \u2014 ${p.reason}`}`
   ).join("\n");
-  clack6.note(prereqLines, "Coverage prerequisites");
+  clack7.note(prereqLines, "Coverage prerequisites");
   let disableCoverage = false;
   for (const m of missing) {
     if (!m.installCommand) continue;
-    const choice = await clack6.select({
+    const choice = await clack7.select({
       message: `${m.label} is not installed. It is required for coverage percentage checks.`,
       options: [
         {
@@ -2154,9 +2548,9 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
     });
     assertNotCancelled(choice);
     if (choice === "install") {
-      const is = clack6.spinner();
+      const is = clack7.spinner();
       is.start(`Installing ${m.label}...`);
-      const result = (0, import_node_child_process4.spawnSync)(m.installCommand, {
+      const result = (0, import_node_child_process5.spawnSync)(m.installCommand, {
         cwd: projectRoot,
         shell: true,
         encoding: "utf-8",
@@ -2166,16 +2560,16 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
         is.stop(`Installed ${m.label}`);
       } else {
         is.stop(`Failed to install ${m.label}`);
-        clack6.log.warn(
+        clack7.log.warn(
           `Install manually: ${m.installCommand}
 Coverage percentage checks will not work until the dependency is installed.`
         );
       }
     } else if (choice === "disable") {
       disableCoverage = true;
-      clack6.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
+      clack7.log.info("Coverage percentage checks disabled. Missing-test checks remain active.");
     } else {
-      clack6.log.info(
+      clack7.log.info(
         `Coverage percentage checks will fail until ${m.label} is installed.
 Install later: ${m.installCommand}`
       );
@@ -2185,8 +2579,8 @@ Install later: ${m.installCommand}`
 }
 function hasDependency(projectRoot, name) {
   try {
-    const pkgPath = path12.join(projectRoot, "package.json");
-    const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path14.join(projectRoot, "package.json");
+    const pkg = JSON.parse(fs14.readFileSync(pkgPath, "utf-8"));
     return !!(pkg.devDependencies?.[name] || pkg.dependencies?.[name]);
   } catch {
     return false;
@@ -2208,84 +2602,58 @@ function filterHighConfidence(conventions, meta) {
 }
 
 // src/utils/update-gitignore.ts
-var fs13 = __toESM(require("fs"), 1);
-var path13 = __toESM(require("path"), 1);
+var fs15 = __toESM(require("fs"), 1);
+var path15 = __toESM(require("path"), 1);
 function updateGitignore(projectRoot) {
-  const gitignorePath = path13.join(projectRoot, ".gitignore");
+  const gitignorePath = path15.join(projectRoot, ".gitignore");
   let content = "";
-  if (fs13.existsSync(gitignorePath)) {
-    content = fs13.readFileSync(gitignorePath, "utf-8");
+  if (fs15.existsSync(gitignorePath)) {
+    content = fs15.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()}
 `;
-    fs13.writeFileSync(gitignorePath, `${prefix}${block}`);
-  }
-}
-
-// src/utils/write-generated-files.ts
-var fs14 = __toESM(require("fs"), 1);
-var path14 = __toESM(require("path"), 1);
-var import_context = require("@viberails/context");
-var CONTEXT_DIR = ".viberails";
-var CONTEXT_FILE = "context.md";
-var SCAN_RESULT_FILE = "scan-result.json";
-function writeGeneratedFiles(projectRoot, config, scanResult) {
-  const contextDir = path14.join(projectRoot, CONTEXT_DIR);
-  try {
-    if (!fs14.existsSync(contextDir)) {
-      fs14.mkdirSync(contextDir, { recursive: true });
-    }
-    const context = (0, import_context.generateContext)(config);
-    fs14.writeFileSync(path14.join(contextDir, CONTEXT_FILE), context);
-    fs14.writeFileSync(
-      path14.join(contextDir, SCAN_RESULT_FILE),
-      `${JSON.stringify(scanResult, null, 2)}
-`
-    );
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to write generated files to ${contextDir}: ${message}`);
+    fs15.writeFileSync(gitignorePath, `${prefix}${block}`);
   }
 }
 
 // src/commands/init-hooks.ts
-var fs15 = __toESM(require("fs"), 1);
-var path15 = __toESM(require("path"), 1);
-var import_chalk8 = __toESM(require("chalk"), 1);
+var fs16 = __toESM(require("fs"), 1);
+var path16 = __toESM(require("path"), 1);
+var import_chalk9 = __toESM(require("chalk"), 1);
 var import_yaml = require("yaml");
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path15.join(projectRoot, "lefthook.yml");
-  if (fs15.existsSync(lefthookPath)) {
+  const lefthookPath = path16.join(projectRoot, "lefthook.yml");
+  if (fs16.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${import_chalk8.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${import_chalk9.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return "lefthook.yml";
   }
-  const huskyDir = path15.join(projectRoot, ".husky");
-  if (fs15.existsSync(huskyDir)) {
+  const huskyDir = path16.join(projectRoot, ".husky");
+  if (fs16.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${import_chalk8.default.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${import_chalk9.default.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return ".husky/pre-commit";
   }
-  const gitDir = path15.join(projectRoot, ".git");
-  if (fs15.existsSync(gitDir)) {
-    const hooksDir = path15.join(gitDir, "hooks");
-    if (!fs15.existsSync(hooksDir)) {
-      fs15.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_chalk8.default.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${import_chalk9.default.green("\u2713")} .git/hooks/pre-commit`);
     return ".git/hooks/pre-commit";
   }
   return void 0;
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path15.join(hooksDir, "pre-commit");
-  if (fs15.existsSync(hookPath)) {
-    const existing = fs15.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;
-    fs15.writeFileSync(
+    fs16.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -2302,10 +2670,10 @@ npx viberails check --staged
     "npx viberails check --staged",
     ""
   ].join("\n");
-  fs15.writeFileSync(hookPath, script, { mode: 493 });
+  fs16.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs15.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"]) {
@@ -2317,29 +2685,29 @@ function addLefthookPreCommit(lefthookPath) {
   doc["pre-commit"].commands.viberails = {
     run: "npx viberails check --staged"
   };
-  fs15.writeFileSync(lefthookPath, (0, import_yaml.stringify)(doc));
+  fs16.writeFileSync(lefthookPath, (0, import_yaml.stringify)(doc));
 }
 function detectHookManager(projectRoot) {
-  if (fs15.existsSync(path15.join(projectRoot, "lefthook.yml"))) return "Lefthook";
-  if (fs15.existsSync(path15.join(projectRoot, ".husky"))) return "Husky";
-  if (fs15.existsSync(path15.join(projectRoot, ".git"))) return "git hook";
+  if (fs16.existsSync(path16.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs16.existsSync(path16.join(projectRoot, ".husky"))) return "Husky";
+  if (fs16.existsSync(path16.join(projectRoot, ".git"))) return "git hook";
   return void 0;
 }
 function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path15.join(projectRoot, ".claude");
-  if (!fs15.existsSync(claudeDir)) {
-    fs15.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path16.join(projectRoot, ".claude");
+  if (!fs16.existsSync(claudeDir)) {
+    fs16.mkdirSync(claudeDir, { recursive: true });
   }
-  const settingsPath = path15.join(claudeDir, "settings.json");
+  const settingsPath = path16.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs15.existsSync(settingsPath)) {
+  if (fs16.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs15.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs16.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${import_chalk8.default.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
+        `  ${import_chalk9.default.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      console.warn(`  Fix the JSON manually, then re-run ${import_chalk8.default.cyan("viberails init --force")}`);
+      console.warn(`  Fix the JSON manually, then re-run ${import_chalk9.default.cyan("viberails init --force")}`);
       return;
     }
   }
@@ -2360,30 +2728,30 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs15.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs16.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
-  console.log(`  ${import_chalk8.default.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+  console.log(`  ${import_chalk9.default.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function setupClaudeMdReference(projectRoot) {
-  const claudeMdPath = path15.join(projectRoot, "CLAUDE.md");
+  const claudeMdPath = path16.join(projectRoot, "CLAUDE.md");
   let content = "";
-  if (fs15.existsSync(claudeMdPath)) {
-    content = fs15.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();
-  fs15.writeFileSync(claudeMdPath, prefix + ref);
-  console.log(`  ${import_chalk8.default.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+  fs16.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${import_chalk9.default.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
 }
 function setupGithubAction(projectRoot, packageManager) {
-  const workflowDir = path15.join(projectRoot, ".github", "workflows");
-  const workflowPath = path15.join(workflowDir, "viberails.yml");
-  if (fs15.existsSync(workflowPath)) {
-    const existing = fs15.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;
   }
-  fs15.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`;
@@ -2417,71 +2785,71 @@ function setupGithubAction(projectRoot, packageManager) {
     ""
   );
   const content = lines.filter((l) => l !== void 0).join("\n");
-  fs15.writeFileSync(workflowPath, content);
+  fs16.writeFileSync(workflowPath, content);
   return ".github/workflows/viberails.yml";
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path15.join(huskyDir, "pre-commit");
-  if (fs15.existsSync(hookPath)) {
-    const existing = fs15.readFileSync(hookPath, "utf-8");
+  const hookPath = path16.join(huskyDir, "pre-commit");
+  if (fs16.existsSync(hookPath)) {
+    const existing = fs16.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs15.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
 npx viberails check --staged
 `);
     }
     return;
   }
-  fs15.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
+  fs16.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
 }
 
 // src/commands/init-hooks-extra.ts
-var fs16 = __toESM(require("fs"), 1);
-var path16 = __toESM(require("path"), 1);
-var import_chalk9 = __toESM(require("chalk"), 1);
+var fs17 = __toESM(require("fs"), 1);
+var path17 = __toESM(require("path"), 1);
+var import_chalk10 = __toESM(require("chalk"), 1);
 var import_yaml2 = require("yaml");
 function addPreCommitStep(projectRoot, name, command, marker) {
-  const lefthookPath = path16.join(projectRoot, "lefthook.yml");
-  if (fs16.existsSync(lefthookPath)) {
-    const content = fs16.readFileSync(lefthookPath, "utf-8");
+  const lefthookPath = path17.join(projectRoot, "lefthook.yml");
+  if (fs17.existsSync(lefthookPath)) {
+    const content = fs17.readFileSync(lefthookPath, "utf-8");
     if (content.includes(marker)) return void 0;
     const doc = (0, import_yaml2.parse)(content) ?? {};
     if (!doc["pre-commit"]) doc["pre-commit"] = { commands: {} };
     if (!doc["pre-commit"].commands) doc["pre-commit"].commands = {};
     doc["pre-commit"].commands[name] = { run: command };
-    fs16.writeFileSync(lefthookPath, (0, import_yaml2.stringify)(doc));
+    fs17.writeFileSync(lefthookPath, (0, import_yaml2.stringify)(doc));
     return "lefthook.yml";
   }
-  const huskyDir = path16.join(projectRoot, ".husky");
-  if (fs16.existsSync(huskyDir)) {
-    const hookPath = path16.join(huskyDir, "pre-commit");
-    if (fs16.existsSync(hookPath)) {
-      const existing = fs16.readFileSync(hookPath, "utf-8");
+  const huskyDir = path17.join(projectRoot, ".husky");
+  if (fs17.existsSync(huskyDir)) {
+    const hookPath = path17.join(huskyDir, "pre-commit");
+    if (fs17.existsSync(hookPath)) {
+      const existing = fs17.readFileSync(hookPath, "utf-8");
       if (existing.includes(marker)) return void 0;
-      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs17.writeFileSync(hookPath, `${existing.trimEnd()}
 ${command}
 `);
     } else {
-      fs16.writeFileSync(hookPath, `#!/bin/sh
+      fs17.writeFileSync(hookPath, `#!/bin/sh
 ${command}
 `, { mode: 493 });
     }
     return ".husky/pre-commit";
   }
-  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 });
-    const hookPath = path16.join(hooksDir, "pre-commit");
-    if (fs16.existsSync(hookPath)) {
-      const existing = fs16.readFileSync(hookPath, "utf-8");
+  const gitDir = path17.join(projectRoot, ".git");
+  if (fs17.existsSync(gitDir)) {
+    const hooksDir = path17.join(gitDir, "hooks");
+    if (!fs17.existsSync(hooksDir)) fs17.mkdirSync(hooksDir, { recursive: true });
+    const hookPath = path17.join(hooksDir, "pre-commit");
+    if (fs17.existsSync(hookPath)) {
+      const existing = fs17.readFileSync(hookPath, "utf-8");
       if (existing.includes(marker)) return void 0;
-      fs16.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs17.writeFileSync(hookPath, `${existing.trimEnd()}
 
 # ${name}
 ${command}
 `);
     } else {
-      fs16.writeFileSync(hookPath, `#!/bin/sh
+      fs17.writeFileSync(hookPath, `#!/bin/sh
 # Generated by viberails
 
 # ${name}
@@ -2497,7 +2865,7 @@ ${command}
 function setupTypecheckHook(projectRoot) {
   const target = addPreCommitStep(projectRoot, "typecheck", "npx tsc --noEmit", "tsc");
   if (target) {
-    console.log(`  ${import_chalk9.default.green("\u2713")} ${target} \u2014 added typecheck (tsc --noEmit)`);
+    console.log(`  ${import_chalk10.default.green("\u2713")} ${target} \u2014 added typecheck (tsc --noEmit)`);
   }
   return target;
 }
@@ -2506,7 +2874,7 @@ function setupLintHook(projectRoot, linter) {
   const linterName = linter === "biome" ? "Biome" : "ESLint";
   const target = addPreCommitStep(projectRoot, "lint", command, linter);
   if (target) {
-    console.log(`  ${import_chalk9.default.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
+    console.log(`  ${import_chalk10.default.green("\u2713")} ${target} \u2014 added ${linterName} lint check`);
   }
   return target;
 }
@@ -2540,7 +2908,7 @@ function setupSelectedIntegrations(projectRoot, integrations, opts) {
 }
 
 // src/commands/init.ts
-var CONFIG_FILE4 = "viberails.config.json";
+var CONFIG_FILE5 = "viberails.config.json";
 function getExemptedPackages(config) {
   return config.packages.filter((pkg) => pkg.rules?.testCoverage === 0 && pkg.path !== ".").map((pkg) => pkg.path);
 }
@@ -2551,11 +2919,11 @@ async function initCommand(options, cwd) {
       "No package.json found. Make sure you are inside a JS/TS project, then run:\n  npx viberails"
     );
   }
-  const configPath = path17.join(projectRoot, CONFIG_FILE4);
-  if (fs17.existsSync(configPath) && !options.force) {
+  const configPath = path18.join(projectRoot, CONFIG_FILE5);
+  if (fs18.existsSync(configPath) && !options.force) {
     console.log(
-      `${import_chalk10.default.yellow("!")} viberails is already initialized.
-  Run ${import_chalk10.default.cyan("viberails sync")} to update, or ${import_chalk10.default.cyan("viberails init --force")} to start fresh.`
+      `${import_chalk11.default.yellow("!")} viberails is already initialized.
+  Run ${import_chalk11.default.cyan("viberails config")} to edit rules, ${import_chalk11.default.cyan("viberails sync")} to update, or ${import_chalk11.default.cyan("viberails init --force")} to start fresh.`
     );
     return;
   }
@@ -2563,9 +2931,9 @@ async function initCommand(options, cwd) {
   await initInteractive(projectRoot, configPath, options);
 }
 async function initNonInteractive(projectRoot, configPath) {
-  console.log(import_chalk10.default.dim("Scanning project..."));
-  const scanResult = await (0, import_scanner.scan)(projectRoot);
-  const config = (0, import_config6.generateConfig)(scanResult);
+  console.log(import_chalk11.default.dim("Scanning project..."));
+  const scanResult = await (0, import_scanner2.scan)(projectRoot);
+  const config = (0, import_config8.generateConfig)(scanResult);
   for (const pkg of config.packages) {
     const pkgMeta = config._meta?.packages?.[pkg.path]?.conventions;
     pkg.conventions = filterHighConfidence(pkg.conventions ?? {}, pkgMeta);
@@ -2576,11 +2944,11 @@ async function initNonInteractive(projectRoot, configPath) {
   const exempted = getExemptedPackages(config);
   if (exempted.length > 0) {
     console.log(
-      `  ${import_chalk10.default.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${import_chalk10.default.dim("(types-only)")}`
+      `  ${import_chalk11.default.dim("Auto-exempted from coverage:")} ${exempted.join(", ")} ${import_chalk11.default.dim("(types-only)")}`
     );
   }
   if (config.packages.length > 1) {
-    console.log(import_chalk10.default.dim("Building import graph..."));
+    console.log(import_chalk11.default.dim("Building import graph..."));
     const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
     const packages = resolveWorkspacePackages(projectRoot, config.packages);
     const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
@@ -2592,51 +2960,51 @@ async function initNonInteractive(projectRoot, configPath) {
       console.log(`  Inferred ${denyCount} boundary rules`);
     }
   }
-  const compacted = (0, import_config6.compactConfig)(config);
-  fs17.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  const compacted = (0, import_config8.compactConfig)(config);
+  fs18.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   setupClaudeCodeHook(projectRoot);
   setupClaudeMdReference(projectRoot);
-  const preCommitTarget = setupPreCommitHook(projectRoot);
   const rootPkg = config.packages[0];
   const rootPkgPm = rootPkg?.stack?.packageManager ?? "npm";
   const actionTarget = setupGithubAction(projectRoot, rootPkgPm);
-  const typecheckTarget = rootPkg?.stack?.language === "typescript" ? setupTypecheckHook(projectRoot) : void 0;
+  const hookManager = detectHookManager(projectRoot);
+  const hasHookManager = hookManager === "Lefthook" || hookManager === "Husky";
+  const preCommitTarget = hasHookManager ? setupPreCommitHook(projectRoot) : void 0;
   const linter = rootPkg?.stack?.linter?.split("@")[0];
-  const lintTarget = linter ? setupLintHook(projectRoot, linter) : void 0;
-  const ok = import_chalk10.default.green("\u2713");
+  const ok = import_chalk11.default.green("\u2713");
   const created = [
-    `${ok} ${path17.basename(configPath)}`,
+    `${ok} ${path18.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_chalk10.default.yellow("!")} pre-commit hook skipped`,
-    typecheckTarget ? `${ok} ${typecheckTarget} \u2014 added typecheck` : "",
-    lintTarget ? `${ok} ${lintTarget} \u2014 added lint check` : "",
+    preCommitTarget ? `${ok} ${preCommitTarget}` : `${import_chalk11.default.yellow("!")} pre-commit hook skipped (install lefthook or husky)`,
     actionTarget ? `${ok} ${actionTarget} \u2014 blocks PRs on violations` : ""
   ].filter(Boolean);
+  if (hasHookManager && rootPkg?.stack?.language === "typescript") setupTypecheckHook(projectRoot);
+  if (hasHookManager && linter) setupLintHook(projectRoot, linter);
   console.log(`
 Created:
 ${created.map((f) => `  ${f}`).join("\n")}`);
 }
 async function initInteractive(projectRoot, configPath, options) {
-  clack7.intro("viberails");
-  if (fs17.existsSync(configPath) && options.force) {
+  clack8.intro("viberails");
+  if (fs18.existsSync(configPath) && options.force) {
     const replace = await confirmDangerous(
-      `${path17.basename(configPath)} already exists and will be replaced. Continue?`
+      `${path18.basename(configPath)} already exists and will be replaced. Continue?`
     );
     if (!replace) {
-      clack7.outro("Aborted. No files were written.");
+      clack8.outro("Aborted. No files were written.");
       return;
     }
   }
-  const s = clack7.spinner();
+  const s = clack8.spinner();
   s.start("Scanning project...");
-  const scanResult = await (0, import_scanner.scan)(projectRoot);
-  const config = (0, import_config6.generateConfig)(scanResult);
+  const scanResult = await (0, import_scanner2.scan)(projectRoot);
+  const config = (0, import_config8.generateConfig)(scanResult);
   s.stop("Scan complete");
   const prereqResult = await promptMissingPrereqs(
     projectRoot,
@@ -2646,16 +3014,13 @@ async function initInteractive(projectRoot, configPath, options) {
     config.rules.testCoverage = 0;
   }
   if (scanResult.statistics.totalFiles === 0) {
-    clack7.log.warn(
+    clack8.log.warn(
       "No source files detected. Try running from the project root,\nor check that source files exist. Run viberails sync after adding files."
     );
   }
-  clack7.note(formatScanResultsText(scanResult), "Scan results");
-  const rulesLines = formatRulesText(config);
+  clack8.note(formatScanResultsText(scanResult), "Scan results");
   const exemptedPkgs = getExemptedPackages(config);
-  if (exemptedPkgs.length > 0)
-    rulesLines.push(`Auto-exempted from coverage: ${exemptedPkgs.join(", ")} (types-only)`);
-  clack7.note(rulesLines.join("\n"), "Rules");
+  displayInitSummary(config, exemptedPkgs);
   const decision = await promptInitDecision();
   if (decision === "customize") {
     const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
@@ -2669,41 +3034,16 @@ async function initInteractive(projectRoot, configPath, options) {
       coverageCommand: config.defaults?.coverage?.command,
       packageOverrides: config.packages
     });
-    if (overrides.packageOverrides) config.packages = overrides.packageOverrides;
-    config.rules.maxFileLines = overrides.maxFileLines;
-    config.rules.testCoverage = overrides.testCoverage;
-    config.rules.enforceMissingTests = overrides.enforceMissingTests;
-    config.rules.enforceNaming = overrides.enforceNaming;
-    for (const pkg of config.packages) {
-      pkg.coverage = pkg.coverage ?? {};
-      if (pkg.coverage.summaryPath === void 0) {
-        pkg.coverage.summaryPath = overrides.coverageSummaryPath;
-      }
-      if (pkg.coverage.command === void 0 && overrides.coverageCommand) {
-        pkg.coverage.command = overrides.coverageCommand;
-      }
-    }
-    if (overrides.fileNamingValue) {
-      const oldNaming = rootPkg.conventions?.fileNaming;
-      rootPkg.conventions = rootPkg.conventions ?? {};
-      rootPkg.conventions.fileNaming = overrides.fileNamingValue;
-      if (oldNaming && oldNaming !== overrides.fileNamingValue) {
-        for (const pkg of config.packages) {
-          if (pkg.conventions?.fileNaming === oldNaming) {
-            pkg.conventions.fileNaming = overrides.fileNamingValue;
-          }
-        }
-      }
-    }
+    applyRuleOverrides(config, overrides);
   }
   if (config.packages.length > 1) {
-    clack7.note(
+    clack8.note(
       "Boundary rules prevent packages from importing where they\nshouldn't. viberails scans your existing imports and creates\nrules based on what's already working.",
       "Boundaries"
     );
     const shouldInfer = await confirm3("Infer boundary rules from import patterns?");
     if (shouldInfer) {
-      const bs = clack7.spinner();
+      const bs = clack8.spinner();
       bs.start("Building import graph...");
       const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
       const packages = resolveWorkspacePackages(projectRoot, config.packages);
@@ -2715,7 +3055,7 @@ async function initInteractive(projectRoot, configPath, options) {
         config.rules.enforceBoundaries = true;
         bs.stop(`Inferred ${denyCount} boundary rules`);
         const boundaryLines = Object.entries(inferred.deny).map(([pkg, denied]) => `${pkg} must NOT import from: ${denied.join(", ")}`).join("\n");
-        clack7.note(boundaryLines, "Boundary rules");
+        clack8.note(boundaryLines, "Boundary rules");
       } else {
         bs.stop("No boundary rules inferred");
       }
@@ -2723,22 +3063,23 @@ async function initInteractive(projectRoot, configPath, options) {
   }
   const hookManager = detectHookManager(projectRoot);
   const rootPkgStack = (config.packages.find((p) => p.path === ".") ?? config.packages[0])?.stack;
-  const integrations = await promptIntegrations(hookManager, {
+  const integrations = await promptIntegrations(projectRoot, hookManager, {
     isTypeScript: rootPkgStack?.language === "typescript",
-    linter: rootPkgStack?.linter?.split("@")[0]
+    linter: rootPkgStack?.linter?.split("@")[0],
+    packageManager: rootPkgStack?.packageManager
   });
   const shouldWrite = await confirm3("Write configuration and set up selected integrations?");
   if (!shouldWrite) {
-    clack7.outro("Aborted. No files were written.");
+    clack8.outro("Aborted. No files were written.");
     return;
   }
-  const compacted = (0, import_config6.compactConfig)(config);
-  fs17.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
+  const compacted = (0, import_config8.compactConfig)(config);
+  fs18.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   const createdFiles = [
-    path17.basename(configPath),
+    path18.basename(configPath),
     ".viberails/context.md",
     ".viberails/scan-result.json",
     ...setupSelectedIntegrations(projectRoot, integrations, {
@@ -2746,155 +3087,27 @@ async function initInteractive(projectRoot, configPath, options) {
       packageManager: rootPkgStack?.packageManager
     })
   ];
-  clack7.log.success(`Created:
+  clack8.log.success(`Created:
 ${createdFiles.map((f) => `  ${f}`).join("\n")}`);
-  clack7.outro(
+  clack8.outro(
     `Done! Next: review viberails.config.json, then run viberails check
-  ${import_chalk10.default.dim("Tip: use")} ${import_chalk10.default.cyan("viberails check --enforce")} ${import_chalk10.default.dim("in CI to block PRs on violations.")}`
+  ${import_chalk11.default.dim("Tip: use")} ${import_chalk11.default.cyan("viberails check --enforce")} ${import_chalk11.default.dim("in CI to block PRs on violations.")}`
   );
 }
 
 // src/commands/sync.ts
-var fs18 = __toESM(require("fs"), 1);
-var path18 = __toESM(require("path"), 1);
-var import_config7 = require("@viberails/config");
-var import_scanner2 = require("@viberails/scanner");
-var import_chalk11 = __toESM(require("chalk"), 1);
-
-// src/utils/diff-configs.ts
-var import_types5 = require("@viberails/types");
-function parseStackString(s) {
-  const atIdx = s.indexOf("@");
-  if (atIdx > 0) {
-    return { name: s.slice(0, atIdx), version: s.slice(atIdx + 1) };
-  }
-  return { name: s };
-}
-function displayStackName(s) {
-  const { name, version } = parseStackString(s);
-  const allMaps = {
-    ...import_types5.FRAMEWORK_NAMES,
-    ...import_types5.STYLING_NAMES,
-    ...import_types5.ORM_NAMES
-  };
-  const display = allMaps[name] ?? name;
-  return version ? `${display} ${version}` : display;
-}
-function isNewlyDetected(config, pkgPath, key) {
-  return config._meta?.packages?.[pkgPath]?.conventions?.[key]?.detected === true;
-}
-var STACK_FIELDS = [
-  "framework",
-  "styling",
-  "backend",
-  "orm",
-  "linter",
-  "formatter",
-  "testRunner"
-];
-var CONVENTION_KEYS = [
-  "fileNaming",
-  "componentNaming",
-  "hookNaming",
-  "importAlias"
-];
-var STRUCTURE_FIELDS = [
-  { key: "srcDir", label: "source directory" },
-  { key: "pages", label: "pages directory" },
-  { key: "components", label: "components directory" },
-  { key: "hooks", label: "hooks directory" },
-  { key: "utils", label: "utilities directory" },
-  { key: "types", label: "types directory" },
-  { key: "tests", label: "tests directory" },
-  { key: "testPattern", label: "test pattern" }
-];
-function diffPackage(existing, merged, mergedConfig) {
-  const changes = [];
-  const pkgPrefix = existing.path === "." ? "" : `${existing.path}: `;
-  for (const field of STACK_FIELDS) {
-    const oldVal = existing.stack?.[field];
-    const newVal = merged.stack?.[field];
-    if (!oldVal && newVal) {
-      changes.push({
-        type: "added",
-        description: `${pkgPrefix}Stack: added ${displayStackName(newVal)}`
-      });
-    } else if (oldVal && newVal && oldVal !== newVal) {
-      changes.push({
-        type: "changed",
-        description: `${pkgPrefix}Stack: ${displayStackName(oldVal)} \u2192 ${displayStackName(newVal)}`
-      });
-    }
-  }
-  for (const key of CONVENTION_KEYS) {
-    const oldVal = existing.conventions?.[key];
-    const newVal = merged.conventions?.[key];
-    const label = import_types5.CONVENTION_LABELS[key] ?? key;
-    if (!oldVal && newVal) {
-      changes.push({
-        type: "added",
-        description: `${pkgPrefix}New convention: ${label} (${newVal})`
-      });
-    } else if (oldVal && newVal && oldVal !== newVal) {
-      const suffix = isNewlyDetected(mergedConfig, merged.path, key) ? " (newly detected)" : "";
-      changes.push({
-        type: "changed",
-        description: `${pkgPrefix}Convention updated: ${label} (${newVal})${suffix}`
-      });
-    }
-  }
-  for (const { key, label } of STRUCTURE_FIELDS) {
-    const oldVal = existing.structure?.[key];
-    const newVal = merged.structure?.[key];
-    if (!oldVal && newVal) {
-      changes.push({
-        type: "added",
-        description: `${pkgPrefix}Structure: detected ${label} (${newVal})`
-      });
-    }
-  }
-  return changes;
-}
-function diffConfigs(existing, merged) {
-  const changes = [];
-  const existingByPath = new Map(existing.packages.map((p) => [p.path, p]));
-  const mergedByPath = new Map(merged.packages.map((p) => [p.path, p]));
-  for (const existingPkg of existing.packages) {
-    const mergedPkg = mergedByPath.get(existingPkg.path);
-    if (mergedPkg) {
-      changes.push(...diffPackage(existingPkg, mergedPkg, merged));
-    }
-  }
-  for (const mergedPkg of merged.packages) {
-    if (!existingByPath.has(mergedPkg.path)) {
-      changes.push({ type: "added", description: `New package: ${mergedPkg.path}` });
-    }
-  }
-  return changes;
-}
-function formatStatsDelta(oldStats, newStats) {
-  const fileDelta = newStats.totalFiles - oldStats.totalFiles;
-  const lineDelta = newStats.totalLines - oldStats.totalLines;
-  if (fileDelta === 0 && lineDelta === 0) return void 0;
-  const parts = [];
-  if (fileDelta !== 0) {
-    const sign = fileDelta > 0 ? "+" : "";
-    parts.push(`${sign}${fileDelta.toLocaleString()} files`);
-  }
-  if (lineDelta !== 0) {
-    const sign = lineDelta > 0 ? "+" : "";
-    parts.push(`${sign}${lineDelta.toLocaleString()} lines`);
-  }
-  return `${parts.join(", ")} since last sync`;
-}
-
-// src/commands/sync.ts
-var CONFIG_FILE5 = "viberails.config.json";
+var fs19 = __toESM(require("fs"), 1);
+var path19 = __toESM(require("path"), 1);
+var clack9 = __toESM(require("@clack/prompts"), 1);
+var import_config9 = require("@viberails/config");
+var import_scanner3 = require("@viberails/scanner");
+var import_chalk12 = __toESM(require("chalk"), 1);
+var CONFIG_FILE6 = "viberails.config.json";
 var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
-  const scanResultPath = path18.join(projectRoot, SCAN_RESULT_FILE2);
+  const scanResultPath = path19.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs18.readFileSync(scanResultPath, "utf-8");
+    const raw = fs19.readFileSync(scanResultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.statistics?.totalFiles !== void 0) {
       return parsed.statistics;
@@ -2903,7 +3116,7 @@ function loadPreviousStats(projectRoot) {
   }
   return void 0;
 }
-async function syncCommand(cwd) {
+async function syncCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
   if (!projectRoot) {
@@ -2911,15 +3124,15 @@ async function syncCommand(cwd) {
       "No package.json found in this directory or any parent.\n\nMake sure you are inside a JavaScript or TypeScript project, then run:\n  npx viberails"
     );
   }
-  const configPath = path18.join(projectRoot, CONFIG_FILE5);
-  const existing = await (0, import_config7.loadConfig)(configPath);
+  const configPath = path19.join(projectRoot, CONFIG_FILE6);
+  const existing = await (0, import_config9.loadConfig)(configPath);
   const previousStats = loadPreviousStats(projectRoot);
-  console.log(import_chalk11.default.dim("Scanning project..."));
-  const scanResult = await (0, import_scanner2.scan)(projectRoot);
-  const merged = (0, import_config7.mergeConfig)(existing, scanResult);
-  const compacted = (0, import_config7.compactConfig)(merged);
+  console.log(import_chalk12.default.dim("Scanning project..."));
+  const scanResult = await (0, import_scanner3.scan)(projectRoot);
+  const merged = (0, import_config9.mergeConfig)(existing, scanResult);
+  const compacted = (0, import_config9.compactConfig)(merged);
   const compactedJson = JSON.stringify(compacted, null, 2);
-  const rawDisk = fs18.readFileSync(configPath, "utf-8").trim();
+  const rawDisk = fs19.readFileSync(configPath, "utf-8").trim();
   const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const mergedWithoutSync = compactedJson.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
   const configChanged = diskWithoutSync !== mergedWithoutSync;
@@ -2927,31 +3140,69 @@ async function syncCommand(cwd) {
   const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
   if (changes.length > 0 || statsDelta) {
     console.log(`
-${import_chalk11.default.bold("Changes:")}`);
+${import_chalk12.default.bold("Changes:")}`);
     for (const change of changes) {
-      const icon = change.type === "removed" ? import_chalk11.default.red("-") : import_chalk11.default.green("+");
+      const icon = change.type === "removed" ? import_chalk12.default.red("-") : import_chalk12.default.green("+");
       console.log(`  ${icon} ${change.description}`);
     }
     if (statsDelta) {
-      console.log(`  ${import_chalk11.default.dim(statsDelta)}`);
+      console.log(`  ${import_chalk12.default.dim(statsDelta)}`);
     }
   }
-  fs18.writeFileSync(configPath, `${compactedJson}
+  if (options?.interactive) {
+    clack9.intro("viberails sync (interactive)");
+    clack9.note(formatRulesText(merged).join("\n"), "Rules after sync");
+    const decision = await clack9.select({
+      message: "How would you like to proceed?",
+      options: [
+        { value: "accept", label: "Accept changes" },
+        { value: "customize", label: "Customize rules" },
+        { value: "cancel", label: "Cancel (no changes written)" }
+      ]
+    });
+    assertNotCancelled(decision);
+    if (decision === "cancel") {
+      clack9.outro("Sync cancelled. No files were written.");
+      return;
+    }
+    if (decision === "customize") {
+      const rootPkg = merged.packages.find((p) => p.path === ".") ?? merged.packages[0];
+      const overrides = await promptRuleMenu({
+        maxFileLines: merged.rules.maxFileLines,
+        testCoverage: merged.rules.testCoverage,
+        enforceMissingTests: merged.rules.enforceMissingTests,
+        enforceNaming: merged.rules.enforceNaming,
+        fileNamingValue: rootPkg.conventions?.fileNaming,
+        coverageSummaryPath: rootPkg.coverage?.summaryPath ?? "coverage/coverage-summary.json",
+        coverageCommand: merged.defaults?.coverage?.command,
+        packageOverrides: merged.packages
+      });
+      applyRuleOverrides(merged, overrides);
+      const recompacted = (0, import_config9.compactConfig)(merged);
+      fs19.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
+`);
+      writeGeneratedFiles(projectRoot, merged, scanResult);
+      clack9.log.success("Updated config with your customizations.");
+      clack9.outro("Done! Run viberails check to verify.");
+      return;
+    }
+  }
+  fs19.writeFileSync(configPath, `${compactedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${import_chalk11.default.bold("Synced:")}`);
+${import_chalk12.default.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${import_chalk11.default.yellow("!")} ${CONFIG_FILE5} \u2014 updated (review changes)`);
+    console.log(`  ${import_chalk12.default.yellow("!")} ${CONFIG_FILE6} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${import_chalk11.default.green("\u2713")} ${CONFIG_FILE5} \u2014 unchanged`);
+    console.log(`  ${import_chalk12.default.green("\u2713")} ${CONFIG_FILE6} \u2014 unchanged`);
   }
-  console.log(`  ${import_chalk11.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${import_chalk11.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${import_chalk12.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${import_chalk12.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.5.0";
+var VERSION = "0.5.2";
 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) => {
@@ -2959,16 +3210,25 @@ 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_chalk12.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk13.default.red("Error:")} ${message}`);
+    process.exit(1);
+  }
+});
+program.command("sync").description("Re-scan and update generated files").option("-i, --interactive", "Review changes before writing").action(async (options) => {
+  try {
+    await syncCommand(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${import_chalk13.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
-program.command("sync").description("Re-scan and update generated files").action(async () => {
+program.command("config").description("Interactively edit existing config rules").option("--rescan", "Re-scan project first (picks up new packages, stack changes)").action(async (options) => {
   try {
-    await syncCommand();
+    await configCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk12.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk13.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -2989,7 +3249,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_chalk12.default.red("Error:")} ${message}`);
+      console.error(`${import_chalk13.default.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -3000,7 +3260,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_chalk12.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk13.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -3009,7 +3269,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_chalk12.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk13.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });