viberails 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,829 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VERSION: () => VERSION
+});
+module.exports = __toCommonJS(index_exports);
+var import_chalk6 = __toESM(require("chalk"), 1);
+var import_commander = require("commander");
+
+// src/commands/boundaries.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_config = require("@viberails/config");
+var import_chalk = __toESM(require("chalk"), 1);
+
+// src/utils/find-project-root.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function findProjectRoot(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+// src/utils/prompt.ts
+var readline = __toESM(require("readline"), 1);
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve3) => {
+    rl.question(`${message} (Y/n) `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      resolve3(trimmed === "" || trimmed === "y" || trimmed === "yes");
+    });
+  });
+}
+
+// src/utils/resolve-workspace-packages.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+function resolveWorkspacePackages(projectRoot, workspace) {
+  const packages = [];
+  for (const relativePath of workspace.packages) {
+    const absPath = path2.join(projectRoot, relativePath);
+    const pkgJsonPath = path2.join(absPath, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) continue;
+    let pkg;
+    try {
+      pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    } catch {
+      continue;
+    }
+    const name = pkg.name;
+    if (!name) continue;
+    const allDeps = [
+      ...Object.keys(pkg.dependencies ?? {}),
+      ...Object.keys(pkg.devDependencies ?? {})
+    ];
+    packages.push({ name, path: absPath, relativePath, internalDeps: allDeps });
+  }
+  const packageNames = new Set(packages.map((p) => p.name));
+  for (const pkg of packages) {
+    pkg.internalDeps = pkg.internalDeps.filter((dep) => packageNames.has(dep));
+  }
+  return packages;
+}
+
+// src/commands/boundaries.ts
+var CONFIG_FILE = "viberails.config.json";
+async function boundariesCommand(options, cwd) {
+  const startDir = cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(startDir);
+  if (!projectRoot) {
+    throw new Error("No package.json found. Are you in a JS/TS project?");
+  }
+  const configPath = path3.join(projectRoot, CONFIG_FILE);
+  if (!fs3.existsSync(configPath)) {
+    throw new Error("No viberails.config.json found. Run `viberails init` first.");
+  }
+  const config = await (0, import_config.loadConfig)(configPath);
+  if (options.graph) {
+    await showGraph(projectRoot, config);
+    return;
+  }
+  if (options.infer) {
+    await inferAndDisplay(projectRoot, config, configPath);
+    return;
+  }
+  displayRules(config);
+}
+function displayRules(config) {
+  if (!config.boundaries || config.boundaries.length === 0) {
+    console.log(import_chalk.default.yellow("No boundary rules configured."));
+    console.log(`Run ${import_chalk.default.cyan("viberails boundaries --infer")} to generate rules.`);
+    return;
+  }
+  const allowRules = config.boundaries.filter((r) => r.allow);
+  const denyRules = config.boundaries.filter((r) => !r.allow);
+  console.log(`
+${import_chalk.default.bold(`Boundary rules (${config.boundaries.length} rules):`)}
+`);
+  for (const r of allowRules) {
+    console.log(`  ${import_chalk.default.green("\u2713")} ${r.from} \u2192 ${r.to}`);
+  }
+  for (const r of denyRules) {
+    const reason = r.reason ? import_chalk.default.dim(` (${r.reason})`) : "";
+    console.log(`  ${import_chalk.default.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
+  }
+  console.log(
+    `
+Enforcement: ${config.rules.enforceBoundaries ? import_chalk.default.green("on") : import_chalk.default.yellow("off")}`
+  );
+}
+async function inferAndDisplay(projectRoot, config, configPath) {
+  console.log(import_chalk.default.dim("Analyzing imports..."));
+  const { buildImportGraph, inferBoundaries } = await import("@viberails/graph");
+  const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
+  const graph = await buildImportGraph(projectRoot, {
+    packages,
+    ignore: config.ignore
+  });
+  console.log(import_chalk.default.dim(`${graph.nodes.length} files, ${graph.edges.length} edges`));
+  const inferred = inferBoundaries(graph);
+  if (inferred.length === 0) {
+    console.log(import_chalk.default.yellow("No boundary rules could be inferred."));
+    return;
+  }
+  const allow = inferred.filter((r) => r.allow);
+  const deny = inferred.filter((r) => !r.allow);
+  console.log(`
+${import_chalk.default.bold("Inferred boundary rules:")}
+`);
+  for (const r of allow) {
+    console.log(`  ${import_chalk.default.green("\u2713")} ${r.from} \u2192 ${r.to}`);
+  }
+  for (const r of deny) {
+    const reason = r.reason ? import_chalk.default.dim(` (${r.reason})`) : "";
+    console.log(`  ${import_chalk.default.red("\u2717")} ${r.from} \u2192 ${r.to}${reason}`);
+  }
+  console.log(`
+  ${allow.length} allowed, ${deny.length} denied`);
+  const shouldSave = await confirm("\nSave to viberails.config.json?");
+  if (shouldSave) {
+    config.boundaries = inferred;
+    config.rules.enforceBoundaries = true;
+    fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+    console.log(`${import_chalk.default.green("\u2713")} Saved ${inferred.length} rules`);
+  }
+}
+async function showGraph(projectRoot, config) {
+  console.log(import_chalk.default.dim("Building import graph..."));
+  const { buildImportGraph } = await import("@viberails/graph");
+  const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
+  const graph = await buildImportGraph(projectRoot, {
+    packages,
+    ignore: config.ignore
+  });
+  console.log(`
+${import_chalk.default.bold("Import dependency graph:")}
+`);
+  console.log(`  ${graph.nodes.length} files, ${graph.edges.length} imports
+`);
+  if (graph.packages.length > 0) {
+    for (const pkg of graph.packages) {
+      const deps = pkg.internalDeps.length > 0 ? `
+${pkg.internalDeps.map((d) => `    \u2192 ${d}`).join("\n")}` : import_chalk.default.dim(" (no internal deps)");
+      console.log(`  ${pkg.name}${deps}`);
+    }
+  }
+  if (graph.cycles.length > 0) {
+    console.log(`
+${import_chalk.default.yellow("Cycles detected:")}`);
+    for (const cycle of graph.cycles) {
+      const paths = cycle.map((f) => path3.relative(projectRoot, f));
+      console.log(`  ${paths.join(" \u2192 ")}`);
+    }
+  }
+}
+
+// src/commands/check.ts
+var import_node_child_process = require("child_process");
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_config2 = require("@viberails/config");
+var import_chalk2 = __toESM(require("chalk"), 1);
+var CONFIG_FILE2 = "viberails.config.json";
+var SOURCE_EXTS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro"
+]);
+var NAMING_PATTERNS = {
+  "kebab-case": /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
+  camelCase: /^[a-z][a-zA-Z0-9]*$/,
+  PascalCase: /^[A-Z][a-zA-Z0-9]*$/,
+  snake_case: /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/
+};
+async function checkCommand(options, cwd) {
+  const startDir = cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(startDir);
+  if (!projectRoot) {
+    console.error(`${import_chalk2.default.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)) {
+    console.error(
+      `${import_chalk2.default.red("Error:")} No viberails.config.json found. Run \`viberails init\` first.`
+    );
+    return 1;
+  }
+  const config = await (0, import_config2.loadConfig)(configPath);
+  let filesToCheck;
+  if (options.staged) {
+    filesToCheck = getStagedFiles(projectRoot);
+  } else if (options.files && options.files.length > 0) {
+    filesToCheck = options.files;
+  } else {
+    filesToCheck = getAllSourceFiles(projectRoot, config);
+  }
+  if (filesToCheck.length === 0) {
+    console.log(`${import_chalk2.default.green("\u2713")} No files to check.`);
+    return 0;
+  }
+  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 lines = countFileLines(absPath);
+      if (lines !== null && lines > config.rules.maxFileLines) {
+        violations.push({
+          file: relPath,
+          rule: "file-size",
+          message: `${lines} lines (max ${config.rules.maxFileLines}). Split into focused modules.`,
+          severity
+        });
+      }
+    }
+    if (config.rules.enforceNaming && config.conventions.fileNaming) {
+      const namingViolation = checkNaming(relPath, config);
+      if (namingViolation) {
+        violations.push({
+          file: relPath,
+          rule: "file-naming",
+          message: namingViolation,
+          severity
+        });
+      }
+    }
+  }
+  if (config.rules.requireTests && !options.staged && !options.files) {
+    const testViolations = checkMissingTests(projectRoot, config, severity);
+    violations.push(...testViolations);
+  }
+  if (config.rules.enforceBoundaries && config.boundaries && config.boundaries.length > 0 && !options.noBoundaries) {
+    const startTime = Date.now();
+    const { buildImportGraph, checkBoundaries } = await import("@viberails/graph");
+    const packages = config.workspace ? resolveWorkspacePackages(projectRoot, config.workspace) : void 0;
+    const graph = await buildImportGraph(projectRoot, {
+      packages,
+      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;
+    for (const bv of boundaryViolations) {
+      if (filterSet && !filterSet.has(bv.file)) continue;
+      const relFile = path4.relative(projectRoot, bv.file);
+      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})` : ""}`,
+        severity
+      });
+    }
+    const elapsed = Date.now() - startTime;
+    console.log(import_chalk2.default.dim(`  Boundary check: ${graph.nodes.length} files in ${elapsed}ms`));
+  }
+  if (violations.length === 0) {
+    console.log(`${import_chalk2.default.green("\u2713")} ${filesToCheck.length} files checked \u2014 no violations`);
+    return 0;
+  }
+  for (const v of violations) {
+    const icon = v.severity === "error" ? import_chalk2.default.red("\u2717") : import_chalk2.default.yellow("!");
+    console.log(`${icon} ${import_chalk2.default.dim(v.rule)} ${v.file}: ${v.message}`);
+  }
+  const word = violations.length === 1 ? "violation" : "violations";
+  console.log(`
+${violations.length} ${word} found.`);
+  if (config.enforcement === "enforce") {
+    console.log(import_chalk2.default.red("Fix violations before committing."));
+    return 1;
+  }
+  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;
+  }
+}
+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 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;
+    }
+    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
+      });
+    }
+  }
+  return violations;
+}
+function getStagedFiles(projectRoot) {
+  try {
+    const output = (0, import_node_child_process.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;
+}
+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;
+}
+
+// src/commands/init.ts
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+var import_config3 = require("@viberails/config");
+var import_scanner = require("@viberails/scanner");
+var import_chalk4 = __toESM(require("chalk"), 1);
+
+// src/display.ts
+var import_types = require("@viberails/types");
+var import_chalk3 = __toESM(require("chalk"), 1);
+var CONVENTION_LABELS = {
+  fileNaming: "File naming",
+  componentNaming: "Component naming",
+  hookNaming: "Hook naming",
+  importAlias: "Import alias"
+};
+function formatItem(item, nameMap) {
+  const name = nameMap?.[item.name] ?? item.name;
+  return item.version ? `${name} ${item.version}` : name;
+}
+function confidenceLabel(convention) {
+  const pct = Math.round(convention.consistency);
+  if (convention.confidence === "high") {
+    return `${pct}% \u2014 high confidence, will enforce`;
+  }
+  return `${pct}% \u2014 medium confidence, suggested only`;
+}
+function displayScanResults(scanResult) {
+  const { stack, conventions } = scanResult;
+  console.log(`
+${import_chalk3.default.bold("Detected:")}`);
+  if (stack.framework) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.framework, import_types.FRAMEWORK_NAMES)}`);
+  }
+  console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.language)}`);
+  if (stack.styling) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.styling, import_types.STYLING_NAMES)}`);
+  }
+  if (stack.backend) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.backend, import_types.FRAMEWORK_NAMES)}`);
+  }
+  if (stack.linter) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.linter)}`);
+  }
+  if (stack.testRunner) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.testRunner)}`);
+  }
+  if (stack.packageManager) {
+    console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(stack.packageManager)}`);
+  }
+  if (stack.libraries.length > 0) {
+    for (const lib of stack.libraries) {
+      console.log(`  ${import_chalk3.default.green("\u2713")} ${formatItem(lib, import_types.LIBRARY_NAMES)}`);
+    }
+  }
+  const meaningfulDirs = scanResult.structure.directories.filter((d) => d.role !== "unknown");
+  if (meaningfulDirs.length > 0) {
+    console.log(`
+${import_chalk3.default.bold("Structure:")}`);
+    for (const dir of meaningfulDirs) {
+      const label = import_types.ROLE_DESCRIPTIONS[dir.role] ?? dir.role;
+      const files = dir.fileCount === 1 ? "1 file" : `${dir.fileCount} files`;
+      console.log(`  ${import_chalk3.default.green("\u2713")} ${dir.path} \u2014 ${label} (${files})`);
+    }
+  }
+  const conventionEntries = Object.entries(conventions);
+  if (conventionEntries.length > 0) {
+    console.log(`
+${import_chalk3.default.bold("Conventions:")}`);
+    for (const [key, convention] of conventionEntries) {
+      if (convention.confidence === "low") continue;
+      const label = CONVENTION_LABELS[key] ?? key;
+      const ind = convention.confidence === "high" ? import_chalk3.default.green("\u2713") : import_chalk3.default.yellow("~");
+      const detail = import_chalk3.default.dim(`(${confidenceLabel(convention)})`);
+      console.log(`  ${ind} ${label}: ${convention.value} ${detail}`);
+    }
+  }
+  console.log("");
+}
+
+// src/utils/write-generated-files.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var import_context = require("@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 = (0, import_context.generateContext)(config);
+  fs5.writeFileSync(path5.join(contextDir, CONTEXT_FILE), context);
+  fs5.writeFileSync(
+    path5.join(contextDir, SCAN_RESULT_FILE),
+    `${JSON.stringify(scanResult, null, 2)}
+`
+  );
+}
+
+// src/commands/init.ts
+var CONFIG_FILE3 = "viberails.config.json";
+function filterHighConfidence(conventions) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(conventions)) {
+    if (value === void 0) continue;
+    if (typeof value === "string") {
+      filtered[key] = value;
+    } else if (value._confidence === "high") {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+async function initCommand(options, cwd) {
+  const startDir = cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(startDir);
+  if (!projectRoot) {
+    throw new Error(
+      "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)) {
+    console.log(
+      import_chalk4.default.yellow("!") + " viberails is already initialized in this project.\n  Run " + import_chalk4.default.cyan("viberails sync") + " to update the generated files."
+    );
+    return;
+  }
+  console.log(import_chalk4.default.dim("Scanning project..."));
+  const scanResult = await (0, import_scanner.scan)(projectRoot);
+  displayScanResults(scanResult);
+  if (scanResult.statistics.totalFiles === 0) {
+    console.log(
+      import_chalk4.default.yellow("!") + " No source files detected. viberails will generate context with minimal content.\n  Run " + import_chalk4.default.cyan("viberails sync") + " after adding source files.\n"
+    );
+  }
+  if (!options.yes) {
+    const accepted = await confirm("Does this look right?");
+    if (!accepted) {
+      console.log("Aborted.");
+      return;
+    }
+  }
+  const config = (0, import_config3.generateConfig)(scanResult);
+  if (options.yes) {
+    config.conventions = filterHighConfidence(config.conventions);
+  }
+  if (config.workspace && config.workspace.packages.length > 0) {
+    let shouldInfer = options.yes;
+    if (!options.yes) {
+      shouldInfer = await confirm("Infer boundary rules from import patterns?");
+    }
+    if (shouldInfer) {
+      console.log(import_chalk4.default.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 });
+      const inferred = inferBoundaries(graph);
+      if (inferred.length > 0) {
+        config.boundaries = inferred;
+        config.rules.enforceBoundaries = true;
+        console.log(`  ${import_chalk4.default.green("\u2713")} Inferred ${inferred.length} boundary rules`);
+      }
+    }
+  }
+  fs6.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+  writeGeneratedFiles(projectRoot, config, scanResult);
+  updateGitignore(projectRoot);
+  setupPreCommitHook(projectRoot);
+  console.log(`
+${import_chalk4.default.bold("Created:")}`);
+  console.log(`  ${import_chalk4.default.green("\u2713")} ${CONFIG_FILE3}`);
+  console.log(`  ${import_chalk4.default.green("\u2713")} .viberails/context.md`);
+  console.log(`  ${import_chalk4.default.green("\u2713")} .viberails/scan-result.json`);
+  console.log(`
+${import_chalk4.default.bold("Next steps:")}`);
+  console.log(`  1. Review ${import_chalk4.default.cyan("viberails.config.json")} and adjust rules`);
+  console.log(
+    `  2. Commit ${import_chalk4.default.cyan("viberails.config.json")} and ${import_chalk4.default.cyan(".viberails/context.md")}`
+  );
+  console.log(`  3. Run ${import_chalk4.default.cyan("viberails check")} to verify your project passes`);
+}
+function updateGitignore(projectRoot) {
+  const gitignorePath = path6.join(projectRoot, ".gitignore");
+  let content = "";
+  if (fs6.existsSync(gitignorePath)) {
+    content = fs6.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()}
+${block}`);
+  }
+}
+function setupPreCommitHook(projectRoot) {
+  const lefthookPath = path6.join(projectRoot, "lefthook.yml");
+  if (fs6.existsSync(lefthookPath)) {
+    addLefthookPreCommit(lefthookPath);
+    console.log(`  ${import_chalk4.default.green("\u2713")} lefthook.yml \u2014 added viberails pre-commit`);
+    return;
+  }
+  const huskyDir = path6.join(projectRoot, ".husky");
+  if (fs6.existsSync(huskyDir)) {
+    writeHuskyPreCommit(huskyDir);
+    console.log(`  ${import_chalk4.default.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 });
+    }
+    writeGitHookPreCommit(hooksDir);
+    console.log(`  ${import_chalk4.default.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");
+    if (existing.includes("viberails")) return;
+    fs6.writeFileSync(
+      hookPath,
+      `${existing.trimEnd()}
+
+# viberails check
+npx viberails check --staged
+`
+    );
+    return;
+  }
+  const script = [
+    "#!/bin/sh",
+    "# Generated by viberails \u2014 https://viberails.sh",
+    "",
+    "npx viberails check --staged",
+    ""
+  ].join("\n");
+  fs6.writeFileSync(hookPath, script, { mode: 493 });
+}
+function addLefthookPreCommit(lefthookPath) {
+  const content = fs6.readFileSync(lefthookPath, "utf-8");
+  if (content.includes("viberails")) return;
+  const addition = ["", "  viberails:", "    run: npx viberails check --staged"].join("\n");
+  fs6.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");
+    if (!existing.includes("viberails")) {
+      fs6.writeFileSync(hookPath, `${existing.trimEnd()}
+npx viberails check --staged
+`);
+    }
+    return;
+  }
+  fs6.writeFileSync(hookPath, "#!/bin/sh\nnpx viberails check --staged\n", { mode: 493 });
+}
+
+// src/commands/sync.ts
+var fs7 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+var import_config4 = require("@viberails/config");
+var import_scanner2 = require("@viberails/scanner");
+var import_chalk5 = __toESM(require("chalk"), 1);
+var CONFIG_FILE4 = "viberails.config.json";
+async function syncCommand(cwd) {
+  const startDir = cwd ?? process.cwd();
+  const projectRoot = findProjectRoot(startDir);
+  if (!projectRoot) {
+    throw new Error(
+      "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 (0, import_config4.loadConfig)(configPath);
+  console.log(import_chalk5.default.dim("Scanning project..."));
+  const scanResult = await (0, import_scanner2.scan)(projectRoot);
+  const merged = (0, import_config4.mergeConfig)(existing, scanResult);
+  fs7.writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}
+`);
+  writeGeneratedFiles(projectRoot, merged, scanResult);
+  console.log(`
+${import_chalk5.default.bold("Synced:")}`);
+  console.log(`  ${import_chalk5.default.green("\u2713")} ${CONFIG_FILE4} \u2014 updated`);
+  console.log(`  ${import_chalk5.default.green("\u2713")} .viberails/context.md \u2014 regenerated`);
+  console.log(`  ${import_chalk5.default.green("\u2713")} .viberails/scan-result.json \u2014 updated`);
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var program = new import_commander.Command();
+program.name("viberails").description("Guardrails for vibe coding").version(VERSION);
+program.command("init", { isDefault: true }).description("Scan your project and set up enforcement guardrails").option("-y, --yes", "Non-interactive mode (use defaults, high-confidence only)").action(async (options) => {
+  try {
+    await initCommand(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${import_chalk6.default.red("Error:")} ${message}`);
+    process.exit(1);
+  }
+});
+program.command("sync").description("Re-scan and update generated files").action(async () => {
+  try {
+    await syncCommand();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${import_chalk6.default.red("Error:")} ${message}`);
+    process.exit(1);
+  }
+});
+program.command("check").description("Check files against enforced rules").option("--staged", "Check only staged files (for pre-commit hooks)").option("--files <files...>", "Check specific files").option("--no-boundaries", "Skip boundary checking").action(async (options) => {
+  try {
+    const exitCode = await checkCommand({
+      ...options,
+      noBoundaries: options.boundaries === false
+    });
+    process.exit(exitCode);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${import_chalk6.default.red("Error:")} ${message}`);
+    process.exit(1);
+  }
+});
+program.command("boundaries").description("Display, infer, or inspect import boundary rules").option("--infer", "Infer boundary rules from current import patterns").option("--graph", "Display import graph summary").action(async (options) => {
+  try {
+    await boundariesCommand(options);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${import_chalk6.default.red("Error:")} ${message}`);
+    process.exit(1);
+  }
+});
+program.parse();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION
+});
+//# sourceMappingURL=index.cjs.map