@beignet/cli 0.0.27 → 0.0.28

package/src/check.ts

@@ -0,0 +1,246 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createPainter } from "./ansi.js";
+import { detectPackageManager, spawnCommand } from "./db.js";
+import {
+  applyDoctorFixes,
+  formatDoctor,
+  type InspectFix,
+  inspectApp,
+} from "./inspect.js";
+import { formatLint, lintApp } from "./lint.js";
+
+/**
+ * One step of `beignet check`.
+ *
+ * `output` carries the failing step's formatted diagnostics or captured
+ * script output so the summary is actionable without a re-run.
+ */
+export type CheckStep = {
+  name: string;
+  command: string;
+  status: "passed" | "failed" | "skipped";
+  detail?: string;
+  output?: string;
+  durationMs: number;
+};
+
+export type CheckAppResult = {
+  schemaVersion: 1;
+  targetDir: string;
+  runner: string;
+  ok: boolean;
+  fixes: InspectFix[];
+  steps: CheckStep[];
+};
+
+export type CheckAppOptions = {
+  cwd?: string;
+  fix?: boolean;
+  color?: boolean;
+  /** Called after each step completes, for incremental progress output. */
+  onStep?: (step: CheckStep) => void;
+};
+
+const scriptStepNames = ["lint", "typecheck", "test"] as const;
+
+/**
+ * Run the whole app validation loop as one command: `beignet lint`,
+ * `beignet doctor --strict` (optionally with fixes), and the app's own
+ * `lint`, `typecheck`, and `test` package scripts through the detected
+ * package manager.
+ *
+ * Every step runs even when an earlier one fails, so a single run reports
+ * everything that needs fixing. Missing package scripts are reported as
+ * skipped, never as failures.
+ */
+export async function checkApp(
+  options: CheckAppOptions = {},
+): Promise<CheckAppResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const runner = await detectPackageManager(targetDir);
+  const steps: CheckStep[] = [];
+  const record = (step: CheckStep): void => {
+    steps.push(step);
+    options.onStep?.(step);
+  };
+
+  record(await lintStep(targetDir, options));
+  const { step: doctorStep, fixes } = await runDoctorStep(targetDir, options);
+  record(doctorStep);
+
+  const scripts = await readPackageScripts(targetDir);
+  for (const script of scriptStepNames) {
+    record(await scriptStep(targetDir, runner, script, scripts));
+  }
+
+  return {
+    schemaVersion: 1,
+    targetDir,
+    runner,
+    ok: steps.every((step) => step.status !== "failed"),
+    fixes,
+    steps,
+  };
+}
+
+/**
+ * Format a completed step as a single status line, with the failing step's
+ * output indented underneath.
+ */
+export function formatCheckStep(
+  step: CheckStep,
+  options: { color?: boolean } = {},
+): string {
+  const paint = createPainter(options.color);
+  const mark =
+    step.status === "passed"
+      ? paint("✓", "green")
+      : step.status === "failed"
+        ? paint("✗", "red")
+        : paint("-", "cyan");
+  const detail = step.detail ? ` (${step.detail})` : "";
+  const line = `${mark} ${step.name}${detail}`;
+  if (step.status !== "failed" || !step.output?.trim()) return line;
+
+  const indented = step.output
+    .trimEnd()
+    .split("\n")
+    .map((outputLine) => `  ${outputLine}`)
+    .join("\n");
+  return `${line}\n${indented}`;
+}
+
+/**
+ * Format the closing summary line, e.g. `3 passed, 1 failed, 1 skipped`.
+ */
+export function formatCheckSummary(
+  result: CheckAppResult,
+  options: { color?: boolean } = {},
+): string {
+  const paint = createPainter(options.color);
+  const counts = {
+    passed: result.steps.filter((step) => step.status === "passed").length,
+    failed: result.steps.filter((step) => step.status === "failed").length,
+    skipped: result.steps.filter((step) => step.status === "skipped").length,
+  };
+  const parts = [`${counts.passed} passed`];
+  if (counts.failed > 0) parts.push(paint(`${counts.failed} failed`, "red"));
+  if (counts.skipped > 0) parts.push(`${counts.skipped} skipped`);
+  return parts.join(", ");
+}
+
+/**
+ * Format a full result at once (JSON-free callers and tests).
+ */
+export function formatCheck(
+  result: CheckAppResult,
+  options: { color?: boolean } = {},
+): string {
+  const lines = result.steps.map((step) => formatCheckStep(step, options));
+  return `${lines.join("\n")}\n\n${formatCheckSummary(result, options)}`;
+}
+
+async function lintStep(
+  targetDir: string,
+  options: CheckAppOptions,
+): Promise<CheckStep> {
+  const startedAt = Date.now();
+  const result = await lintApp({ cwd: targetDir });
+  const failed = result.diagnostics.length > 0;
+
+  return {
+    name: "beignet lint",
+    command: "beignet lint",
+    status: failed ? "failed" : "passed",
+    ...(failed ? { output: formatLint(result, { color: options.color }) } : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+async function runDoctorStep(
+  targetDir: string,
+  options: CheckAppOptions,
+): Promise<{ step: CheckStep; fixes: InspectFix[] }> {
+  const startedAt = Date.now();
+  const fixes = options.fix
+    ? await applyDoctorFixes({ cwd: targetDir, strict: true })
+    : [];
+  const result = await inspectApp({ cwd: targetDir, strict: true });
+  result.fixes = fixes;
+  const failed = result.diagnostics.some(
+    (diagnostic) =>
+      diagnostic.severity === "error" || diagnostic.severity === "warning",
+  );
+
+  return {
+    step: {
+      name: "beignet doctor --strict",
+      command: "beignet doctor --strict",
+      status: failed ? "failed" : "passed",
+      ...(fixes.length > 0
+        ? {
+            detail: `${fixes.length} ${fixes.length === 1 ? "fix" : "fixes"} applied`,
+          }
+        : {}),
+      ...(failed
+        ? { output: formatDoctor(result, { color: options.color }) }
+        : {}),
+      durationMs: Date.now() - startedAt,
+    },
+    fixes,
+  };
+}
+
+async function scriptStep(
+  targetDir: string,
+  runner: string,
+  script: (typeof scriptStepNames)[number],
+  scripts: Record<string, string>,
+): Promise<CheckStep> {
+  const command = `${runner} run ${script}`;
+  if (!scripts[script]) {
+    return {
+      name: script,
+      command,
+      status: "skipped",
+      detail: `no "${script}" script in package.json`,
+      durationMs: 0,
+    };
+  }
+
+  const startedAt = Date.now();
+  const result = await spawnCommand(runner, ["run", script], targetDir, {
+    captureOutput: true,
+  });
+  const failed = result.exitCode !== 0;
+
+  return {
+    name: script,
+    command,
+    status: failed ? "failed" : "passed",
+    detail: command,
+    ...(failed
+      ? { output: [result.stdout, result.stderr].filter(Boolean).join("\n") }
+      : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+async function readPackageScripts(
+  targetDir: string,
+): Promise<Record<string, string>> {
+  let source: string;
+  try {
+    source = await readFile(path.join(targetDir, "package.json"), "utf8");
+  } catch {
+    throw new Error(
+      "Could not find package.json. Run beignet check from the app root.",
+    );
+  }
+
+  const parsed = JSON.parse(source) as {
+    scripts?: Record<string, string>;
+  };
+  return parsed.scripts ?? {};
+}

package/src/db.ts

@@ -482,7 +482,7 @@ async function readPackageJson(cwd: string): Promise<PackageJson> {
   }
 }
 
-async function detectPackageManager(cwd: string): Promise<string> {
+export async function detectPackageManager(cwd: string): Promise<string> {
   if (await exists(path.join(cwd, "bun.lock"))) return "bun";
   if (await exists(path.join(cwd, "bun.lockb"))) return "bun";
   if (await exists(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
@@ -500,7 +500,7 @@ async function exists(filePath: string): Promise<boolean> {
   }
 }
 
-function spawnCommand(
+export function spawnCommand(
   command: string,
   args: readonly string[],
   cwd: string,

package/src/index.ts

@@ -105,6 +105,12 @@ type LintFlags = {
   format?: OutputFormat;
 };
 
+type CheckFlags = {
+  json?: boolean;
+  fix?: boolean;
+  cwd?: string;
+};
+
 type DbFlags = {
   json?: boolean;
   dryRun?: boolean;
@@ -601,6 +607,55 @@ const doctorCommand = buildCommand<DoctorFlags, [], CliContext>({
   },
 });
 
+const checkCommand = buildCommand<CheckFlags, [], CliContext>({
+  docs: {
+    brief: "Run the full app validation loop as one command.",
+    fullDescription:
+      "Runs beignet lint, beignet doctor --strict, and the app's lint, typecheck, and test package scripts through the detected package manager. Every step runs even when an earlier one fails, so one run reports everything. Missing package scripts are skipped, not failed.",
+  },
+  parameters: {
+    flags: {
+      json: jsonFlag,
+      fix: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief: "Apply low-risk doctor fixes before checking.",
+      },
+      cwd: cwdFlag,
+    } satisfies FlagParametersForType<CheckFlags, CliContext>,
+  },
+  loader: async () => {
+    const { checkApp, formatCheckStep, formatCheckSummary } = await import(
+      "./check.js"
+    );
+
+    return async function runCheck(this: CliContext, flags: CheckFlags) {
+      const color = useColor();
+      const result = await checkApp({
+        cwd: flags.cwd,
+        fix: flags.fix,
+        color,
+        ...(flags.json
+          ? {}
+          : {
+              onStep: (step) =>
+                writeOutput(this, formatCheckStep(step, { color })),
+            }),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : `\n${formatCheckSummary(result, { color })}`,
+      );
+      if (!result.ok) {
+        this.process.exitCode = 1;
+      }
+    };
+  },
+});
+
 const lintCommand = buildCommand<LintFlags, [], CliContext>({
   docs: {
     brief: "Check Beignet dependency direction conventions.",
@@ -1493,6 +1548,7 @@ const rootRoutes = buildRouteMap({
 Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
   },
   routes: {
+    check: checkCommand,
     completion: completionRoutes,
     create: createCommand,
     db: dbRoutes,
@@ -1506,6 +1562,10 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     schedule: scheduleRoutes,
     task: taskRoutes,
   },
+  aliases: {
+    // The singular form is a common near-miss for the providers commands.
+    provider: "providers",
+  },
 });
 
 const cli = buildApplication(rootRoutes, {
@@ -1697,19 +1757,13 @@ ${openStep}
 
 Inspect the app:
   ${cli} routes
-  ${run} lint
-  ${cli} lint
-  ${cli} doctor
+  ${cli} check
 
 Generate a feature:
   ${cli} make feature projects
   ${cli} db generate
   ${cli} db migrate
-  ${run} test
-  ${run} lint
-  ${run} typecheck
-  ${cli} lint
-  ${cli} doctor`;
+  ${cli} check`;
 }
 
 function packageRunnerFromPackageManager(pm: PackageManager): string {

package/src/inspect.ts

@@ -19,6 +19,10 @@ import {
   formatGithubAnnotation,
   type GithubAnnotationSeverity,
 } from "./github-annotations.js";
+import {
+  providersFilePath,
+  wireListenersProviderSource,
+} from "./make/shared.js";
 import {
   detectedProviderVariants,
   diagnosticPackageJsonFile,
@@ -269,6 +273,14 @@ export async function applyDoctorFixes(
     ...(await fixUnregisteredOutboxEntries(targetDir, files, drift, config)),
   );
 
+  const listenerFix = await fixUnregisteredListeners(
+    targetDir,
+    files,
+    drift,
+    config,
+  );
+  if (listenerFix) fixes.push(listenerFix);
+
   const openApiFix = await fixDirectOpenApiArrayDrift(
     targetDir,
     files,
@@ -5462,6 +5474,94 @@ async function fixUnregisteredTasks(
   });
 }
 
+/**
+ * Wire fully unregistered feature listener registries into the providers
+ * file with the same `<registry>Provider` block `beignet make listener`
+ * generates, so both write paths stay byte-compatible.
+ *
+ * Bails without writing when the providers file or its exported array is
+ * missing or customized, when the app has no eventBus port to register
+ * against, or when the registry name is already imported from another file.
+ * The diagnostic stays in every bail case.
+ */
+async function fixUnregisteredListeners(
+  targetDir: string,
+  files: string[],
+  drift: WorkflowRegistrationDrift,
+  config: ResolvedBeignetConfig,
+): Promise<InspectFix | undefined> {
+  const candidates = drift.listeners.unregistered.filter(
+    (entry) => entry.fullyUnregistered,
+  );
+  if (candidates.length === 0) return undefined;
+
+  const providersFile = providersFilePath(config);
+  const contextFile = normalizePath(
+    path.join(path.dirname(config.paths.server), "context.ts"),
+  );
+  const wiringDependencies = [
+    providersFile,
+    contextFile,
+    config.paths.appContext,
+    config.paths.ports,
+  ];
+  if (wiringDependencies.some((file) => !files.includes(file))) {
+    return undefined;
+  }
+
+  // The generated wiring registers listeners on ports.eventBus; without the
+  // port the fix would produce code that cannot typecheck.
+  const portsSource = await readFile(
+    path.join(targetDir, config.paths.ports),
+    "utf8",
+  );
+  if (!/\beventBus\s*[:?]/.test(portsSource)) return undefined;
+
+  const providersPath = path.join(targetDir, providersFile);
+  const original = await readFile(providersPath, "utf8");
+  let next = original;
+  const registeredNames: string[] = [];
+
+  for (const { registry } of candidates) {
+    const imported = parseNamedImportSources(next).get(registry.registryName);
+    if (imported) {
+      const importedFile = sourceFileFromImport(
+        imported.sourcePath,
+        providersFile,
+        files,
+      );
+      if (importedFile !== registry.indexFile) return undefined;
+    }
+
+    const result = wireListenersProviderSource(next, {
+      registryName: registry.registryName,
+      featureKebab: listenerFeatureKebab(registry.indexFile),
+      listenerModule: `@/${modulePath(registry.indexFile)}`,
+      config,
+    });
+    if (result.kind === "missing") return undefined;
+    if (result.kind === "updated") {
+      next = result.source;
+      registeredNames.push(registry.registryName);
+    }
+  }
+
+  if (next === original || registeredNames.length === 0) return undefined;
+
+  await writeFile(providersPath, next);
+  return {
+    code: "BEIGNET_LISTENER_UNREGISTERED",
+    file: providersFile,
+    message: `Registered ${registeredNames.join(", ")} with registerListeners(...) in ${providersFile}.`,
+  };
+}
+
+function listenerFeatureKebab(indexFile: string): string {
+  return path.posix.basename(
+    path.posix.dirname(path.posix.dirname(normalizePath(indexFile))),
+  );
+}
+
 async function fixUnregisteredOutboxEntries(
   targetDir: string,
   files: string[],

package/src/make/shared.ts

@@ -7,6 +7,7 @@ import {
   type ResolvedBeignetConfig,
 } from "../config.js";
 import {
+  type AppendResult,
   appendToArrayExpression,
   appendToNamedArray,
   arrayInitializerInfo,
@@ -349,6 +350,93 @@ export function providersFilePath(config: ResolvedBeignetConfig): string {
   return `${directoryPath(path.dirname(config.paths.server))}/providers.ts`;
 }
 
+/**
+ * Wire a feature listener registry into the generated providers file by
+ * adding a `<registry>Provider` lifecycle provider whose setup calls
+ * `registerListeners(...)` and registering it in the providers array.
+ *
+ * Shared by `beignet make listener` and `beignet doctor --fix` so both write
+ * paths produce byte-identical wiring. Returns `missing` when the exported
+ * providers array anchor cannot be found; callers decide whether that is a
+ * hard error (make) or a keep-the-diagnostic bail (doctor).
+ */
+export function wireListenersProviderSource(
+  source: string,
+  options: {
+    registryName: string;
+    featureKebab: string;
+    listenerModule: string;
+    config: ResolvedBeignetConfig;
+  },
+): AppendResult {
+  const { registryName, featureKebab, listenerModule, config } = options;
+  const providerName = `${registryName}Provider`;
+  let next = source;
+  next = addNamedImport(next, "registerListeners", "@beignet/core/events");
+  next = addNamedImport(next, "createServiceActor", "@beignet/core/ports");
+  next = addNamedImport(next, "createProvider", "@beignet/core/providers");
+  next = addNamedTypeImport(
+    next,
+    "AppContext",
+    aliasModule(config.paths.appContext),
+  );
+  next = addNamedTypeImport(
+    next,
+    "AppServiceContextInput",
+    aliasModule(path.join(path.dirname(config.paths.server), "context.ts")),
+  );
+  next = addNamedTypeImport(next, "AppPorts", aliasModule(config.paths.ports));
+
+  const listenerImport = `import { ${registryName} } from "${listenerModule}";`;
+  if (!next.includes(listenerImport)) {
+    next = insertAfterImports(next, listenerImport);
+  }
+
+  if (!new RegExp(`\\bconst\\s+${providerName}\\b`).test(next)) {
+    const providerDefinition = `const ${providerName} = createProvider<
+\tPick<AppPorts, "eventBus" | "logger">,
+\tAppContext,
+\tAppServiceContextInput
+>()({
+\tname: "${featureKebab}-listeners",
+\tsetup({ ports, createServiceContext }) {
+\t\tconst unregister = registerListeners(ports.eventBus, ${registryName}, {
+\t\t\tctx: () =>
+\t\t\t\tcreateServiceContext({
+\t\t\t\t\tactor: createServiceActor("beignet-listener"),
+\t\t\t\t}),
+\t\t\tonError(error, listener) {
+\t\t\t\tports.logger.error("Event listener failed", {
+\t\t\t\t\terror,
+\t\t\t\t\tlistenerName: listener.name,
+\t\t\t\t});
+\t\t\t},
+\t\t});
+
+\t\treturn {
+\t\t\tstop() {
+\t\t\t\tunregister();
+\t\t\t},
+\t\t};
+\t},
+});
+`;
+    const withProvider = next.replace(
+      /\nexport const providers = \[/,
+      `\n${providerDefinition}\nexport const providers = [`,
+    );
+    if (withProvider === next) return { kind: "missing" };
+    next = withProvider;
+  }
+
+  const appended = appendToNamedArray(next, "providers", providerName);
+  if (appended.kind === "missing") return { kind: "missing" };
+  if (appended.kind === "updated") next = appended.source;
+
+  if (next === source) return { kind: "unchanged" };
+  return { kind: "updated", source: next };
+}
+
 /**
  * Wire provider-backed app ports a generator depends on.
  *

package/src/make.ts

@@ -131,6 +131,7 @@ import {
   usesFeatureOwnedPolicies,
   usesFeatureOwnedTests,
   type WriteGeneratedFileResult,
+  wireListenersProviderSource,
   wirePortProviders,
   writeGeneratedFile,
   writePlannedGeneratedFile,
@@ -1392,79 +1393,20 @@ async function updateListenerProviderWiring(
   }
 
   const listenerIndex = featureArtifactIndexFile("listener", names, config);
-  const providerName = `${names.featureSingularCamel}ListenersProvider`;
-  let next = original;
-  next = addNamedImport(next, "registerListeners", "@beignet/core/events");
-  next = addNamedImport(next, "createServiceActor", "@beignet/core/ports");
-  next = addNamedImport(next, "createProvider", "@beignet/core/providers");
-  next = addNamedTypeImport(
-    next,
-    "AppContext",
-    aliasModule(config.paths.appContext),
-  );
-  next = addNamedTypeImport(
-    next,
-    "AppServiceContextInput",
-    aliasModule(path.join(path.dirname(config.paths.server), "context.ts")),
-  );
-  next = addNamedTypeImport(next, "AppPorts", aliasModule(config.paths.ports));
-
-  const listenerImport = `import { ${listenerIndex.registryName} } from "${aliasModule(listenerIndex.path)}";`;
-  if (!next.includes(listenerImport)) {
-    next = insertAfterImports(next, listenerImport);
-  }
-
-  if (!new RegExp(`\\bconst\\s+${providerName}\\b`).test(next)) {
-    const providerDefinition = `const ${providerName} = createProvider<
-\tPick<AppPorts, "eventBus" | "logger">,
-\tAppContext,
-\tAppServiceContextInput
->()({
-\tname: "${names.feature.kebab}-listeners",
-\tsetup({ ports, createServiceContext }) {
-\t\tconst unregister = registerListeners(ports.eventBus, ${listenerIndex.registryName}, {
-\t\t\tctx: () =>
-\t\t\t\tcreateServiceContext({
-\t\t\t\t\tactor: createServiceActor("beignet-listener"),
-\t\t\t\t}),
-\t\t\tonError(error, listener) {
-\t\t\t\tports.logger.error("Event listener failed", {
-\t\t\t\t\terror,
-\t\t\t\t\tlistenerName: listener.name,
-\t\t\t\t});
-\t\t\t},
-\t\t});
-
-\t\treturn {
-\t\t\tstop() {
-\t\t\t\tunregister();
-\t\t\t},
-\t\t};
-\t},
-});
-`;
-    const withProvider = next.replace(
-      /\nexport const providers = \[/,
-      `\n${providerDefinition}\nexport const providers = [`,
-    );
-    if (withProvider === next) {
-      throw new Error(
-        `Could not find the exported providers array in ${providersFile}. Register ${listenerIndex.registryName} manually with registerListeners(...), or restore the generated providers file before running make listener.`,
-      );
-    }
-    next = withProvider;
-  }
-
-  const appended = appendToNamedArray(next, "providers", providerName);
-  if (appended.kind === "missing") {
+  const result = wireListenersProviderSource(original, {
+    registryName: listenerIndex.registryName,
+    featureKebab: names.feature.kebab,
+    listenerModule: aliasModule(listenerIndex.path),
+    config,
+  });
+  if (result.kind === "missing") {
     throw new Error(
       `Could not find the exported providers array in ${providersFile}. Register ${listenerIndex.registryName} manually with registerListeners(...), or restore the generated providers file before running make listener.`,
     );
   }
-  if (appended.kind === "updated") next = appended.source;
 
-  if (next === original) return "skipped";
-  if (!options.dryRun) await writeFile(filePath, next);
+  if (result.kind === "unchanged") return "skipped";
+  if (!options.dryRun) await writeFile(filePath, result.source);
   return "updated";
 }
 

package/src/mcp.ts

@@ -380,7 +380,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "doctor_fix",
     {
       description:
-        "Apply low-risk doctor fixes, then re-check the app. Repairs route-group, schedule, task, and outbox registration drift; listener registration drift is report-only. Returns applied fixes and remaining diagnostics as JSON.",
+        "Apply low-risk doctor fixes, then re-check the app. Repairs route-group, schedule, task, outbox, and listener registration drift. Returns applied fixes and remaining diagnostics as JSON.",
       inputSchema: {
         strict: z
           .boolean()