viberails 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import { Command } from "commander";
 
 // src/commands/boundaries.ts
@@ -34,11 +34,11 @@ async function confirm(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     rl.question(`${message} (Y/n) `, (answer) => {
       rl.close();
       const trimmed = answer.trim().toLowerCase();
-      resolve3(trimmed === "" || trimmed === "y" || trimmed === "yes");
+      resolve4(trimmed === "" || trimmed === "y" || trimmed === "yes");
     });
   });
 }
@@ -187,12 +187,42 @@ ${chalk.yellow("Cycles detected:")}`);
 }
 
 // src/commands/check.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { loadConfig as loadConfig2 } from "@viberails/config";
+import chalk2 from "chalk";
+
+// src/commands/check-config.ts
+function resolveConfigForFile(relPath, config) {
+  if (!config.packages || config.packages.length === 0) {
+    return { rules: config.rules, conventions: config.conventions };
+  }
+  const sortedPackages = [...config.packages].sort((a, b) => b.path.length - a.path.length);
+  for (const pkg of sortedPackages) {
+    if (relPath.startsWith(`${pkg.path}/`) || relPath === pkg.path) {
+      return {
+        rules: { ...config.rules, ...pkg.rules },
+        conventions: { ...config.conventions, ...pkg.conventions }
+      };
+    }
+  }
+  return { rules: config.rules, conventions: config.conventions };
+}
+function resolveIgnoreForFile(relPath, config) {
+  const globalIgnore = config.ignore;
+  if (!config.packages) return globalIgnore;
+  for (const pkg of config.packages) {
+    if (pkg.ignore && relPath.startsWith(`${pkg.path}/`)) {
+      return [...globalIgnore, ...pkg.ignore];
+    }
+  }
+  return globalIgnore;
+}
+
+// src/commands/check-files.ts
 import { execSync } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
-import { loadConfig as loadConfig2 } from "@viberails/config";
-import chalk2 from "chalk";
-var CONFIG_FILE2 = "viberails.config.json";
 var SOURCE_EXTS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -210,6 +240,160 @@ var NAMING_PATTERNS = {
   PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
   snake_case: /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/
 };
+function isIgnored(relPath, ignorePatterns) {
+  for (const pattern of ignorePatterns) {
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3);
+      if (relPath.startsWith(`${prefix}/`) || relPath === prefix) return true;
+    } else if (pattern.startsWith("**/")) {
+      const suffix = pattern.slice(3);
+      if (relPath.endsWith(suffix)) return true;
+    } else if (relPath === pattern || relPath.startsWith(`${pattern}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function countFileLines(filePath) {
+  try {
+    const content = fs4.readFileSync(filePath, "utf-8");
+    if (content.length === 0) return 0;
+    let count = 1;
+    for (let i = 0; i < content.length; i++) {
+      if (content.charCodeAt(i) === 10) count++;
+    }
+    return count;
+  } catch {
+    return null;
+  }
+}
+function checkNaming(relPath, conventions) {
+  const filename = path4.basename(relPath);
+  const ext = path4.extname(filename);
+  if (!SOURCE_EXTS.has(ext)) return void 0;
+  if (filename.startsWith("index.") || filename.includes(".config.") || filename.includes(".test.") || filename.includes(".spec.") || filename.startsWith(".")) {
+    return void 0;
+  }
+  const bare = filename.slice(0, filename.indexOf("."));
+  const convention = typeof conventions.fileNaming === "string" ? conventions.fileNaming : conventions.fileNaming?.value;
+  if (!convention) return void 0;
+  const pattern = NAMING_PATTERNS[convention];
+  if (!pattern || pattern.test(bare)) return void 0;
+  return `File name "${filename}" does not follow ${convention} convention.`;
+}
+function getStagedFiles(projectRoot) {
+  try {
+    const output = execSync("git diff --cached --name-only --diff-filter=ACM", {
+      cwd: projectRoot,
+      encoding: "utf-8"
+    });
+    return output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getAllSourceFiles(projectRoot, config) {
+  const files = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const rel = path4.relative(projectRoot, path4.join(dir, entry.name));
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
+          continue;
+        }
+        if (isIgnored(rel, config.ignore)) continue;
+        walk(path4.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        const ext = path4.extname(entry.name);
+        if (SOURCE_EXTS.has(ext) && !isIgnored(rel, config.ignore)) {
+          files.push(rel);
+        }
+      }
+    }
+  };
+  walk(projectRoot);
+  return files;
+}
+function collectSourceFiles(dir, projectRoot) {
+  const files = [];
+  const walk = (d) => {
+    let entries;
+    try {
+      entries = fs4.readdirSync(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules") continue;
+        walk(path4.join(d, entry.name));
+      } else if (entry.isFile()) {
+        files.push(path4.relative(projectRoot, path4.join(d, entry.name)));
+      }
+    }
+  };
+  walk(dir);
+  return files;
+}
+
+// src/commands/check-tests.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+var SOURCE_EXTS2 = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro"
+]);
+function checkMissingTests(projectRoot, config, severity) {
+  const violations = [];
+  const { testPattern } = config.structure;
+  if (!testPattern) return violations;
+  const srcDir = config.structure.srcDir;
+  if (!srcDir) return violations;
+  const srcPath = path5.join(projectRoot, srcDir);
+  if (!fs5.existsSync(srcPath)) return violations;
+  const testSuffix = testPattern.replace("*", "");
+  const sourceFiles = collectSourceFiles(srcPath, projectRoot);
+  for (const relFile of sourceFiles) {
+    const basename6 = path5.basename(relFile);
+    if (basename6.includes(".test.") || basename6.includes(".spec.") || basename6.startsWith("index.") || basename6.endsWith(".d.ts")) {
+      continue;
+    }
+    const ext = path5.extname(basename6);
+    if (!SOURCE_EXTS2.has(ext)) continue;
+    const stem = basename6.slice(0, basename6.indexOf("."));
+    const expectedTestFile = `${stem}${testSuffix}`;
+    const dir = path5.dirname(path5.join(projectRoot, relFile));
+    const colocatedTest = path5.join(dir, expectedTestFile);
+    const testsDir = config.structure.tests;
+    const dedicatedTest = testsDir ? path5.join(projectRoot, testsDir, expectedTestFile) : null;
+    const hasTest = fs5.existsSync(colocatedTest) || dedicatedTest !== null && fs5.existsSync(dedicatedTest);
+    if (!hasTest) {
+      violations.push({
+        file: relFile,
+        rule: "missing-test",
+        message: `No test file found. Expected \`${expectedTestFile}\`.`,
+        severity
+      });
+    }
+  }
+  return violations;
+}
+
+// src/commands/check.ts
+var CONFIG_FILE2 = "viberails.config.json";
 async function checkCommand(options, cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
@@ -217,8 +401,8 @@ async function checkCommand(options, cwd) {
     console.error(`${chalk2.red("Error:")} No package.json found. Are you in a JS/TS project?`);
     return 1;
   }
-  const configPath = path4.join(projectRoot, CONFIG_FILE2);
-  if (!fs4.existsSync(configPath)) {
+  const configPath = path6.join(projectRoot, CONFIG_FILE2);
+  if (!fs6.existsSync(configPath)) {
     console.error(
       `${chalk2.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
     );
@@ -240,23 +424,25 @@ async function checkCommand(options, cwd) {
   const violations = [];
   const severity = config.enforcement === "enforce" ? "error" : "warn";
   for (const file of filesToCheck) {
-    const absPath = path4.isAbsolute(file) ? file : path4.join(projectRoot, file);
-    const relPath = path4.relative(projectRoot, absPath);
-    if (isIgnored(relPath, config.ignore)) continue;
-    if (!fs4.existsSync(absPath)) continue;
-    if (config.rules.maxFileLines > 0) {
+    const absPath = path6.isAbsolute(file) ? file : path6.join(projectRoot, file);
+    const relPath = path6.relative(projectRoot, absPath);
+    const effectiveIgnore = resolveIgnoreForFile(relPath, config);
+    if (isIgnored(relPath, effectiveIgnore)) continue;
+    if (!fs6.existsSync(absPath)) continue;
+    const resolved = resolveConfigForFile(relPath, config);
+    if (resolved.rules.maxFileLines > 0) {
       const lines = countFileLines(absPath);
-      if (lines !== null && lines > config.rules.maxFileLines) {
+      if (lines !== null && lines > resolved.rules.maxFileLines) {
         violations.push({
           file: relPath,
           rule: "file-size",
-          message: `${lines} lines (max ${config.rules.maxFileLines}). Split into focused modules.`,
+          message: `${lines} lines (max ${resolved.rules.maxFileLines}). Split into focused modules.`,
           severity
         });
       }
     }
-    if (config.rules.enforceNaming && config.conventions.fileNaming) {
-      const namingViolation = checkNaming(relPath, config);
+    if (resolved.rules.enforceNaming && resolved.conventions.fileNaming) {
+      const namingViolation = checkNaming(relPath, resolved.conventions);
       if (namingViolation) {
         violations.push({
           file: relPath,
@@ -280,10 +466,10 @@ async function checkCommand(options, cwd) {
       ignore: config.ignore
     });
     const boundaryViolations = checkBoundaries(graph, config.boundaries);
-    const filterSet = options.staged || options.files ? new Set(filesToCheck.map((f) => path4.resolve(projectRoot, f))) : null;
+    const filterSet = options.staged || options.files ? new Set(filesToCheck.map((f) => path6.resolve(projectRoot, f))) : null;
     for (const bv of boundaryViolations) {
       if (filterSet && !filterSet.has(bv.file)) continue;
-      const relFile = path4.relative(projectRoot, bv.file);
+      const relFile = path6.relative(projectRoot, bv.file);
       violations.push({
         file: relFile,
         rule: "boundary-violation",
@@ -311,153 +497,378 @@ ${violations.length} ${word} found.`);
   }
   return 0;
 }
-function countFileLines(filePath) {
-  try {
-    const content = fs4.readFileSync(filePath, "utf-8");
-    if (content.length === 0) return 0;
-    let count = 1;
-    for (let i = 0; i < content.length; i++) {
-      if (content.charCodeAt(i) === 10) count++;
-    }
-    return count;
-  } catch {
-    return null;
-  }
+
+// src/commands/fix.ts
+import { execSync as execSync2 } from "child_process";
+import * as fs9 from "fs";
+import * as path10 from "path";
+import { createInterface as createInterface2 } from "readline";
+import { loadConfig as loadConfig3 } from "@viberails/config";
+import chalk3 from "chalk";
+
+// src/commands/fix-imports.ts
+import * as path7 from "path";
+function stripExtension(filePath) {
+  return filePath.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
 }
-function checkNaming(relPath, config) {
-  const filename = path4.basename(relPath);
-  const ext = path4.extname(filename);
-  if (!SOURCE_EXTS.has(ext)) return void 0;
-  if (filename.startsWith("index.") || filename.includes(".config.") || filename.includes(".test.") || filename.includes(".spec.") || filename.startsWith(".")) {
-    return void 0;
-  }
-  const bare = filename.slice(0, filename.indexOf("."));
-  const convention = typeof config.conventions.fileNaming === "string" ? config.conventions.fileNaming : config.conventions.fileNaming?.value;
-  if (!convention) return void 0;
-  const pattern = NAMING_PATTERNS[convention];
-  if (!pattern || pattern.test(bare)) return void 0;
-  return `File name "${filename}" does not follow ${convention} convention.`;
+function computeNewSpecifier(oldSpecifier, newBare) {
+  const hasJsExt = oldSpecifier.endsWith(".js");
+  const base = hasJsExt ? oldSpecifier.slice(0, -3) : oldSpecifier;
+  const dir = base.lastIndexOf("/");
+  const prefix = dir >= 0 ? base.slice(0, dir + 1) : "";
+  const newSpec = prefix + newBare;
+  return hasJsExt ? `${newSpec}.js` : newSpec;
 }
-function checkMissingTests(projectRoot, config, severity) {
-  const violations = [];
-  const { testPattern } = config.structure;
-  if (!testPattern) return violations;
-  const srcDir = config.structure.srcDir;
-  if (!srcDir) return violations;
-  const srcPath = path4.join(projectRoot, srcDir);
-  if (!fs4.existsSync(srcPath)) return violations;
-  const testSuffix = testPattern.replace("*", "");
-  const sourceFiles = collectSourceFiles(srcPath, projectRoot);
-  for (const relFile of sourceFiles) {
-    const basename2 = path4.basename(relFile);
-    if (basename2.includes(".test.") || basename2.includes(".spec.") || basename2.startsWith("index.") || basename2.endsWith(".d.ts")) {
-      continue;
+async function updateImportsAfterRenames(renames, projectRoot) {
+  if (renames.length === 0) return [];
+  const { Project, SyntaxKind } = await import("ts-morph");
+  const renameMap = /* @__PURE__ */ new Map();
+  for (const r of renames) {
+    const oldStripped = stripExtension(r.oldAbsPath);
+    const newFilename = path7.basename(r.newPath);
+    const newName = newFilename.slice(0, newFilename.indexOf("."));
+    renameMap.set(oldStripped, { newBare: newName });
+  }
+  const project = new Project({
+    tsConfigFilePath: void 0,
+    skipAddingFilesFromTsConfig: true
+  });
+  project.addSourceFilesAtPaths(path7.join(projectRoot, "**/*.{ts,tsx,js,jsx,mjs,cjs}"));
+  const updates = [];
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js"];
+  for (const sourceFile of project.getSourceFiles()) {
+    const filePath = sourceFile.getFilePath();
+    if (filePath.includes("/node_modules/") || filePath.includes("/dist/")) continue;
+    const fileDir = path7.dirname(filePath);
+    for (const decl of sourceFile.getImportDeclarations()) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier.startsWith(".")) continue;
+      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
+      if (!match) continue;
+      const newSpec = computeNewSpecifier(specifier, match.newBare);
+      updates.push({
+        file: filePath,
+        oldSpecifier: specifier,
+        newSpecifier: newSpec,
+        line: decl.getStartLineNumber()
+      });
+      decl.setModuleSpecifier(newSpec);
     }
-    const ext = path4.extname(basename2);
-    if (!SOURCE_EXTS.has(ext)) continue;
-    const stem = basename2.slice(0, basename2.indexOf("."));
-    const expectedTestFile = `${stem}${testSuffix}`;
-    const dir = path4.dirname(path4.join(projectRoot, relFile));
-    const colocatedTest = path4.join(dir, expectedTestFile);
-    const testsDir = config.structure.tests;
-    const dedicatedTest = testsDir ? path4.join(projectRoot, testsDir, expectedTestFile) : null;
-    const hasTest = fs4.existsSync(colocatedTest) || dedicatedTest !== null && fs4.existsSync(dedicatedTest);
-    if (!hasTest) {
-      violations.push({
-        file: relFile,
-        rule: "missing-test",
-        message: `No test file found. Expected \`${expectedTestFile}\`.`,
-        severity
+    for (const decl of sourceFile.getExportDeclarations()) {
+      const specifier = decl.getModuleSpecifierValue();
+      if (!specifier || !specifier.startsWith(".")) continue;
+      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
+      if (!match) continue;
+      const newSpec = computeNewSpecifier(specifier, match.newBare);
+      updates.push({
+        file: filePath,
+        oldSpecifier: specifier,
+        newSpecifier: newSpec,
+        line: decl.getStartLineNumber()
       });
+      decl.setModuleSpecifier(newSpec);
+    }
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      if (call.getExpression().getKind() !== SyntaxKind.ImportKeyword) continue;
+      const args = call.getArguments();
+      if (args.length === 0) continue;
+      const arg = args[0];
+      if (arg.getKind() !== SyntaxKind.StringLiteral) continue;
+      const specifier = arg.getText().slice(1, -1);
+      if (!specifier.startsWith(".")) continue;
+      const match = resolveToRenamedFile(specifier, fileDir, renameMap, extensions);
+      if (!match) continue;
+      const newSpec = computeNewSpecifier(specifier, match.newBare);
+      updates.push({
+        file: filePath,
+        oldSpecifier: specifier,
+        newSpecifier: newSpec,
+        line: call.getStartLineNumber()
+      });
+      const quote = arg.getText()[0];
+      arg.replaceWithText(`${quote}${newSpec}${quote}`);
     }
   }
-  return violations;
+  if (updates.length > 0) {
+    await project.save();
+  }
+  return updates;
 }
-function getStagedFiles(projectRoot) {
-  try {
-    const output = execSync("git diff --cached --name-only --diff-filter=ACM", {
-      cwd: projectRoot,
-      encoding: "utf-8"
-    });
-    return output.trim().split("\n").filter(Boolean);
-  } catch {
-    return [];
+function resolveToRenamedFile(specifier, fromDir, renameMap, extensions) {
+  const cleanSpec = specifier.endsWith(".js") ? specifier.slice(0, -3) : specifier;
+  const resolved = path7.resolve(fromDir, cleanSpec);
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    const stripped = stripExtension(candidate);
+    const match = renameMap.get(stripped);
+    if (match) return match;
   }
+  return void 0;
 }
-function getAllSourceFiles(projectRoot, config) {
-  const files = [];
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs4.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const rel = path4.relative(projectRoot, path4.join(dir, entry.name));
-      if (entry.isDirectory()) {
-        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") {
-          continue;
-        }
-        if (isIgnored(rel, config.ignore)) continue;
-        walk(path4.join(dir, entry.name));
-      } else if (entry.isFile()) {
-        const ext = path4.extname(entry.name);
-        if (SOURCE_EXTS.has(ext) && !isIgnored(rel, config.ignore)) {
-          files.push(rel);
+
+// src/commands/fix-naming.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+
+// src/commands/convert-name.ts
+function splitIntoWords(name) {
+  const parts = name.split(/[-_]/);
+  const words = [];
+  for (const part of parts) {
+    if (part === "") continue;
+    let current = "";
+    for (let i = 0; i < part.length; i++) {
+      const ch = part[i];
+      const isUpper = ch >= "A" && ch <= "Z";
+      if (isUpper && current.length > 0) {
+        const prevIsUpper = current[current.length - 1] >= "A" && current[current.length - 1] <= "Z";
+        const nextIsLower = i + 1 < part.length && part[i + 1] >= "a" && part[i + 1] <= "z";
+        if (!prevIsUpper || nextIsLower) {
+          words.push(current.toLowerCase());
+          current = "";
         }
       }
+      current += ch;
     }
+    if (current) words.push(current.toLowerCase());
+  }
+  return words;
+}
+function convertName(bare, target) {
+  const words = splitIntoWords(bare);
+  if (words.length === 0) return bare;
+  switch (target) {
+    case "kebab-case":
+      return words.join("-");
+    case "camelCase":
+      return words[0] + words.slice(1).map(capitalize).join("");
+    case "PascalCase":
+      return words.map(capitalize).join("");
+    case "snake_case":
+      return words.join("_");
+    default:
+      return bare;
+  }
+}
+function capitalize(word) {
+  if (word.length === 0) return word;
+  return word[0].toUpperCase() + word.slice(1);
+}
+
+// src/commands/fix-naming.ts
+function computeRename(relPath, targetConvention, projectRoot) {
+  const filename = path8.basename(relPath);
+  const dir = path8.dirname(relPath);
+  const dotIndex = filename.indexOf(".");
+  if (dotIndex === -1) return null;
+  const bare = filename.slice(0, dotIndex);
+  const suffix = filename.slice(dotIndex);
+  const newBare = convertName(bare, targetConvention);
+  if (newBare === bare) return null;
+  const newFilename = newBare + suffix;
+  const newRelPath = path8.join(dir, newFilename);
+  const oldAbsPath = path8.join(projectRoot, relPath);
+  const newAbsPath = path8.join(projectRoot, newRelPath);
+  if (fs7.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);
+  return true;
+}
+function deduplicateRenames(renames) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const r of renames) {
+    if (seen.has(r.newAbsPath)) continue;
+    seen.add(r.newAbsPath);
+    result.push(r);
+  }
+  return result;
+}
+
+// src/commands/fix-tests.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+function generateTestStub(sourceRelPath, config, projectRoot) {
+  const { testPattern } = config.structure;
+  if (!testPattern) return null;
+  const basename6 = path9.basename(sourceRelPath);
+  const stem = basename6.slice(0, basename6.indexOf("."));
+  const testSuffix = testPattern.replace("*", "");
+  const testFilename = `${stem}${testSuffix}`;
+  const dir = path9.dirname(path9.join(projectRoot, sourceRelPath));
+  const testAbsPath = path9.join(dir, testFilename);
+  if (fs8.existsSync(testAbsPath)) return null;
+  return {
+    path: path9.relative(projectRoot, testAbsPath),
+    absPath: testAbsPath,
+    moduleName: stem
   };
-  walk(projectRoot);
-  return files;
 }
-function collectSourceFiles(dir, projectRoot) {
-  const files = [];
-  const walk = (d) => {
-    let entries;
-    try {
-      entries = fs4.readdirSync(d, { withFileTypes: true });
-    } catch {
-      return;
+function writeTestStub(stub, config) {
+  const runner = config.stack.testRunner === "jest" ? "jest" : "vitest";
+  const importLine = runner === "jest" ? "" : "import { describe, it, expect } from 'vitest';\n\n";
+  const content = `${importLine}describe('${stub.moduleName}', () => {
+  it.todo('add tests');
+});
+`;
+  fs8.mkdirSync(path9.dirname(stub.absPath), { recursive: true });
+  fs8.writeFileSync(stub.absPath, content);
+}
+
+// src/commands/fix.ts
+var CONFIG_FILE3 = "viberails.config.json";
+async function fixCommand(options, cwd) {
+  const startDir = cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(startDir);
+  if (!projectRoot) {
+    console.error(`${chalk3.red("Error:")} No package.json found. Are you in a JS/TS project?`);
+    return 1;
+  }
+  const configPath = path10.join(projectRoot, CONFIG_FILE3);
+  if (!fs9.existsSync(configPath)) {
+    console.error(
+      `${chalk3.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+    );
+    return 1;
+  }
+  const config = await loadConfig3(configPath);
+  if (!options.yes && !options.dryRun) {
+    const isDirty = checkGitDirty(projectRoot);
+    if (isDirty) {
+      console.log(
+        chalk3.yellow("Warning: You have uncommitted changes. Consider committing first.")
+      );
     }
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (entry.name === "node_modules") continue;
-        walk(path4.join(d, entry.name));
-      } else if (entry.isFile()) {
-        files.push(path4.relative(projectRoot, path4.join(d, entry.name)));
-      }
+  }
+  const shouldFixNaming = !options.rule || options.rule.includes("file-naming");
+  const shouldFixTests = !options.rule || options.rule.includes("missing-test");
+  const allFiles = getAllSourceFiles(projectRoot, config);
+  const renames = [];
+  if (shouldFixNaming) {
+    for (const file of allFiles) {
+      const resolved = resolveConfigForFile(file, config);
+      if (!resolved.rules.enforceNaming || !resolved.conventions.fileNaming) continue;
+      const violation = checkNaming(file, resolved.conventions);
+      if (!violation) continue;
+      const convention = getConventionValue(resolved.conventions.fileNaming);
+      if (!convention) continue;
+      const rename = computeRename(file, convention, projectRoot);
+      if (rename) renames.push(rename);
     }
-  };
-  walk(dir);
-  return files;
+  }
+  const dedupedRenames = deduplicateRenames(renames);
+  const testStubs = [];
+  if (shouldFixTests && config.rules.requireTests) {
+    const testViolations = checkMissingTests(projectRoot, config, "warn");
+    for (const v of testViolations) {
+      const stub = generateTestStub(v.file, config, projectRoot);
+      if (stub) testStubs.push(stub);
+    }
+  }
+  if (dedupedRenames.length === 0 && testStubs.length === 0) {
+    console.log(`${chalk3.green("\u2713")} No fixable violations found.`);
+    return 0;
+  }
+  printPlan(dedupedRenames, testStubs);
+  if (options.dryRun) {
+    console.log(chalk3.dim("\nDry run \u2014 no changes applied."));
+    return 0;
+  }
+  if (!options.yes) {
+    const confirmed = await promptConfirm("Apply these fixes?");
+    if (!confirmed) {
+      console.log("Aborted.");
+      return 0;
+    }
+  }
+  let renameCount = 0;
+  for (const rename of dedupedRenames) {
+    if (executeRename(rename)) {
+      renameCount++;
+    }
+  }
+  let importUpdateCount = 0;
+  if (renameCount > 0) {
+    const appliedRenames = dedupedRenames.filter((r) => fs9.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)) {
+      writeTestStub(stub, config);
+      stubCount++;
+    }
+  }
+  console.log("");
+  if (renameCount > 0) {
+    console.log(`${chalk3.green("\u2713")} Renamed ${renameCount} file${renameCount > 1 ? "s" : ""}`);
+  }
+  if (importUpdateCount > 0) {
+    console.log(
+      `${chalk3.green("\u2713")} Updated ${importUpdateCount} import${importUpdateCount > 1 ? "s" : ""}`
+    );
+  }
+  if (stubCount > 0) {
+    console.log(`${chalk3.green("\u2713")} Generated ${stubCount} test stub${stubCount > 1 ? "s" : ""}`);
+  }
+  return 0;
 }
-function isIgnored(relPath, ignorePatterns) {
-  for (const pattern of ignorePatterns) {
-    if (pattern.endsWith("/**")) {
-      const prefix = pattern.slice(0, -3);
-      if (relPath.startsWith(`${prefix}/`) || relPath === prefix) return true;
-    } else if (pattern.startsWith("**/")) {
-      const suffix = pattern.slice(3);
-      if (relPath.endsWith(suffix)) return true;
-    } else if (relPath === pattern || relPath.startsWith(`${pattern}/`)) {
-      return true;
+function printPlan(renames, stubs) {
+  if (renames.length > 0) {
+    console.log(chalk3.bold("\nFile renames:"));
+    for (const r of renames) {
+      console.log(`  ${chalk3.red(r.oldPath)} \u2192 ${chalk3.green(r.newPath)}`);
     }
   }
-  return false;
+  if (stubs.length > 0) {
+    console.log(chalk3.bold("\nTest stubs to create:"));
+    for (const s of stubs) {
+      console.log(`  ${chalk3.green("+")} ${s.path}`);
+    }
+  }
+}
+function checkGitDirty(projectRoot) {
+  try {
+    const output = execSync2("git status --porcelain", {
+      cwd: projectRoot,
+      encoding: "utf-8"
+    });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function getConventionValue(convention) {
+  if (typeof convention === "string") return convention;
+  if (convention && typeof convention === "object" && "value" in convention) {
+    return convention.value;
+  }
+  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/init.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs11 from "fs";
+import * as path12 from "path";
 import { generateConfig } from "@viberails/config";
 import { scan } from "@viberails/scanner";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // src/display.ts
 import { FRAMEWORK_NAMES, LIBRARY_NAMES, ROLE_DESCRIPTIONS, STYLING_NAMES } from "@viberails/types";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 var CONVENTION_LABELS = {
   fileNaming: "File naming",
   componentNaming: "Component naming",
@@ -475,53 +886,128 @@ function confidenceLabel(convention) {
   }
   return `${pct}% \u2014 medium confidence, suggested only`;
 }
+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(`
+${chalk4.bold(`Detected: (monorepo, ${packages.length} packages)`)}`);
+  console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.language)}`);
+  if (stack.packageManager) {
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.packageManager)}`);
+  }
+  if (stack.linter) {
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.linter)}`);
+  }
+  if (stack.testRunner) {
+    console.log(`  ${chalk4.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(`
+${chalk4.bold("Structure:")}`);
+    for (const pkg of packagesWithDirs) {
+      const meaningfulDirs = pkg.structure.directories.filter((d) => d.role !== "unknown");
+      if (meaningfulDirs.length === 0) continue;
+      console.log(`  ${pkg.relativePath}:`);
+      for (const dir of meaningfulDirs) {
+        const label = ROLE_DESCRIPTIONS[dir.role] ?? dir.role;
+        const files = dir.fileCount === 1 ? "1 file" : `${dir.fileCount} files`;
+        console.log(`    ${chalk4.green("\u2713")} ${dir.path} \u2014 ${label} (${files})`);
+      }
+    }
+  }
+  const conventionEntries = Object.entries(scanResult.conventions);
+  if (conventionEntries.length > 0) {
+    console.log(`
+${chalk4.bold("Conventions:")}`);
+    for (const [key, convention] of conventionEntries) {
+      if (convention.confidence === "low") continue;
+      const label = CONVENTION_LABELS[key] ?? key;
+      const pkgValues = 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" ? chalk4.green("\u2713") : chalk4.yellow("~");
+        const detail = chalk4.dim(`(${confidenceLabel(convention)})`);
+        console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+      } else {
+        console.log(`  ${chalk4.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}%)`);
+        }
+      }
+    }
+  }
+  console.log("");
+}
 function displayScanResults(scanResult) {
+  if (scanResult.packages.length > 1) {
+    displayMonorepoResults(scanResult);
+    return;
+  }
   const { stack, conventions } = scanResult;
   console.log(`
-${chalk3.bold("Detected:")}`);
+${chalk4.bold("Detected:")}`);
   if (stack.framework) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.framework, FRAMEWORK_NAMES)}`);
   }
-  console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.language)}`);
+  console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.language)}`);
   if (stack.styling) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.styling, STYLING_NAMES)}`);
   }
   if (stack.backend) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.backend, FRAMEWORK_NAMES)}`);
   }
   if (stack.linter) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.linter)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.linter)}`);
   }
   if (stack.testRunner) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.testRunner)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.testRunner)}`);
   }
   if (stack.packageManager) {
-    console.log(`  ${chalk3.green("\u2713")} ${formatItem(stack.packageManager)}`);
+    console.log(`  ${chalk4.green("\u2713")} ${formatItem(stack.packageManager)}`);
   }
   if (stack.libraries.length > 0) {
     for (const lib of stack.libraries) {
-      console.log(`  ${chalk3.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES)}`);
+      console.log(`  ${chalk4.green("\u2713")} ${formatItem(lib, LIBRARY_NAMES)}`);
     }
   }
   const meaningfulDirs = scanResult.structure.directories.filter((d) => d.role !== "unknown");
   if (meaningfulDirs.length > 0) {
     console.log(`
