viberails 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk11 from "chalk";
+import chalk10 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
@@ -28,19 +28,104 @@ function findProjectRoot(startDir) {
 }
 
 // src/utils/prompt.ts
-import * as readline from "readline";
-async function confirm(message) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+import * as clack from "@clack/prompts";
+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" }
+    ]
   });
-  return new Promise((resolve4) => {
-    rl.question(`${message} (Y/n) `, (answer) => {
-      rl.close();
-      const trimmed = answer.trim().toLowerCase();
-      resolve4(trimmed === "" || trimmed === "y" || trimmed === "yes");
-    });
+  assertNotCancelled(result);
+  return result;
+}
+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";
+    }
+  });
+  assertNotCancelled(maxFileLinesResult);
+  const requireTestsResult = await clack.confirm({
+    message: "Require matching test files for source files?",
+    initialValue: defaults.requireTests
+  });
+  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"
+      }
+    ],
+    initialValues: ["preCommit", "claude"],
+    required: false
   });
+  assertNotCancelled(result);
+  return {
+    preCommitHook: result.includes("preCommit"),
+    claudeCodeHook: result.includes("claude")
+  };
 }
 
 // src/utils/resolve-workspace-packages.ts
@@ -66,7 +151,7 @@ function resolveWorkspacePackages(projectRoot, workspace) {
     ];
     packages.push({ name, path: absPath, relativePath, internalDeps: allDeps });
   }
-  const packageNames = new Set(packages.map((p3) => p3.name));
+  const packageNames = new Set(packages.map((p) => p.name));
   for (const pkg of packages) {
     pkg.internalDeps = pkg.internalDeps.filter((dep) => packageNames.has(dep));
   }
@@ -96,37 +181,23 @@ async function boundariesCommand(options, cwd) {
   }
   displayRules(config);
 }
