viberails 0.3.3 → 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) {
@@ -560,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 = [];
@@ -622,7 +693,9 @@ 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(chalk2.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+    }
   }
   if (options.format === "json") {
     console.log(
@@ -649,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";
@@ -793,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
@@ -855,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) {
@@ -875,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;
@@ -886,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,
@@ -900,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
@@ -914,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.`
     );
@@ -978,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++;
     }
@@ -1005,7 +1124,7 @@ 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";
@@ -1439,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";
@@ -1448,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)}
 `
@@ -1465,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`);
@@ -1493,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()}
 
@@ -1513,71 +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 checkAndReport = [
-    `FILE=$(${extractFile})`,
-    'if [ -z "$FILE" ]; then exit 0; fi',
-    'OUTPUT=$(npx viberails check --files "$FILE" --format json 2>&1)',
-    `if echo "$OUTPUT" | node -e "process.exit(JSON.parse(require('fs').readFileSync(0,'utf8')).violations?.length?0:1)" 2>/dev/null; then`,
-    '  echo "$OUTPUT" >&2',
-    "  exit 2",
-    "fi",
-    "exit 0"
-  ].join("\n");
-  const hookCommand = checkAndReport;
+  const hookCommand = "if [ -x ./node_modules/.bin/viberails ]; then ./node_modules/.bin/viberails check --hook; else npx viberails check --hook; fi";
   hooks.PostToolUse = [
     ...existing,
     {
@@ -1591,34 +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 (fs11.existsSync(claudeMdPath)) {
-    content = fs11.readFileSync(claudeMdPath, "utf-8");
+  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();
-  fs11.writeFileSync(claudeMdPath, prefix + ref);
+  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
@@ -1639,10 +1739,6 @@ 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);
@@ -1652,7 +1748,7 @@ async function initCommand(options, cwd) {
     );
   }
   const configPath = path13.join(projectRoot, CONFIG_FILE4);
-  if (fs12.existsSync(configPath) && !options.force) {
+  if (fs13.existsSync(configPath) && !options.force) {
     console.log(
       `${chalk8.yellow("!")} viberails is already initialized.
   Run ${chalk8.cyan("viberails sync")} to update, or ${chalk8.cyan("viberails init --force")} to start fresh.`
@@ -1682,7 +1778,7 @@ async function initCommand(options, cwd) {
         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);
@@ -1709,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: getConventionStr3(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(
@@ -1759,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);
@@ -1776,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`);
     }
   }
@@ -1796,19 +1876,19 @@ ${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";
@@ -1943,7 +2023,7 @@ var SCAN_RESULT_FILE2 = ".viberails/scan-result.json";
 function loadPreviousStats(projectRoot) {
   const scanResultPath = path14.join(projectRoot, SCAN_RESULT_FILE2);
   try {
-    const raw = fs13.readFileSync(scanResultPath, "utf-8");
+    const raw = fs14.readFileSync(scanResultPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.statistics?.totalFiles !== void 0) {
       return parsed.statistics;
@@ -1982,7 +2062,7 @@ ${chalk9.bold("Changes:")}`);
       console.log(`  ${chalk9.dim(statsDelta)}`);
     }
   }
-  fs13.writeFileSync(configPath, `${mergedJson}
+  fs14.writeFileSync(configPath, `${mergedJson}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
@@ -1997,7 +2077,7 @@ ${chalk9.bold("Synced:")}`);
 }
 
 // src/index.ts
-var VERSION = "0.3.3";
+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)").option("-f, --force", "Re-initialize, replacing existing config").action(async (options) => {
@@ -2018,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,