viberails 0.3.2 → 0.4.0

package/dist/index.js

@@ -56,50 +56,115 @@ async function promptInitDecision() {
   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: [
+async function promptRuleMenu(defaults) {
+  const state = { ...defaults };
+  while (true) {
+    const namingHint = state.enforceNaming ? `yes${state.fileNamingValue ? ` (${state.fileNamingValue})` : ""}` : "no";
+    const enforcementHint = state.enforcement === "warn" ? "warn \u2014 violations shown but commits allowed" : "enforce \u2014 commits blocked on violation";
+    const options = [
+      { value: "maxFileLines", label: "Max file lines", hint: String(state.maxFileLines) },
       {
-        value: "warn",
-        label: "warn",
-        hint: "show violations but don't block commits (recommended)"
+        value: "requireTests",
+        label: "Require test files",
+        hint: state.requireTests ? "yes" : "no"
       },
-      {
-        value: "enforce",
-        label: "enforce",
-        hint: "block commits with violations"
-      }
-    ],
-    initialValue: defaults.enforcement
-  });
-  assertNotCancelled(enforcementResult);
+      { value: "enforceNaming", label: "Enforce file naming", hint: namingHint },
+      { value: "enforcement", label: "Enforcement mode", hint: enforcementHint }
+    ];
+    if (state.packageOverrides && state.packageOverrides.length > 0) {
+      const count = state.packageOverrides.length;
+      options.push({
+        value: "packageOverrides",
+        label: "Per-package overrides",
+        hint: `${count} package${count > 1 ? "s" : ""} differ (view)`
+      });
+    }
+    options.push({ value: "done", label: "Done" });
+    const choice = await clack.select({
+      message: "Customize rules",
+      options
+    });
+    assertNotCancelled(choice);
+    if (choice === "done") break;
+    if (choice === "packageOverrides" && state.packageOverrides) {
+      const lines = state.packageOverrides.map((pkg) => {
+        const diffs = [];
+        if (pkg.conventions) {
+          for (const [key, val] of Object.entries(pkg.conventions)) {
+            const v = typeof val === "string" ? val : val?.value;
+            if (v) diffs.push(`${key}: ${v}`);
+          }
+        }
+        if (pkg.stack) {
+          for (const [key, val] of Object.entries(pkg.stack)) {
+            if (val) diffs.push(`${key}: ${val}`);
+          }
+        }
+        return `${pkg.path}
+  ${diffs.join(", ") || "minor differences"}`;
+      });
+      clack.note(
+        `${lines.join("\n\n")}
+
+Edit the "packages" section in viberails.config.json to adjust.`,
+        "Per-package overrides"
+      );
+      continue;
+    }
+    if (choice === "maxFileLines") {
+      const result = await clack.text({
+        message: "Maximum lines per source file?",
+        initialValue: String(state.maxFileLines),
+        validate: (v) => {
+          const n = Number.parseInt(v, 10);
+          if (Number.isNaN(n) || n < 1) return "Enter a positive number";
+        }
+      });
+      assertNotCancelled(result);
+      state.maxFileLines = Number.parseInt(result, 10);
+    }
+    if (choice === "requireTests") {
+      const result = await clack.confirm({
+        message: "Require matching test files for source files?",
+        initialValue: state.requireTests
+      });
+      assertNotCancelled(result);
+      state.requireTests = result;
+    }
+    if (choice === "enforceNaming") {
+      const result = await clack.confirm({
+        message: state.fileNamingValue ? `Enforce file naming? (detected: ${state.fileNamingValue})` : "Enforce file naming?",
+        initialValue: state.enforceNaming
+      });
+      assertNotCancelled(result);
+      state.enforceNaming = result;
+    }
+    if (choice === "enforcement") {
+      const result = 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: state.enforcement
+      });
+      assertNotCancelled(result);
+      state.enforcement = result;
+    }
+  }
   return {
-    maxFileLines: Number.parseInt(maxFileLinesResult, 10),
-    requireTests: requireTestsResult,
-    enforceNaming: enforceNamingResult,
-    enforcement: enforcementResult
+    maxFileLines: state.maxFileLines,
+    requireTests: state.requireTests,
+    enforceNaming: state.enforceNaming,
+    enforcement: state.enforcement
   };
 }
 async function promptIntegrations(hookManager) {
@@ -116,15 +181,21 @@ async function promptIntegrations(hookManager) {
         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"],
+    initialValues: ["preCommit", "claude", "claudeMd"],
     required: false
   });
   assertNotCancelled(result);
   return {
     preCommitHook: result.includes("preCommit"),
-    claudeCodeHook: result.includes("claude")
+    claudeCodeHook: result.includes("claude"),
+    claudeMdRef: result.includes("claudeMd")
   };
 }
 
