viberails 0.3.1 → 0.3.3

package/dist/index.cjs

@@ -34,14 +34,14 @@ __export(index_exports, {
   VERSION: () => VERSION
 });
 module.exports = __toCommonJS(index_exports);
-var import_chalk11 = __toESM(require("chalk"), 1);
+var import_chalk10 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
 
 // src/commands/boundaries.ts
 var fs3 = __toESM(require("fs"), 1);
 var path3 = __toESM(require("path"), 1);
 var import_config = require("@viberails/config");
-var import_chalk2 = __toESM(require("chalk"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
 
 // src/utils/find-project-root.ts
 var fs = __toESM(require("fs"), 1);
@@ -61,43 +61,110 @@ function findProjectRoot(startDir) {
 }
 
 // src/utils/prompt.ts
-var readline = __toESM(require("readline"), 1);
-var import_chalk = __toESM(require("chalk"), 1);
-async function confirm(message) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise((resolve4) => {
-    rl.question(`${message} (Y/n) `, (answer) => {
-      rl.close();
-      const trimmed = answer.trim().toLowerCase();
-      resolve4(trimmed === "" || trimmed === "y" || trimmed === "yes");
-    });
+var clack = __toESM(require("@clack/prompts"), 1);
+function assertNotCancelled(value) {
+  if (clack.isCancel(value)) {
+    clack.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+}
+async function confirm2(message) {
+  const result = await clack.confirm({ message, initialValue: true });
+  assertNotCancelled(result);
+  return result;
+}
+async function confirmDangerous(message) {
+  const result = await clack.confirm({ message, initialValue: false });
+  assertNotCancelled(result);
+  return result;
+}
+async function promptInitDecision() {
+  const result = await clack.select({
+    message: "Accept these settings?",
+    options: [
+      { value: "accept", label: "Yes, looks good", hint: "recommended" },
+      { value: "customize", label: "Let me customize" }
+    ]
   });
+  assertNotCancelled(result);
+  return result;
 }
-async function selectIntegrations(hookManager) {
-  const result = { preCommitHook: true, claudeCodeHook: true };
-  const hookLabel = hookManager ? `Pre-commit hook (detected: ${hookManager})` : "Pre-commit hook (git hook)";
-  console.log("Set up integrations:");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+async function promptRuleCustomization(defaults) {
+  const maxFileLinesResult = await clack.text({
+    message: "Maximum lines per source file?",
+    placeholder: String(defaults.maxFileLines),
+    initialValue: String(defaults.maxFileLines),
+    validate: (v) => {
+      const n = Number.parseInt(v, 10);
+      if (Number.isNaN(n) || n < 1) return "Enter a positive number";
+    }
   });
-  const askYn = (label, defaultYes) => new Promise((resolve4) => {
-    const hint = defaultYes ? "Y/n" : "y/N";
-    rl.question(`  ${label}? (${hint}) `, (answer) => {
-      const trimmed = answer.trim().toLowerCase();
-      if (trimmed === "") resolve4(defaultYes);
-      else resolve4(trimmed === "y" || trimmed === "yes");
-    });
+  assertNotCancelled(maxFileLinesResult);
+  const requireTestsResult = await clack.confirm({
+    message: "Require matching test files for source files?",
+    initialValue: defaults.requireTests
   });
-  console.log(`    ${import_chalk.default.dim("Runs viberails check automatically when you commit")}`);
-  result.preCommitHook = await askYn(hookLabel, true);
-  console.log(`    ${import_chalk.default.dim("Checks files against your rules when Claude edits them")}`);
-  result.claudeCodeHook = await askYn("Claude Code hook", true);
-  rl.close();
-  return result;
+  assertNotCancelled(requireTestsResult);
+  const namingLabel = defaults.fileNamingValue ? `Enforce file naming? (detected: ${defaults.fileNamingValue})` : "Enforce file naming?";
+  const enforceNamingResult = await clack.confirm({
+    message: namingLabel,
+    initialValue: defaults.enforceNaming
+  });
+  assertNotCancelled(enforceNamingResult);
+  const enforcementResult = await clack.select({
+    message: "Enforcement mode",
+    options: [
+      {
+        value: "warn",
+        label: "warn",
+        hint: "show violations but don't block commits (recommended)"
+      },
+      {
+        value: "enforce",
+        label: "enforce",
+        hint: "block commits with violations"
+      }
+    ],
+    initialValue: defaults.enforcement
+  });
+  assertNotCancelled(enforcementResult);
+  return {
+    maxFileLines: Number.parseInt(maxFileLinesResult, 10),
+    requireTests: requireTestsResult,
+    enforceNaming: enforceNamingResult,
+    enforcement: enforcementResult
+  };
+}
+async function promptIntegrations(hookManager) {
+  const hookLabel = hookManager ? `Pre-commit hook (${hookManager})` : "Pre-commit hook (git hook)";
+  const result = await clack.multiselect({
+    message: "Set up integrations?",
+    options: [
+      {
+        value: "preCommit",
+        label: hookLabel,
+        hint: "runs checks when you commit"
+      },
+      {
+        value: "claude",
+        label: "Claude Code hook",
+        hint: "checks files when Claude edits them"
+      },
+      {
+        value: "claudeMd",
+        label: "CLAUDE.md reference",
+        hint: "appends @.viberails/context.md so Claude loads rules automatically"
+      }
+    ],
+    initialValues: ["preCommit", "claude", "claudeMd"],
+    required: false
+  });
+  assertNotCancelled(result);
+  return {
+    preCommitHook: result.includes("preCommit"),
+    claudeCodeHook: result.includes("claude"),
+    claudeMdRef: result.includes("claudeMd")
+  };
 }
 
 // src/utils/resolve-workspace-packages.ts
@@ -154,67 +221,65 @@ async function boundariesCommand(options, cwd) {
   displayRules(config);
 }
 function displayRules(config) {
-  if (!config.boundaries || config.boundaries.length === 0) {
-    console.log(import_chalk2.default.yellow("No boundary rules configured."));
-    console.log(`Run ${import_chalk2.default.cyan("viberails boundaries --infer")} to generate rules.`);
+  if (!config.boundaries || Object.keys(config.boundaries.deny).length === 0) {
+    console.log(import_chalk.default.yellow("No boundary rules configured."));
+    console.log(`Run ${import_chalk.default.cyan("viberails boundaries --infer")} to generate rules.`);
     return;
   }
-  const allowRules = config.boundaries.filter((r) => r.allow);
-  const denyRules = config.boundaries.filter((r) => !r.allow);
+  const { deny } = config.boundaries;
+  const sources = Object.keys(deny).filter((k) => deny[k].length > 0);
+  const totalRules = sources.reduce((sum, k) => sum + deny[k].length, 0);
   console.log(`
-${import_chalk2.default.bold(`Boundary rules (${config.boundaries.length} rules):`)}
+${import_chalk.default.bold(`Boundary rules (${totalRules} deny rules):`)}
 `);
-  for (const r of allowRules) {
-    console.log(`  ${import_chalk2.default.green("\u2713")} ${r.from} \u2192 ${r.to}`);
-  }
-  for (const r of denyRules) {
-    const reason = r.reason ? import_chalk2.default.dim(` (${r.reason})`) : "";
-    console.log(`  ${import_chalk2.default.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
+  for (const source of sources) {
+    for (const target of deny[source]) {
+      console.log(`  ${import_chalk.default.red("\u2717")} ${source} \u2192 ${target}`);
+    }
   }
   console.log(
     `
-Enforcement: ${config.rules.enforceBoundaries ? import_chalk2.default.green("on") : import_chalk2.default.yellow("off")}`
+Enforcement: ${config.rules.enforceBoundaries ? import_chalk.default.green("on") : import_chalk.default.yellow("off")}`
   );
 }
 async function inferAndDisplay(projectRoot, config, configPath) {
-  console.log(import_chalk2.default.dim("Analyzing imports..."));
+  console.log(import_chalk.default.dim("Analyzing imports..."));
   const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
   const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
   const graph = await buildImportGraph(projectRoot, {
     packages,
     ignore: config.ignore
   });
-  console.log(import_chalk2.default.dim(`${graph.nodes.length} files, ${graph.edges.length} edges`));
+  console.log(import_chalk.default.dim(`${graph.nodes.length} files, ${graph.edges.length} edges`));
   const inferred = inferBoundaries(graph);
-  if (inferred.length === 0) {
-    console.log(import_chalk2.default.yellow("No boundary rules could be inferred."));
+  const sources = Object.keys(inferred.deny).filter((k) => inferred.deny[k].length > 0);
+  const totalRules = sources.reduce((sum, k) => sum + inferred.deny[k].length, 0);
+  if (totalRules === 0) {
+    console.log(import_chalk.default.yellow("No boundary rules could be inferred."));
     return;
   }
-  const allow = inferred.filter((r) => r.allow);
-  const deny = inferred.filter((r) => !r.allow);
   console.log(`
-${import_chalk2.default.bold("Inferred boundary rules:")}
+${import_chalk.default.bold("Inferred boundary rules:")}
 `);
-  for (const r of allow) {
-    console.log(`  ${import_chalk2.default.green("\u2713")} ${r.from} \u2192 ${r.to}`);
-  }
-  for (const r of deny) {
-    const reason = r.reason ? import_chalk2.default.dim(` (${r.reason})`) : "";
-    console.log(`  ${import_chalk2.default.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
+  for (const source of sources) {
+    for (const target of inferred.deny[source]) {
+      console.log(`  ${import_chalk.default.red("\u2717")} ${source} \u2192 ${target}`);
+    }
   }
   console.log(`
-  ${allow.length} allowed, ${deny.length} denied`);
-  const shouldSave = await confirm("\nSave to viberails.config.json?");
+  ${totalRules} denied`);
+  console.log("");
+  const shouldSave = await confirm2("Save to viberails.config.json?");
   if (shouldSave) {
     config.boundaries = inferred;
     config.rules.enforceBoundaries = true;
     fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `);
-    console.log(`${import_chalk2.default.green("\u2713")} Saved ${inferred.length} rules`);
+    console.log(`${import_chalk.default.green("\u2713")} Saved ${totalRules} rules`);
   }
 }
 async function showGraph(projectRoot, config) {
-  console.log(import_chalk2.default.dim("Building import graph..."));
+  console.log(import_chalk.default.dim("Building import graph..."));
   const { buildImportGraph } = await import("@viberails/graph");
   const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
   const graph = await buildImportGraph(projectRoot, {
@@ -222,20 +287,20 @@ async function showGraph(projectRoot, config) {
     ignore: config.ignore
   });
   console.log(`
-${import_chalk2.default.bold("Import dependency graph:")}
+${import_chalk.default.bold("Import dependency graph:")}
 `);
   console.log(`  ${graph.nodes.length} files, ${graph.edges.length} imports
 `);
   if (graph.packages.length > 0) {
     for (const pkg of graph.packages) {
       const deps = pkg.internalDeps.length > 0 ? `
-${pkg.internalDeps.map((d) => `    \u2192 ${d}`).join("\n")}` : import_chalk2.default.dim(" (no internal deps)");
+${pkg.internalDeps.map((d) => `    \u2192 ${d}`).join("\n")}` : import_chalk.default.dim(" (no internal deps)");
       console.log(`  ${pkg.name}${deps}`);
     }
   }
   if (graph.cycles.length > 0) {
     console.log(`
-${import_chalk2.default.yellow("Cycles detected:")}`);
+${import_chalk.default.yellow("Cycles detected:")}`);
     for (const cycle of graph.cycles) {
       const paths = cycle.map((f) => path3.relative(projectRoot, f));
       console.log(`  ${paths.join(" \u2192 ")}`);
@@ -247,7 +312,7 @@ ${import_chalk2.default.yellow("Cycles detected:")}`);
 var fs6 = __toESM(require("fs"), 1);
 var path6 = __toESM(require("path"), 1);
 var import_config2 = require("@viberails/config");
-var import_chalk3 = __toESM(require("chalk"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
 
 // src/commands/check-config.ts
 function resolveConfigForFile(relPath, config) {
@@ -485,12 +550,12 @@ function printGroupedViolations(violations, limit) {
     const toShow = group.slice(0, remaining);
     const hidden = group.length - toShow.length;
     for (const v of toShow) {
-      const icon = v.severity === "error" ? import_chalk3.default.red("\u2717") : import_chalk3.default.yellow("!");
-      console.log(`${icon} ${import_chalk3.default.dim(v.rule)} ${v.file}: ${v.message}`);
+      const icon = v.severity === "error" ? import_chalk2.default.red("\u2717") : import_chalk2.default.yellow("!");
+      console.log(`${icon} ${import_chalk2.default.dim(v.rule)} ${v.file}: ${v.message}`);
     }
     totalShown += toShow.length;
     if (hidden > 0) {
-      console.log(import_chalk3.default.dim(`  ... and ${hidden} more ${rule} violations`));
+      console.log(import_chalk2.default.dim(`  ... and ${hidden} more ${rule} violations`));
     }
   }
 }
@@ -508,13 +573,13 @@ async function checkCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
   if (!projectRoot) {
-    console.error(`${import_chalk3.default.red("Error:")} No package.json found. Are you in a JS/TS project?`);
+    console.error(`${import_chalk2.default.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
   const configPath = path6.join(projectRoot, CONFIG_FILE2);
   if (!fs6.existsSync(configPath)) {
     console.error(
-      `${import_chalk3.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+      `${import_chalk2.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
     return 1;
   }
@@ -528,7 +593,7 @@ async function checkCommand(options, cwd) {
     filesToCheck = getAllSourceFiles(projectRoot, config);
   }
   if (filesToCheck.length === 0) {
-    console.log(`${import_chalk3.default.green("\u2713")} No files to check.`);
+    console.log(`${import_chalk2.default.green("\u2713")} No files to check.`);
     return 0;
   }
   const violations = [];
@@ -569,7 +634,7 @@ async function checkCommand(options, cwd) {
     const testViolations = checkMissingTests(projectRoot, config, severity);
     violations.push(...testViolations);
   }
-  if (config.rules.enforceBoundaries && config.boundaries && config.boundaries.length > 0 && !options.noBoundaries) {
+  if (config.rules.enforceBoundaries && config.boundaries && Object.keys(config.boundaries.deny).length > 0 && !options.noBoundaries) {
     const startTime = Date.now();
     const { buildImportGraph, checkBoundaries } = await import("@viberails/graph");
     const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
@@ -585,12 +650,12 @@ async function checkCommand(options, cwd) {
       violations.push({
         file: relFile,
         rule: "boundary-violation",
-        message: `Imports "${bv.specifier}" violating boundary: ${bv.rule.from} \u2192 ${bv.rule.to}${bv.rule.reason ? ` (${bv.rule.reason})` : ""}`,
+        message: `Imports "${bv.specifier}" violating boundary: ${bv.rule.from} \u2192 ${bv.rule.to}`,
         severity
       });
     }
     const elapsed = Date.now() - startTime;
-    console.log(import_chalk3.default.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+    console.log(import_chalk2.default.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
   }
   if (options.format === "json") {
     console.log(
@@ -603,7 +668,7 @@ async function checkCommand(options, cwd) {
     return config.enforcement === "enforce" && violations.length > 0 ? 1 : 0;
   }
   if (violations.length === 0) {
-    console.log(`${import_chalk3.default.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
+    console.log(`${import_chalk2.default.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
     return 0;
   }
   if (!options.quiet) {
@@ -611,7 +676,7 @@ async function checkCommand(options, cwd) {
   }
   printSummary(violations);
   if (config.enforcement === "enforce") {
-    console.log(import_chalk3.default.red("Fix violations before committing."));
+    console.log(import_chalk2.default.red("Fix violations before committing."));
     return 1;
   }
   return 0;
@@ -621,23 +686,22 @@ async function checkCommand(options, cwd) {
 var fs9 = __toESM(require("fs"), 1);
 var path10 = __toESM(require("path"), 1);
 var import_config3 = require("@viberails/config");
-var import_chalk5 = __toESM(require("chalk"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
 
 // src/commands/fix-helpers.ts
 var import_node_child_process2 = require("child_process");
-var import_node_readline = require("readline");
-var import_chalk4 = __toESM(require("chalk"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 function printPlan(renames, stubs) {
   if (renames.length > 0) {
-    console.log(import_chalk4.default.bold("\nFile renames:"));
+    console.log(import_chalk3.default.bold("\nFile renames:"));
     for (const r of renames) {
-      console.log(`  ${import_chalk4.default.red(r.oldPath)} \u2192 ${import_chalk4.default.green(r.newPath)}`);
+      console.log(`  ${import_chalk3.default.red(r.oldPath)} \u2192 ${import_chalk3.default.green(r.newPath)}`);
     }
   }
   if (stubs.length > 0) {
-    console.log(import_chalk4.default.bold("\nTest stubs to create:"));
+    console.log(import_chalk3.default.bold("\nTest stubs to create:"));
     for (const s of stubs) {
-      console.log(`  ${import_chalk4.default.green("+")} ${s.path}`);
+      console.log(`  ${import_chalk3.default.green("+")} ${s.path}`);
     }
   }
 }
@@ -659,15 +723,6 @@ function getConventionValue(convention) {
   }
   return void 0;
 }
-function promptConfirm(question) {
-  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
-    rl.question(`${question} (y/N) `, (answer) => {
-      rl.close();
-      resolve4(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
-    });
-  });
-}
 
 // src/commands/fix-imports.ts
 var path7 = __toESM(require("path"), 1);
@@ -888,13 +943,13 @@ async function fixCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
   if (!projectRoot) {
-    console.error(`${import_chalk5.default.red("Error:")} No package.json found. Are you in a JS/TS project?`);
+    console.error(`${import_chalk4.default.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
   const configPath = path10.join(projectRoot, CONFIG_FILE3);
   if (!fs9.existsSync(configPath)) {
     console.error(
-      `${import_chalk5.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+      `${import_chalk4.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
     return 1;
   }
@@ -903,7 +958,7 @@ async function fixCommand(options, cwd) {
     const isDirty = checkGitDirty(projectRoot);
     if (isDirty) {
       console.log(
-        import_chalk5.default.yellow("Warning: You have uncommitted changes. Consider committing first.")
+        import_chalk4.default.yellow("Warning: You have uncommitted changes. Consider committing first.")
       );
     }
   }
@@ -933,16 +988,16 @@ async function fixCommand(options, cwd) {
     }
   }
   if (dedupedRenames.length === 0 && testStubs.length === 0) {
-    console.log(`${import_chalk5.default.green("\u2713")} No fixable violations found.`);
+    console.log(`${import_chalk4.default.green("\u2713")} No fixable violations found.`);
     return 0;
   }
   printPlan(dedupedRenames, testStubs);
   if (options.dryRun) {
-    console.log(import_chalk5.default.dim("\nDry run \u2014 no changes applied."));
+    console.log(import_chalk4.default.dim("\nDry run \u2014 no changes applied."));
     return 0;
   }
   if (!options.yes) {
-    const confirmed = await promptConfirm("Apply these fixes?");
+    const confirmed = await confirmDangerous("Apply these fixes?");
     if (!confirmed) {
       console.log("Aborted.");
       return 0;
@@ -969,15 +1024,15 @@ async function fixCommand(options, cwd) {
   }
   console.log("");
   if (renameCount > 0) {
-    console.log(`${import_chalk5.default.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
+    console.log(`${import_chalk4.default.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
   }
   if (importUpdateCount > 0) {
     console.log(
-      `${import_chalk5.default.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
+      `${import_chalk4.default.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
     );
   }
   if (stubCount > 0) {
-    console.log(`${import_chalk5.default.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
+    console.log(`${import_chalk4.default.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
   }
   return 0;
 }
@@ -985,13 +1040,13 @@ async function fixCommand(options, cwd) {
 // src/commands/init.ts
 var fs12 = __toESM(require("fs"), 1);
 var path13 = __toESM(require("path"), 1);
+var clack2 = __toESM(require("@clack/prompts"), 1);
 var import_config4 = require("@viberails/config");
 var import_scanner = require("@viberails/scanner");
-var import_chalk9 = __toESM(require("chalk"), 1);
+var import_chalk8 = __toESM(require("chalk"), 1);
 
-// src/display.ts
-var import_types3 = require("@viberails/types");
-var import_chalk7 = __toESM(require("chalk"), 1);
+// src/display-text.ts
+var import_types4 = require("@viberails/types");
 
 // src/display-helpers.ts
 var import_types = require("@viberails/types");
@@ -1042,9 +1097,13 @@ function formatRoleGroup(group) {
   return `${group.label} \u2014 ${dirs} (${files})`;
 }
 
+// src/display.ts
+var import_types3 = require("@viberails/types");
+var import_chalk6 = __toESM(require("chalk"), 1);
+
 // src/display-monorepo.ts
 var import_types2 = require("@viberails/types");
-var import_chalk6 = __toESM(require("chalk"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
 function formatPackageSummary(pkg) {
   const parts = [];
   if (pkg.stack.framework) {
@@ -1060,19 +1119,19 @@ function formatPackageSummary(pkg) {
 function displayMonorepoResults(scanResult) {
   const { stack, packages } = scanResult;
   console.log(`
-${import_chalk6.default.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
-  console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.language)}`);
+${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_chalk6.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
+    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
   if (stack.linter) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.linter)}`);
+    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.linter)}`);
   }
   if (stack.formatter) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.formatter)}`);
+    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.formatter)}`);
   }
   if (stack.testRunner) {
-    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
+    console.log(`  ${import_chalk5.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
   console.log("");
   for (const pkg of packages) {
@@ -1083,13 +1142,13 @@ ${import_chalk6.default.bold(`Detected: (monorepo, ${packages.length} packages)`
   );
   if (packagesWithDirs.length > 0) {
     console.log(`
-${import_chalk6.default.bold("Structure:")}`);
+${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_chalk6.default.green("\u2713")} ${formatRoleGroup(group)}`);
+        console.log(`    ${import_chalk5.default.green("\u2713")} ${formatRoleGroup(group)}`);
       }
     }
   }
@@ -1097,14 +1156,60 @@ ${import_chalk6.default.bold("Structure:")}`);
   displaySummarySection(scanResult);
   console.log("");
 }
+function formatPackageSummaryPlain(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}`;
+}
+function formatMonorepoResultsText(scanResult, config) {
+  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) 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)}`);
+      }
+    }
+  }
+  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);
+  }
+  lines.push(...formatRulesText(config));
+  return lines.join("\n");
+}
 
 // src/display.ts
-var CONVENTION_LABELS = {
-  fileNaming: "File naming",
-  componentNaming: "Component naming",
-  hookNaming: "Hook naming",
-  importAlias: "Import alias"
-};
 function formatItem(item, nameMap) {
   const name = nameMap?.[item.name] ?? item.name;
   return item.version ? `${name} ${item.version}` : name;
@@ -1120,27 +1225,27 @@ function displayConventions(scanResult) {
   const conventionEntries = Object.entries(scanResult.conventions);
   if (conventionEntries.length === 0) return;
   console.log(`
-${import_chalk7.default.bold("Conventions:")}`);
+${import_chalk6.default.bold("Conventions:")}`);
   for (const [key, convention] of conventionEntries) {
     if (convention.confidence === "low") continue;
-    const label = CONVENTION_LABELS[key] ?? key;
+    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_chalk7.default.green("\u2713") : import_chalk7.default.yellow("~");
-        const detail = import_chalk7.default.dim(`(${confidenceLabel(convention)})`);
+        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_chalk7.default.yellow("~")} ${label}: varies by package`);
+        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}%)`);
         }
       }
     } else {
-      const ind = convention.confidence === "high" ? import_chalk7.default.green("\u2713") : import_chalk7.default.yellow("~");
-      const detail = import_chalk7.default.dim(`(${confidenceLabel(convention)})`);
+      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}`);
     }
   }
@@ -1148,7 +1253,7 @@ ${import_chalk7.default.bold("Conventions:")}`);
 function displaySummarySection(scanResult) {
   const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
   console.log(`
-${import_chalk7.default.bold("Summary:")}`);
+${import_chalk6.default.bold("Summary:")}`);
   console.log(`  ${formatSummary(scanResult.statistics, pkgCount)}`);
   const ext = formatExtensions(scanResult.statistics.filesByExtension);
   if (ext) {
@@ -1162,43 +1267,43 @@ function displayScanResults(scanResult) {
   }
   const { stack } = scanResult;
   console.log(`
-${import_chalk7.default.bold("Detected:")}`);
+${import_chalk6.default.bold("Detected:")}`);
   if (stack.framework) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.framework, import_types3.FRAMEWORK_NAMES)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.framework, import_types3.FRAMEWORK_NAMES)}`);
   }
-  console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.language)}`);
+  console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.language)}`);
   if (stack.styling) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.styling, import_types3.STYLING_NAMES)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.styling, import_types3.STYLING_NAMES)}`);
   }
   if (stack.backend) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.backend, import_types3.FRAMEWORK_NAMES)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.backend, import_types3.FRAMEWORK_NAMES)}`);
   }
   if (stack.orm) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.orm, import_types3.ORM_NAMES)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.orm, import_types3.ORM_NAMES)}`);
   }
   if (stack.linter) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.linter)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.linter)}`);
   }
   if (stack.formatter) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.formatter)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.formatter)}`);
   }
   if (stack.testRunner) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
   if (stack.packageManager) {
-    console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
+    console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
   if (stack.libraries.length > 0) {
     for (const lib of stack.libraries) {
-      console.log(`  ${import_chalk7.default.green("\u2713")} ${formatItem(lib, import_types3.LIBRARY_NAMES)}`);
+      console.log(`  ${import_chalk6.default.green("\u2713")} ${formatItem(lib, import_types3.LIBRARY_NAMES)}`);
     }
   }
   const groups = groupByRole(scanResult.structure.directories);
   if (groups.length > 0) {
     console.log(`
-${import_chalk7.default.bold("Structure:")}`);
+${import_chalk6.default.bold("Structure:")}`);
     for (const group of groups) {
-      console.log(`  ${import_chalk7.default.green("\u2713")} ${formatRoleGroup(group)}`);
+      console.log(`  ${import_chalk6.default.green("\u2713")} ${formatRoleGroup(group)}`);
     }
   }
   displayConventions(scanResult);
@@ -1209,38 +1314,151 @@ function getConventionStr(cv) {
   return typeof cv === "string" ? cv : cv.value;
 }
 function displayRulesPreview(config) {
-  console.log(`${import_chalk7.default.bold("Rules:")}`);
-  console.log(`  ${import_chalk7.default.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
+  console.log(`${import_chalk6.default.bold("Rules:")}`);
+  console.log(`  ${import_chalk6.default.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
   if (config.rules.requireTests && config.structure.testPattern) {
     console.log(
-      `  ${import_chalk7.default.dim("\u2022")} Require test files: yes (${config.structure.testPattern})`
+      `  ${import_chalk6.default.dim("\u2022")} Require test files: yes (${config.structure.testPattern})`
     );
   } else if (config.rules.requireTests) {
-    console.log(`  ${import_chalk7.default.dim("\u2022")} Require test files: yes`);
+    console.log(`  ${import_chalk6.default.dim("\u2022")} Require test files: yes`);
   } else {
-    console.log(`  ${import_chalk7.default.dim("\u2022")} Require test files: no`);
+    console.log(`  ${import_chalk6.default.dim("\u2022")} Require test files: no`);
   }
   if (config.rules.enforceNaming && config.conventions.fileNaming) {
     console.log(
-      `  ${import_chalk7.default.dim("\u2022")} Enforce file naming: ${getConventionStr(config.conventions.fileNaming)}`
+      `  ${import_chalk6.default.dim("\u2022")} Enforce file naming: ${getConventionStr(config.conventions.fileNaming)}`
     );
   } else {
-    console.log(`  ${import_chalk7.default.dim("\u2022")} Enforce file naming: no`);
+    console.log(`  ${import_chalk6.default.dim("\u2022")} Enforce file naming: no`);
   }
   console.log(
-    `  ${import_chalk7.default.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
+    `  ${import_chalk6.default.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
   );
   console.log("");
   if (config.enforcement === "enforce") {
-    console.log(`${import_chalk7.default.bold("Enforcement mode:")} enforce (violations will block commits)`);
+    console.log(`${import_chalk6.default.bold("Enforcement mode:")} enforce (violations will block commits)`);
   } else {
     console.log(
-      `${import_chalk7.default.bold("Enforcement mode:")} warn (violations shown but won't block commits)`
+      `${import_chalk6.default.bold("Enforcement mode:")} warn (violations shown but won't block commits)`
     );
   }
   console.log("");
 }
 
+// src/display-text.ts
+function getConventionStr2(cv) {
+  return typeof cv === "string" ? cv : cv.value;
+}
+function plainConfidenceLabel(convention) {
+  const pct = Math.round(convention.consistency);
+  if (convention.confidence === "high") {
+    return `${pct}%`;
+  }
+  return `${pct}%, suggested only`;
+}
+function formatConventionsText(scanResult) {
+  const lines = [];
+  const conventionEntries = Object.entries(scanResult.conventions);
+  if (conventionEntries.length === 0) return lines;
+  lines.push("");
+  lines.push("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" ? "\u2713" : "~";
+        lines.push(`  ${ind} ${label}: ${convention.value} (${plainConfidenceLabel(convention)})`);
+      } else {
+        lines.push(`  ~ ${label}: varies by package`);
+        for (const pv of pkgValues) {
+          const pct = Math.round(pv.convention.consistency);
+          lines.push(`    ${pv.relativePath}: ${pv.convention.value} (${pct}%)`);
+        }
+      }
+    } else {
+      const ind = convention.confidence === "high" ? "\u2713" : "~";
+      lines.push(`  ${ind} ${label}: ${convention.value} (${plainConfidenceLabel(convention)})`);
+    }
+  }
+  return lines;
+}
+function formatRulesText(config) {
+  const lines = [];
+  lines.push("");
+  lines.push("Rules:");
+  lines.push(`  \u2022 Max file size: ${config.rules.maxFileLines} lines`);
+  if (config.rules.requireTests && config.structure.testPattern) {
+    lines.push(`  \u2022 Require test files: yes (${config.structure.testPattern})`);
+  } else if (config.rules.requireTests) {
+    lines.push("  \u2022 Require test files: yes");
+  } else {
+    lines.push("  \u2022 Require test files: no");
+  }
+  if (config.rules.enforceNaming && config.conventions.fileNaming) {
+    lines.push(`  \u2022 Enforce file naming: ${getConventionStr2(config.conventions.fileNaming)}`);
+  } else {
+    lines.push("  \u2022 Enforce file naming: no");
+  }
+  lines.push(`  \u2022 Enforcement mode: ${config.enforcement}`);
+  return lines;
+}
+function formatScanResultsText(scanResult, config) {
+  if (scanResult.packages.length > 1) {
+    return formatMonorepoResultsText(scanResult, config);
+  }
+  const lines = [];
+  const { stack } = scanResult;
+  lines.push("Detected:");
+  if (stack.framework) {
+    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_types4.STYLING_NAMES)}`);
+  }
+  if (stack.backend) {
+    lines.push(`  \u2713 ${formatItem(stack.backend, import_types4.FRAMEWORK_NAMES)}`);
+  }
+  if (stack.orm) {
+    lines.push(`  \u2713 ${formatItem(stack.orm, import_types4.ORM_NAMES)}`);
+  }
+  const secondaryParts = [];
+  if (stack.packageManager) secondaryParts.push(formatItem(stack.packageManager));
+  if (stack.linter) secondaryParts.push(formatItem(stack.linter));
+  if (stack.formatter) secondaryParts.push(formatItem(stack.formatter));
+  if (stack.testRunner) secondaryParts.push(formatItem(stack.testRunner));
+  if (secondaryParts.length > 0) {
+    lines.push(`  \u2713 ${secondaryParts.join(" \xB7 ")}`);
+  }
+  if (stack.libraries.length > 0) {
+    for (const lib of stack.libraries) {
+      lines.push(`  \u2713 ${formatItem(lib, import_types4.LIBRARY_NAMES)}`);
+    }
+  }
+  const groups = groupByRole(scanResult.structure.directories);
+  if (groups.length > 0) {
+    lines.push("");
+    lines.push("Structure:");
+    for (const group of groups) {
+      lines.push(`  \u2713 ${formatRoleGroup(group)}`);
+    }
+  }
+  lines.push(...formatConventionsText(scanResult));
+  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
+  lines.push("");
+  lines.push(formatSummary(scanResult.statistics, pkgCount));
+  const ext = formatExtensions(scanResult.statistics.filesByExtension);
+  if (ext) {
+    lines.push(ext);
+  }
+  lines.push(...formatRulesText(config));
+  return lines.join("\n");
+}
+
 // src/utils/write-generated-files.ts
 var fs10 = __toESM(require("fs"), 1);
 var path11 = __toESM(require("path"), 1);
@@ -1270,18 +1488,18 @@ function writeGeneratedFiles(projectRoot, config, scanResult) {
 // src/commands/init-hooks.ts
 var fs11 = __toESM(require("fs"), 1);
 var path12 = __toESM(require("path"), 1);
-var import_chalk8 = __toESM(require("chalk"), 1);
+var import_chalk7 = __toESM(require("chalk"), 1);
 function setupPreCommitHook(projectRoot) {
   const lefthookPath = path12.join(projectRoot, "lefthook.yml");
   if (fs11.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${import_chalk8.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${import_chalk7.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return;
   }
   const huskyDir = path12.join(projectRoot, ".husky");
   if (fs11.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${import_chalk8.default.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${import_chalk7.default.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return;
   }
   const gitDir = path12.join(projectRoot, ".git");
@@ -1291,7 +1509,7 @@ function setupPreCommitHook(projectRoot) {
       fs11.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${import_chalk8.default.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${import_chalk7.default.green("\u2713")} .git/hooks/pre-commit`);
   }
 }
 function writeGitHookPreCommit(hooksDir) {
@@ -1361,7 +1579,7 @@ function setupClaudeCodeHook(projectRoot) {
       settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${import_chalk8.default.yellow("!")} .claude/settings.json contains invalid JSON \u2014 resetting to add hook`
+        `  ${import_chalk7.default.yellow("!")} .claude/settings.json contains invalid JSON \u2014 resetting to add hook`
       );
       settings = {};
     }
@@ -1370,7 +1588,17 @@ function setupClaudeCodeHook(projectRoot) {
   const existing = hooks.PostToolUse ?? [];
   if (existing.some((h) => JSON.stringify(h).includes("viberails"))) return;
   const extractFile = `node -e "try{process.stdout.write(JSON.parse(require('fs').readFileSync(0,'utf8')).tool_input?.file_path??'')}catch{}"`;
-  const hookCommand = `FILE=$(${extractFile}) && [ -n "$FILE" ] && npx viberails check --files "$FILE" --format json; exit 0`;
+  const checkAndReport = [
+    `FILE=$(${extractFile})`,
+    'if [ -z "$FILE" ]; then exit 0; fi',
+    'OUTPUT=$(npx viberails check --files "$FILE" --format json 2>&1)',
+    `if echo "$OUTPUT" | node -e "process.exit(JSON.parse(require('fs').readFileSync(0,'utf8')).violations?.length?0:1)" 2>/dev/null; then`,
+    '  echo "$OUTPUT" >&2',
+    "  exit 2",
+    "fi",
+    "exit 0"
+  ].join("\n");
+  const hookCommand = checkAndReport;
   hooks.PostToolUse = [
     ...existing,
     {
@@ -1386,7 +1614,19 @@ function setupClaudeCodeHook(projectRoot) {
   settings.hooks = hooks;
   fs11.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_chalk7.default.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
+}
+function setupClaudeMdReference(projectRoot) {
+  const claudeMdPath = path12.join(projectRoot, "CLAUDE.md");
+  let content = "";
+  if (fs11.existsSync(claudeMdPath)) {
+    content = fs11.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();
+  fs11.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${import_chalk7.default.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
 }
 function writeHuskyPreCommit(huskyDir) {
   const hookPath = path12.join(huskyDir, "pre-commit");
@@ -1416,6 +1656,14 @@ function filterHighConfidence(conventions) {
   }
   return filtered;
 }
+function getConventionStr3(cv) {
+  if (!cv) return void 0;
+  return typeof cv === "string" ? cv : cv.value;
+}
+function hasConventionOverrides(config) {
+  if (!config.packages || config.packages.length === 0) return false;
+  return config.packages.some((pkg) => pkg.conventions && Object.keys(pkg.conventions).length > 0);
+}
 async function initCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
@@ -1425,84 +1673,146 @@ async function initCommand(options, cwd) {
     );
   }
   const configPath = path13.join(projectRoot, CONFIG_FILE4);
-  if (fs12.existsSync(configPath)) {
+  if (fs12.existsSync(configPath) && !options.force) {
     console.log(
-      import_chalk9.default.yellow("!") + " viberails is already initialized in this project.\n  Run " + import_chalk9.default.cyan("viberails sync") + " to update the generated files."
+      `${import_chalk8.default.yellow("!")} viberails is already initialized.
+  Run ${import_chalk8.default.cyan("viberails sync")} to update, or ${import_chalk8.default.cyan("viberails init --force")} to start fresh.`
     );
     return;
   }
-  console.log(import_chalk9.default.dim("Scanning project..."));
-  const scanResult = await (0, import_scanner.scan)(projectRoot);
-  const config = (0, import_config4.generateConfig)(scanResult);
   if (options.yes) {
-    config.conventions = filterHighConfidence(config.conventions);
+    console.log(import_chalk8.default.dim("Scanning project..."));
+    const scanResult2 = await (0, import_scanner.scan)(projectRoot);
+    const config2 = (0, import_config4.generateConfig)(scanResult2);
+    config2.conventions = filterHighConfidence(config2.conventions);
+    displayScanResults(scanResult2);
+    displayRulesPreview(config2);
+    if (config2.workspace?.packages && config2.workspace.packages.length > 0) {
+      console.log(import_chalk8.default.dim("Building import graph..."));
+      const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
+      const packages = resolveWorkspacePackages(projectRoot, config2.workspace);
+      const graph = await buildImportGraph(projectRoot, {
+        packages,
+        ignore: config2.ignore
+      });
+      const inferred = inferBoundaries(graph);
+      const denyCount = Object.values(inferred.deny).reduce((sum, arr) => sum + arr.length, 0);
+      if (denyCount > 0) {
+        config2.boundaries = inferred;
+        config2.rules.enforceBoundaries = true;
+        console.log(`  Inferred ${denyCount} boundary rules`);
+      }
+    }
+    fs12.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+`);
+    writeGeneratedFiles(projectRoot, config2, scanResult2);
+    updateGitignore(projectRoot);
+    setupClaudeMdReference(projectRoot);
+    console.log(`
+Created:`);
+    console.log(`  ${import_chalk8.default.green("\u2713")} ${CONFIG_FILE4}`);
+    console.log(`  ${import_chalk8.default.green("\u2713")} .viberails/context.md`);
+    console.log(`  ${import_chalk8.default.green("\u2713")} .viberails/scan-result.json`);
+    return;
   }