-${chalk3.bold("Structure:")}`);
+${chalk4.bold("Structure:")}`);
     for (const dir of meaningfulDirs) {
       const label = ROLE_DESCRIPTIONS[dir.role] ?? dir.role;
       const files = dir.fileCount === 1 ? "1 file" : `${dir.fileCount} files`;
-      console.log(`  ${chalk3.green("\u2713")} ${dir.path} \u2014 ${label} (${files})`);
+      console.log(`  ${chalk4.green("\u2713")} ${dir.path} \u2014 ${label} (${files})`);
     }
   }
   const conventionEntries = Object.entries(conventions);
   if (conventionEntries.length > 0) {
     console.log(`
-${chalk3.bold("Conventions:")}`);
+${chalk4.bold("Conventions:")}`);
     for (const [key, convention] of conventionEntries) {
       if (convention.confidence === "low") continue;
       const label = CONVENTION_LABELS[key] ?? key;
-      const ind = convention.confidence === "high" ? chalk3.green("\u2713") : chalk3.yellow("~");
-      const detail = chalk3.dim(`(${confidenceLabel(convention)})`);
+      const ind = convention.confidence === "high" ? chalk4.green("\u2713") : chalk4.yellow("~");
+      const detail = chalk4.dim(`(${confidenceLabel(convention)})`);
       console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
     }
   }
@@ -529,28 +1015,33 @@ ${chalk3.bold("Conventions:")}`);
 }
 
 // src/utils/write-generated-files.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs10 from "fs";