@@ -182,22 +253,21 @@ async function boundariesCommand(options, cwd) {
   displayRules(config);
 }
 function displayRules(config) {
-  if (!config.boundaries || config.boundaries.length === 0) {
+  if (!config.boundaries || Object.keys(config.boundaries.deny).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);
+  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(`
-${chalk.bold(`Boundary rules (${config.boundaries.length} rules):`)}
+${chalk.bold(`Boundary rules (${totalRules} deny rules):`)}
 `);
-  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}`);
+  for (const source of sources) {
+    for (const target of deny[source]) {
+      console.log(`  ${chalk.red("\u2717")} ${source} \u2192 ${target}`);
+    }
   }
   console.log(
     `
@@ -214,24 +284,22 @@ async function inferAndDisplay(projectRoot, config, configPath) {
   });
   console.log(chalk.dim(`${graph.nodes.length} files, ${graph.edges.length} edges`));
   const inferred = inferBoundaries(graph);
-  if (inferred.length === 0) {
+  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(chalk.yellow("No boundary rules could be inferred."));
     return;
   }
-  const allow = inferred.filter((r) => r.allow);
-  const deny = inferred.filter((r) => !r.allow);
   console.log(`
 ${chalk.bold("Inferred boundary rules:")}
 `);
-  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}`);
+  for (const source of sources) {
+    for (const target of inferred.deny[source]) {
+      console.log(`  ${chalk.red("\u2717")} ${source} \u2192 ${target}`);
+    }
   }
   console.log(`
