@bull-js/cli 0.0.0-stage → 0.3.0

package/dist/bin.js

@@ -0,0 +1,1578 @@
+#!/usr/bin/env node
+import {
+  VERSION,
+  banner,
+  bullArt,
+  createCommand,
+  detectPackageManager,
+  ensureIndexHtml,
+  fail,
+  loadProject,
+  runAnalysis,
+  runScript,
+  viteConfig
+} from "./chunk-KF3FEGRV.js";
+import {
+  loadBullConfig
+} from "./chunk-FHBUQ5I5.js";
+
+// src/bin.ts
+import { cac } from "cac";
+import pc9 from "picocolors";
+
+// src/commands/build.ts
+import pc from "picocolors";
+import { build as viteBuild } from "vite";
+async function buildCommand(rootArg, options) {
+  banner("build");
+  const project = await loadProject(rootArg, "build", { mode: options.mode, configFile: options.config });
+  const result = runAnalysis(project);
+  if (result.errorCount > 0) {
+    console.log();
+    fail(
+      `Build cancelled: ${result.errorCount} MVVM architecture ${result.errorCount === 1 ? "violation" : "violations"}.`,
+      "Fix them and run `bull build` again."
+    );
+    return;
+  }
+  if (!ensureIndexHtml(project.root)) return;
+  console.log();
+  await viteBuild(viteConfig(project, { build: { outDir: options.outDir } }));
+  console.log(`
+  ${pc.green("\u2713")} ${pc.bold("Build ready")} ${pc.dim(`\u2192 ${options.outDir ?? "dist"}/`)}
+`);
+}
+
+// src/commands/check.ts
+import { serializeResult } from "@bull-js/core";
+async function checkCommand(rootArg, options) {
+  const json = options.format === "json";
+  if (!json) banner("check");
+  const project = await loadProject(rootArg, "build");
+  if (json) {
+    const result2 = project.analyzer.analyze();
+    process.stdout.write(`${JSON.stringify(serializeResult(result2, { frames: false }), null, 2)}
+`);
+    if (result2.errorCount > 0) process.exitCode = 1;
+    return;
+  }
+  const result = runAnalysis(project);
+  if (result.errorCount > 0) process.exitCode = 1;
+}
+
+// src/commands/completion.ts
+var SHELLS = ["bash", "zsh", "fish", "powershell"];
+var GLOBAL_FLAGS = ["--help", "--version"];
+function bash(commands, zsh) {
+  const names = commands.flatMap((c) => [c.name, ...c.aliases]).join(" ");
+  const cases = commands.map((c) => `    ${[c.name, ...c.aliases].join("|")}) flags="${[...c.flags, "--help"].join(" ")}" ;;`).join("\n");
+  return `# bull completions for ${zsh ? "zsh" : "bash"}. Add this line to your ~/.${zsh ? "zshrc" : "bashrc"}:
+#   eval "$(bull completion ${zsh ? "zsh" : "bash"})"
+${zsh ? "autoload -U +X bashcompinit && bashcompinit\n" : ""}_bull_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=( $(compgen -W "${names} ${GLOBAL_FLAGS.join(" ")}" -- "$cur") )
+    return
+  fi
+  local flags=""
+  case "\${COMP_WORDS[1]}" in
+${cases}
+  esac
+  if [[ "$cur" == -* ]]; then
+    COMPREPLY=( $(compgen -W "$flags" -- "$cur") )
+  fi
+}
+complete -o default -F _bull_completions bull
+`;
+}
+function fish(commands) {
+  const quote = (text) => text.replace(/'/g, "\\'");
+  const lines = commands.flatMap((c) => {
+    const names = [c.name, ...c.aliases];
+    return [
+      ...names.map((n) => `complete -c bull -n __fish_use_subcommand -f -a ${n} -d '${quote(c.description)}'`),
+      ...c.flags.map(
+        (f) => `complete -c bull -n '__fish_seen_subcommand_from ${names.join(" ")}' -l ${f.replace(/^--/, "")}`
+      )
+    ];
+  });
+  return `# bull completions for fish. Save them with:
+#   bull completion fish > ~/.config/fish/completions/bull.fish
+complete -c bull -l help -d 'Show help'
+complete -c bull -l version -d 'Show the version'
+${lines.join("\n")}
+`;
+}
+function powershell(commands) {
+  const table = commands.map((c) => {
+    const flags = [...c.flags, "--help"].map((f) => `'${f}'`).join(", ");
+    return [c.name, ...c.aliases].map((n) => `  '${n}' = @(${flags})`).join("\n");
+  }).join("\n");
+  return `# bull completions for PowerShell. Add this line to your $PROFILE:
+#   bull completion powershell | Out-String | Invoke-Expression
+$bullFlags = @{
+${table}
+}
+Register-ArgumentCompleter -Native -CommandName bull -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $words = @($commandAst.CommandElements | Select-Object -Skip 1 | ForEach-Object { $_.ToString() })
+  if ($words.Count -eq 0 -or ($words.Count -eq 1 -and $wordToComplete)) {
+    $candidates = @($bullFlags.Keys) + @(${GLOBAL_FLAGS.map((f) => `'${f}'`).join(", ")})
+  } else {
+    $candidates = $bullFlags[$words[0]]
+  }
+  $candidates | Where-Object { $_ -like "$wordToComplete*" } | Sort-Object | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`;
+}
+function completionScript(shell, commands) {
+  switch (shell) {
+    case "bash":
+      return bash(commands, false);
+    case "zsh":
+      return bash(commands, true);
+    case "fish":
+      return fish(commands);
+    case "powershell":
+      return powershell(commands);
+  }
+}
+function completionCommand(shellArg, commands) {
+  const shell = shellArg?.toLowerCase() === "pwsh" ? "powershell" : shellArg?.toLowerCase();
+  if (!SHELLS.includes(shell)) {
+    fail(
+      `Usage: bull completion <${SHELLS.join("|")}>`,
+      'Example: eval "$(bull completion bash)" in ~/.bashrc, or `bull completion powershell | Out-String | Invoke-Expression` in $PROFILE.'
+    );
+    return;
+  }
+  process.stdout.write(completionScript(shell, commands));
+}
+
+// src/commands/dev.ts
+import fs from "fs";
+import path from "path";
+import { createServer, preview } from "vite";
+async function devCommand(rootArg, options) {
+  banner("dev");
+  const project = await loadProject(rootArg, "serve", { mode: options.mode, configFile: options.config });
+  if (!ensureIndexHtml(project.root)) return;
+  const server = await createServer(
+    viteConfig(project, {
+      server: {
+        port: options.port ?? project.config.dev?.port,
+        open: options.open ?? project.config.dev?.open,
+        host: options.host
+      }
+    })
+  );
+  await server.listen();
+  server.printUrls();
+  server.bindCLIShortcuts({ print: true });
+}
+async function previewCommand(rootArg, options) {
+  banner("preview");
+  const project = await loadProject(rootArg, "build", { configFile: options.config });
+  const outDir = options.outDir ?? project.config.vite?.build?.outDir ?? "dist";
+  if (!fs.existsSync(path.resolve(project.root, outDir, "index.html"))) {
+    fail(`There is no build in ${outDir}/ to preview.`, "Run `bull build` first.");
+    return;
+  }
+  const server = await preview(
+    viteConfig(project, {
+      build: { outDir },
+      preview: { port: options.port, open: options.open, host: options.host }
+    })
+  );
+  server.printUrls();
+}
+
+// src/commands/explain.ts
+import fs2 from "fs";
+import path2 from "path";
+import {
+  formatExplain,
+  formatRuleList,
+  RULE_LIST,
+  RULES,
+  ruleBySlug,
+  ruleToMarkdown
+} from "@bull-js/core";
+import pc2 from "picocolors";
+function explainCommand(code, options) {
+  if (options.all && options.format === "md") {
+    const outDir = path2.resolve(options.out ?? "docs/rules");
+    fs2.mkdirSync(outDir, { recursive: true });
+    const index = [
+      "# Bull architecture rules",
+      "",
+      "| Code | Rule | Severity | Can be disabled |",
+      "|---|---|---|---|"
+    ];
+    for (const meta2 of RULE_LIST) {
+      fs2.writeFileSync(path2.join(outDir, `${meta2.code}.md`), ruleToMarkdown(meta2));
+      index.push(
+        `| [${meta2.code}](./${meta2.code}.md) | ${meta2.summary} | ${meta2.severity === "error" ? "error" : "warning"} | ${meta2.configurable ? "yes" : "no"} |`
+      );
+    }
+    fs2.writeFileSync(path2.join(outDir, "README.md"), `${index.join("\n")}
+`);
+    console.log(`  ${pc2.green("\u2713")} ${RULE_LIST.length} rules documented in ${path2.relative(process.cwd(), outDir)}/`);
+    return;
+  }
+  if (!code || options.all) {
+    process.stdout.write(formatRuleList());
+    return;
+  }
+  const normalized = /^\d+$/.test(code) ? `MVVM${code.padStart(3, "0")}` : code.toUpperCase();
+  const meta = RULES[normalized] ?? ruleBySlug(code);
+  if (!meta) {
+    fail(`There is no rule "${code}".`, "See the full list with `bull explain`.");
+    return;
+  }
+  process.stdout.write(options.format === "md" ? ruleToMarkdown(meta) : formatExplain(meta));
+}
+
+// src/tooling/doctor.ts
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import { ProjectAnalyzer } from "@bull-js/core";
+import pc3 from "picocolors";
+function packageDir(from, name) {
+  let dir = path3.resolve(from);
+  for (; ; ) {
+    const candidate = path3.join(dir, "node_modules", name);
+    if (fs3.existsSync(path3.join(candidate, "package.json"))) return fs3.realpathSync.native(candidate);
+    const parent = path3.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function versionOf(root, pkg) {
+  const dir = packageDir(root, pkg);
+  return dir ? JSON.parse(fs3.readFileSync(path3.join(dir, "package.json"), "utf8")).version : void 0;
+}
+function readJsonc(file2) {
+  try {
+    const text = fs3.readFileSync(file2, "utf8").replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:"'])\/\/.*$/gm, "$1").replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+var minor = (v) => v.split(".").slice(0, 2).join(".");
+async function runDoctor(root, nodeVersion = process.versions.node) {
+  const checks = [];
+  const add = (c) => checks.push(c);
+  const nodeMajor = Number(nodeVersion.split(".")[0]);
+  add(
+    nodeMajor >= 20 ? { status: "ok", title: `Node.js ${nodeVersion}` } : { status: "fail", title: `Node.js ${nodeVersion}`, hint: "Bull needs Node.js 20 or newer." }
+  );
+  if (!fs3.existsSync(path3.join(root, "package.json"))) {
+    add({
+      status: "fail",
+      title: "package.json not found",
+      hint: "Run `bull doctor` from your project root, or pass the path."
+    });
+    return checks;
+  }
+  const react = versionOf(root, "react");
+  const reactDom = versionOf(root, "react-dom");
+  if (!react || !reactDom) {
+    add({ status: "fail", title: "React is not installed", hint: "npm install react react-dom" });
+  } else if (minor(react) !== minor(reactDom)) {
+    add({
+      status: "fail",
+      title: `react ${react} and react-dom ${reactDom} do not match`,
+      hint: "Install the same version of both."
+    });
+  } else {
+    add({ status: "ok", title: `React ${react}` });
+  }
+  const runtimeDir = packageDir(root, "@bull-js/runtime");
+  if (!runtimeDir) {
+    add({ status: "fail", title: "@bull-js/runtime is not installed", hint: "npm install @bull-js/runtime" });
+  } else {
+    add({ status: "ok", title: `@bull-js/runtime ${versionOf(root, "@bull-js/runtime") ?? ""}`.trim() });
+    const fromApp = packageDir(root, "react");
+    const fromRuntime = packageDir(runtimeDir, "react");
+    if (fromApp && fromRuntime && fromApp !== fromRuntime) {
+      add({
+        status: "fail",
+        title: "Two copies of React are installed",
+        detail: `${path3.relative(root, fromApp)} and ${path3.relative(root, fromRuntime)}`,
+        hint: "Remove the nested copy (npm dedupe) so hooks share one React."
+      });
+    } else if (fromApp) {
+      add({ status: "ok", title: "A single copy of React" });
+    }
+  }
+  const vite = versionOf(path3.dirname(fileURLToPath(import.meta.url)), "vite");
+  add(
+    vite ? { status: "ok", title: `Vite ${vite}` } : { status: "warn", title: "Vite could not be resolved", hint: "Reinstall @bull-js/cli." }
+  );
+  let config = {};
+  try {
+    const loaded = await loadBullConfig(root, "serve");
+    config = loaded.config;
+    add({
+      status: "ok",
+      title: loaded.file ? `${path3.basename(loaded.file)} loads` : "No bull.config.ts (defaults are used)"
+    });
+  } catch (error) {
+    add({ status: "fail", title: "bull.config could not be loaded", detail: error.message.split("\n")[0] });
+  }
+  const analyzer = new ProjectAnalyzer(root, config);
+  const result = analyzer.analyze();
+  const configErrors = result.diagnostics.filter((d) => d.code === "MVVM900");
+  for (const d of configErrors) add({ status: "fail", title: "Invalid configuration", detail: d.message });
+  const indexHtml = path3.join(root, "index.html");
+  const entry = `/${path3.posix.relative(analyzer.config.root, analyzer.config.compositionRoot)}`;
+  if (!fs3.existsSync(indexHtml)) {
+    add({
+      status: "fail",
+      title: "index.html not found",
+      hint: `Add one with <script type="module" src="${entry}"></script>.`
+    });
+  } else if (!fs3.readFileSync(indexHtml, "utf8").includes(entry)) {
+    add({
+      status: "warn",
+      title: `index.html does not load ${entry}`,
+      hint: `Point its module script at the composition root (${entry}).`
+    });
+  } else {
+    add({ status: "ok", title: `index.html loads ${entry}` });
+  }
+  const tsconfig = readJsonc(path3.join(root, "tsconfig.json"));
+  if (!tsconfig) {
+    add({
+      status: "warn",
+      title: "tsconfig.json not found or unreadable",
+      hint: 'Use "jsx": "react-jsx" and "strict": true.'
+    });
+  } else {
+    const options = tsconfig.compilerOptions ?? {};
+    const problems = [
+      options.jsx !== "react-jsx" && options.jsx !== "react-jsxdev" ? '"jsx": "react-jsx"' : "",
+      options.strict !== true ? '"strict": true' : ""
+    ].filter(Boolean);
+    add(
+      problems.length ? { status: "warn", title: "tsconfig.json could be stricter", hint: `Set ${problems.join(" and ")}.` } : { status: "ok", title: "tsconfig.json uses react-jsx and strict mode" }
+    );
+  }
+  const missing = result.diagnostics.filter((d) => d.code === "MVVM001").map((d) => d.data.dir);
+  add(
+    missing.length ? {
+      status: "fail",
+      title: `Missing layer folders: ${missing.join(", ")}`,
+      hint: "Create them, or run `bull g feature <name>`."
+    } : { status: "ok", title: "src/model, src/viewmodel and src/view exist" }
+  );
+  if (result.diagnostics.some((d) => d.code === "MVVM005")) {
+    add({
+      status: "fail",
+      title: "The composition root is missing",
+      hint: `Create ${entry.slice(1)} with createBullApp().`
+    });
+  }
+  const eslintConfig = ["eslint.config.js", "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts"].map((f) => path3.join(root, f)).find((f) => fs3.existsSync(f));
+  if (!eslintConfig) {
+    add({
+      status: "warn",
+      title: "No ESLint flat config",
+      hint: "Add @bull-js/eslint-plugin to see violations in your editor."
+    });
+  } else if (!fs3.readFileSync(eslintConfig, "utf8").includes("@bull-js/eslint-plugin")) {
+    add({
+      status: "warn",
+      title: `${path3.basename(eslintConfig)} does not use @bull-js/eslint-plugin`,
+      hint: "Spread bull.configs.recommended into it."
+    });
+  } else {
+    add({ status: "ok", title: "ESLint uses @bull-js/eslint-plugin" });
+  }
+  const architecture = result.diagnostics.filter((d) => d.code !== "MVVM900");
+  const errors = architecture.filter((d) => d.severity === "error").length;
+  add(
+    errors ? {
+      status: "fail",
+      title: `Architecture: ${errors} error(s)`,
+      hint: "Run `bull check` for details, or `bull fix` for the automatic ones."
+    } : architecture.length ? {
+      status: "warn",
+      title: `Architecture: ${architecture.length} warning(s)`,
+      hint: "Run `bull check` for details."
+    } : { status: "ok", title: "Architecture respects MVVM" }
+  );
+  return checks;
+}
+async function doctorCommand(rootArg) {
+  console.log(`
+${bullArt("doctor")}
+`);
+  const root = path3.resolve(rootArg ?? ".");
+  const checks = await runDoctor(root);
+  const icon = { ok: pc3.green("\u2713"), warn: pc3.yellow("!"), fail: pc3.red("\u2717") };
+  for (const c of checks) {
+    console.log(`  ${icon[c.status]} ${c.title}${c.detail ? pc3.dim(`  ${c.detail}`) : ""}`);
+    if (c.hint && c.status !== "ok") console.log(`    ${pc3.dim(c.hint.replace(/`/g, ""))}`);
+  }
+  const fails = checks.filter((c) => c.status === "fail").length;
+  const warns = checks.filter((c) => c.status === "warn").length;
+  console.log(
+    `
+  ${fails ? pc3.red(`${fails} problem(s)`) : pc3.green("Healthy")}${warns ? pc3.yellow(` \xB7 ${warns} suggestion(s)`) : ""}
+`
+  );
+  if (fails) process.exitCode = 1;
+}
+
+// src/tooling/fix.ts
+import fs4 from "fs";
+import path4 from "path";
+import {
+  fileEdges,
+  formatSummary,
+  isAutoFixable,
+  ProjectAnalyzer as ProjectAnalyzer2,
+  stripExtension,
+  toKebab
+} from "@bull-js/core";
+import pc4 from "picocolors";
+function offsetAt(source, pos) {
+  let offset = 0;
+  for (let line = 1; line < pos.line; line++) {
+    const next = source.indexOf("\n", offset);
+    if (next < 0) return source.length;
+    offset = next + 1;
+  }
+  return offset + pos.column - 1;
+}
+function applyEdits(source, edits) {
+  let out = source;
+  let lastStart = Infinity;
+  for (const e of [...edits].sort((a, b) => b.start - a.start)) {
+    if (e.end > lastStart) continue;
+    out = out.slice(0, e.start) + e.text + out.slice(e.end);
+    lastStart = e.start;
+  }
+  return out;
+}
+var escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function planFixes(result) {
+  const { config } = result;
+  const rel = (f) => path4.posix.relative(config.root, f);
+  const sources = /* @__PURE__ */ new Map();
+  const source = (file2) => {
+    if (!sources.has(file2)) sources.set(file2, result.readSource(file2) ?? fs4.readFileSync(file2, "utf8"));
+    return sources.get(file2);
+  };
+  const edits = /* @__PURE__ */ new Map();
+  const addEdit = (file2, edit) => {
+    if (!edits.has(file2)) edits.set(file2, []);
+    edits.get(file2).push(edit);
+  };
+  const outcomes = [];
+  const renames = /* @__PURE__ */ new Map();
+  const done = (d, message, applied = true) => outcomes.push({ code: d.code, file: rel(d.file), message, applied });
+  for (const d of result.diagnostics) {
+    if (!d.file || !isAutoFixable(d)) continue;
+    const src = source(d.file);
+    if (d.code === "MVVM302" && d.range) {
+      const start = offsetAt(src, d.range.start);
+      const end = offsetAt(src, d.range.end);
+      const text = src.slice(start, end);
+      const name = d.data.member;
+      if (d.data.kind === "state") {
+        if (src.includes(`#${name}`)) {
+          done(d, `skipped: \`#${name}\` already exists`, false);
+          continue;
+        }
+        const init = /=\s*([\s\S]*?);?\s*$/.exec(text)?.[1];
+        if (!init) {
+          done(d, "skipped: could not read the initializer", false);
+          continue;
+        }
+        const lineStart = src.lastIndexOf("\n", start) + 1;
+        const indent = /^[ \t]*/.exec(src.slice(lineStart))[0];
+        addEdit(d.file, {
+          start,
+          end,
+          text: `readonly #${name} = ${init};
+${indent}readonly ${name} = this.#${name}.readonly;`
+        });
+        for (const m of src.matchAll(new RegExp(`this\\.${escapeRegExp(name)}\\b`, "g"))) {
+          if (m.index >= start && m.index < end) continue;
+          addEdit(d.file, { start: m.index, end: m.index + m[0].length, text: `this.#${name}` });
+        }
+        done(d, `made \`${name}\` private and exposed \`${name}\` as a read-only view`);
+      } else if (d.data.kind === "mutable") {
+        const modifiers = /^((?:(?:public|override|declare)\s+)*)/.exec(text)[1];
+        addEdit(d.file, { start: start + modifiers.length, end: start + modifiers.length, text: "readonly " });
+        done(d, `marked \`${name}\` as readonly`);
+      } else if (d.data.kind === "param") {
+        const fixed = text.replace(/^(?:(?:public|private|protected|readonly)\s+)*/, "private readonly ");
+        addEdit(d.file, { start, end, text: fixed });
+        done(d, `made the dependency \`${name}\` private readonly`);
+      }
+      continue;
+    }
+    if (d.code === "MVVM100" && d.range) {
+      const vmName = d.data.viewModel;
+      const vmFile = path4.posix.join(
+        config.srcDir,
+        "viewmodel",
+        `${toKebab(vmName.replace(/ViewModel$/, ""))}.viewmodel.ts`
+      );
+      if (!fs4.existsSync(vmFile)) {
+        done(d, `skipped: there is no ${rel(vmFile)} to re-export the type from`, false);
+        continue;
+      }
+      const modelTarget = path4.posix.join(path4.posix.dirname(d.file), d.data.source);
+      let fromVm = path4.posix.relative(path4.posix.dirname(vmFile), modelTarget);
+      if (!fromVm.startsWith(".")) fromVm = `./${fromVm}`;
+      const names = d.data.imported;
+      const vmSource = source(vmFile);
+      if (!vmSource.includes(`export type { ${names} }`)) {
+        const lastImport = [...vmSource.matchAll(/^import[^;]*;[ \t]*$/gm)].at(-1);
+        const at = lastImport ? lastImport.index + lastImport[0].length + 1 : 0;
+        addEdit(vmFile, { start: at, end: at, text: `export type { ${names} } from "${fromVm}";
+` });
+      }
+      let toVm = stripExtension(path4.posix.relative(path4.posix.dirname(d.file), vmFile));
+      if (!toVm.startsWith(".")) toVm = `./${toVm}`;
+      const start = offsetAt(src, d.range.start);
+      const end = offsetAt(src, d.range.end);
+      const statement = src.slice(start, end);
+      addEdit(d.file, { start, end, text: statement.replace(/(["'])[^"']+\1/, `$1${toVm}$1`) });
+      done(d, `the View now imports \`${names}\` from ${vmName}, which re-exports it`);
+      continue;
+    }
+    if (d.code === "MVVM003") {
+      const target = path4.posix.join(path4.posix.dirname(d.file), d.data.suggested);
+      if (fs4.existsSync(target) || [...renames.values()].includes(target)) {
+        done(d, `skipped: ${rel(target)} already exists`, false);
+        continue;
+      }
+      renames.set(d.file, target);
+      const oldSegment = stripExtension(path4.posix.basename(d.file));
+      const newSegment = stripExtension(path4.posix.basename(target));
+      let updated = 0;
+      for (const e of fileEdges(config, result.files)) {
+        if (e.to !== d.file) continue;
+        const importer = source(e.from);
+        const at = offsetAt(importer, e.range.start);
+        const statement = importer.slice(at, offsetAt(importer, e.range.end));
+        const quoted = new RegExp(`(["'])([^"']*?)${escapeRegExp(oldSegment)}(\\.[jt]sx?)?\\1`);
+        const match = quoted.exec(statement);
+        if (!match) continue;
+        const replacement = `${match[1]}${match[2]}${newSegment}${match[3] && d.data.suggested.endsWith(match[3]) ? match[3] : ""}${match[1]}`;
+        addEdit(e.from, { start: at + match.index, end: at + match.index + match[0].length, text: replacement });
+        updated++;
+      }
+      done(d, `renamed to ${rel(target)}${updated ? ` and updated ${updated} import${updated === 1 ? "" : "s"}` : ""}`);
+    }
+  }
+  const contents = /* @__PURE__ */ new Map();
+  for (const [file2, list] of edits) contents.set(file2, applyEdits(source(file2), list));
+  return { outcomes, contents, renames };
+}
+function applyFixPlan(plan) {
+  for (const [file2, content] of plan.contents) fs4.writeFileSync(file2, content);
+  for (const [from, to] of plan.renames) fs4.renameSync(from, to);
+}
+function miniDiff(before, after, colors = pc4.isColorSupported) {
+  const c = pc4.createColors(colors);
+  const a = before.split("\n");
+  const b = after.split("\n");
+  const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1; i2 >= 0; i2--) {
+    for (let j2 = b.length - 1; j2 >= 0; j2--) {
+      lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+    }
+  }
+  const out = [];
+  let i = 0;
+  let j = 0;
+  let inHunk = false;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) {
+      i++;
+      j++;
+      inHunk = false;
+      continue;
+    }
+    if (!inHunk) {
+      out.push(c.cyan(`@@ line ${j + 1} @@`));
+      inHunk = true;
+    }
+    if (i < a.length && (j >= b.length || lcs[i + 1][j] >= lcs[i][j + 1])) out.push(c.red(`- ${a[i++]}`));
+    else out.push(c.green(`+ ${b[j++]}`));
+  }
+  return out.map((l) => `      ${l}`).join("\n");
+}
+async function fixCommand(rootArg, options) {
+  banner(options.dryRun ? "fix (dry run)" : "fix");
+  const root = path4.resolve(rootArg ?? ".");
+  const { config } = await loadBullConfig(root, "serve");
+  const analyzer = new ProjectAnalyzer2(root, config);
+  const before = analyzer.analyze();
+  const plan = planFixes(before);
+  const rel = (f) => path4.posix.relative(analyzer.config.root, f);
+  if (plan.outcomes.length === 0) {
+    const fixable = before.diagnostics.length;
+    console.log(
+      fixable ? `  ${pc4.dim("Nothing to fix automatically.")} ${fixable} diagnostic(s) need a human: run ${pc4.cyan("bull check")}.` : `  ${pc4.green("\u2713")} Nothing to fix: the architecture is clean.`
+    );
+    return;
+  }
+  for (const o of plan.outcomes) {
+    const mark = o.applied ? pc4.green(options.dryRun ? "\u25CB" : "\u2714") : pc4.yellow("\xB7");
+    console.log(`  ${mark} ${pc4.dim(o.code)}  ${o.file}  ${o.applied ? o.message : pc4.yellow(o.message)}`);
+  }
+  if (options.dryRun) {
+    console.log();
+    for (const [file2, content] of plan.contents) {
+      const original = before.readSource(file2) ?? fs4.readFileSync(file2, "utf8");
+      console.log(
+        `    ${pc4.bold(rel(file2))}${plan.renames.has(file2) ? pc4.dim(` \u2192 ${rel(plan.renames.get(file2))}`) : ""}`
+      );
+      console.log(`${miniDiff(original, content)}
+`);
+    }
+    for (const [from, to] of plan.renames) {
+      if (!plan.contents.has(from)) console.log(`    ${pc4.bold(rel(from))} ${pc4.dim("\u2192")} ${rel(to)}
+`);
+    }
+    console.log(`  ${pc4.dim("Dry run: nothing was written. Run")} ${pc4.cyan("bull fix")} ${pc4.dim("to apply.")}`);
+    return;
+  }
+  applyFixPlan(plan);
+  analyzer.invalidate();
+  const after = analyzer.analyze();
+  console.log(`
+${formatSummary(after)}`);
+  if (after.diagnostics.length)
+    console.log(`
+  ${pc4.dim("Run")} ${pc4.cyan("bull check")} ${pc4.dim("for the details of what is left.")}`);
+  if (after.errorCount > 0) process.exitCode = 1;
+}
+
+// src/tooling/generate.ts
+import fs5 from "fs";
+import { createRequire } from "module";
+import path5 from "path";
+import { formatReport, ProjectAnalyzer as ProjectAnalyzer3, toKebab as toKebab2, toPascalCase } from "@bull-js/core";
+import pc5 from "picocolors";
+function normalizeName(raw) {
+  const stem = raw.trim().replace(/\.(tsx?|jsx?)$/, "").replace(/[.\-_\s](viewmodel|view|model|repository|service|entity)$/i, "").replace(/(?<=[a-z0-9])(ViewModel|View|Model|Repository|Service|Entity)$/, "");
+  const kebab = toKebab2(stem.replace(/\s+/g, "-")).replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  if (!kebab) throw new Error(`"${raw}" is not a valid name. Use something like "todo-list" or "TodoList".`);
+  return { kebab, pascal: toPascalCase(kebab) };
+}
+var templates = {
+  model: (n) => `// Model: plain domain types and functions. No React, no reactive state.
+export interface ${n.pascal} {
+  readonly id: string;
+}
+
+export function create${n.pascal}(id: string): ${n.pascal} {
+  return { id };
+}
+`,
+  entity: (n) => `export interface ${n.pascal} {
+  readonly id: string;
+  readonly createdAt: number;
+}
+
+export function create${n.pascal}(id: string, now = Date.now()): ${n.pascal} {
+  return { id, createdAt: now };
+}
+`,
+  repository: (n) => `// Model: the only layer that does I/O. Swap the in-memory list for fetch, storage or an API.
+export class ${n.pascal}Repository {
+  #items: string[] = [];
+
+  async list(): Promise<string[]> {
+    return [...this.#items];
+  }
+
+  async add(item: string): Promise<void> {
+    this.#items.push(item);
+  }
+}
+`,
+  service: (n) => `// Model: a domain service. Inject it into ViewModels through their constructor.
+export class ${n.pascal}Service {
+  run(input: string): string {
+    return input;
+  }
+}
+`,
+  viewmodel: (n) => `import { ViewModel } from "@bull-js/runtime";
+
+export class ${n.pascal}ViewModel extends ViewModel {
+  readonly #items = this.state<string[]>([]);
+
+  readonly items = this.#items.readonly;
+  readonly isEmpty = this.computed(() => this.#items.value.length === 0);
+
+  readonly add = this.command((item: string) => this.#items.update((items) => [...items, item]));
+}
+`,
+  viewmodelWithRepository: (n) => `import { ViewModel } from "@bull-js/runtime";
+import type { ${n.pascal}Repository } from "../model/${n.kebab}.repository";
+
+export class ${n.pascal}ViewModel extends ViewModel {
+  readonly #items = this.state<string[]>([]);
+
+  readonly items = this.#items.readonly;
+  readonly isEmpty = this.computed(() => this.#items.value.length === 0);
+
+  readonly load = this.command(async () => this.#items.set(await this.repo.list()));
+  readonly add = this.command(async (item: string) => {
+    await this.repo.add(item);
+    this.#items.update((items) => [...items, item]);
+  });
+
+  constructor(private readonly repo: ${n.pascal}Repository) {
+    super();
+  }
+
+  protected override onActivate() {
+    void this.load.execute();
+  }
+}
+`,
+  viewmodelTest: (n, withRepository) => `// ViewModels are plain classes: test them without React or a DOM.
+import { describe, expect, it } from "vitest";
+${withRepository ? `import { ${n.pascal}Repository } from "../model/${n.kebab}.repository";
+` : ""}import { ${n.pascal}ViewModel } from "./${n.kebab}.viewmodel";
+
+describe("${n.pascal}ViewModel", () => {
+  it("adds items", async () => {
+    const vm = new ${n.pascal}ViewModel(${withRepository ? `new ${n.pascal}Repository()` : ""});
+    ${withRepository ? "await " : ""}vm.add.execute("first");
+    expect(vm.items.value).toEqual(["first"]);
+    expect(vm.isEmpty.value).toBe(false);
+  });
+});
+`,
+  boundView: (n) => `import { useBinding, useViewModel } from "@bull-js/runtime/react";
+import { ${n.pascal}ViewModel } from "../viewmodel/${n.kebab}.viewmodel";
+
+export function ${n.pascal}View() {
+  const vm = useViewModel(${n.pascal}ViewModel);
+  const items = useBinding(vm.items);
+  const isEmpty = useBinding(vm.isEmpty);
+
+  return (
+    <section>
+      <h2>${n.pascal}</h2>
+      {isEmpty ? (
+        <p>Nothing here yet.</p>
+      ) : (
+        <ul>
+          {items.map((item) => (
+            <li key={item}>{item}</li>
+          ))}
+        </ul>
+      )}
+      <button onClick={() => vm.add.execute(\`Item \${items.length + 1}\`)}>Add</button>
+    </section>
+  );
+}
+`,
+  existingViewModelView: (n) => `import { useViewModel } from "@bull-js/runtime/react";
+import { ${n.pascal}ViewModel } from "../viewmodel/${n.kebab}.viewmodel";
+
+export function ${n.pascal}View() {
+  const vm = useViewModel(${n.pascal}ViewModel);
+  // Read with useBinding(vm.something) and act with vm.someCommand.execute().
+  return <section data-viewmodel={vm.constructor.name}>${n.pascal}</section>;
+}
+`,
+  presentationalView: (n) => `/** Presentational View: receives data and callbacks through props, owns no state. */
+export function ${n.pascal}View(props: { title: string }) {
+  return (
+    <section>
+      <h2>{props.title}</h2>
+    </section>
+  );
+}
+`
+};
+function file(target, content) {
+  return fs5.existsSync(target) ? { path: target, content, action: "skip", note: "already exists" } : { path: target, content, action: "create" };
+}
+function planGenerate(type, rawName, options) {
+  const n = normalizeName(rawName);
+  const dir = (layer) => path5.join(options.srcDir, layer);
+  const files = [];
+  const hints = [];
+  const wantTest = options.test ?? hasVitest(options.root);
+  if (type === "model") {
+    const kind = options.kind ?? "model";
+    if (!(kind in templates))
+      throw new Error(`Unknown model kind "${kind}". Use model, entity, repository or service.`);
+    files.push(file(path5.join(dir("model"), `${n.kebab}.${kind}.ts`), templates[kind](n)));
+    if (kind === "repository" || kind === "service") {
+      const cls = `${n.pascal}${kind === "repository" ? "Repository" : "Service"}`;
+      hints.push(
+        `Inject \`${cls}\` into a ViewModel constructor and register it: \`c.model(${cls}, () => new ${cls}())\`.`
+      );
+    }
+  }
+  if (type === "viewmodel" || type === "feature") {
+    const withRepository = type === "feature";
+    if (withRepository) files.push(file(path5.join(dir("model"), `${n.kebab}.repository.ts`), templates.repository(n)));
+    files.push(
+      file(
+        path5.join(dir("viewmodel"), `${n.kebab}.viewmodel.ts`),
+        withRepository ? templates.viewmodelWithRepository(n) : templates.viewmodel(n)
+      )
+    );
+    if (wantTest) {
+      files.push(
+        file(path5.join(dir("viewmodel"), `${n.kebab}.viewmodel.test.ts`), templates.viewmodelTest(n, withRepository))
+      );
+    }
+  }
+  if (type === "view" || type === "feature") {
+    const vmFile = path5.join(dir("viewmodel"), `${n.kebab}.viewmodel.ts`);
+    const content = type === "feature" ? templates.boundView(n) : fs5.existsSync(vmFile) ? templates.existingViewModelView(n) : templates.presentationalView(n);
+    files.push(file(path5.join(dir("view"), `${n.kebab}.view.tsx`), content));
+    hints.push(`Render \`<${n.pascal}View />\` from another View (for example your root View).`);
+  }
+  if (type === "feature") {
+    const registration = registerInCompositionRoot(options, n);
+    if (registration) files.push(registration);
+    else {
+      hints.push(
+        `Register the feature in your composition root:
+      c.model(${n.pascal}Repository, () => new ${n.pascal}Repository());
+      c.viewModel(${n.pascal}ViewModel, (c) => new ${n.pascal}ViewModel(c.get(${n.pascal}Repository)));`
+      );
+    }
+  }
+  return { files, hints };
+}
+function hasVitest(root) {
+  try {
+    createRequire(path5.join(root, "package.json")).resolve("vitest/package.json");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerInCompositionRoot(options, n) {
+  const rootFile = options.compositionRoot;
+  if (!fs5.existsSync(rootFile)) return void 0;
+  const source = fs5.readFileSync(rootFile, "utf8");
+  if (source.includes(`${n.pascal}ViewModel`)) return void 0;
+  const register = /register\s*:\s*\(?\s*(\w+)\s*\)?\s*=>\s*\{\r?\n?/.exec(source);
+  if (!register) return void 0;
+  const param = register[1];
+  const after = source.slice(register.index + register[0].length);
+  const indent = /^([ \t]*)\S/.exec(after)?.[1] || "    ";
+  const rel = (layer, fileName) => "./" + path5.posix.relative(path5.posix.dirname(toPosix(rootFile)), toPosix(path5.join(options.srcDir, layer, fileName))).replace(/\.tsx?$/, "");
+  const imports = `import { ${n.pascal}Repository } from "${rel("model", `${n.kebab}.repository.ts`)}";
+import { ${n.pascal}ViewModel } from "${rel("viewmodel", `${n.kebab}.viewmodel.ts`)}";
+`;
+  const lines = `${indent}${param}.model(${n.pascal}Repository, () => new ${n.pascal}Repository());
+${indent}${param}.viewModel(${n.pascal}ViewModel, (${param}) => new ${n.pascal}ViewModel(${param}.get(${n.pascal}Repository)));
+`;
+  const open = source.indexOf("{", register.index + register[0].trimEnd().length - 1);
+  let depth = 0;
+  let close = -1;
+  for (let i = open; i < source.length; i++) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}" && --depth === 0) {
+      close = i;
+      break;
+    }
+  }
+  if (close < 0) return void 0;
+  const insertAt = source.lastIndexOf("\n", close) + 1;
+  let updated = source.slice(0, insertAt) + lines + source.slice(insertAt);
+  const lastImport = [...updated.matchAll(/^import[^;]*;[ \t]*$/gm)].at(-1);
+  const importAt = lastImport ? lastImport.index + lastImport[0].length + 1 : 0;
+  updated = updated.slice(0, importAt) + imports + updated.slice(importAt);
+  return { path: rootFile, content: updated, action: "update", note: "registered the Model and ViewModel" };
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+var TYPES = {
+  model: "model",
+  m: "model",
+  viewmodel: "viewmodel",
+  vm: "viewmodel",
+  view: "view",
+  v: "view",
+  feature: "feature",
+  f: "feature"
+};
+async function generateCommand(typeArg, name, options) {
+  banner(options.dryRun ? "generate (dry run)" : "generate");
+  const type = TYPES[typeArg?.toLowerCase()];
+  if (!type || !name) {
+    fail(
+      "Usage: bull generate <feature|model|viewmodel|view> <name>",
+      "Example: `bull g feature todo-list` creates a repository, a ViewModel, its test and a View."
+    );
+    return;
+  }
+  const root = path5.resolve(options.root ?? ".");
+  const { config } = await loadBullConfig(root, "serve");
+  const analyzer = new ProjectAnalyzer3(root, config);
+  let plan;
+  try {
+    plan = planGenerate(type, name, {
+      root,
+      srcDir: analyzer.config.srcDir,
+      compositionRoot: analyzer.config.compositionRoot,
+      kind: options.kind,
+      test: options.test
+    });
+  } catch (error) {
+    fail(error.message);
+    return;
+  }
+  for (const f of plan.files) {
+    const rel = path5.relative(root, f.path).replace(/\\/g, "/");
+    if (f.action === "skip") {
+      console.log(`  ${pc5.yellow("\xB7")} ${rel} ${pc5.dim(`(${f.note}, left untouched)`)}`);
+      continue;
+    }
+    if (!options.dryRun) {
+      fs5.mkdirSync(path5.dirname(f.path), { recursive: true });
+      fs5.writeFileSync(f.path, f.content);
+    }
+    const mark = f.action === "create" ? pc5.green("+") : pc5.cyan("~");
+    const verb = options.dryRun ? f.action === "create" ? "would create" : "would update" : f.action === "create" ? "" : f.note ?? "updated";
+    console.log(`  ${mark} ${rel}${verb ? pc5.dim(`  ${verb}`) : ""}`);
+  }
+  for (const hint of plan.hints)
+    console.log(`
+  ${pc5.cyan("\u2192")} ${hint.replace(/`([^`]+)`/g, (_, c) => pc5.cyan(c))}`);
+  if (options.dryRun) return;
+  const result = analyzer.analyze();
+  console.log(`
+${formatReport(result, { width: Math.min(process.stdout.columns || 88, 100) })}`);
+  if (result.errorCount > 0) process.exitCode = 1;
+}
+
+// src/tooling/graph.ts
+import { exec } from "child_process";
+import fs6 from "fs";
+import path6 from "path";
+import { buildImportGraph, LAYER_LABEL, ProjectAnalyzer as ProjectAnalyzer4 } from "@bull-js/core";
+import pc6 from "picocolors";
+var COLUMNS = ["root", "view", "viewmodel", "model", "allowed", "outside"];
+var COLUMN_LABEL = {
+  root: "Composition root",
+  view: "View",
+  viewmodel: "ViewModel",
+  model: "Model",
+  allowed: "Resources",
+  outside: "Outside the layers"
+};
+function sortedNodes(graph) {
+  return [...graph.nodes].sort(
+    (a, b) => COLUMNS.indexOf(a.kind) - COLUMNS.indexOf(b.kind) || a.rel.localeCompare(b.rel)
+  );
+}
+function layerEdgeCounts(graph) {
+  const kindOf = new Map(graph.nodes.map((n) => [n.file, n.kind]));
+  const counts = /* @__PURE__ */ new Map();
+  for (const e of graph.edges) {
+    const from = kindOf.get(e.from);
+    const to = kindOf.get(e.to);
+    const key = `${from}\u2192${to}`;
+    const entry = counts.get(key) ?? { from, to, count: 0, violation: e.violation };
+    entry.count++;
+    counts.set(key, entry);
+  }
+  return [...counts.values()].sort(
+    (a, b) => COLUMNS.indexOf(a.from) - COLUMNS.indexOf(b.from) || COLUMNS.indexOf(a.to) - COLUMNS.indexOf(b.to)
+  );
+}
+function renderTree(graph, colors = pc6.isColorSupported) {
+  const c = pc6.createColors(colors);
+  const relOf = new Map(graph.nodes.map((n) => [n.file, n.rel]));
+  const out = [];
+  let column;
+  for (const node of sortedNodes(graph)) {
+    if (node.kind !== column) {
+      column = node.kind;
+      out.push(`  ${c.bold(COLUMN_LABEL[column] ?? column)}`);
+    }
+    out.push(`    ${node.rel}`);
+    for (const e of graph.edges.filter((edge) => edge.from === node.file)) {
+      const target = relOf.get(e.to) ?? e.to;
+      const type = e.typeOnly ? c.dim(" (type)") : "";
+      if (e.violation) out.push(`      ${c.red(`\u2717 \u2192 ${target}`)}${type}  ${c.red(e.violation)}`);
+      else if (e.inCycle) out.push(`      ${c.yellow(`\u21BB \u2192 ${target}`)}${type}  ${c.yellow("MVVM105")}`);
+      else out.push(`      ${c.dim("\u2192")} ${target}${type}`);
+    }
+  }
+  out.push("");
+  out.push(`  ${c.bold("Layer edges")}`);
+  for (const e of layerEdgeCounts(graph)) {
+    const label = `${LAYER_LABEL[e.from]} \u2192 ${LAYER_LABEL[e.to]}`.padEnd(36);
+    const line = `    ${label} ${String(e.count).padStart(3)}`;
+    out.push(e.violation ? c.red(`${line}  \u2717 ${e.violation}`) : line);
+  }
+  const violations = graph.edges.filter((e) => e.violation).length;
+  out.push("");
+  out.push(
+    violations || graph.cycles.length ? `  ${c.red("\u2717")} ${violations} edge(s) break the dependency direction, ${graph.cycles.length} cycle(s)` : `  ${c.green("\u2713")} Every edge follows View \u2500\u2500\u25B6 ViewModel \u2500\u2500\u25B6 Model`
+  );
+  return `${out.join("\n")}
+`;
+}
+function renderMermaid(graph) {
+  const nodes = sortedNodes(graph);
+  const id = new Map(nodes.map((n, i) => [n.file, `n${i}`]));
+  const out = ["flowchart LR"];
+  for (const kind of COLUMNS) {
+    const members = nodes.filter((n) => n.kind === kind);
+    if (!members.length) continue;
+    out.push(`  subgraph layer_${kind}["${COLUMN_LABEL[kind]}"]`);
+    for (const n of members) out.push(`    ${id.get(n.file)}["${path6.posix.basename(n.rel)}"]`);
+    out.push("  end");
+  }
+  const styles = [];
+  graph.edges.forEach((e, i) => {
+    out.push(
+      `  ${id.get(e.from)} ${e.typeOnly ? "-.->" : "-->"}${e.violation ? `|${e.violation}|` : ""} ${id.get(e.to)}`
+    );
+    if (e.violation) styles.push(`  linkStyle ${i} stroke:#e2456f,stroke-width:2.5px`);
+    else if (e.inCycle) styles.push(`  linkStyle ${i} stroke:#f5a524,stroke-width:2px`);
+  });
+  return `${[...out, ...styles].join("\n")}
+`;
+}
+var FILL = {
+  root: "#f1edff",
+  view: "#e8f7ee",
+  viewmodel: "#efe9ff",
+  model: "#e7f0ff",
+  allowed: "#f4f4f5",
+  outside: "#fde8ec"
+};
+function renderDot(graph) {
+  const out = [
+    "digraph bull {",
+    "  rankdir=LR; nodesep=0.3; ranksep=1.2;",
+    '  node [shape=box, style="rounded,filled", fontname="Helvetica", fontsize=11, color="#c9c4d8"];',
+    '  edge [color="#8d8aa0", arrowsize=0.7];'
+  ];
+  for (const kind of COLUMNS) {
+    const members = graph.nodes.filter((n) => n.kind === kind);
+    if (!members.length) continue;
+    out.push(
+      `  subgraph cluster_${kind} { label="${COLUMN_LABEL[kind]}"; style=rounded; color="#d9d4e8"; fontname="Helvetica";`
+    );
+    for (const n of members)
+      out.push(`    "${n.rel}" [label="${path6.posix.basename(n.rel)}", fillcolor="${FILL[kind]}"];`);
+    out.push("  }");
+  }
+  const relOf = new Map(graph.nodes.map((n) => [n.file, n.rel]));
+  for (const e of graph.edges) {
+    const attrs = [];
+    if (e.typeOnly) attrs.push("style=dashed");
+    if (e.violation) attrs.push(`color="#e2456f", penwidth=2, label="${e.violation}", fontcolor="#e2456f", fontsize=9`);
+    else if (e.inCycle) attrs.push('color="#f5a524", penwidth=2');
+    out.push(`  "${relOf.get(e.from)}" -> "${relOf.get(e.to)}"${attrs.length ? ` [${attrs.join(", ")}]` : ""};`);
+  }
+  out.push("}");
+  return `${out.join("\n")}
+`;
+}
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function renderHtml(graph, title) {
+  const NODE_W = 220;
+  const NODE_H = 34;
+  const GAP_Y = 12;
+  const COL_W = 330;
+  const TOP = 110;
+  const LEFT = 40;
+  const columns = COLUMNS.filter((k) => graph.nodes.some((n) => n.kind === k));
+  const position = /* @__PURE__ */ new Map();
+  let maxRows = 0;
+  columns.forEach((kind, col) => {
+    const members = graph.nodes.filter((n) => n.kind === kind).sort((a, b) => a.rel.localeCompare(b.rel));
+    maxRows = Math.max(maxRows, members.length);
+    for (const [row, n] of members.entries()) {
+      position.set(n.file, { x: LEFT + col * COL_W, y: TOP + row * (NODE_H + GAP_Y) });
+    }
+  });
+  const width = LEFT * 2 + (columns.length - 1) * COL_W + NODE_W + 60;
+  const height = TOP + maxRows * (NODE_H + GAP_Y) + 40;
+  const index = new Map(graph.nodes.map((n, i) => [n.file, i]));
+  const edges = graph.edges.map((e, i) => {
+    const a = position.get(e.from);
+    const b = position.get(e.to);
+    let d;
+    if (Math.abs(a.x - b.x) < 1) {
+      const x = a.x + NODE_W;
+      const bulge = 36 + Math.min(80, Math.abs(a.y - b.y) / 4);
+      d = `M${x},${a.y + NODE_H / 2} C${x + bulge},${a.y + NODE_H / 2} ${x + bulge},${b.y + NODE_H / 2} ${x + 4},${b.y + NODE_H / 2}`;
+    } else if (b.x > a.x) {
+      const sx = a.x + NODE_W;
+      const tx = b.x - 4;
+      const skipped = Math.round((b.x - a.x) / COL_W) - 1;
+      if (skipped > 0) {
+        const lift = 46 + 18 * skipped + Math.abs(a.y - b.y) / 6;
+        const top = Math.min(a.y, b.y) - lift;
+        d = `M${sx},${a.y + NODE_H / 2} C${sx + 70},${top} ${tx - 70},${top} ${tx},${b.y + NODE_H / 2}`;
+      } else {
+        const mid = (sx + tx) / 2;
+        d = `M${sx},${a.y + NODE_H / 2} C${mid},${a.y + NODE_H / 2} ${mid},${b.y + NODE_H / 2} ${tx},${b.y + NODE_H / 2}`;
+      }
+    } else {
+      const sx = a.x;
+      const tx = b.x + NODE_W + 4;
+      d = `M${sx},${a.y + NODE_H / 2} C${sx - 90},${a.y - 30} ${tx + 90},${b.y + NODE_H + 30} ${tx},${b.y + NODE_H / 2}`;
+    }
+    const cls = ["edge", e.violation ? "bad" : e.inCycle ? "cycle" : "", e.typeOnly ? "type" : ""].filter(Boolean).join(" ");
+    const label = e.violation ? `<title>${esc(e.violation)}</title>` : "";
+    return `<path id="e${i}" class="${cls}" data-from="${index.get(e.from)}" data-to="${index.get(e.to)}" d="${d}" marker-end="url(#${e.violation ? "arrow-bad" : "arrow"})">${label}</path>`;
+  }).join("\n      ");
+  const headers = columns.map((kind, col) => `<text class="col" x="${LEFT + col * COL_W}" y="28">${esc(COLUMN_LABEL[kind] ?? kind)}</text>`).join("\n      ");
+  const nodes = graph.nodes.map((n) => {
+    const p = position.get(n.file);
+    const bad = graph.edges.some((e) => (e.from === n.file || e.to === n.file) && e.violation);
+    const name = path6.posix.basename(n.rel);
+    return `<g class="node ${n.kind}${bad ? " has-bad" : ""}" data-id="${index.get(n.file)}" transform="translate(${p.x},${p.y})">
+        <title>${esc(n.rel)}</title>
+        <rect width="${NODE_W}" height="${NODE_H}" rx="9"/>
+        <circle cx="16" cy="${NODE_H / 2}" r="4"/>
+        <text x="28" y="${NODE_H / 2 + 4}">${esc(name.length > 27 ? `${name.slice(0, 26)}\u2026` : name)}</text>
+      </g>`;
+  }).join("\n      ");
+  const violations = graph.edges.filter((e) => e.violation).length;
+  const status = violations || graph.cycles.length ? `<span class="pill bad">\u2717 ${violations} edge(s) break the direction \xB7 ${graph.cycles.length} cycle(s)</span>` : `<span class="pill ok">\u2713 Every edge follows View \u2192 ViewModel \u2192 Model</span>`;
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)} \xB7 Bull graph</title>
+<style>
+  :root { --bg:#f7f6f3; --panel:#ffffff; --ink:#1d1b22; --muted:#77737f; --line:#e4e0ea;
+    --view:#1f9d5a; --viewmodel:#6b4dff; --model:#2f6fe4; --root:#9a7b2f; --other:#9a95a8; --bad:#e2456f; --cycle:#e8930c; --edge:#b3aec2; }
+  @media (prefers-color-scheme: dark) {
+    :root { --bg:#0f0d15; --panel:#17151f; --ink:#ecebf2; --muted:#8f8b9c; --line:#2a2735;
+      --view:#4ad48a; --viewmodel:#a48bff; --model:#6aa2ff; --root:#e0c06a; --other:#8a8597; --edge:#4c4858; }
+  }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: var(--bg); color: var(--ink); font: 14px/1.5 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; }
+  header { display: flex; align-items: center; gap: 14px; padding: 20px 28px; border-bottom: 1px solid var(--line); flex-wrap: wrap; }
+  header h1 { font-size: 17px; margin: 0; }
+  header p { margin: 0; color: var(--muted); font-size: 13px; }
+  .spacer { flex: 1; }
+  .pill { font-size: 12px; font-weight: 600; padding: 4px 12px; border-radius: 999px; }
+  .pill.ok { background: color-mix(in srgb, var(--view) 15%, transparent); color: var(--view); }
+  .pill.bad { background: color-mix(in srgb, var(--bad) 15%, transparent); color: var(--bad); }
+  .legend { display: flex; gap: 18px; padding: 12px 28px; color: var(--muted); font-size: 12px; flex-wrap: wrap; }
+  .legend i { display: inline-block; width: 22px; height: 0; border-top: 2px solid var(--edge); vertical-align: middle; margin-right: 6px; }
+  .legend .bad i { border-color: var(--bad); }
+  .legend .cycle i { border-color: var(--cycle); }
+  .legend .type i { border-top-style: dashed; }
+  main { overflow: auto; padding: 8px 0 32px; }
+  svg { display: block; margin: 0 auto; }
+  .col { font-size: 12px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; fill: var(--muted); }
+  .node rect { fill: var(--panel); stroke: var(--line); stroke-width: 1.2; transition: stroke .15s; }
+  .node text { font: 12.5px ui-monospace, SFMono-Regular, Menlo, monospace; fill: var(--ink); }
+  .node circle { fill: var(--other); }
+  .node.view circle { fill: var(--view); } .node.viewmodel circle { fill: var(--viewmodel); }
+  .node.model circle { fill: var(--model); } .node.root circle { fill: var(--root); }
+  .node.has-bad rect { stroke: var(--bad); }
+  .node { cursor: default; }
+  .edge { fill: none; stroke: var(--edge); stroke-width: 1.4; transition: opacity .15s, stroke-width .15s; }
+  .edge.type { stroke-dasharray: 4 4; }
+  .edge.cycle { stroke: var(--cycle); stroke-width: 2; }
+  .edge.bad { stroke: var(--bad); stroke-width: 2.4; }
+  #arrow path { fill: var(--edge); } #arrow-bad path { fill: var(--bad); }
+  svg.focus .edge { opacity: .12; } svg.focus .edge.on { opacity: 1; stroke-width: 2.6; }
+  svg.focus .node { opacity: .35; } svg.focus .node.on { opacity: 1; }
+</style>
+</head>
+<body>
+<header>
+  ${BULL_SVG}
+  <div><h1>${esc(title)}</h1><p>Import graph \xB7 ${graph.nodes.length} files \xB7 ${graph.edges.length} edges \xB7 hover a file to trace it</p></div>
+  <div class="spacer"></div>
+  ${status}
+</header>
+<div class="legend">
+  <span><i></i>import</span><span class="type"><i></i>type-only import</span>
+  <span class="bad"><i></i>breaks View \u2192 ViewModel \u2192 Model</span><span class="cycle"><i></i>import cycle</span>
+</div>
+<main>
+  <svg id="graph" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="Import graph">
+    <defs>
+      <marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z"/></marker>
+      <marker id="arrow-bad" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z"/></marker>
+    </defs>
+    <g>
+      ${headers}
+    </g>
+    <g>
+      ${edges}
+    </g>
+    <g>
+      ${nodes}
+    </g>
+  </svg>
+</main>
+<script>
+  const svg = document.getElementById("graph");
+  svg.querySelectorAll(".node").forEach((node) => {
+    const id = node.dataset.id;
+    node.addEventListener("mouseenter", () => {
+      svg.classList.add("focus");
+      node.classList.add("on");
+      svg.querySelectorAll('.edge[data-from="' + id + '"], .edge[data-to="' + id + '"]').forEach((edge) => {
+        edge.classList.add("on");
+        svg.querySelector('.node[data-id="' + edge.dataset.from + '"]').classList.add("on");
+        svg.querySelector('.node[data-id="' + edge.dataset.to + '"]').classList.add("on");
+      });
+    });
+    node.addEventListener("mouseleave", () => {
+      svg.classList.remove("focus");
+      svg.querySelectorAll(".on").forEach((el) => el.classList.remove("on"));
+    });
+  });
+</script>
+</body>
+</html>
+`;
+}
+var BULL_SVG = `<svg width="36" height="36" viewBox="0 0 64 64" aria-hidden="true">
+    <path d="M19 20C10.5 20 4.5 15 4 5.5c3.5 5.8 9 8.6 17 9.2Z" fill="#ffc9a8"/>
+    <path d="M45 20c8.5 0 14.5-5 15-14.5c-3.5 5.8-9 8.6-17 9.2Z" fill="#ffc9a8"/>
+    <path d="M18 15h28L32 36Z" fill="#a78bfa"/><path d="M18 15l14 21v21h-6L20.5 34Z" fill="#6b4dff"/>
+    <path d="M46 15 32 36v21h6l5.5-23Z" fill="#f0507c"/><rect x="23" y="45" width="18" height="12" rx="6" fill="#33224a"/>
+  </svg>`;
+async function graphCommand(rootArg, options) {
+  const format = options.format ?? "tree";
+  if (!["tree", "mermaid", "dot", "html", "json"].includes(format)) {
+    fail(`Unknown format "${format}".`, "Use tree, mermaid, dot, html or json.");
+    return;
+  }
+  const root = path6.resolve(rootArg ?? ".");
+  const { config } = await loadBullConfig(root, "serve");
+  const graph = buildImportGraph(new ProjectAnalyzer4(root, config).analyze());
+  const title = path6.basename(root);
+  const text = format === "mermaid" ? renderMermaid(graph) : format === "dot" ? renderDot(graph) : format === "json" ? `${JSON.stringify(graph, null, 2)}
+` : format === "html" ? renderHtml(graph, title) : void 0;
+  if (text === void 0) {
+    banner("graph");
+    process.stdout.write(renderTree(graph));
+  } else if (options.out || format === "html") {
+    const out = path6.resolve(options.out ?? "bull-graph.html");
+    fs6.writeFileSync(out, text);
+    banner("graph");
+    console.log(`  ${pc6.green("\u2713")} Wrote ${pc6.bold(path6.relative(process.cwd(), out) || out)}`);
+    if (options.open) openInBrowser(out);
+  } else {
+    process.stdout.write(text);
+  }
+  if (graph.edges.some((e) => e.violation) || graph.cycles.length) process.exitCode = 1;
+}
+function openInBrowser(file2) {
+  const command = process.platform === "win32" ? `start "" "${file2}"` : process.platform === "darwin" ? `open "${file2}"` : `xdg-open "${file2}"`;
+  exec(command);
+}
+
+// src/tooling/info.ts
+import fs7 from "fs";
+import path7 from "path";
+import { LAYER_LABEL as LAYER_LABEL2, ProjectAnalyzer as ProjectAnalyzer5 } from "@bull-js/core";
+import pc7 from "picocolors";
+function isPublic(m) {
+  return m.access === "public" && !m.static;
+}
+function collectInfo(result, configFile) {
+  const { config } = result;
+  const rel = (f) => path7.posix.relative(config.root, f);
+  const views = result.files.filter((f) => f.kind === "view" && f.facts).map((f) => ({
+    file: rel(f.file),
+    name: path7.posix.basename(f.file).replace(/\.view\.tsx$/, ""),
+    binds: [
+      ...f.facts.declarators.filter((d) => d.callee === "useViewModel" && d.arg).map((d) => d.arg),
+      // `const { pay } = useViewModel(CartViewModel)` binds it too.
+      ...f.facts.destructurings.flatMap(
+        (d) => "callee" in d.init && d.init.callee === "useViewModel" && d.init.arg ? [d.init.arg] : []
+      )
+    ]
+  }));
+  const viewModels = [];
+  for (const f of result.files.filter((x) => x.kind === "viewmodel" && x.facts)) {
+    for (const cls of f.facts.classes.filter((c) => c.exported && c.name && c.superClass?.endsWith("ViewModel"))) {
+      const members = cls.members.filter(isPublic);
+      const pick = (test) => members.filter(test).map((m) => m.name);
+      viewModels.push({
+        name: cls.name,
+        file: rel(f.file),
+        state: pick((m) => m.kind === "field" && (m.init === "readonly-view" || m.init === "state")),
+        computed: pick((m) => m.kind === "field" && m.init === "computed"),
+        commands: pick((m) => m.kind === "field" && m.init === "command"),
+        values: pick((m) => m.kind === "field" && (m.init === "other" || m.init === "none")),
+        methods: pick((m) => m.kind === "method" || m.kind === "getter"),
+        injects: cls.members.filter((m) => m.kind === "param-property").map((m) => m.type ?? m.name),
+        usedBy: views.filter((v) => v.binds.includes(cls.name)).map((v) => v.file)
+      });
+    }
+  }
+  let name = path7.basename(config.root);
+  try {
+    name = JSON.parse(fs7.readFileSync(path7.join(config.root, "package.json"), "utf8")).name ?? name;
+  } catch {
+  }
+  const overrides = [
+    ...[...config.rules].map(([code, severity]) => `${code}: ${severity}`),
+    ...[...config.view.allowHooks].map((hook) => `view.allowHooks: ${hook}`),
+    ...config.alias.map(([prefix, target]) => `alias ${prefix} \u2192 ${path7.posix.relative(config.root, target) || "."}`)
+  ];
+  return {
+    name,
+    root: config.root,
+    configFile,
+    counts: { model: result.stats.model, viewmodel: result.stats.viewmodel, view: result.stats.view },
+    viewModels,
+    views,
+    overrides,
+    errors: result.errorCount,
+    warnings: result.warningCount
+  };
+}
+function formatInfo(info, colors = pc7.isColorSupported) {
+  const c = pc7.createColors(colors);
+  const out = [];
+  const row = (label, items, color = (s) => s) => items.length && out.push(`      ${c.dim(label.padEnd(9))} ${items.map(color).join(c.dim(", "))}`);
+  out.push(`  ${c.bold(info.name)} ${c.dim(info.root)}`);
+  out.push(`  ${c.dim("config")}   ${info.configFile ? path7.basename(info.configFile) : "defaults"}`);
+  out.push("");
+  out.push(`  ${c.bold("Layers")}`);
+  for (const layer of ["view", "viewmodel", "model"]) {
+    out.push(`    ${LAYER_LABEL2[layer].padEnd(10)} ${String(info.counts[layer]).padStart(3)} file(s)`);
+  }
+  out.push("");
+  out.push(`  ${c.bold("ViewModels")} ${c.dim("(public API)")}`);
+  if (!info.viewModels.length) out.push(`    ${c.dim("none yet \u2014 try `bull g feature <name>`")}`);
+  for (const vm of info.viewModels) {
+    out.push(`    ${c.magenta(vm.name)} ${c.dim(vm.file)}`);
+    row("state", vm.state, c.cyan);
+    row("computed", vm.computed, c.cyan);
+    row("commands", vm.commands, c.green);
+    row("values", vm.values);
+    row("methods", vm.methods);
+    row("injects", vm.injects, c.blue);
+    row("used by", vm.usedBy);
+    if (!vm.usedBy.length) out.push(`      ${c.dim("used by".padEnd(9))} ${c.yellow("no View binds it yet")}`);
+  }
+  out.push("");
+  out.push(`  ${c.bold("Views")}`);
+  for (const v of info.views) {
+    out.push(`    ${v.file.padEnd(40)} ${v.binds.length ? c.magenta(v.binds.join(", ")) : c.dim("presentational")}`);
+  }
+  if (info.overrides.length) {
+    out.push("");
+    out.push(`  ${c.bold("Config overrides")}`);
+    for (const o of info.overrides) out.push(`    ${o}`);
+  }
+  out.push("");
+  out.push(
+    info.errors || info.warnings ? `  ${c.red("\u2717")} ${info.errors} error(s), ${info.warnings} warning(s) \u2014 run ${c.cyan("bull check")}` : `  ${c.green("\u2713")} MVVM architecture ok`
+  );
+  return `${out.join("\n")}
+`;
+}
+async function infoCommand(rootArg, options) {
+  const root = path7.resolve(rootArg ?? ".");
+  const { config, file: file2 } = await loadBullConfig(root, "serve");
+  const info = collectInfo(new ProjectAnalyzer5(root, config).analyze(), file2);
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(info, null, 2)}
+`);
+    return;
+  }
+  banner("info");
+  process.stdout.write(formatInfo(info));
+}
+
+// src/tooling/init.ts
+import fs8 from "fs";
+import path8 from "path";
+import pc8 from "picocolors";
+var CONFIG = `import { defineConfig } from "@bull-js/cli";
+
+export default defineConfig({});
+`;
+var SCRIPTS = {
+  dev: "bull",
+  build: "bull build",
+  preview: "bull preview",
+  check: "bull check"
+};
+var DEPENDENCIES = ["@bull-js/runtime"];
+var DEV_DEPENDENCIES = ["@bull-js/cli", "@bull-js/eslint-plugin"];
+var LAYERS = ["model", "viewmodel", "view"];
+function planInit(root) {
+  const pkgFile = path8.join(root, "package.json");
+  if (!fs8.existsSync(pkgFile)) {
+    throw new Error("There is no package.json here. To start from scratch use `bull create <name>`.");
+  }
+  const original = fs8.readFileSync(pkgFile, "utf8");
+  const pkg = JSON.parse(original);
+  const changes = [];
+  const config = ["bull.config.ts", "bull.config.mts", "bull.config.js", "bull.config.mjs"].find(
+    (f) => fs8.existsSync(path8.join(root, f))
+  );
+  changes.push(
+    config ? { path: config, action: "skip", detail: "already exists" } : { path: "bull.config.ts", action: "create", detail: "empty config, ready to extend" }
+  );
+  for (const layer of LAYERS) {
+    const dir = `src/${layer}`;
+    changes.push(
+      fs8.existsSync(path8.join(root, dir)) ? { path: `${dir}/`, action: "skip", detail: "already exists" } : { path: `${dir}/`, action: "create", detail: `${layer} layer` }
+    );
+  }
+  const added = [];
+  const kept = [];
+  pkg.scripts ??= {};
+  for (const [name, command] of Object.entries(SCRIPTS)) {
+    const current = pkg.scripts[name];
+    if (current === void 0) {
+      pkg.scripts[name] = command;
+      added.push(`scripts.${name}`);
+    } else if (current !== command) {
+      kept.push(`scripts.${name} ("${current}")`);
+    }
+  }
+  const range = `^${VERSION}`;
+  const addDeps = (field, names) => {
+    for (const name of names) {
+      if (pkg.dependencies?.[name] || pkg.devDependencies?.[name]) continue;
+      pkg[field] = { ...pkg[field], [name]: range };
+      added.push(name);
+    }
+  };
+  addDeps("dependencies", DEPENDENCIES);
+  addDeps("devDependencies", DEV_DEPENDENCIES);
+  if (added.length) changes.push({ path: "package.json", action: "update", detail: `adds ${added.join(", ")}` });
+  if (kept.length) changes.push({ path: "package.json", action: "skip", detail: `keeps ${kept.join(", ")}` });
+  return { changes, pkg: added.length ? pkg : void 0 };
+}
+function initCommand(rootArg, options) {
+  banner(options.dryRun ? "init (dry run)" : "init");
+  const root = path8.resolve(rootArg ?? ".");
+  let plan;
+  try {
+    plan = planInit(root);
+  } catch (error) {
+    fail(error.message);
+    return;
+  }
+  for (const change of plan.changes) {
+    if (change.action === "skip") {
+      console.log(`  ${pc8.yellow("\xB7")} ${change.path} ${pc8.dim(`(${change.detail}, left untouched)`)}`);
+      continue;
+    }
+    const mark = change.action === "create" ? pc8.green("+") : pc8.cyan("~");
+    const verb = options.dryRun ? change.action === "create" ? "would create: " : "would update: " : "";
+    console.log(`  ${mark} ${change.path}  ${pc8.dim(`${verb}${change.detail}`)}`);
+    if (options.dryRun) continue;
+    const abs = path8.join(root, change.path);
+    if (change.path.endsWith("/")) fs8.mkdirSync(abs, { recursive: true });
+    else if (change.path === "bull.config.ts") fs8.writeFileSync(abs, CONFIG);
+  }
+  if (!options.dryRun && plan.pkg) {
+    fs8.writeFileSync(path8.join(root, "package.json"), `${JSON.stringify(plan.pkg, null, 2)}
+`);
+  }
+  const pm = detectPackageManager();
+  console.log(`
+  Next steps:
+    ${pc8.cyan(`${pm} install`)}
+    ${pc8.cyan("npx bull g feature home")}   ${pc8.dim("a first Model, ViewModel and View")}
+    ${pc8.cyan("npx bull doctor")}           ${pc8.dim("checks the rest of the setup")}
+    ${pc8.cyan(runScript(pm, "dev"))}
+`);
+}
+
+// src/bin.ts
+var cli = cac("bull");
+cli.command("[root]", "Dev server with live architecture checks").alias("dev").option("--port <port>", "Port").option("--open", "Open the browser").option("--host [host]", "Expose on the network").option("--mode <mode>", "Vite mode (defaults to development)").option("--config <file>", "Use this config file instead of bull.config.ts").action((root, options) => devCommand(root, options));
+cli.command("build [root]", "Checks the architecture and, if it holds, builds for production").option("--out-dir <dir>", "Output folder (defaults to dist)").option("--mode <mode>", "Vite mode (defaults to production)").option("--config <file>", "Use this config file instead of bull.config.ts").action((root, options) => buildCommand(root, options));
+cli.command("preview [root]", "Serves the production build").option("--port <port>", "Port").option("--open", "Open the browser").option("--host [host]", "Expose on the network").option("--out-dir <dir>", "Folder with the build (defaults to dist)").option("--config <file>", "Use this config file instead of bull.config.ts").action((root, options) => previewCommand(root, options));
+cli.command("check [root]", "Only checks the architecture (great for CI)").option("--format <format>", "pretty | json", { default: "pretty" }).action((root, options) => checkCommand(root, options));
+cli.command("explain [code]", "Explains a rule (MVVM100, 100 or view-imports-model). Without a code, lists them all").option("--all", "All rules").option("--format <format>", "text | md").option("--out <dir>", "With --all --format md: folder where the docs are written").action((code, options) => explainCommand(code, options));
+cli.command("create [name]", "Creates a new project with the MVVM structure (asks for the details without a name)").option("--template <template>", "Template", { default: "default" }).option("--pm <pm>", "Package manager: npm | pnpm | yarn | bun (defaults to the one running the command)").option("--no-install", "Do not install the dependencies").option("--no-git", "Do not initialize a git repository").example("  bull create my-app").example("  bull create my-app --pm pnpm --no-git").action((name, options) => createCommand(name, options));
+cli.command("init [root]", "Adds Bull to an existing project: config, layer folders, scripts and dependencies").option("--dry-run", "Show what would change without changing it").action((root, options) => initCommand(root, options));
+cli.command("generate <type> [name]", "Scaffolds a feature, model, viewmodel or view with the right names").alias("g").option("--kind <kind>", "Model kind: model | entity | repository | service").option("--dry-run", "Show what would be written without writing it").option("--no-test", "Do not generate a ViewModel test").option("--root <dir>", "Project root (defaults to the current folder)").example("  bull g feature todo-list").example("  bull g model user --kind repository").action(
+  (type, name, options) => generateCommand(type, name, { ...options, test: options.test === false ? false : void 0 })
+);
+cli.command("graph [root]", "Shows the import graph between layers and the edges that break MVVM").option("--format <format>", "tree | mermaid | dot | html | json", { default: "tree" }).option("--out <file>", "Write the output to a file (html defaults to bull-graph.html)").option("--open", "Open the HTML graph in the browser").example("  bull graph --format html --open").example("  bull graph --format mermaid > docs/architecture.mmd").action((root, options) => graphCommand(root, options));
+cli.command("fix [root]", "Applies the safe automatic fixes (renames, readonly state, type re-exports)").option("--dry-run", "Show a diff of the changes without writing them").action((root, options) => fixCommand(root, options));
+cli.command("doctor [root]", "Checks the environment and the project setup").action((root) => doctorCommand(root));
+cli.command("info [root]", "Summarizes the project: layers, ViewModel APIs and which Views bind them").option("--json", "Print the summary as JSON").action((root, options) => infoCommand(root, options));
+cli.command("completion [shell]", "Prints shell completions: bash | zsh | fish | powershell").example('  eval "$(bull completion bash)"').example("  bull completion powershell | Out-String | Invoke-Expression").action((shell) => completionCommand(shell, completionCommands()));
+function completionCommands() {
+  return cli.commands.filter((c) => c.name !== "completion").map((c) => ({
+    name: c.name === "" ? "dev" : c.name,
+    aliases: c.aliasNames.filter((a) => a !== "dev"),
+    description: c.description,
+    flags: c.options.flatMap((o) => o.rawName.match(/--[\w-]+/g) ?? [])
+  }));
+}
+var GROUPS = [
+  ["Develop", ["", "build", "preview", "create", "init"]],
+  ["Architecture", ["check", "explain", "graph", "fix"]],
+  ["Tooling", ["generate", "doctor", "info", "completion"]]
+];
+cli.help((sections) => {
+  sections[0] = { body: `
+${bullArt()}
+` };
+  const commands = sections.findIndex((s) => s.title === "Commands");
+  if (commands >= 0 && (!cli.matchedCommand || cli.matchedCommand.name === "")) {
+    const label = (name) => {
+      const cmd2 = cli.commands.find((c) => c.name === name);
+      const aliases = cmd2.aliasNames.filter((a) => a !== "dev");
+      const raw = name === "" ? "dev [root]" : cmd2.rawName;
+      return [`${raw}${aliases.length ? pc9.dim(` (${aliases.join(", ")})`) : ""}`, cmd2.description];
+    };
+    const width = Math.max(...GROUPS.flatMap(([, names]) => names.map((n) => cmd(label(n)[0]).length))) + 2;
+    const body = GROUPS.map(
+      ([title, names]) => `${pc9.bold(title)}
+` + names.map((n) => `  ${label(n)[0]}${" ".repeat(width - cmd(label(n)[0]).length)}${label(n)[1]}`).join("\n")
+    ).join("\n\n");
+    sections.splice(commands, 1, { body });
+    const more = sections.findIndex((s) => s.title?.startsWith("For more info"));
+    if (more >= 0)
+      sections.splice(more, 1, { body: pc9.dim("Run `bull <command> --help` for the options of each command.") });
+  }
+  return sections;
+});
+function cmd(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+cli.version(VERSION);
+try {
+  cli.parse(process.argv, { run: false });
+  await cli.runMatchedCommand();
+} catch (error) {
+  console.error(`
+  ${pc9.red("\u2717")} ${error.message}
+`);
+  process.exitCode = 1;
+}