viberails 0.6.2 → 0.6.4

package/dist/index.cjs

@@ -64,11 +64,34 @@ function findProjectRoot(startDir) {
 var clack5 = __toESM(require("@clack/prompts"), 1);
 
 // src/utils/prompt-integrations.ts
-var import_node_child_process = require("child_process");
 var clack = __toESM(require("@clack/prompts"), 1);
+
+// src/utils/spawn-async.ts
+var import_node_child_process = require("child_process");
+function spawnAsync(command, cwd) {
+  return new Promise((resolve4) => {
+    const child = (0, import_node_child_process.spawn)(command, { cwd, shell: true, stdio: "pipe" });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (status) => {
+      resolve4({ status, stdout, stderr });
+    });
+    child.on("error", () => {
+      resolve4({ status: 1, stdout, stderr });
+    });
+  });
+}
+
+// src/utils/prompt-integrations.ts
 async function promptHookManagerInstall(projectRoot, packageManager, isWorkspace) {
   const choice = await clack.select({
-    message: "No git hook manager detected. Install Lefthook for shareable pre-commit hooks?",
+    message: "No shared git hook manager detected. Install Lefthook?",
     options: [
       {
         value: "install",
@@ -88,12 +111,7 @@ async function promptHookManagerInstall(projectRoot, packageManager, isWorkspace
   const installCmd = pm === "yarn" ? "yarn add -D lefthook" : pm === "pnpm" ? `pnpm add -D${isWorkspace ? " -w" : ""} lefthook` : "npm install -D lefthook";
   const s = clack.spinner();
   s.start("Installing Lefthook...");
-  const result = (0, import_node_child_process.spawnSync)(installCmd, {
-    cwd: projectRoot,
-    shell: true,
-    encoding: "utf-8",
-    stdio: "pipe"
-  });
+  const result = await spawnAsync(installCmd, projectRoot);
   if (result.status === 0) {
     const fs21 = await import("fs");
     const path21 = await import("path");
@@ -161,7 +179,7 @@ async function promptIntegrations(projectRoot, hookManager, tools) {
   );
   const initialValues = isBareHook ? options.filter((o) => o.value !== "preCommit").map((o) => o.value) : options.map((o) => o.value);
   const result = await clack.multiselect({
-    message: "Set up integrations?",
+    message: "Optional integrations",
     options,
     initialValues,
     required: false
@@ -568,16 +586,49 @@ async function confirmDangerous(message) {
   assertNotCancelled(result);
   return result;
 }
+async function promptExistingConfigAction(configFile) {
+  const result = await clack5.select({
+    message: `${configFile} already exists. What do you want to do?`,
+    options: [
+      {
+        value: "edit",
+        label: "Edit existing config",
+        hint: "open the current rules and save updates in place"
+      },
+      {
+        value: "replace",
+        label: "Replace with a fresh scan",
+        hint: "re-scan the project and overwrite the current config"
+      },
+      {
+        value: "cancel",
+        label: "Cancel",
+        hint: "leave the current setup unchanged"
+      }
+    ]
+  });
+  assertNotCancelled(result);
+  return result;
+}
 async function promptInitDecision() {
   const result = await clack5.select({
-    message: "Accept these rules?",
+    message: "How do you want to proceed?",
     options: [
       {
         value: "accept",
-        label: "Yes, looks good",
-        hint: "warns on violation; use --enforce in CI to block"
+        label: "Accept defaults",
+        hint: "writes the config with these defaults; use --enforce in CI to block"
       },
-      { value: "customize", label: "Let me customize rules" }
+      {
+        value: "customize",
+        label: "Customize rules",
+        hint: "edit limits, naming, test coverage, and package overrides"
+      },
+      {
+        value: "review",
+        label: "Review detected details",
+        hint: "show the full scan report with package and structure details"
+      }
     ]
   });
   assertNotCancelled(result);
@@ -1624,6 +1675,15 @@ function formatMonorepoResultsText(scanResult) {
 }
 
 // src/display.ts
+var INIT_OVERVIEW_NAMES = {
+  typescript: "TypeScript",
+  javascript: "JavaScript",
+  eslint: "ESLint",
+  prettier: "Prettier",
+  jest: "Jest",
+  vitest: "Vitest",
+  biome: "Biome"
+};
 function formatItem(item, nameMap) {
   const name = nameMap?.[item.name] ?? item.name;
   return item.version ? `${name} ${item.version}` : name;
@@ -1753,11 +1813,40 @@ function displayRulesPreview(config) {
   );
   console.log("");
 }
-function displayInitSummary(config, exemptedPackages) {
+function formatDetectedOverview(scanResult) {
+  const { stack } = scanResult;
+  const primaryParts = [];
+  const secondaryParts = [];
+  const formatOverviewItem = (item, nameMap) => formatItem(item, { ...INIT_OVERVIEW_NAMES, ...nameMap });
+  if (scanResult.packages.length > 1) {
+    primaryParts.push("monorepo");
+    primaryParts.push(`${scanResult.packages.length} packages`);
+  } else if (stack.framework) {
+    primaryParts.push(formatItem(stack.framework, import_types3.FRAMEWORK_NAMES));
+  } else {
+    primaryParts.push("single package");
+  }
+  primaryParts.push(formatOverviewItem(stack.language));
+  if (stack.styling) {
+    primaryParts.push(formatOverviewItem(stack.styling, import_types3.STYLING_NAMES));
+  }
+  if (stack.packageManager) secondaryParts.push(formatOverviewItem(stack.packageManager));
+  if (stack.linter) secondaryParts.push(formatOverviewItem(stack.linter));
+  if (stack.formatter) secondaryParts.push(formatOverviewItem(stack.formatter));
+  if (stack.testRunner) secondaryParts.push(formatOverviewItem(stack.testRunner));
+  const primary = primaryParts.map((part) => import_chalk5.default.cyan(part)).join(import_chalk5.default.dim(" \xB7 "));
+  const secondary = secondaryParts.join(import_chalk5.default.dim(" \xB7 "));
+  return secondary ? `${primary}
+  ${import_chalk5.default.dim(secondary)}` : primary;
+}
+function displayInitOverview(scanResult, config, exemptedPackages) {
   const root = config.packages.find((p) => p.path === ".") ?? config.packages[0];
   const isMonorepo = config.packages.length > 1;
   const ok = import_chalk5.default.green("\u2713");
-  const off = import_chalk5.default.dim("\u25CB");
+  const info = import_chalk5.default.yellow("~");
+  console.log("");
+  console.log(`  ${import_chalk5.default.bold("Ready to initialize:")}`);
+  console.log(`  ${formatDetectedOverview(scanResult)}`);
   console.log("");
   console.log(`  ${import_chalk5.default.bold("Rules to apply:")}`);
   console.log(`  ${ok} Max file size: ${import_chalk5.default.cyan(`${config.rules.maxFileLines} lines`)}`);
@@ -1765,7 +1854,7 @@ function displayInitSummary(config, exemptedPackages) {
   if (config.rules.enforceNaming && fileNaming) {
     console.log(`  ${ok} File naming: ${import_chalk5.default.cyan(fileNaming)}`);
   } else {
-    console.log(`  ${off} File naming: ${import_chalk5.default.dim("not enforced")}`);
+    console.log(`  ${info} File naming: ${import_chalk5.default.dim("not enforced")}`);
   }
   const testPattern = root?.structure?.testPattern ?? config.packages.find((p) => p.structure?.testPattern)?.structure?.testPattern;
   if (config.rules.enforceMissingTests && testPattern) {
@@ -1773,7 +1862,7 @@ function displayInitSummary(config, exemptedPackages) {
   } else if (config.rules.enforceMissingTests) {
     console.log(`  ${ok} Missing tests: ${import_chalk5.default.cyan("enforced")}`);
   } else {
-    console.log(`  ${off} Missing tests: ${import_chalk5.default.dim("not enforced")}`);
+    console.log(`  ${info} Missing tests: ${import_chalk5.default.dim("not enforced")}`);
   }
   if (config.rules.testCoverage > 0) {
     if (isMonorepo) {
@@ -1787,21 +1876,68 @@ function displayInitSummary(config, exemptedPackages) {
       console.log(`  ${ok} Coverage: ${import_chalk5.default.cyan(`${config.rules.testCoverage}%`)}`);
     }
   } else {
-    console.log(`  ${off} Coverage: ${import_chalk5.default.dim("disabled")}`);
+    console.log(`  ${info} Coverage: ${import_chalk5.default.dim("disabled")}`);
   }
   if (exemptedPackages.length > 0) {
     console.log(
       `  ${import_chalk5.default.dim("  exempted:")} ${import_chalk5.default.dim(exemptedPackages.join(", "))} ${import_chalk5.default.dim("(types-only)")}`
     );
   }
+  console.log("");
+  console.log(`  ${import_chalk5.default.bold("Also available:")}`);
   if (isMonorepo) {
-    console.log(
-      `
-  ${import_chalk5.default.dim(`${config.packages.length} packages scanned \xB7 warns on violation \xB7 use --enforce in CI`)}`
-    );
+    console.log(`  ${info} Infer boundaries from current imports`);
+  }
+  console.log(`  ${info} Set up hooks, Claude integration, and CI checks`);
+  console.log(
+    `
+  ${import_chalk5.default.dim("Defaults warn locally. Use --enforce in CI when you want failures to block.")}`
+  );
+  console.log("");
+}
+function summarizeSelectedIntegrations(integrations, opts) {
+  const lines = [];
+  if (opts.hasBoundaries) {
+    lines.push("\u2713 Boundary rules: inferred from current imports");
   } else {
-    console.log(`
-  ${import_chalk5.default.dim("warns on violation \xB7 use --enforce in CI to block")}`);
+    lines.push("~ Boundary rules: not enabled");
+  }
+  if (opts.hasCoverage) {
+    lines.push("\u2713 Coverage checks: enabled");
+  } else {
+    lines.push("~ Coverage checks: disabled");
+  }
+  const selectedIntegrations = [
+    integrations.preCommitHook ? "pre-commit hook" : void 0,
+    integrations.typecheckHook ? "typecheck" : void 0,
+    integrations.lintHook ? "lint check" : void 0,
+    integrations.claudeCodeHook ? "Claude Code hook" : void 0,
+    integrations.claudeMdRef ? "CLAUDE.md reference" : void 0,
+    integrations.githubAction ? "GitHub Actions workflow" : void 0
+  ].filter(Boolean);
+  if (selectedIntegrations.length > 0) {
+    lines.push(`\u2713 Integrations: ${selectedIntegrations.join(" \xB7 ")}`);
+  } else {
+    lines.push("~ Integrations: none selected");
+  }
+  return lines;
+}
+function displaySetupPlan(config, integrations, opts = {}) {
+  const configFile = opts.configFile ?? "viberails.config.json";
+  const lines = summarizeSelectedIntegrations(integrations, {
+    hasBoundaries: config.rules.enforceBoundaries,
+    hasCoverage: config.rules.testCoverage > 0
+  });
+  console.log("");
+  console.log(`  ${import_chalk5.default.bold("Ready to write:")}`);
+  console.log(
+    `  ${opts.replacingExistingConfig ? import_chalk5.default.yellow("!") : import_chalk5.default.green("\u2713")} ${configFile}${opts.replacingExistingConfig ? import_chalk5.default.dim(" (replacing existing config)") : ""}`
+  );
+  console.log(`  ${import_chalk5.default.green("\u2713")} .viberails/context.md`);
+  console.log(`  ${import_chalk5.default.green("\u2713")} .viberails/scan-result.json`);
+  for (const line of lines) {
+    const icon = line.startsWith("\u2713") ? import_chalk5.default.green("\u2713") : import_chalk5.default.yellow("~");
+    console.log(`  ${icon} ${line.slice(2)}`);
   }
   console.log("");
 }
@@ -2113,10 +2249,12 @@ async function configCommand(options, cwd) {
   }
   const configPath = path9.join(projectRoot, CONFIG_FILE3);
   if (!fs10.existsSync(configPath)) {
-    console.log(`${import_chalk6.default.yellow("!")} No config found. Run ${import_chalk6.default.cyan("viberails init")} first.`);
+    console.log(`${import_chalk6.default.yellow("!")} No config found. Run ${import_chalk6.default.cyan("viberails")} first.`);
     return;
   }
-  clack6.intro("viberails config");
+  if (!options.suppressIntro) {
+    clack6.intro("viberails config");
+  }
   const config = await (0, import_config6.loadConfig)(configPath);
   let scanResult = options.rescan ? await rescanAndMerge(projectRoot, config) : void 0;
   clack6.note(formatRulesText(config).join("\n"), "Current rules");
@@ -2690,7 +2828,6 @@ var import_scanner2 = require("@viberails/scanner");
 var import_chalk12 = __toESM(require("chalk"), 1);
 
 // src/utils/check-prerequisites.ts
-var import_node_child_process5 = require("child_process");
 var fs14 = __toESM(require("fs"), 1);
 var path14 = __toESM(require("path"), 1);
 var clack7 = __toESM(require("@clack/prompts"), 1);
@@ -2739,7 +2876,7 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
     const detail = p.affectedPackages ? `needed by: ${p.affectedPackages.join(", ")}` : p.reason;
     return `\u2717 ${p.label} \u2014 ${detail}`;
   }).join("\n");
-  clack7.note(prereqLines, "Coverage prerequisites");
+  clack7.note(prereqLines, "Coverage support");
   let disableCoverage = false;
   for (const m of missing) {
     if (!m.installCommand) continue;
@@ -2750,13 +2887,13 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
       options: [
         {
           value: "install",
-          label: `Yes, install now`,
+          label: "Install now",
           hint: m.installCommand
         },
         {
           value: "disable",
-          label: "No, disable coverage percentage checks",
-          hint: "missing-test checks still active"
+          label: "Disable coverage checks",
+          hint: "missing-test checks still stay active"
         },
         {
           value: "skip",
@@ -2769,12 +2906,7 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
     if (choice === "install") {
       const is = clack7.spinner();
       is.start(`Installing ${m.label}...`);
-      const result = (0, import_node_child_process5.spawnSync)(m.installCommand, {
-        cwd: projectRoot,
-        shell: true,
-        encoding: "utf-8",
-        stdio: "pipe"
-      });
+      const result = await spawnAsync(m.installCommand, projectRoot);
       if (result.status === 0) {
         is.stop(`Installed ${m.label}`);
       } else {
@@ -3221,9 +3353,12 @@ async function initCommand(options, cwd) {
   }
   const configPath = path19.join(projectRoot, CONFIG_FILE5);
   if (fs19.existsSync(configPath) && !options.force) {
+    if (!options.yes) {
+      return initInteractive(projectRoot, configPath, options);
+    }
     console.log(
       `${import_chalk12.default.yellow("!")} viberails is already initialized.
-  Run ${import_chalk12.default.cyan("viberails config")} to edit rules, ${import_chalk12.default.cyan("viberails sync")} to update, or ${import_chalk12.default.cyan("viberails init --force")} to start fresh.`
+  Run ${import_chalk12.default.cyan("viberails")} to review or edit the existing setup, ${import_chalk12.default.cyan("viberails sync")} to update generated files, or ${import_chalk12.default.cyan("viberails init --force")} to replace it.`
     );
     return;
   }
@@ -3301,6 +3436,19 @@ ${created.map((f) => `  ${f}`).join("\n")}`);
 }
 async function initInteractive(projectRoot, configPath, options) {
   clack8.intro("viberails");
+  const replacingExistingConfig = fs19.existsSync(configPath);
+  if (fs19.existsSync(configPath) && !options.force) {
+    const action = await promptExistingConfigAction(path19.basename(configPath));
+    if (action === "cancel") {
+      clack8.outro("Aborted. No files were written.");
+      return;
+    }
+    if (action === "edit") {
+      await configCommand({ suppressIntro: true }, projectRoot);
+      return;
+    }
+    options.force = true;
+  }
   if (fs19.existsSync(configPath) && options.force) {
     const replace = await confirmDangerous(
       `${path19.basename(configPath)} already exists and will be replaced. Continue?`
@@ -3320,10 +3468,18 @@ async function initInteractive(projectRoot, configPath, options) {
       "No source files detected. Try running from the project root,\nor check that source files exist. Run viberails sync after adding files."
     );
   }
-  clack8.note(formatScanResultsText(scanResult), "Scan results");
   const exemptedPkgs = getExemptedPackages(config);
-  displayInitSummary(config, exemptedPkgs);
-  const decision = await promptInitDecision();
+  let decision;
+  while (true) {
+    displayInitOverview(scanResult, config, exemptedPkgs);
+    const nextDecision = await promptInitDecision();
+    if (nextDecision === "review") {
+      clack8.note(formatScanResultsText(scanResult), "Detected details");
+      continue;
+    }
+    decision = nextDecision;
+    break;
+  }
   if (decision === "customize") {
     const rootPkg = config.packages.find((p) => p.path === ".") ?? config.packages[0];
     const overrides = await promptRuleMenu({
@@ -3340,10 +3496,10 @@ async function initInteractive(projectRoot, configPath, options) {
   }
   if (config.packages.length > 1) {
     clack8.note(
-      "Boundary rules prevent packages from importing where they\nshouldn't. viberails scans your existing imports and creates\nrules based on what's already working.",
+      "Optional for monorepos. viberails can infer package boundaries\nfrom imports that already work today, so you start with rules\nthat match the current codebase.",
       "Boundaries"
     );
-    const shouldInfer = await confirm3("Infer boundary rules from import patterns?");
+    const shouldInfer = await confirm3("Infer boundary rules from current import patterns?");
     if (shouldInfer) {
       const bs = clack8.spinner();
       bs.start("Building import graph...");
@@ -3379,27 +3535,31 @@ async function initInteractive(projectRoot, configPath, options) {
     packageManager: rootPkgStack?.packageManager?.split("@")[0],
     isWorkspace: config.packages.length > 1
   });
-  const shouldWrite = await confirm3("Write configuration and set up selected integrations?");
+  displaySetupPlan(config, integrations, {
+    replacingExistingConfig,
+    configFile: path19.basename(configPath)
+  });
+  const shouldWrite = await confirm3("Apply this setup?");
   if (!shouldWrite) {
     clack8.outro("Aborted. No files were written.");
     return;
   }
   const ws = clack8.spinner();
-  ws.start("Writing configuration and setting up integrations...");
+  ws.start("Writing configuration...");
   const compacted = (0, import_config8.compactConfig)(config);
   fs19.writeFileSync(configPath, `${JSON.stringify(compacted, null, 2)}
 `);
   writeGeneratedFiles(projectRoot, config, scanResult);
   updateGitignore(projectRoot);
-  setupSelectedIntegrations(projectRoot, integrations, {
-    linter: rootPkgStack?.linter?.split("@")[0],
-    packageManager: rootPkgStack?.packageManager?.split("@")[0]
-  });
   ws.stop("Configuration written");
   const ok = import_chalk12.default.green("\u2713");
   clack8.log.step(`${ok} ${path19.basename(configPath)}`);
   clack8.log.step(`${ok} .viberails/context.md`);
   clack8.log.step(`${ok} .viberails/scan-result.json`);
+  setupSelectedIntegrations(projectRoot, integrations, {
+    linter: rootPkgStack?.linter?.split("@")[0],
+    packageManager: rootPkgStack?.packageManager?.split("@")[0]
+  });
   clack8.outro(
     `Done! Next: review viberails.config.json, then run viberails check
   ${import_chalk12.default.dim("Tip: use")} ${import_chalk12.default.cyan("viberails check --enforce")} ${import_chalk12.default.dim("in CI to block PRs on violations.")}`
@@ -3410,7 +3570,7 @@ async function initInteractive(projectRoot, configPath, options) {
 var fs20 = __toESM(require("fs"), 1);
 var path20 = __toESM(require("path"), 1);
 var clack9 = __toESM(require("@clack/prompts"), 1);
-var import_config9 = require("@viberails/config");
+var import_config10 = require("@viberails/config");
 var import_scanner3 = require("@viberails/scanner");
 var import_chalk13 = __toESM(require("chalk"), 1);
 var CONFIG_FILE6 = "viberails.config.json";
@@ -3436,14 +3596,14 @@ async function syncCommand(options, cwd) {
     );
   }
   const configPath = path20.join(projectRoot, CONFIG_FILE6);
-  const existing = await (0, import_config9.loadConfig)(configPath);
+  const existing = await (0, import_config10.loadConfig)(configPath);
   const previousStats = loadPreviousStats(projectRoot);
   const s = clack9.spinner();
   s.start("Scanning project...");
   const scanResult = await (0, import_scanner3.scan)(projectRoot);
   s.stop("Scan complete");
-  const merged = (0, import_config9.mergeConfig)(existing, scanResult);
-  const compacted = (0, import_config9.compactConfig)(merged);
+  const merged = (0, import_config10.mergeConfig)(existing, scanResult);
+  const compacted = (0, import_config10.compactConfig)(merged);
   const compactedJson = JSON.stringify(compacted, null, 2);
   const rawDisk = fs20.readFileSync(configPath, "utf-8").trim();
   const diskWithoutSync = rawDisk.replace(/"lastSync":\s*"[^"]*"/, '"lastSync": ""');
@@ -3491,7 +3651,7 @@ ${import_chalk13.default.bold("Changes:")}`);
         packageOverrides: merged.packages
       });
       applyRuleOverrides(merged, overrides);
-      const recompacted = (0, import_config9.compactConfig)(merged);
+      const recompacted = (0, import_config10.compactConfig)(merged);
       fs20.writeFileSync(configPath, `${JSON.stringify(recompacted, null, 2)}
 `);
       writeGeneratedFiles(projectRoot, merged, scanResult);
@@ -3515,7 +3675,7 @@ ${import_chalk13.default.bold("Synced:")}`);
 }
 
 // src/index.ts
-var VERSION = "0.6.2";
+var VERSION = "0.6.4";
 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)").option("-f, --force", "Re-initialize, replacing existing config").action(async (options) => {