-  ${allow.length} allowed, ${deny.length} denied`);
+  ${totalRules} denied`);
   console.log("");
   const shouldSave = await confirm2("Save to viberails.config.json?");
   if (shouldSave) {
@@ -239,7 +307,7 @@ ${chalk.bold("Inferred boundary rules:")}
     config.rules.enforceBoundaries = true;
     fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `);
-    console.log(`${chalk.green("\u2713")} Saved ${inferred.length} rules`);
+    console.log(`${chalk.green("\u2713")} Saved ${totalRules} rules`);
   }
 }
 async function showGraph(projectRoot, config) {
@@ -557,7 +625,13 @@ async function checkCommand(options, cwd) {
     filesToCheck = getAllSourceFiles(projectRoot, config);
   }
   if (filesToCheck.length === 0) {
-    console.log(`${chalk2.green("\u2713")} No files to check.`);
+    if (options.format === "json") {
+      console.log(
+        JSON.stringify({ violations: [], checkedFiles: 0, enforcement: config.enforcement })
+      );
+    } else {
+      console.log(`${chalk2.green("\u2713")} No files to check.`);
+    }
     return 0;
   }
   const violations = [];
@@ -598,7 +672,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;
@@ -614,12 +688,14 @@ 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(chalk2.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+    if (options.format !== "json") {
+      console.log(chalk2.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+    }
   }
   if (options.format === "json") {
     console.log(
@@ -646,8 +722,54 @@ async function checkCommand(options, cwd) {
   return 0;
 }
 
+// src/commands/check-hook.ts
+import * as fs7 from "fs";
+function parseHookFilePath(input) {
+  try {
+    if (!input.trim()) return void 0;
+    const parsed = JSON.parse(input);
+    return parsed?.tool_input?.file_path ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function readStdin() {
+  try {
+    return fs7.readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function hookCheckCommand(cwd) {
+  try {
+    const filePath = parseHookFilePath(readStdin());
+    if (!filePath) return 0;
+    const originalWrite = process.stdout.write.bind(process.stdout);
+    let captured = "";
+    process.stdout.write = (chunk) => {
+      captured += typeof chunk === "string" ? chunk : chunk.toString();
+      return true;
+    };
+    try {
+      await checkCommand({ files: [filePath], format: "json" }, cwd);
+    } finally {
+      process.stdout.write = originalWrite;
+    }
+    if (!captured.trim()) return 0;
+    const result = JSON.parse(captured);
+    if (result.violations?.length > 0) {
+      process.stderr.write(`${captured.trim()}
+`);
+      return 2;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
 // src/commands/fix.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path10 from "path";
 import { loadConfig as loadConfig3 } from "@viberails/config";
 import chalk4 from "chalk";
@@ -790,7 +912,7 @@ function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
 }
 
 // src/commands/fix-naming.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path8 from "path";
 
 // src/commands/convert-name.ts
@@ -852,12 +974,12 @@ function computeRename(relPath, targetConvention, projectRoot) {
   const newRelPath = path8.join(dir, newFilename);
   const oldAbsPath = path8.join(projectRoot, relPath);
   const newAbsPath = path8.join(projectRoot, newRelPath);
-  if (fs7.existsSync(newAbsPath)) return null;
+  if (fs8.existsSync(newAbsPath)) return null;
   return { oldPath: relPath, newPath: newRelPath, oldAbsPath, newAbsPath };
 }
 function executeRename(rename) {
-  if (fs7.existsSync(rename.newAbsPath)) return false;
-  fs7.renameSync(rename.oldAbsPath, rename.newAbsPath);
+  if (fs8.existsSync(rename.newAbsPath)) return false;
+  fs8.renameSync(rename.oldAbsPath, rename.newAbsPath);
   return true;
 }
 function deduplicateRenames(renames) {
@@ -872,7 +994,7 @@ function deduplicateRenames(renames) {
 }
 
 // src/commands/fix-tests.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path9 from "path";
 function generateTestStub(sourceRelPath, config, projectRoot) {
   const { testPattern } = config.structure;
@@ -883,7 +1005,7 @@ function generateTestStub(sourceRelPath, config, projectRoot) {
   const testFilename = `${stem}${testSuffix}`;
   const dir = path9.dirname(path9.join(projectRoot, sourceRelPath));
   const testAbsPath = path9.join(dir, testFilename);
-  if (fs8.existsSync(testAbsPath)) return null;
+  if (fs9.existsSync(testAbsPath)) return null;
   return {
     path: path9.relative(projectRoot, testAbsPath),
     absPath: testAbsPath,
@@ -897,8 +1019,8 @@ function writeTestStub(stub, config) {
   it.todo('add tests');
 });
 `;
-  fs8.mkdirSync(path9.dirname(stub.absPath), { recursive: true });
-  fs8.writeFileSync(stub.absPath, content);
+  fs9.mkdirSync(path9.dirname(stub.absPath), { recursive: true });
+  fs9.writeFileSync(stub.absPath, content);
 }
 
 // src/commands/fix.ts
@@ -911,7 +1033,7 @@ async function fixCommand(options, cwd) {
     return 1;
   }
   const configPath = path10.join(projectRoot, CONFIG_FILE3);