+import * as path11 from "path";
 import { generateContext } from "@viberails/context";
 var CONTEXT_DIR = ".viberails";
 var CONTEXT_FILE = "context.md";
 var SCAN_RESULT_FILE = "scan-result.json";
 function writeGeneratedFiles(projectRoot, config, scanResult) {
-  const contextDir = path5.join(projectRoot, CONTEXT_DIR);
-  if (!fs5.existsSync(contextDir)) {
-    fs5.mkdirSync(contextDir, { recursive: true });
-  }
-  const context = generateContext(config);
-  fs5.writeFileSync(path5.join(contextDir, CONTEXT_FILE), context);
-  fs5.writeFileSync(
-    path5.join(contextDir, SCAN_RESULT_FILE),
-    `${JSON.stringify(scanResult, null, 2)}
+  const contextDir = path11.join(projectRoot, CONTEXT_DIR);
+  try {
+    if (!fs10.existsSync(contextDir)) {
+      fs10.mkdirSync(contextDir, { recursive: true });
+    }
+    const context = generateContext(config);
+    fs10.writeFileSync(path11.join(contextDir, CONTEXT_FILE), context);
+    fs10.writeFileSync(
+      path11.join(contextDir, SCAN_RESULT_FILE),
+      `${JSON.stringify(scanResult, null, 2)}
 `
-  );
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to write generated files to ${contextDir}: ${message}`);
+  }
 }
 
 // src/commands/init.ts