-function countBoundaries(boundaries) {
-  if (!boundaries) return 0;
-  if (Array.isArray(boundaries)) return boundaries.length;
-  return Object.values(boundaries).reduce((sum, denied) => sum + denied.length, 0);
-}
 function displayRules(config) {
-  const total = countBoundaries(config.boundaries);
-  if (total === 0) {
+  if (!config.boundaries || config.boundaries.length === 0) {
     console.log(chalk.yellow("No boundary rules configured."));
     console.log(`Run ${chalk.cyan("viberails boundaries --infer")} to generate rules.`);
     return;
   }
+  const allowRules = config.boundaries.filter((r) => r.allow);
+  const denyRules = config.boundaries.filter((r) => !r.allow);
   console.log(`
-${chalk.bold(`Boundary rules (${total} rules):`)}
+${chalk.bold(`Boundary rules (${config.boundaries.length} rules):`)}
 `);
-  if (Array.isArray(config.boundaries)) {
-    const allowRules = config.boundaries.filter((r) => r.allow);
-    const denyRules = config.boundaries.filter((r) => !r.allow);
-    for (const r of allowRules) {
-      console.log(`  ${chalk.green("\u2713")} ${r.from} \u2192 ${r.to}`);
-    }
-    for (const r of denyRules) {
-      const reason = r.reason ? chalk.dim(` (${r.reason})`) : "";
-      console.log(`  ${chalk.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
-    }
-  } else if (config.boundaries) {
-    for (const [from, denied] of Object.entries(config.boundaries)) {
-      for (const to of denied) {
-        console.log(`  ${chalk.red("\u2717")} ${from} \u2192 ${to}`);
-      }
-    }
+  for (const r of allowRules) {
+    console.log(`  ${chalk.green("\u2713")} ${r.from} \u2192 ${r.to}`);
+  }
+  for (const r of denyRules) {
+    const reason = r.reason ? chalk.dim(` (${r.reason})`) : "";
+    console.log(`  ${chalk.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
   }
   console.log(
     `
@@ -143,29 +214,32 @@ async function inferAndDisplay(projectRoot, config, configPath) {
   });
   console.log(chalk.dim(`${graph.nodes.length} files, ${graph.edges.length} edges`));
   const inferred = inferBoundaries(graph);
-  const entries = Object.entries(inferred);
-  if (entries.length === 0) {
+  if (inferred.length === 0) {
     console.log(chalk.yellow("No boundary rules could be inferred."));
     return;
   }
-  const totalRules = entries.reduce((sum, [, denied]) => sum + denied.length, 0);
+  const allow = inferred.filter((r) => r.allow);
+  const deny = inferred.filter((r) => !r.allow);
   console.log(`
 ${chalk.bold("Inferred boundary rules:")}
 `);
-  for (const [from, denied] of entries) {
-    for (const to of denied) {
-      console.log(`  ${chalk.red("\u2717")} ${from} \u2192 ${to}`);
-    }
+  for (const r of allow) {
+    console.log(`  ${chalk.green("\u2713")} ${r.from} \u2192 ${r.to}`);
+  }
+  for (const r of deny) {
+    const reason = r.reason ? chalk.dim(` (${r.reason})`) : "";
+    console.log(`  ${chalk.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
   }
   console.log(`
-  ${totalRules} deny rules`);
-  const shouldSave = await confirm("\nSave to viberails.config.json?");
+  ${allow.length} allowed, ${deny.length} 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(`${chalk.green("\u2713")} Saved ${totalRules} rules`);
+    console.log(`${chalk.green("\u2713")} Saved ${inferred.length} rules`);
   }
 }
 async function showGraph(projectRoot, config) {
@@ -235,6 +309,7 @@ function resolveIgnoreForFile(relPath, config) {
 import { execSync } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
+import picomatch from "picomatch";
 var ALWAYS_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -270,25 +345,9 @@ var NAMING_PATTERNS = {
   snake_case: /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/
 };
 function isIgnored(relPath, ignorePatterns) {
-  for (const pattern of ignorePatterns) {
-    const startsGlob = pattern.startsWith("**/");
-    const endsGlob = pattern.endsWith("/**");
-    if (startsGlob && endsGlob) {
-      const middle = pattern.slice(3, -3);
-      if (relPath.startsWith(`${middle}/`) || relPath.includes(`/${middle}/`) || relPath === middle) {
-        return true;
-      }
-    } else if (endsGlob) {
-      const prefix = pattern.slice(0, -3);
-      if (relPath.startsWith(`${prefix}/`) || relPath === prefix) return true;
-    } else if (startsGlob) {
-      const suffix = pattern.slice(3);
-      if (relPath.endsWith(suffix) || relPath === suffix) return true;
-    } else if (relPath === pattern || relPath.startsWith(`${pattern}/`)) {
-      return true;
-    }
-  }
-  return false;
+  if (ignorePatterns.length === 0) return false;
+  const isMatch = picomatch(ignorePatterns, { dot: true });
+  return isMatch(relPath);
 }
 function countFileLines(filePath) {
   try {
@@ -539,8 +598,7 @@ async function checkCommand(options, cwd) {
     const testViolations = checkMissingTests(projectRoot, config, severity);
     violations.push(...testViolations);
   }
-  const hasBoundaries = config.boundaries ? Array.isArray(config.boundaries) ? config.boundaries.length > 0 : Object.keys(config.boundaries).length > 0 : false;
-  if (config.rules.enforceBoundaries && hasBoundaries && !options.noBoundaries) {
+  if (config.rules.enforceBoundaries && config.boundaries && config.boundaries.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;
@@ -563,6 +621,16 @@ async function checkCommand(options, cwd) {
     const elapsed = Date.now() - startTime;
     console.log(chalk2.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
   }
+  if (options.format === "json") {
+    console.log(
+      JSON.stringify({
+        violations,
+        checkedFiles: filesToCheck.length,
+        enforcement: config.enforcement
+      })
+    );
+    return config.enforcement === "enforce" && violations.length > 0 ? 1 : 0;
+  }
   if (violations.length === 0) {
     console.log(`${chalk2.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
     return 0;
@@ -586,7 +654,6 @@ import chalk4 from "chalk";
 
 // src/commands/fix-helpers.ts
 import { execSync as execSync2 } from "child_process";
-import { createInterface as createInterface2 } from "readline";
 import chalk3 from "chalk";
 function printPlan(renames, stubs) {
   if (renames.length > 0) {
@@ -620,15 +687,6 @@ function getConventionValue(convention) {
   }
   return void 0;
 }
-function promptConfirm(question) {
-  const rl = createInterface2({ 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
 import * as path7 from "path";
@@ -662,7 +720,8 @@ async function updateImportsAfterRenames(renames, projectRoot) {
   const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
   for (const sourceFile of project.getSourceFiles()) {
     const filePath = sourceFile.getFilePath();
-    if (filePath.includes("/node_modules/") || filePath.includes("/dist/")) continue;
+    const segments = filePath.split(path7.sep);
+    if (segments.includes("node_modules") || segments.includes("dist")) continue;
     const fileDir = path7.dirname(filePath);
     for (const decl of sourceFile.getImportDeclarations()) {
       const specifier = decl.getModuleSpecifierValue();
@@ -902,7 +961,7 @@ async function fixCommand(options, cwd) {
     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;
@@ -945,10 +1004,422 @@ async function fixCommand(options, cwd) {
 // src/commands/init.ts
 import * as fs12 from "fs";
 import * as path13 from "path";
-import * as p2 from "@clack/prompts";
+import * as clack2 from "@clack/prompts";
 import { generateConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
-import chalk9 from "chalk";
+import chalk8 from "chalk";
+
+// src/display.ts
+import { FRAMEWORK_NAMES as FRAMEWORK_NAMES2, LIBRARY_NAMES, ORM_NAMES, STYLING_NAMES as STYLING_NAMES2 } from "@viberails/types";
+import chalk6 from "chalk";
+
+// src/display-helpers.ts
+import { ROLE_DESCRIPTIONS } from "@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] });
+    }
+  }
+  const groups = [];
+  for (const [role, { dirs }] of map) {
+    const label = 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`);
+  }
+  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})`;
+  }
+  const dirs = group.dirCount === 1 ? "1 dir" : `${group.dirCount} dirs`;
+  return `${group.label} \u2014 ${dirs} (${files})`;
+}
+
+// src/display-monorepo.ts
+import { FRAMEWORK_NAMES, STYLING_NAMES } from "@viberails/types";
+import chalk5 from "chalk";
+function formatPackageSummary(pkg) {
+  const parts = [];
+  if (pkg.stack.framework) {
+    parts.push(formatItem(pkg.stack.framework, FRAMEWORK_NAMES));
+  }
+  if (pkg.stack.styling) {
+    parts.push(formatItem(pkg.stack.styling, STYLING_NAMES));
+  }
+  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(`
+${chalk5.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
+  console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.language)}`);
+  if (stack.packageManager) {
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.packageManager)}`);
+  }
+  if (stack.linter) {
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.linter)}`);
+  }
+  if (stack.formatter) {
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.formatter)}`);
+  }
+  if (stack.testRunner) {
+    console.log(`  ${chalk5.green("\u2713")} ${formatItem(stack.testRunner)}`);
+  }
+  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(`
+${chalk5.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(`    ${chalk5.green("\u2713")} ${formatRoleGroup(group)}`);
+      }
+    }
+  }
+  displayConventions(scanResult);
+  displaySummarySection(scanResult);
+  console.log("");
+}
+function formatPackageSummaryPlain(pkg) {
+  const parts = [];
+  if (pkg.stack.framework) {
+    parts.push(formatItem(pkg.stack.framework, FRAMEWORK_NAMES));
+  }
+  if (pkg.stack.styling) {
+    parts.push(formatItem(pkg.stack.styling, 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;
+}
+function confidenceLabel(convention) {
+  const pct = Math.round(convention.consistency);
+  if (convention.confidence === "high") {
+    return `${pct}% \u2014 high confidence, will enforce`;
+  }
+  return `${pct}% \u2014 medium confidence, suggested only`;
+}
+function displayConventions(scanResult) {
+  const conventionEntries = Object.entries(scanResult.conventions);
+  if (conventionEntries.length === 0) return;
+  console.log(`
+${chalk6.bold("Conventions:")}`);
+  for (const [key, convention] of conventionEntries) {
+    if (convention.confidence === "low") continue;
+    const label = 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" ? chalk6.green("\u2713") : chalk6.yellow("~");
+        const detail = chalk6.dim(`(${confidenceLabel(convention)})`);
+        console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+      } else {
+        console.log(`  ${chalk6.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" ? chalk6.green("\u2713") : chalk6.yellow("~");
+      const detail = chalk6.dim(`(${confidenceLabel(convention)})`);
+      console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+    }
+  }
+}
+function displaySummarySection(scanResult) {
+  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
+  console.log(`
+${chalk6.bold("Summary:")}`);
+  console.log(`  ${formatSummary(scanResult.statistics, pkgCount)}`);
+  const ext = formatExtensions(scanResult.statistics.filesByExtension);
+  if (ext) {
+    console.log(`  ${ext}`);
+  }
+}
+function displayScanResults(scanResult) {
+  if (scanResult.packages.length > 1) {
+    displayMonorepoResults(scanResult);
+    return;
+  }
+  const { stack } = scanResult;
+  console.log(`
+${chalk6.bold("Detected:")}`);
+  if (stack.framework) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES2)}`);
+  }
+  console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.language)}`);
+  if (stack.styling) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES2)}`);
+  }
+  if (stack.backend) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES2)}`);
+  }
+  if (stack.orm) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.orm, ORM_NAMES)}`);
+  }
+  if (stack.linter) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.linter)}`);
+  }
+  if (stack.formatter) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.formatter)}`);
+  }
+  if (stack.testRunner) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.testRunner)}`);
+  }
+  if (stack.packageManager) {
+    console.log(`  ${chalk6.green("\u2713")} ${formatItem(stack.packageManager)}`);
+  }
+  if (stack.libraries.length > 0) {
+    for (const lib of stack.libraries) {
+      console.log(`  ${chalk6.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES)}`);
+    }
+  }
+  const groups = groupByRole(scanResult.structure.directories);
+  if (groups.length > 0) {
+    console.log(`
+${chalk6.bold("Structure:")}`);
+    for (const group of groups) {
+      console.log(`  ${chalk6.green("\u2713")} ${formatRoleGroup(group)}`);
+    }
+  }
+  displayConventions(scanResult);
+  displaySummarySection(scanResult);
+  console.log("");
+}
+function getConventionStr(cv) {
+  return typeof cv === "string" ? cv : cv.value;
+}
+function displayRulesPreview(config) {
+  console.log(`${chalk6.bold("Rules:")}`);
+  console.log(`  ${chalk6.dim("\u2022")} Max file size: ${config.rules.maxFileLines} lines`);
+  if (config.rules.requireTests && config.structure.testPattern) {
+    console.log(
+      `  ${chalk6.dim("\u2022")} Require test files: yes (${config.structure.testPattern})`
+    );
+  } else if (config.rules.requireTests) {
+    console.log(`  ${chalk6.dim("\u2022")} Require test files: yes`);
+  } else {
+    console.log(`  ${chalk6.dim("\u2022")} Require test files: no`);
+  }
+  if (config.rules.enforceNaming && config.conventions.fileNaming) {
+    console.log(
+      `  ${chalk6.dim("\u2022")} Enforce file naming: ${getConventionStr(config.conventions.fileNaming)}`
+    );
+  } else {
+    console.log(`  ${chalk6.dim("\u2022")} Enforce file naming: no`);
+  }
+  console.log(
+    `  ${chalk6.dim("\u2022")} Enforce boundaries: ${config.rules.enforceBoundaries ? "yes" : "no"}`
+  );
+  console.log("");
+  if (config.enforcement === "enforce") {
+    console.log(`${chalk6.bold("Enforcement mode:")} enforce (violations will block commits)`);
+  } else {
+    console.log(
+      `${chalk6.bold("Enforcement mode:")} warn (violations shown but won't block commits)`
+    );
+  }
+  console.log("");
+}
+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 = 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: ${getConventionStr(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, FRAMEWORK_NAMES2)}`);
+  }
+  lines.push(`  \u2713 ${formatItem(stack.language)}`);
+  if (stack.styling) {
+    lines.push(`  \u2713 ${formatItem(stack.styling, STYLING_NAMES2)}`);
+  }
+  if (stack.backend) {
+    lines.push(`  \u2713 ${formatItem(stack.backend, FRAMEWORK_NAMES2)}`);
+  }
+  if (stack.orm) {
+    lines.push(`  \u2713 ${formatItem(stack.orm, 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, 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
 import * as fs10 from "fs";
@@ -979,60 +1450,18 @@ function writeGeneratedFiles(projectRoot, config, scanResult) {
 // src/commands/init-hooks.ts
 import * as fs11 from "fs";
 import * as path12 from "path";
-import chalk5 from "chalk";
-function setupClaudeCodeHook(projectRoot) {
-  const claudeDir = path12.join(projectRoot, ".claude");
-  if (!fs11.existsSync(claudeDir)) {
-    fs11.mkdirSync(claudeDir, { recursive: true });
-  }
-  const settingsPath = path12.join(claudeDir, "settings.json");
-  let settings = {};
-  if (fs11.existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
-    } catch {
-    }
-  }
-  const hooks = settings.hooks ?? {};
-  const postToolUse = hooks.PostToolUse;
-  if (Array.isArray(postToolUse)) {
-    const hasViberails = postToolUse.some(
-      (entry) => typeof entry === "object" && entry !== null && Array.isArray(entry.hooks) && entry.hooks.some(
-        (h) => typeof h === "object" && h !== null && typeof h.command === "string" && h.command.includes("viberails")
-      )
-    );
-    if (hasViberails) return;
-  }
-  const viberailsHook = {
-    matcher: "Edit|Write",
-    hooks: [
-      {
-        type: "command",
-        command: "jq -r '.tool_input.file_path' | xargs npx viberails check --files"
-      }
-    ]
-  };
-  if (!hooks.PostToolUse) {
-    hooks.PostToolUse = [viberailsHook];
-  } else if (Array.isArray(hooks.PostToolUse)) {
-    hooks.PostToolUse.push(viberailsHook);
-  }
-  settings.hooks = hooks;
-  fs11.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
-`);
-  console.log(`  ${chalk5.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
-}
+import chalk7 from "chalk";
 function setupPreCommitHook(projectRoot) {
   const lefthookPath = path12.join(projectRoot, "lefthook.yml");
   if (fs11.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${chalk5.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${chalk7.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return;
   }
   const huskyDir = path12.join(projectRoot, ".husky");
   if (fs11.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${chalk5.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${chalk7.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return;
   }
   const gitDir = path12.join(projectRoot, ".git");
@@ -1042,7 +1471,7 @@ function setupPreCommitHook(projectRoot) {
       fs11.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${chalk5.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${chalk7.green("\u2713")} .git/hooks/pre-commit`);
   }
 }
 function writeGitHookPreCommit(hooksDir) {
@@ -1072,10 +1501,72 @@ npx viberails check --staged
 function addLefthookPreCommit(lefthookPath) {
   const content = fs11.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
-  const addition = ["", "  viberails:", "    run: npx viberails check --staged"].join("\n");
-  fs11.writeFileSync(lefthookPath, `${content.trimEnd()}
-${addition}
+  const hasPreCommit = /^pre-commit:/m.test(content);
+  if (hasPreCommit) {
+    const commandBlock = ["", "    viberails:", "      run: npx viberails check --staged"].join(
+      "\n"
+    );
+    const updated = `${content.trimEnd()}
+${commandBlock}
+`;
+    fs11.writeFileSync(lefthookPath, updated);
+  } else {
+    const section = [
+      "",
+      "pre-commit:",
+      "  commands:",
+      "    viberails:",
+      "      run: npx viberails check --staged"
+    ].join("\n");
+    fs11.writeFileSync(lefthookPath, `${content.trimEnd()}
+${section}
 `);
+  }
+}
+function detectHookManager(projectRoot) {
+  if (fs11.existsSync(path12.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs11.existsSync(path12.join(projectRoot, ".husky"))) return "Husky";
+  if (fs11.existsSync(path12.join(projectRoot, ".git"))) return "git hook";
+  return void 0;
+}
+function setupClaudeCodeHook(projectRoot) {
+  const claudeDir = path12.join(projectRoot, ".claude");
+  if (!fs11.existsSync(claudeDir)) {
+    fs11.mkdirSync(claudeDir, { recursive: true });
+  }
+  const settingsPath = path12.join(claudeDir, "settings.json");
+  let settings = {};
+  if (fs11.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+    } catch {
+      console.warn(
+        `  ${chalk7.yellow("!")} .claude/settings.json contains invalid JSON \u2014 resetting to add hook`
+      );
+      settings = {};
+    }
+  }
+  const hooks = settings.hooks ?? {};
+  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`;
+  hooks.PostToolUse = [
+    ...existing,
+    {
+      matcher: "Edit|Write",
+      hooks: [
+        {
+          type: "command",
+          command: hookCommand
+        }
+      ]
+    }
+  ];
+  settings.hooks = hooks;
+  fs11.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+  console.log(`  ${chalk7.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
 function writeHuskyPreCommit(huskyDir) {
   const hookPath = path12.join(huskyDir, "pre-commit");
@@ -1091,187 +1582,6 @@ npx viberails check --staged
   fs11.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
 }
 
-// src/commands/init-wizard.ts
-import * as p from "@clack/prompts";
-import { FRAMEWORK_NAMES as FRAMEWORK_NAMES3, LIBRARY_NAMES as LIBRARY_NAMES2, STYLING_NAMES as STYLING_NAMES3 } from "@viberails/types";
-import chalk8 from "chalk";
-
-// src/display.ts
-import { FRAMEWORK_NAMES as FRAMEWORK_NAMES2, LIBRARY_NAMES, STYLING_NAMES as STYLING_NAMES2 } from "@viberails/types";
-import chalk7 from "chalk";
-
-// src/display-helpers.ts
-import { ROLE_DESCRIPTIONS } from "@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] });
-    }
-  }
-  const groups = [];
-  for (const [role, { dirs }] of map) {
-    const label = 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`);
-  }
-  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 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})`;
-}
-
-// src/display-monorepo.ts
-import { FRAMEWORK_NAMES, STYLING_NAMES } from "@viberails/types";
-import chalk6 from "chalk";
-
-// src/display.ts
-function formatItem(item, nameMap) {
-  const name = nameMap?.[item.name] ?? item.name;
-  return item.version ? `${name} ${item.version}` : name;
-}
-
-// src/commands/init-wizard.ts
-var DEFAULT_WIZARD_RESULT = {
-  enforcement: "warn",
-  checks: {
-    fileSize: true,
-    naming: true,
-    tests: true,
-    boundaries: false
-  },
-  integration: ["pre-commit"]
-};
-async function runWizard(scanResult) {
-  const isMonorepo = scanResult.packages.length > 1;
-  displayScanSummary(scanResult);
-  const enforcement = await p.select({
-    message: "How strict should viberails be?",
-    initialValue: "warn",
-    options: [
-      { value: "warn", label: "Warn", hint: "show issues, never block commits" },
-      { value: "enforce", label: "Enforce", hint: "block commits with violations" }
-    ]
-  });
-  if (p.isCancel(enforcement)) {
-    p.cancel("Setup cancelled.");
-    return null;
-  }
-  const checkOptions = [
-    { value: "fileSize", label: "File size limit (300 lines)" },
-    { value: "naming", label: "File naming conventions" },
-    { value: "tests", label: "Missing test files" }
-  ];
-  if (isMonorepo) {
-    checkOptions.push({ value: "boundaries", label: "Import boundaries" });
-  }
-  const enabledChecks = await p.multiselect({
-    message: "Which checks should viberails run?",
-    options: checkOptions,
-    initialValues: ["fileSize", "naming", "tests"],
-    required: false
-  });
-  if (p.isCancel(enabledChecks)) {
-    p.cancel("Setup cancelled.");
-    return null;
-  }
-  const checks = {
-    fileSize: enabledChecks.includes("fileSize"),
-    naming: enabledChecks.includes("naming"),
-    tests: enabledChecks.includes("tests"),
-    boundaries: enabledChecks.includes("boundaries")
-  };
-  const integrationOptions = [
-    { value: "pre-commit", label: "Git pre-commit hook", hint: "runs on every commit" },
-    {
-      value: "claude-hook",
-      label: "Claude Code hook",
-      hint: "checks files as Claude edits them"
-    },
-    { value: "context-only", label: "Context files only", hint: "no hooks" }
-  ];
-  const integration = await p.multiselect({
-    message: "Where should checks run?",
-    options: integrationOptions,
-    initialValues: ["pre-commit"],
-    required: true
-  });
-  if (p.isCancel(integration)) {
-    p.cancel("Setup cancelled.");
-    return null;
-  }
-  const finalIntegration = integration.includes("context-only") ? ["context-only"] : integration;
-  return {
-    enforcement,
-    checks,
-    integration: finalIntegration
-  };
-}
-function displayScanSummary(scanResult) {
-  const { stack } = scanResult;
-  const parts = [];
-  if (stack.framework) parts.push(formatItem(stack.framework, FRAMEWORK_NAMES3));
-  parts.push(formatItem(stack.language));
-  if (stack.styling) parts.push(formatItem(stack.styling, STYLING_NAMES3));
-  if (stack.backend) parts.push(formatItem(stack.backend, FRAMEWORK_NAMES3));
-  p.log.info(`${chalk8.bold("Stack:")} ${parts.join(", ")}`);
-  if (stack.linter || stack.formatter || stack.testRunner || stack.packageManager) {
-    const tools = [];
-    if (stack.linter) tools.push(formatItem(stack.linter));
-    if (stack.formatter && stack.formatter !== stack.linter)
-      tools.push(formatItem(stack.formatter));
-    if (stack.testRunner) tools.push(formatItem(stack.testRunner));
-    if (stack.packageManager) tools.push(formatItem(stack.packageManager));
-    p.log.info(`${chalk8.bold("Tools:")} ${tools.join(", ")}`);
-  }
-  if (stack.libraries.length > 0) {
-    const libs = stack.libraries.map((lib) => formatItem(lib, LIBRARY_NAMES2)).join(", ");
-    p.log.info(`${chalk8.bold("Libraries:")} ${libs}`);
-  }
-  const groups = groupByRole(scanResult.structure.directories);
-  if (groups.length > 0) {
-    const structParts = groups.map((g) => formatRoleGroup(g));
-    p.log.info(`${chalk8.bold("Structure:")} ${structParts.join(", ")}`);
-  }
-  const conventionEntries = Object.entries(scanResult.conventions).filter(
-    ([, c]) => c.confidence !== "low"
-  );
-  if (conventionEntries.length > 0) {
-    const convParts = conventionEntries.map(([, c]) => {
-      const pct = Math.round(c.consistency);
-      return `${c.value} (${pct}%)`;
-    });
-    p.log.info(`${chalk8.bold("Conventions:")} ${convParts.join(", ")}`);
-  }
-  const pkgCount = scanResult.packages.length > 1 ? scanResult.packages.length : void 0;
-  p.log.info(`${chalk8.bold("Summary:")} ${formatSummary(scanResult.statistics, pkgCount)}`);
-}
-
 // src/commands/init.ts
 var CONFIG_FILE4 = "viberails.config.json";
 function filterHighConfidence(conventions) {
@@ -1286,12 +1596,13 @@ function filterHighConfidence(conventions) {
   }
   return filtered;
 }
-function applyWizardResult(config, wizard) {
-  config.enforcement = wizard.enforcement;
-  if (!wizard.checks.fileSize) config.rules.maxFileLines = 0;
-  config.rules.enforceNaming = wizard.checks.naming;
-  config.rules.requireTests = wizard.checks.tests;
-  config.rules.enforceBoundaries = wizard.checks.boundaries;
+function getConventionStr2(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();
@@ -1304,69 +1615,137 @@ async function initCommand(options, cwd) {
   const configPath = path13.join(projectRoot, CONFIG_FILE4);
   if (fs12.existsSync(configPath)) {
     console.log(
-      chalk9.yellow("!") + " viberails is already initialized in this project.\n  Run " + chalk9.cyan("viberails sync") + " to update the generated files."
+      `${chalk8.yellow("!")} viberails is already initialized.
+  Run ${chalk8.cyan("viberails sync")} to update, or delete viberails.config.json to start fresh.`
     );
     return;
   }
-  p2.intro("viberails");
-  const s = p2.spinner();
+  if (options.yes) {
+    console.log(chalk8.dim("Scanning project..."));
+    const scanResult2 = await scan(projectRoot);
+    const config2 = generateConfig(scanResult2);
+    config2.conventions = filterHighConfidence(config2.conventions);
+    displayScanResults(scanResult2);
+    displayRulesPreview(config2);
+    if (config2.workspace?.packages && config2.workspace.packages.length > 0) {
+      console.log(chalk8.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);
+      if (inferred.length > 0) {
+        config2.boundaries = inferred;
+        config2.rules.enforceBoundaries = true;
+        console.log(`  Inferred ${inferred.length} boundary rules`);
+      }
+    }
+    fs12.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+`);
+    writeGeneratedFiles(projectRoot, config2, scanResult2);
+    updateGitignore(projectRoot);
+    console.log(`
+Created:`);
+    console.log(`  ${chalk8.green("\u2713")} ${CONFIG_FILE4}`);
+    console.log(`  ${chalk8.green("\u2713")} .viberails/context.md`);
+    console.log(`  ${chalk8.green("\u2713")} .viberails/scan-result.json`);
+    return;
+  }
+  clack2.intro("viberails");
+  const s = clack2.spinner();
   s.start("Scanning project...");
   const scanResult = await scan(projectRoot);
+  const config = generateConfig(scanResult);
   s.stop("Scan complete");
   if (scanResult.statistics.totalFiles === 0) {
-    p2.log.warn(
-      `No source files detected. viberails will generate context with minimal content.
-Run ${chalk9.cyan("viberails sync")} after adding source files.`
+    clack2.log.warn(
+      "No source files detected. viberails will generate context\nwith minimal content. Run viberails sync after adding files."
     );
   }
-  let wizard;
-  if (options.yes) {
-    wizard = { ...DEFAULT_WIZARD_RESULT };
-  } else {
-    const result = await runWizard(scanResult);
-    if (!result) return;
-    wizard = result;
+  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: getConventionStr2(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"
+      );
+    }
   }
-  const config = generateConfig(scanResult);
-  if (options.yes) {
-    config.conventions = filterHighConfidence(config.conventions);
-  }
-  applyWizardResult(config, wizard);
-  if (wizard.checks.boundaries && config.workspace && config.workspace.packages.length > 0) {
-    s.start("Inferring boundary rules...");
-    const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
-    const packages = resolveWorkspacePackages(projectRoot, config.workspace);
-    const graph = await buildImportGraph(projectRoot, { packages, ignore: config.ignore });
-    const inferred = inferBoundaries(graph);
-    const ruleCount = Object.values(inferred).reduce((sum, denied) => sum + denied.length, 0);
-    if (ruleCount > 0) {
-      config.boundaries = inferred;
-      s.stop(`Inferred ${ruleCount} boundary rules`);
-    } else {
-      s.stop("No boundary rules could be inferred");
-      config.rules.enforceBoundaries = false;
+  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) {
+      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 inferred = inferBoundaries(graph);
+      if (inferred.length > 0) {
+        config.boundaries = inferred;
+        config.rules.enforceBoundaries = true;
+        bs.stop(`Inferred ${inferred.length} boundary rules`);
+      } else {
+        bs.stop("No boundary rules inferred");
+      }
     }
   }
+  const hookManager = detectHookManager(projectRoot);
+  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);
-  if (wizard.integration.includes("pre-commit")) {
+  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 (wizard.integration.includes("claude-hook")) {
+  if (integrations.claudeCodeHook) {
     setupClaudeCodeHook(projectRoot);
+    createdFiles.push(".claude/settings.json \u2014 added viberails hook");
   }
-  p2.log.success(`${chalk9.bold("Created:")}`);
-  console.log(`  ${chalk9.green("\u2713")} ${CONFIG_FILE4}`);
-  console.log(`  ${chalk9.green("\u2713")} .viberails/context.md`);
-  console.log(`  ${chalk9.green("\u2713")} .viberails/scan-result.json`);
-  p2.outro(
-    `${chalk9.bold("Next steps:")}
-  1. Review ${chalk9.cyan("viberails.config.json")} and adjust rules
-  2. Commit ${chalk9.cyan("viberails.config.json")} and ${chalk9.cyan(".viberails/context.md")}
-  3. Run ${chalk9.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");
@@ -1376,8 +1755,9 @@ function updateGitignore(projectRoot) {
   }
   if (!content.includes(".viberails/scan-result.json")) {
     const block = "\n# viberails\n.viberails/scan-result.json\n";
-    fs12.writeFileSync(gitignorePath, `${content.trimEnd()}
-${block}`);
+    const prefix = content.length === 0 ? "" : `${content.trimEnd()}
+`;
+    fs12.writeFileSync(gitignorePath, `${prefix}${block}`);
   }
 }
 
@@ -1386,7 +1766,7 @@ import * as fs13 from "fs";
 import * as path14 from "path";
 import { loadConfig as loadConfig4, mergeConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
-import chalk10 from "chalk";
+import chalk9 from "chalk";
 var CONFIG_FILE5 = "viberails.config.json";
 async function syncCommand(cwd) {
   const startDir = cwd ?? process.cwd();
@@ -1398,21 +1778,33 @@ async function syncCommand(cwd) {
   }
   const configPath = path14.join(projectRoot, CONFIG_FILE5);
   const existing = await loadConfig4(configPath);
-  console.log(chalk10.dim("Scanning project..."));
+  console.log(chalk9.dim("Scanning project..."));
   const scanResult = await scan2(projectRoot);
   const merged = mergeConfig(existing, scanResult);
-  fs13.writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}
+  const existingJson = JSON.stringify(existing, null, 2);
+  const mergedJson = JSON.stringify(merged, null, 2);
+  const configChanged = existingJson !== mergedJson;
+  if (configChanged) {
+    console.log(
+      `  ${chalk9.yellow("!")} Config updated \u2014 review ${chalk9.cyan(CONFIG_FILE5)} for changes`
+    );
+  }
+  fs13.writeFileSync(configPath, `${mergedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk10.bold("Synced:")}`);
-  console.log(`  ${chalk10.green("\u2713")} ${CONFIG_FILE5} \u2014 updated`);
-  console.log(`  ${chalk10.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk10.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+${chalk9.bold("Synced:")}`);
+  if (configChanged) {
+    console.log(`  ${chalk9.yellow("!")} ${CONFIG_FILE5} \u2014 updated (review changes)`);
+  } else {
+    console.log(`  ${chalk9.green("\u2713")} ${CONFIG_FILE5} \u2014 unchanged`);
+  }
+  console.log(`  ${chalk9.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk9.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.3.2";
 var program = new 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) => {
@@ -1420,7 +1812,7 @@ program.command("init", { isDefault: true }).description("Scan your project and
     await initCommand(options);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk11.red("Error:")} ${message}`);
+    console.error(`${chalk10.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -1429,21 +1821,22 @@ 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(`${chalk11.red("Error:")} ${message}`);
+    console.error(`${chalk10.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
-program.command("check").description("Check files against enforced rules").option("--staged", "Check only staged files (for pre-commit hooks)").option("--files <files...>", "Check specific files").option("--no-boundaries", "Skip boundary checking").option("--quiet", "Show only summary counts, not individual violations").option("--limit <n>", "Maximum number of violations to display", Number.parseInt).action(
+program.command("check").description("Check files against enforced rules").option("--staged", "Check only staged files (for pre-commit hooks)").option("--files <files...>", "Check specific files").option("--no-boundaries", "Skip boundary checking").option("--quiet", "Show only summary counts, not individual violations").option("--limit <n>", "Maximum number of violations to display", Number.parseInt).option("--format <format>", "Output format: text (default) or json").action(
   async (options) => {
     try {
       const exitCode = await checkCommand({
         ...options,
-        noBoundaries: options.boundaries === false
+        noBoundaries: options.boundaries === false,
+        format: options.format === "json" ? "json" : "text"
       });
       process.exit(exitCode);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      console.error(`${chalk11.red("Error:")} ${message}`);
+      console.error(`${chalk10.red("Error:")} ${message}`);
       process.exit(1);
     }
   }
@@ -1454,7 +1847,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(`${chalk11.red("Error:")} ${message}`);
+    console.error(`${chalk10.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -1463,7 +1856,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(`${chalk11.red("Error:")} ${message}`);
+    console.error(`${chalk10.red("Error:")} ${message}`);
     process.exit(1);
   }
 });