-  if (!fs9.existsSync(configPath)) {
+  if (!fs10.existsSync(configPath)) {
     console.error(
       `${chalk4.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
@@ -975,13 +1097,13 @@ async function fixCommand(options, cwd) {
   }
   let importUpdateCount = 0;
   if (renameCount > 0) {
-    const appliedRenames = dedupedRenames.filter((r) => fs9.existsSync(r.newAbsPath));
+    const appliedRenames = dedupedRenames.filter((r) => fs10.existsSync(r.newAbsPath));
     const updates = await updateImportsAfterRenames(appliedRenames, projectRoot);
     importUpdateCount = updates.length;
   }
   let stubCount = 0;
   for (const stub of testStubs) {
-    if (!fs9.existsSync(stub.absPath)) {
+    if (!fs10.existsSync(stub.absPath)) {
       writeTestStub(stub, config);
       stubCount++;
     }
@@ -1002,16 +1124,21 @@ async function fixCommand(options, cwd) {
 }
 
 // src/commands/init.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path13 from "path";
 import * as clack2 from "@clack/prompts";
 import { generateConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
 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-text.ts
+import {
+  CONVENTION_LABELS as CONVENTION_LABELS2,
+  FRAMEWORK_NAMES as FRAMEWORK_NAMES3,
+  LIBRARY_NAMES as LIBRARY_NAMES2,
+  ORM_NAMES as ORM_NAMES2,
+  STYLING_NAMES as STYLING_NAMES3
+} from "@viberails/types";
 
 // src/display-helpers.ts
 import { ROLE_DESCRIPTIONS } from "@viberails/types";
@@ -1062,6 +1189,16 @@ function formatRoleGroup(group) {
   return `${group.label} \u2014 ${dirs} (${files})`;
 }
 
+// src/display.ts
+import {
+  CONVENTION_LABELS,
+  FRAMEWORK_NAMES as FRAMEWORK_NAMES2,
+  LIBRARY_NAMES,
+  ORM_NAMES,
+  STYLING_NAMES as STYLING_NAMES2
+} from "@viberails/types";
+import chalk6 from "chalk";
+
 // src/display-monorepo.ts
 import { FRAMEWORK_NAMES, STYLING_NAMES } from "@viberails/types";
 import chalk5 from "chalk";
@@ -1171,12 +1308,6 @@ function formatMonorepoResultsText(scanResult, config) {
 }
 
 // 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;
@@ -1312,6 +1443,11 @@ function displayRulesPreview(config) {
   }
   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") {
@@ -1327,7 +1463,7 @@ function formatConventionsText(scanResult) {
   lines.push("Conventions:");
   for (const [key, convention] of conventionEntries) {
     if (convention.confidence === "low") continue;
-    const label = CONVENTION_LABELS[key] ?? key;
+    const label = CONVENTION_LABELS2[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);
@@ -1361,7 +1497,7 @@ function formatRulesText(config) {
     lines.push("  \u2022 Require test files: no");
   }
   if (config.rules.enforceNaming && config.conventions.fileNaming) {
-    lines.push(`  \u2022 Enforce file naming: ${getConventionStr(config.conventions.fileNaming)}`);
+    lines.push(`  \u2022 Enforce file naming: ${getConventionStr2(config.conventions.fileNaming)}`);
   } else {
     lines.push("  \u2022 Enforce file naming: no");
   }
@@ -1376,17 +1512,17 @@ function formatScanResultsText(scanResult, config) {
   const { stack } = scanResult;
   lines.push("Detected:");
   if (stack.framework) {
-    lines.push(`  \u2713 ${formatItem(stack.framework, FRAMEWORK_NAMES2)}`);
+    lines.push(`  \u2713 ${formatItem(stack.framework, FRAMEWORK_NAMES3)}`);
   }
   lines.push(`  \u2713 ${formatItem(stack.language)}`);
   if (stack.styling) {
-    lines.push(`  \u2713 ${formatItem(stack.styling, STYLING_NAMES2)}`);
+    lines.push(`  \u2713 ${formatItem(stack.styling, STYLING_NAMES3)}`);
   }
   if (stack.backend) {
-    lines.push(`  \u2713 ${formatItem(stack.backend, FRAMEWORK_NAMES2)}`);
+    lines.push(`  \u2713 ${formatItem(stack.backend, FRAMEWORK_NAMES3)}`);
   }
   if (stack.orm) {
-    lines.push(`  \u2713 ${formatItem(stack.orm, ORM_NAMES)}`);
+    lines.push(`  \u2713 ${formatItem(stack.orm, ORM_NAMES2)}`);
   }
   const secondaryParts = [];
   if (stack.packageManager) secondaryParts.push(formatItem(stack.packageManager));
@@ -1398,7 +1534,7 @@ function formatScanResultsText(scanResult, config) {
   }
   if (stack.libraries.length > 0) {
     for (const lib of stack.libraries) {
-      lines.push(`  \u2713 ${formatItem(lib, LIBRARY_NAMES)}`);
+      lines.push(`  \u2713 ${formatItem(lib, LIBRARY_NAMES2)}`);
     }
   }
   const groups = groupByRole(scanResult.structure.directories);
@@ -1422,7 +1558,7 @@ function formatScanResultsText(scanResult, config) {
 }
 
 // src/utils/write-generated-files.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path11 from "path";
 import { generateContext } from "@viberails/context";
 var CONTEXT_DIR = ".viberails";
@@ -1431,12 +1567,12 @@ var SCAN_RESULT_FILE = "scan-result.json";
 function writeGeneratedFiles(projectRoot, config, scanResult) {
   const contextDir = path11.join(projectRoot, CONTEXT_DIR);
   try {
-    if (!fs10.existsSync(contextDir)) {
-      fs10.mkdirSync(contextDir, { recursive: true });
+    if (!fs11.existsSync(contextDir)) {
+      fs11.mkdirSync(contextDir, { recursive: true });
     }
     const context = generateContext(config);
-    fs10.writeFileSync(path11.join(contextDir, CONTEXT_FILE), context);
-    fs10.writeFileSync(
+    fs11.writeFileSync(path11.join(contextDir, CONTEXT_FILE), context);
+    fs11.writeFileSync(
       path11.join(contextDir, SCAN_RESULT_FILE),
       `${JSON.stringify(scanResult, null, 2)}
 `
@@ -1448,27 +1584,28 @@ function writeGeneratedFiles(projectRoot, config, scanResult) {
 }
 
 // src/commands/init-hooks.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path12 from "path";
 import chalk7 from "chalk";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function setupPreCommitHook(projectRoot) {
   const lefthookPath = path12.join(projectRoot, "lefthook.yml");
-  if (fs11.existsSync(lefthookPath)) {
+  if (fs12.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
     console.log(`  ${chalk7.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return;
   }
   const huskyDir = path12.join(projectRoot, ".husky");
-  if (fs11.existsSync(huskyDir)) {
+  if (fs12.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
     console.log(`  ${chalk7.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return;
   }
   const gitDir = path12.join(projectRoot, ".git");
-  if (fs11.existsSync(gitDir)) {
+  if (fs12.existsSync(gitDir)) {
     const hooksDir = path12.join(gitDir, "hooks");
-    if (!fs11.existsSync(hooksDir)) {
-      fs11.mkdirSync(hooksDir, { recursive: true });
+    if (!fs12.existsSync(hooksDir)) {
+      fs12.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
     console.log(`  ${chalk7.green("\u2713")} .git/hooks/pre-commit`);
@@ -1476,10 +1613,10 @@ function setupPreCommitHook(projectRoot) {
 }
 function writeGitHookPreCommit(hooksDir) {
   const hookPath = path12.join(hooksDir, "pre-commit");
-  if (fs11.existsSync(hookPath)) {
-    const existing = fs11.readFileSync(hookPath, "utf-8");
+  if (fs12.existsSync(hookPath)) {
+    const existing = fs12.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs11.writeFileSync(
+    fs12.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -1496,61 +1633,51 @@ npx viberails check --staged
     "npx viberails check --staged",
     ""
   ].join("\n");
-  fs11.writeFileSync(hookPath, script, { mode: 493 });
+  fs12.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs11.readFileSync(lefthookPath, "utf-8");
+  const content = fs12.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
-  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}
-`);
+  const doc = parseYaml(content) ?? {};
+  if (!doc["pre-commit"]) {
+    doc["pre-commit"] = { commands: {} };
   }
+  if (!doc["pre-commit"].commands) {
+    doc["pre-commit"].commands = {};
+  }
+  doc["pre-commit"].commands.viberails = {
+    run: "npx viberails check --staged"
+  };
+  fs12.writeFileSync(lefthookPath, stringifyYaml(doc));
 }
 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";
+  if (fs12.existsSync(path12.join(projectRoot, "lefthook.yml"))) return "Lefthook";
+  if (fs12.existsSync(path12.join(projectRoot, ".husky"))) return "Husky";
+  if (fs12.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 });
+  if (!fs12.existsSync(claudeDir)) {
+    fs12.mkdirSync(claudeDir, { recursive: true });
   }
   const settingsPath = path12.join(claudeDir, "settings.json");
   let settings = {};
-  if (fs11.existsSync(settingsPath)) {
+  if (fs12.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
     } catch {
       console.warn(
-        `  ${chalk7.yellow("!")} .claude/settings.json contains invalid JSON \u2014 resetting to add hook`
+        `  ${chalk7.yellow("!")} .claude/settings.json contains invalid JSON \u2014 skipping hook setup`
       );
-      settings = {};
+      console.warn(`  Fix the JSON manually, then re-run ${chalk7.cyan("viberails init --force")}`);
+      return;
     }
   }
   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`;
+  const hookCommand = "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --hook; else npx viberails check --hook; fi";
   hooks.PostToolUse = [
     ...existing,
     {
@@ -1564,22 +1691,34 @@ function setupClaudeCodeHook(projectRoot) {
     }
   ];
   settings.hooks = hooks;
-  fs11.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs12.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
   console.log(`  ${chalk7.green("\u2713")} .claude/settings.json \u2014 added viberails PostToolUse hook`);
 }
+function setupClaudeMdReference(projectRoot) {
+  const claudeMdPath = path12.join(projectRoot, "CLAUDE.md");
+  let content = "";
+  if (fs12.existsSync(claudeMdPath)) {
+    content = fs12.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();
+  fs12.writeFileSync(claudeMdPath, prefix + ref);
+  console.log(`  ${chalk7.green("\u2713")} CLAUDE.md \u2014 added @.viberails/context.md reference`);
+}
 function writeHuskyPreCommit(huskyDir) {
   const hookPath = path12.join(huskyDir, "pre-commit");
-  if (fs11.existsSync(hookPath)) {
-    const existing = fs11.readFileSync(hookPath, "utf-8");
+  if (fs12.existsSync(hookPath)) {
+    const existing = fs12.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs11.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs12.writeFileSync(hookPath, `${existing.trimEnd()}
 npx viberails check --staged
 `);
     }
     return;
   }
-  fs11.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
+  fs12.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
 }
 
 // src/commands/init.ts
@@ -1596,14 +1735,10 @@ function filterHighConfidence(conventions) {
   }
   return filtered;
 }
-function getConventionStr2(cv) {
+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);
@@ -1613,10 +1748,10 @@ async function initCommand(options, cwd) {
     );
   }
   const configPath = path13.join(projectRoot, CONFIG_FILE4);
-  if (fs12.existsSync(configPath)) {
+  if (fs13.existsSync(configPath) && !options.force) {
     console.log(
       `${chalk8.yellow("!")} viberails is already initialized.
-  Run ${chalk8.cyan("viberails sync")} to update, or delete viberails.config.json to start fresh.`
+  Run ${chalk8.cyan("viberails sync")} to update, or ${chalk8.cyan("viberails init --force")} to start fresh.`
     );
     return;
   }
@@ -1636,16 +1771,18 @@ async function initCommand(options, cwd) {
         ignore: config2.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) {
         config2.boundaries = inferred;
         config2.rules.enforceBoundaries = true;
-        console.log(`  Inferred ${inferred.length} boundary rules`);
+        console.log(`  Inferred ${denyCount} boundary rules`);
       }
     }