-var CONFIG_FILE3 = "viberails.config.json";
+var CONFIG_FILE4 = "viberails.config.json";
 function filterHighConfidence(conventions) {
   const filtered = {};
   for (const [key, value] of Object.entries(conventions)) {
@@ -571,19 +1062,19 @@ async function initCommand(options, cwd) {
       "No package.json found in this directory or any parent.\n\nMake sure you are inside a JavaScript or TypeScript project, then run:\n  npx viberails"
     );
   }
-  const configPath = path6.join(projectRoot, CONFIG_FILE3);
-  if (fs6.existsSync(configPath)) {
+  const configPath = path12.join(projectRoot, CONFIG_FILE4);
+  if (fs11.existsSync(configPath)) {
     console.log(
-      chalk4.yellow("!") + " viberails is already initialized in this project.\n  Run " + chalk4.cyan("viberails sync") + " to update the generated files."
+      chalk5.yellow("!") + " viberails is already initialized in this project.\n  Run " + chalk5.cyan("viberails sync") + " to update the generated files."
     );
     return;
   }
-  console.log(chalk4.dim("Scanning project..."));
+  console.log(chalk5.dim("Scanning project..."));
   const scanResult = await scan(projectRoot);
   displayScanResults(scanResult);
   if (scanResult.statistics.totalFiles === 0) {
     console.log(
-      chalk4.yellow("!") + " No source files detected. viberails will generate context with minimal content.\n  Run " + chalk4.cyan("viberails sync") + " after adding source files.\n"
+      chalk5.yellow("!") + " No source files detected. viberails will generate context with minimal content.\n  Run " + chalk5.cyan("viberails sync") + " after adding source files.\n"
     );
   }
   if (!options.yes) {
@@ -603,7 +1094,7 @@ async function initCommand(options, cwd) {
       shouldInfer = await confirm("Infer boundary rules from import patterns?");
     }
     if (shouldInfer) {
-      console.log(chalk4.dim("Building import graph..."));
+      console.log(chalk5.dim("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 });
@@ -611,69 +1102,69 @@ async function initCommand(options, cwd) {
       if (inferred.length > 0) {
         config.boundaries = inferred;
         config.rules.enforceBoundaries = true;
-        console.log(`  ${chalk4.green("\u2713")} Inferred ${inferred.length} boundary rules`);
+        console.log(`  ${chalk5.green("\u2713")} Inferred ${inferred.length} boundary rules`);
       }
     }
   }
-  fs6.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  fs11.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
   setupPreCommitHook(projectRoot);
   console.log(`
-${chalk4.bold("Created:")}`);
-  console.log(`  ${chalk4.green("\u2713")} ${CONFIG_FILE3}`);
-  console.log(`  ${chalk4.green("\u2713")} .viberails/context.md`);
-  console.log(`  ${chalk4.green("\u2713")} .viberails/scan-result.json`);
+${chalk5.bold("Created:")}`);
+  console.log(`  ${chalk5.green("\u2713")} ${CONFIG_FILE4}`);
+  console.log(`  ${chalk5.green("\u2713")} .viberails/context.md`);
+  console.log(`  ${chalk5.green("\u2713")} .viberails/scan-result.json`);
   console.log(`
-${chalk4.bold("Next steps:")}`);
-  console.log(`  1. Review ${chalk4.cyan("viberails.config.json")} and adjust rules`);
+${chalk5.bold("Next steps:")}`);
+  console.log(`  1. Review ${chalk5.cyan("viberails.config.json")} and adjust rules`);
   console.log(
-    `  2. Commit ${chalk4.cyan("viberails.config.json")} and ${chalk4.cyan(".viberails/context.md")}`
+    `  2. Commit ${chalk5.cyan("viberails.config.json")} and ${chalk5.cyan(".viberails/context.md")}`
   );
-  console.log(`  3. Run ${chalk4.cyan("viberails check")} to verify your project passes`);
+  console.log(`  3. Run ${chalk5.cyan("viberails check")} to verify your project passes`);
 }
 function updateGitignore(projectRoot) {
-  const gitignorePath = path6.join(projectRoot, ".gitignore");
+  const gitignorePath = path12.join(projectRoot, ".gitignore");
   let content = "";
-  if (fs6.existsSync(gitignorePath)) {
-    content = fs6.readFileSync(gitignorePath, "utf-8");
+  if (fs11.existsSync(gitignorePath)) {
+    content = fs11.readFileSync(gitignorePath, "utf-8");
   }
   if (!content.includes(".viberails/scan-result.json")) {
     const block = "\n# viberails\n.viberails/scan-result.json\n";
-    fs6.writeFileSync(gitignorePath, `${content.trimEnd()}
+    fs11.writeFileSync(gitignorePath, `${content.trimEnd()}
 ${block}`);
   }
 }
 function setupPreCommitHook(projectRoot) {
-  const lefthookPath = path6.join(projectRoot, "lefthook.yml");
-  if (fs6.existsSync(lefthookPath)) {
+  const lefthookPath = path12.join(projectRoot, "lefthook.yml");
+  if (fs11.existsSync(lefthookPath)) {
     addLefthookPreCommit(lefthookPath);
-    console.log(`  ${chalk4.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    console.log(`  ${chalk5.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
     return;
   }
-  const huskyDir = path6.join(projectRoot, ".husky");
-  if (fs6.existsSync(huskyDir)) {
+  const huskyDir = path12.join(projectRoot, ".husky");
+  if (fs11.existsSync(huskyDir)) {
     writeHuskyPreCommit(huskyDir);
-    console.log(`  ${chalk4.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
+    console.log(`  ${chalk5.green("\u2713")} .husky/pre-commit \u2014 added viberails check`);
     return;
   }
-  const gitDir = path6.join(projectRoot, ".git");
-  if (fs6.existsSync(gitDir)) {
-    const hooksDir = path6.join(gitDir, "hooks");
-    if (!fs6.existsSync(hooksDir)) {
-      fs6.mkdirSync(hooksDir, { recursive: true });
+  const gitDir = path12.join(projectRoot, ".git");
+  if (fs11.existsSync(gitDir)) {
+    const hooksDir = path12.join(gitDir, "hooks");
+    if (!fs11.existsSync(hooksDir)) {
+      fs11.mkdirSync(hooksDir, { recursive: true });
     }
     writeGitHookPreCommit(hooksDir);
-    console.log(`  ${chalk4.green("\u2713")} .git/hooks/pre-commit`);
+    console.log(`  ${chalk5.green("\u2713")} .git/hooks/pre-commit`);
   }
 }
 function writeGitHookPreCommit(hooksDir) {
-  const hookPath = path6.join(hooksDir, "pre-commit");
-  if (fs6.existsSync(hookPath)) {
-    const existing = fs6.readFileSync(hookPath, "utf-8");
+  const hookPath = path12.join(hooksDir, "pre-commit");
+  if (fs11.existsSync(hookPath)) {
+    const existing = fs11.readFileSync(hookPath, "utf-8");
     if (existing.includes("viberails")) return;
-    fs6.writeFileSync(
+    fs11.writeFileSync(
       hookPath,
       `${existing.trimEnd()}
 
@@ -690,37 +1181,37 @@ npx viberails check --staged
     "npx viberails check --staged",
     ""
   ].join("\n");
-  fs6.writeFileSync(hookPath, script, { mode: 493 });
+  fs11.writeFileSync(hookPath, script, { mode: 493 });
 }
 function addLefthookPreCommit(lefthookPath) {
-  const content = fs6.readFileSync(lefthookPath, "utf-8");
+  const content = fs11.readFileSync(lefthookPath, "utf-8");
   if (content.includes("viberails")) return;
   const addition = ["", "  viberails:", "    run: npx viberails check --staged"].join("\n");
-  fs6.writeFileSync(lefthookPath, `${content.trimEnd()}
+  fs11.writeFileSync(lefthookPath, `${content.trimEnd()}
 ${addition}
 `);
 }
 function writeHuskyPreCommit(huskyDir) {
-  const hookPath = path6.join(huskyDir, "pre-commit");
-  if (fs6.existsSync(hookPath)) {
-    const existing = fs6.readFileSync(hookPath, "utf-8");
+  const hookPath = path12.join(huskyDir, "pre-commit");
+  if (fs11.existsSync(hookPath)) {
+    const existing = fs11.readFileSync(hookPath, "utf-8");
     if (!existing.includes("viberails")) {
-      fs6.writeFileSync(hookPath, `${existing.trimEnd()}
+      fs11.writeFileSync(hookPath, `${existing.trimEnd()}
 npx viberails check --staged
 `);
     }
     return;
   }
-  fs6.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
+  fs11.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
 }
 
 // src/commands/sync.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
-import { loadConfig as loadConfig3, mergeConfig } from "@viberails/config";
+import * as fs12 from "fs";
+import * as path13 from "path";
+import { loadConfig as loadConfig4, mergeConfig } from "@viberails/config";
 import { scan as scan2 } from "@viberails/scanner";
-import chalk5 from "chalk";
-var CONFIG_FILE4 = "viberails.config.json";
+import chalk6 from "chalk";
+var CONFIG_FILE5 = "viberails.config.json";
 async function syncCommand(cwd) {
   const startDir = cwd ?? process.cwd();
   const projectRoot = findProjectRoot(startDir);
@@ -729,23 +1220,23 @@ async function syncCommand(cwd) {
       "No package.json found in this directory or any parent.\n\nMake sure you are inside a JavaScript or TypeScript project, then run:\n  npx viberails"
     );
   }
-  const configPath = path7.join(projectRoot, CONFIG_FILE4);
-  const existing = await loadConfig3(configPath);
-  console.log(chalk5.dim("Scanning project..."));
+  const configPath = path13.join(projectRoot, CONFIG_FILE5);
+  const existing = await loadConfig4(configPath);
+  console.log(chalk6.dim("Scanning project..."));
   const scanResult = await scan2(projectRoot);
   const merged = mergeConfig(existing, scanResult);
-  fs7.writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}
+  fs12.writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, merged, scanResult);
   console.log(`
-${chalk5.bold("Synced:")}`);
-  console.log(`  ${chalk5.green("\u2713")} ${CONFIG_FILE4} \u2014 updated`);
-  console.log(`  ${chalk5.green("\u2713")} .viberails/context.md \u2014 regenerated`);
-  console.log(`  ${chalk5.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+${chalk6.bold("Synced:")}`);
+  console.log(`  ${chalk6.green("\u2713")} ${CONFIG_FILE5} \u2014 updated`);
+  console.log(`  ${chalk6.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${chalk6.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
 }
 
 // src/index.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.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) => {
@@ -753,7 +1244,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(`${chalk6.red("Error:")} ${message}`);
+    console.error(`${chalk7.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -762,7 +1253,7 @@ program.command("sync").description("Re-scan and update generated files").action
     await syncCommand();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk6.red("Error:")} ${message}`);
+    console.error(`${chalk7.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -775,7 +1266,17 @@ program.command("check").description("Check files against enforced rules").optio
     process.exit(exitCode);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(`${chalk6.red("Error:")} ${message}`);
+    console.error(`${chalk7.red("Error:")} ${message}`);
+    process.exit(1);
+  }
+});
+program.command("fix").description("Auto-fix file naming violations and generate missing test stubs").option("--dry-run", "Show planned fixes without applying them").option("--rule <rules...>", "Fix only specific rules (file-naming, missing-test)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+  try {
+    const exitCode = await fixCommand(options);
+    process.exit(exitCode);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${chalk7.red("Error:")} ${message}`);
     process.exit(1);
   }
 });
@@ -784,7 +1285,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(`${chalk6.red("Error:")} ${message}`);
+    console.error(`${chalk7.red("Error:")} ${message}`);
     process.exit(1);
   }
 });