viberails 0.6.2 → 0.6.4

package/dist/index.js

@@ -31,11 +31,34 @@ function findProjectRoot(startDir) {
 import * as clack5 from "@clack/prompts";
 
 // src/utils/prompt-integrations.ts
-import { spawnSync } from "child_process";
 import * as clack from "@clack/prompts";
+
+// src/utils/spawn-async.ts
+import { spawn } from "child_process";
+function spawnAsync(command, cwd) {
+  return new Promise((resolve4) => {
+    const child = 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",
@@ -55,12 +78,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 = 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");
@@ -128,7 +146,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
@@ -535,16 +553,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);
@@ -742,7 +793,7 @@ function resolveIgnoreForFile(relPath, config) {
 }
 
 // src/commands/check-coverage.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 import * as fs4 from "fs";
 import * as path4 from "path";
 import { inferCoverageCommand } from "@viberails/config";
@@ -785,7 +836,7 @@ function readCoveragePercentage(summaryPath) {
   }
 }
 function runCoverageCommand(pkgRoot, command) {
-  const result = spawnSync2(command, {
+  const result = spawnSync(command, {
     cwd: pkgRoot,
     shell: true,
     encoding: "utf-8",
@@ -1603,6 +1654,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;
@@ -1732,11 +1792,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, FRAMEWORK_NAMES2));
+  } else {
+    primaryParts.push("single package");
+  }
+  primaryParts.push(formatOverviewItem(stack.language));
+  if (stack.styling) {
+    primaryParts.push(formatOverviewItem(stack.styling, STYLING_NAMES2));
+  }
+  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) => chalk5.cyan(part)).join(chalk5.dim(" \xB7 "));
+  const secondary = secondaryParts.join(chalk5.dim(" \xB7 "));
+  return secondary ? `${primary}
+  ${chalk5.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 = chalk5.green("\u2713");
-  const off = chalk5.dim("\u25CB");
+  const info = chalk5.yellow("~");
+  console.log("");
+  console.log(`  ${chalk5.bold("Ready to initialize:")}`);
+  console.log(`  ${formatDetectedOverview(scanResult)}`);
   console.log("");
   console.log(`  ${chalk5.bold("Rules to apply:")}`);
   console.log(`  ${ok} Max file size: ${chalk5.cyan(`${config.rules.maxFileLines} lines`)}`);
@@ -1744,7 +1833,7 @@ function displayInitSummary(config, exemptedPackages) {
   if (config.rules.enforceNaming && fileNaming) {
     console.log(`  ${ok} File naming: ${chalk5.cyan(fileNaming)}`);
   } else {
-    console.log(`  ${off} File naming: ${chalk5.dim("not enforced")}`);
+    console.log(`  ${info} File naming: ${chalk5.dim("not enforced")}`);
   }
   const testPattern = root?.structure?.testPattern ?? config.packages.find((p) => p.structure?.testPattern)?.structure?.testPattern;
   if (config.rules.enforceMissingTests && testPattern) {
@@ -1752,7 +1841,7 @@ function displayInitSummary(config, exemptedPackages) {
   } else if (config.rules.enforceMissingTests) {
     console.log(`  ${ok} Missing tests: ${chalk5.cyan("enforced")}`);
   } else {
-    console.log(`  ${off} Missing tests: ${chalk5.dim("not enforced")}`);
+    console.log(`  ${info} Missing tests: ${chalk5.dim("not enforced")}`);
   }
   if (config.rules.testCoverage > 0) {
     if (isMonorepo) {
@@ -1766,21 +1855,68 @@ function displayInitSummary(config, exemptedPackages) {
       console.log(`  ${ok} Coverage: ${chalk5.cyan(`${config.rules.testCoverage}%`)}`);
     }
   } else {
-    console.log(`  ${off} Coverage: ${chalk5.dim("disabled")}`);
+    console.log(`  ${info} Coverage: ${chalk5.dim("disabled")}`);
   }
   if (exemptedPackages.length > 0) {
     console.log(
       `  ${chalk5.dim("  exempted:")} ${chalk5.dim(exemptedPackages.join(", "))} ${chalk5.dim("(types-only)")}`
     );
   }
+  console.log("");
+  console.log(`  ${chalk5.bold("Also available:")}`);
   if (isMonorepo) {
-    console.log(
-      `
-  ${chalk5.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(
+    `
+  ${chalk5.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(`
-  ${chalk5.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(`  ${chalk5.bold("Ready to write:")}`);
+  console.log(
+    `  ${opts.replacingExistingConfig ? chalk5.yellow("!") : chalk5.green("\u2713")} ${configFile}${opts.replacingExistingConfig ? chalk5.dim(" (replacing existing config)") : ""}`
+  );
+  console.log(`  ${chalk5.green("\u2713")} .viberails/context.md`);
+  console.log(`  ${chalk5.green("\u2713")} .viberails/scan-result.json`);
+  for (const line of lines) {
+    const icon = line.startsWith("\u2713") ? chalk5.green("\u2713") : chalk5.yellow("~");
+    console.log(`  ${icon} ${line.slice(2)}`);
   }
   console.log("");
 }
@@ -2092,10 +2228,12 @@ async function configCommand(options, cwd) {
   }
   const configPath = path9.join(projectRoot, CONFIG_FILE3);
   if (!fs10.existsSync(configPath)) {
-    console.log(`${chalk6.yellow("!")} No config found. Run ${chalk6.cyan("viberails init")} first.`);
+    console.log(`${chalk6.yellow("!")} No config found. Run ${chalk6.cyan("viberails")} first.`);
     return;
   }
-  clack6.intro("viberails config");
+  if (!options.suppressIntro) {
+    clack6.intro("viberails config");
+  }
   const config = await loadConfig3(configPath);
   let scanResult = options.rescan ? await rescanAndMerge(projectRoot, config) : void 0;
   clack6.note(formatRulesText(config).join("\n"), "Current rules");
@@ -2669,7 +2807,6 @@ import { scan as scan2 } from "@viberails/scanner";
 import chalk12 from "chalk";
 
 // src/utils/check-prerequisites.ts
-import { spawnSync as spawnSync3 } from "child_process";
 import * as fs14 from "fs";
 import * as path14 from "path";
 import * as clack7 from "@clack/prompts";
@@ -2718,7 +2855,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;
@@ -2729,13 +2866,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",
@@ -2748,12 +2885,7 @@ async function promptMissingPrereqs(projectRoot, prereqs) {
     if (choice === "install") {
       const is = clack7.spinner();
       is.start(`Installing ${m.label}...`);
-      const result = spawnSync3(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 {
@@ -3200,9 +3332,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(
       `${chalk12.yellow("!")} viberails is already initialized.
-  Run ${chalk12.cyan("viberails config")} to edit rules, ${chalk12.cyan("viberails sync")} to update, or ${chalk12.cyan("viberails init --force")} to start fresh.`
+  Run ${chalk12.cyan("viberails")} to review or edit the existing setup, ${chalk12.cyan("viberails sync")} to update generated files, or ${chalk12.cyan("viberails init --force")} to replace it.`
     );
     return;
   }
@@ -3280,6 +3415,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?`
@@ -3299,10 +3447,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({
@@ -3319,10 +3475,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...");
@@ -3358,27 +3514,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 = compactConfig3(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 = chalk12.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
   ${chalk12.dim("Tip: use")} ${chalk12.cyan("viberails check --enforce")} ${chalk12.dim("in CI to block PRs on violations.")}`
@@ -3494,7 +3654,7 @@ ${chalk13.bold("Synced:")}`);
 }
 
 // src/index.ts
-var VERSION = "0.6.2";
+var VERSION = "0.6.4";
 var program = new Command();
 program.name("viberails").description("Guardrails for vibe coding").version(VERSION);
 program.command("init", { isDefault: true }).description("Scan your project and set up enforcement guardrails").option("-y, --yes", "Non-interactive mode (use defaults, high-confidence only)").option("-f, --force", "Re-initialize, replacing existing config").action(async (options) => {