-    fs12.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
+    fs13.writeFileSync(configPath, `${JSON.stringify(config2, null, 2)}
 `);
     writeGeneratedFiles(projectRoot, config2, scanResult2);
     updateGitignore(projectRoot);
+    setupClaudeMdReference(projectRoot);
     console.log(`
 Created:`);
     console.log(`  ${chalk8.green("\u2713")} ${CONFIG_FILE4}`);
@@ -1668,27 +1805,18 @@ Created:`);
   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({
+    const overrides = await promptRuleMenu({
       maxFileLines: config.rules.maxFileLines,
       requireTests: config.rules.requireTests,
       enforceNaming: config.rules.enforceNaming,
       enforcement: config.enforcement,
-      fileNamingValue: getConventionStr2(config.conventions.fileNaming)
+      fileNamingValue: getConventionStr3(config.conventions.fileNaming),
+      packageOverrides: config.packages
     });
     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?.packages && config.workspace.packages.length > 0) {
     clack2.note(
@@ -1706,10 +1834,11 @@ Created:`);
         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;
-        bs.stop(`Inferred ${inferred.length} boundary rules`);
+        bs.stop(`Inferred ${denyCount} boundary rules`);
       } else {
         bs.stop("No boundary rules inferred");
       }
@@ -1717,13 +1846,7 @@ Created:`);
   }
   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)}
+  fs13.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
@@ -1734,8 +1857,7 @@ Created:`);
   ];
   if (integrations.preCommitHook) {
     setupPreCommitHook(projectRoot);
-    const hookMgr = detectHookManager(projectRoot);
-    if (hookMgr) {
+    if (hookManager === "Lefthook") {
       createdFiles.push(`lefthook.yml \u2014 added viberails pre-commit`);
     }
   }
@@ -1743,6 +1865,10 @@ Created:`);
     setupClaudeCodeHook(projectRoot);
     createdFiles.push(".claude/settings.json \u2014 added viberails hook");
   }
+  if (integrations.claudeMdRef) {
+    setupClaudeMdReference(projectRoot);
+    createdFiles.push("CLAUDE.md \u2014 added @.viberails/context.md reference");
+  }
   clack2.log.success(`Created:
 ${createdFiles.map((f) => `  ${f}`).join("\n")}`);
   clack2.outro("Done! Next: review viberails.config.json, then run viberails check");
@@ -1750,24 +1876,162 @@ ${createdFiles.map((f) => `  ${f}`).join("\n")}`);
 function updateGitignore(projectRoot) {
   const gitignorePath = path13.join(projectRoot, ".gitignore");
   let content = "";
-  if (fs12.existsSync(gitignorePath)) {
-    content = fs12.readFileSync(gitignorePath, "utf-8");
+  if (fs13.existsSync(gitignorePath)) {
+    content = fs13.readFileSync(gitignorePath, "utf-8");
   }
   if (!content.includes(".viberails/scan-result.json")) {
     const block = "\n# viberails\n.viberails/scan-result.json\n";
     const prefix = content.length === 0 ? "" : `${content.trimEnd()}
 `;
-    fs12.writeFileSync(gitignorePath, `${prefix}${block}`);
+    fs13.writeFileSync(gitignorePath, `${prefix}${block}`);
   }
 }
 
 // src/commands/sync.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path14 from "path";
 import { loadConfig as loadConfig4, mergeConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
 import chalk9 from "chalk";
+
+// src/utils/diff-configs.ts
+import { CONVENTION_LABELS as CONVENTION_LABELS3, FRAMEWORK_NAMES as FRAMEWORK_NAMES4, ORM_NAMES as ORM_NAMES3, STYLING_NAMES as STYLING_NAMES4 } from "@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 = {
+    ...FRAMEWORK_NAMES4,
+    ...STYLING_NAMES4,
+    ...ORM_NAMES3
+  };
+  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 = CONVENTION_LABELS3[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 = fs14.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);
@@ -1778,18 +2042,27 @@ async function syncCommand(cwd) {
   }
   const configPath = path14.join(projectRoot, CONFIG_FILE5);
   const existing = await loadConfig4(configPath);
+  const previousStats = loadPreviousStats(projectRoot);
   console.log(chalk9.dim("Scanning project..."));
   const scanResult = await scan2(projectRoot);
   const merged = 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(
-      `  ${chalk9.yellow("!")} Config updated \u2014 review ${chalk9.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(`
+${chalk9.bold("Changes:")}`);
+    for (const change of changes) {
+      const icon = change.type === "removed" ? chalk9.red("-") : chalk9.green("+");
+      console.log(`  ${icon} ${change.description}`);
+    }
+    if (statsDelta) {
+      console.log(`  ${chalk9.dim(statsDelta)}`);
+    }
   }
-  fs13.writeFileSync(configPath, `${mergedJson}
+  fs14.writeFileSync(configPath, `${mergedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
@@ -1804,10 +2077,10 @@ ${chalk9.bold("Synced:")}`);
 }
 
 // src/index.ts
-var VERSION = "0.3.2";
+var VERSION = "0.4.0";
 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) => {
+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) {
@@ -1825,9 +2098,13 @@ program.command("sync").description("Re-scan and update generated files").action
     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).option("--format <format>", "Output format: text (default) or json").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").option("--hook", "Claude Code hook mode: read file from stdin, output to stderr").action(
   async (options) => {
     try {
+      if (options.hook) {
+        const exitCode2 = await hookCheckCommand();
+        process.exit(exitCode2);
+      }
       const exitCode = await checkCommand({
         ...options,
         noBoundaries: options.boundaries === false,