-  displayScanResults(scanResult);
+  clack2.intro("viberails");
+  const s = clack2.spinner();
+  s.start("Scanning project...");
+  const scanResult = await (0, import_scanner.scan)(projectRoot);
+  const config = (0, import_config4.generateConfig)(scanResult);
+  s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    console.log(
-      import_chalk9.default.yellow("!") + " No source files detected. viberails will generate context with minimal content.\n  Run " + import_chalk9.default.cyan("viberails sync") + " after adding source files.\n"
+    clack2.log.warn(
+      "No source files detected. viberails will generate context\nwith minimal content. Run viberails sync after adding files."
     );
   }
-  displayRulesPreview(config);
-  if (!options.yes) {
-    const accepted = await confirm("Proceed with these settings?");
-    if (!accepted) {
-      console.log("Aborted.");
-      return;
+  const resultsText = formatScanResultsText(scanResult, config);
+  clack2.note(resultsText, "Scan results");
+  const decision = await promptInitDecision();
+  if (decision === "customize") {
+    clack2.note(
+      "Rules control what viberails checks for.\nYou can change these later in viberails.config.json.",
+      "Rules"
+    );
+    const overrides = await promptRuleCustomization({
+      maxFileLines: config.rules.maxFileLines,
+      requireTests: config.rules.requireTests,
+      enforceNaming: config.rules.enforceNaming,
+      enforcement: config.enforcement,
+      fileNamingValue: getConventionStr3(config.conventions.fileNaming)
+    });
+    config.rules.maxFileLines = overrides.maxFileLines;
+    config.rules.requireTests = overrides.requireTests;
+    config.rules.enforceNaming = overrides.enforceNaming;
+    config.enforcement = overrides.enforcement;
+    if (config.workspace?.packages && config.workspace.packages.length > 0) {
+      clack2.note(
+        'These rules apply globally. To customize per package,\nedit the "packages" section in viberails.config.json.',
+        "Per-package overrides"
+      );
     }
   }
-  if (config.workspace && config.workspace.packages.length > 0) {
-    let shouldInfer = options.yes;
-    if (!options.yes) {
-      console.log(import_chalk9.default.dim("  Scans imports between packages to suggest dependency rules"));
-      shouldInfer = await confirm("Infer boundary rules from import patterns?");
-    }
+  if (config.workspace?.packages && config.workspace.packages.length > 0) {
+    clack2.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 confirm2("Infer boundary rules from import patterns?");
     if (shouldInfer) {
-      console.log(import_chalk9.default.dim("Building import graph..."));
+      const bs = clack2.spinner();
+      bs.start("Building import graph...");
       const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
       const packages = resolveWorkspacePackages(projectRoot, config.workspace);
-      const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
+      const graph = await buildImportGraph(projectRoot, {
+        packages,
+        ignore: config.ignore
+      });
       const inferred = inferBoundaries(graph);
-      if (inferred.length > 0) {
+      const denyCount = Object.values(inferred.deny).reduce((sum, arr) => sum + arr.length, 0);
+      if (denyCount > 0) {
         config.boundaries = inferred;
         config.rules.enforceBoundaries = true;
-        console.log(`  ${import_chalk9.default.green("\u2713")} Inferred ${inferred.length} boundary rules`);
+        bs.stop(`Inferred ${denyCount} boundary rules`);
+      } else {
+        bs.stop("No boundary rules inferred");
       }
     }
   }
   const hookManager = detectHookManager(projectRoot);
-  let integrations = { preCommitHook: true, claudeCodeHook: true };
-  if (!options.yes) {
-    console.log("");
-    integrations = await selectIntegrations(hookManager);
+  const integrations = await promptIntegrations(hookManager);
+  if (hasConventionOverrides(config)) {
+    clack2.note(
+      "Some packages use different conventions. Per-package\noverrides have been saved in viberails.config.json \u2014\nreview and adjust as needed.",
+      "Per-package conventions"
+    );
   }
   fs12.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
-  console.log(`
-${import_chalk9.default.bold("Created:")}`);
-  console.log(`  ${import_chalk9.default.green("\u2713")} ${CONFIG_FILE4}`);
-  console.log(`  ${import_chalk9.default.green("\u2713")} .viberails/context.md`);
-  console.log(`  ${import_chalk9.default.green("\u2713")} .viberails/scan-result.json`);
+  const createdFiles = [
+    CONFIG_FILE4,
+    ".viberails/context.md",
+    ".viberails/scan-result.json"
+  ];
   if (integrations.preCommitHook) {
     setupPreCommitHook(projectRoot);
+    const hookMgr = detectHookManager(projectRoot);
+    if (hookMgr) {
+      createdFiles.push(`lefthook.yml \u2014 added viberails pre-commit`);
+    }
   }
   if (integrations.claudeCodeHook) {
     setupClaudeCodeHook(projectRoot);
+    createdFiles.push(".claude/settings.json \u2014 added viberails hook");
   }
-  const filesToCommit = [
-    `${import_chalk9.default.cyan("viberails.config.json")}`,
-    import_chalk9.default.cyan(".viberails/context.md")
-  ];
-  if (integrations.claudeCodeHook) {
-    filesToCommit.push(import_chalk9.default.cyan(".claude/settings.json"));
+  if (integrations.claudeMdRef) {
+    setupClaudeMdReference(projectRoot);
+    createdFiles.push("CLAUDE.md \u2014 added @.viberails/context.md reference");
   }
-  console.log(`
-${import_chalk9.default.bold("Next steps:")}`);
-  console.log(`  1. Review ${import_chalk9.default.cyan("viberails.config.json")} and adjust rules`);
-  console.log(`  2. Commit ${filesToCommit.join(", ")}`);
-  console.log(`  3. Run ${import_chalk9.default.cyan("viberails check")} to verify your project passes`);
+  clack2.log.success(`Created:
+${createdFiles.map((f) => `  ${f}`).join("\n")}`);
+  clack2.outro("Done! Next: review viberails.config.json, then run viberails check");
 }
 function updateGitignore(projectRoot) {
   const gitignorePath = path13.join(projectRoot, ".gitignore");
@@ -1523,8 +1833,146 @@ var fs13 = __toESM(require("fs"), 1);
 var path14 = __toESM(require("path"), 1);
 var import_config5 = require("@viberails/config");
 var import_scanner2 = require("@viberails/scanner");
-var import_chalk10 = __toESM(require("chalk"), 1);
+var import_chalk9 = __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 conventionStr(cv) {
+  return typeof cv === "string" ? cv : cv.value;
+}
+function isDetected(cv) {
+  return typeof cv !== "string" && cv._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 diffConfigs(existing, merged) {
+  const changes = [];
+  for (const field of STACK_FIELDS) {
+    const oldVal = existing.stack[field];
+    const newVal = merged.stack[field];
+    if (!oldVal && newVal) {
+      changes.push({ type: "added", description: `Stack: added ${displayStackName(newVal)}` });
+    } else if (oldVal && newVal && oldVal !== newVal) {
+      changes.push({
+        type: "changed",
+        description: `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: `New convention: ${label} (${conventionStr(newVal)})`
+      });
+    } else if (oldVal && newVal && isDetected(newVal)) {
+      changes.push({
+        type: "changed",
+        description: `Convention updated: ${label} (${conventionStr(newVal)})`
+      });
+    }
+  }
+  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: `Structure: detected ${label} (${newVal})` });
+    }
+  }
+  const existingPaths = new Set((existing.packages ?? []).map((p) => p.path));
+  for (const pkg of merged.packages ?? []) {
+    if (!existingPaths.has(pkg.path)) {
+      changes.push({ type: "added", description: `New package: ${pkg.path}` });
+    }
+  }
+  const existingWsPkgs = new Set(existing.workspace?.packages ?? []);
+  const mergedWsPkgs = new Set(merged.workspace?.packages ?? []);
+  for (const pkg of mergedWsPkgs) {
+    if (!existingWsPkgs.has(pkg)) {
+      changes.push({ type: "added", description: `Workspace: added ${pkg}` });
+    }
+  }
+  for (const pkg of existingWsPkgs) {
+    if (!mergedWsPkgs.has(pkg)) {
+      changes.push({ type: "removed", description: `Workspace: removed ${pkg}` });
+    }
+  }
+  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 SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
+function loadPreviousStats(projectRoot) {
+  const scanResultPath = path14.join(projectRoot, SCAN_RESULT_FILE2);
+  try {
+    const raw = fs13.readFileSync(scanResultPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.statistics?.totalFiles !== void 0) {
+      return parsed.statistics;
+    }
+  } catch {
+  }
+  return void 0;
+}
 async function syncCommand(cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
@@ -1535,41 +1983,50 @@ async function syncCommand(cwd) {
   }
   const configPath = path14.join(projectRoot, CONFIG_FILE5);
   const existing = await (0, import_config5.loadConfig)(configPath);
-  console.log(import_chalk10.default.dim("Scanning project..."));
+  const previousStats = loadPreviousStats(projectRoot);
+  console.log(import_chalk9.default.dim("Scanning project..."));
   const scanResult = await (0, import_scanner2.scan)(projectRoot);
   const merged = (0, import_config5.mergeConfig)(existing, scanResult);
   const existingJson = JSON.stringify(existing, null, 2);
   const mergedJson = JSON.stringify(merged, null, 2);
   const configChanged = existingJson !== mergedJson;
-  if (configChanged) {
-    console.log(
-      `  ${import_chalk10.default.yellow("!")} Config updated \u2014 review ${import_chalk10.default.cyan(CONFIG_FILE5)} for changes`
-    );
+  const changes = configChanged ? diffConfigs(existing, merged) : [];
+  const statsDelta = previousStats ? formatStatsDelta(previousStats, scanResult.statistics) : void 0;
+  if (changes.length > 0 || statsDelta) {
+    console.log(`
+${import_chalk9.default.bold("Changes:")}`);
+    for (const change of changes) {
+      const icon = change.type === "removed" ? import_chalk9.default.red("-") : import_chalk9.default.green("+");
+      console.log(`  ${icon} ${change.description}`);
+    }
+    if (statsDelta) {
+      console.log(`  ${import_chalk9.default.dim(statsDelta)}`);
+    }
   }
   fs13.writeFileSync(configPath, `${mergedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${import_chalk10.default.bold("Synced:")}`);
+${import_chalk9.default.bold("Synced:")}`);
   if (configChanged) {
-    console.log(`  ${import_chalk10.default.yellow("!")} ${CONFIG_FILE5} \u2014 updated (review changes)`);
+    console.log(`  ${import_chalk9.default.yellow("!")} ${CONFIG_FILE5} \u2014 updated (review changes)`);
   } else {
-    console.log(`  ${import_chalk10.default.green("\u2713")} ${CONFIG_FILE5} \u2014 unchanged`);
+    console.log(`  ${import_chalk9.default.green("\u2713")} ${CONFIG_FILE5} \u2014 unchanged`);
   }
-  console.log(`  ${import_chalk10.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${import_chalk10.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+  console.log(`  ${import_chalk9.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${import_chalk9.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.3.1";
+var VERSION = "0.3.3";
 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)").action(async (options) => {
+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) => {
   try {
     await initCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk11.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk10.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -1578,7 +2035,7 @@ program.command("sync").description("Re-scan and update generated files").action
     await syncCommand();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${import_chalk11.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk10.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -1593,7 +2050,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_chalk11.default.red("Error:")} ${message}`);
+      console.error(`${import_chalk10.default.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -1604,7 +2061,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_chalk11.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk10.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -1613,7 +2070,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_chalk11.default.red("Error:")} ${message}`);
+    console.error(`${import_chalk10.default.red("Error:")} ${message}`);
     process.exit(1);
   }
 });