@beignet/cli 0.0.40 → 0.0.42

package/src/lib.ts

@@ -6,16 +6,79 @@
  * loads command modules lazily.
  */
 
+export type {
+  AppMapEdge,
+  AppMapEdgeKind,
+  AppMapNode,
+  AppMapNodeKind,
+  AppMapNodeStatus,
+  AppMapOptions,
+  AppMapProjectionOptions,
+  AppMapResult,
+  AppMapSource,
+  AppMapSummary,
+  AppMapUnresolvedReference,
+} from "./app-map.js";
+export {
+  appMapNodeKinds,
+  formatAppMap,
+  mapApp,
+  projectAppMap,
+} from "./app-map.js";
 export type { CreateOptions } from "./create.js";
 export { createProject } from "./create.js";
-export { runDatabaseCommand } from "./db.js";
+export type {
+  DatabaseCommand,
+  DatabaseSchemaDialect,
+  DatabaseSchemaTable,
+  RunDatabaseCommandOptions,
+  RunDatabaseCommandResult,
+  SyncDatabaseSchemaOptions,
+  SyncDatabaseSchemaResult,
+} from "./db.js";
+export { runDatabaseCommand, syncDatabaseSchema } from "./db.js";
+export type {
+  DoctorFixApplyResult,
+  DoctorFixFileChange,
+  DoctorFixOperation,
+  DoctorFixOperationId,
+  DoctorFixPlan,
+  InspectFix,
+} from "./doctor-fixes.js";
+export { doctorFixOperationIds } from "./doctor-fixes.js";
+export type {
+  ExplainAppOptions,
+  ExplainAppResult,
+  ExplainEvidence,
+  ExplainFinding,
+  ExplainRelatedNode,
+  ExplainRelationship,
+  ExplainSuggestedAction,
+  ExplainSuggestedFile,
+  ExplainTarget,
+  ExplainTargetKind,
+} from "./explain.js";
+export {
+  explainApp,
+  explainTargetKinds,
+  formatExplain,
+} from "./explain.js";
 export { main } from "./index.js";
+export type {
+  ApplyDoctorFixPlanOptions,
+  DoctorFixInspectionResult,
+  DoctorFixPlanResult,
+} from "./inspect.js";
 export {
   applyDoctorFixes,
+  applyDoctorFixPlan,
   formatDoctor,
+  formatDoctorFixPlan,
+  formatDoctorFixPlanGithub,
   formatDoctorGithub,
   formatRoutes,
   inspectApp,
+  planDoctorFixes,
 } from "./inspect.js";
 export { formatLint, formatLintGithub, lintApp } from "./lint.js";
 export type { MakeFeatureAddon, MakeFeatureRecipe } from "./make.js";

package/src/make/shared.ts

@@ -18,7 +18,7 @@ import {
 import {
   currentGeneratedPackageScripts,
   externalVersions,
-  legacyGeneratedPackageScripts,
+  isLegacyGeneratedPackageScript,
 } from "../templates/shared.js";
 
 export type MakeResult = {
@@ -1096,7 +1096,7 @@ export async function updatePackageScripts(
   for (const [name, command] of Object.entries(scripts)) {
     if (
       !packageJson.scripts[name] ||
-      packageJson.scripts[name] === legacyGeneratedPackageScripts[name]
+      isLegacyGeneratedPackageScript(name, packageJson.scripts[name])
     ) {
       packageJson.scripts[name] = command;
     }
@@ -1162,7 +1162,7 @@ function updateGeneratedPackageScripts(scripts: Record<string, string>): void {
     currentGeneratedPackageScripts,
   )) {
     if (
-      scripts[name] === legacyGeneratedPackageScripts[name] ||
+      isLegacyGeneratedPackageScript(name, scripts[name]) ||
       (name === "test" && !scripts[name])
     ) {
       scripts[name] = command;

package/src/make.ts

@@ -1090,6 +1090,7 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await updateOutboxRegistry(targetDir, names, "jobs", config, {
     dryRun: true,
   });
+  await updateInngestJobRegistry(targetDir, names, config, { dryRun: true });
 
   const result = await makeFeatureArtifact({
     targetDir,
@@ -1116,6 +1117,9 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await applyOutboxPortWiring(result, targetDir, config, {
     dryRun: Boolean(options.dryRun),
   });
+  await applyInngestJobRegistryUpdate(result, targetDir, names, config, {
+    dryRun: Boolean(options.dryRun),
+  });
 
   return result;
 }
@@ -3814,6 +3818,92 @@ async function applyOutboxRegistryUpdate(
   }
 }
 
+function inngestRegistryPath(config: ResolvedBeignetConfig): string {
+  return path.posix.join(path.posix.dirname(config.paths.server), "inngest.ts");
+}
+
+async function appUsesInngestJobs(targetDir: string): Promise<boolean> {
+  const source = await readOptionalFile(path.join(targetDir, "package.json"));
+  if (source === undefined) return false;
+
+  try {
+    const packageJson = JSON.parse(source) as PackageJsonLike;
+    return Boolean(
+      packageJson.dependencies?.["@beignet/provider-jobs-inngest"] ??
+        packageJson.devDependencies?.["@beignet/provider-jobs-inngest"],
+    );
+  } catch {
+    return false;
+  }
+}
+
+async function updateInngestJobRegistry(
+  targetDir: string,
+  names: JobNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult | undefined> {
+  if (!(await appUsesInngestJobs(targetDir))) return undefined;
+
+  const registryPath = inngestRegistryPath(config);
+  const destination = path.join(targetDir, registryPath);
+  const existing = await readOptionalFile(destination);
+  if (existing === undefined) {
+    throw new Error(
+      `@beignet/provider-jobs-inngest is installed, but ${registryPath} is missing. Run \`beignet provider add jobs-inngest\` to create the execution registry before generating jobs.`,
+    );
+  }
+
+  const featureIndexPath = path.join(
+    featureArtifactDir(names, "jobs", config),
+    "index.ts",
+  );
+  const registryName = `${names.featureSingularCamel}Jobs`;
+  const importLine = `import { ${registryName} } from "${aliasModule(featureIndexPath)}";`;
+  let next = existing;
+  if (!next.includes(importLine)) next = insertAfterImports(next, importLine);
+
+  const registry = arrayInitializerInfo(next, "inngestJobs");
+  if (!registry) {
+    throw new Error(
+      `Could not find \`export const inngestJobs = [...]\` in ${registryPath}. Restore the generated registry or register ${registryName} manually.`,
+    );
+  }
+  if (!identifiersFromArrayExpression(registry.text).has(registryName)) {
+    const updatedArray = appendToArrayExpression(registry.text, [
+      `...${registryName}`,
+    ]);
+    next = `${next.slice(0, registry.start)}${updatedArray}${next.slice(
+      registry.end,
+    )}`;
+  }
+
+  if (next === existing) return "skipped";
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
+async function applyInngestJobRegistryUpdate(
+  result: MakeJobResult,
+  targetDir: string,
+  names: JobNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<void> {
+  const registryResult = await updateInngestJobRegistry(
+    targetDir,
+    names,
+    config,
+    options,
+  );
+  if (registryResult === undefined) return;
+
+  const registryPath = inngestRegistryPath(config);
+  if (registryResult === "updated") result.updatedFiles.push(registryPath);
+  if (registryResult === "skipped") result.skippedFiles.push(registryPath);
+  if (!result.files.includes(registryPath)) result.files.push(registryPath);
+}
+
 function schemasFile(
   names: ResourceNames,
   mode: ResourceGenerationMode,
@@ -5145,8 +5235,6 @@ export const ${names.jobExportName} = defineJob("${names.jobName}", {
 \tpayload: ${names.payloadSchemaName},
 \tretry: retry.exponential({
 \t\tattempts: 3,
-\t\tinitialDelay: "1s",
-\t\tmaxDelay: "1m",
 \t}),
 \tasync handle({ payload, ctx }) {
 \t\tctx.ports.logger.info("Job handled", {

package/src/mcp.ts

@@ -2,8 +2,31 @@ import path from "node:path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { type ProviderPresetName, providerPresetChoices } from "./choices.js";
-import { applyDoctorFixes, inspectApp } from "./inspect.js";
+import { mapApp, projectAppMap } from "./app-map.js";
+import { appMapNodeKinds } from "./app-map-schema.js";
+import { checkApp } from "./check.js";
+import {
+  databaseCommandChoices,
+  databaseSchemaDialectChoices,
+  databaseSchemaTableChoices,
+  doctorFixOperationIds,
+  type ProviderPresetName,
+  providerPresetChoices,
+} from "./choices.js";
+import {
+  defaultDatabaseCommandMaxOutputBytes,
+  defaultDatabaseCommandTimeoutMs,
+  runDatabaseCommand,
+  syncDatabaseSchema,
+} from "./db.js";
+import { explainApp, explainTargetKinds } from "./explain.js";
+import {
+  applyDoctorFixesWithResult,
+  applyDoctorFixPlan,
+  createDoctorFixInspectionResult,
+  inspectApp,
+  planDoctorFixes,
+} from "./inspect.js";
 import { lintApp } from "./lint.js";
 import {
   type MakeResourceResult,
@@ -68,6 +91,8 @@ const makeArtifactChoices = [
   "use-case",
 ] as const;
 
+const defaultMcpCheckTimeoutMs = 10 * 60 * 1_000;
+
 type MakeArtifact = (typeof makeArtifactChoices)[number];
 
 const makeInputSchema = {
@@ -325,7 +350,7 @@ async function runProviderAddTool(
 }
 
 /**
- * Build the Beignet MCP server with routes, doctor, lint, and make tools.
+ * Build the Beignet MCP server with app-map, validation, and generator tools.
  * Every tool resolves against the app directory captured at launch.
  */
 export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
@@ -335,6 +360,207 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     version: options.version,
   });
 
+  server.registerTool(
+    "app_map",
+    {
+      description:
+        "Return a deterministic graph of this Beignet app: features, contracts, routes, use cases, authorization, workflows, ports, providers, OpenAPI, tests, dependency edges, and validation findings. Project by feature or node kind to keep agent context focused.",
+      inputSchema: {
+        feature: z
+          .string()
+          .optional()
+          .describe("Project one feature and its direct relationships."),
+        kinds: z
+          .array(z.enum(appMapNodeKinds))
+          .optional()
+          .describe("Include only these app-map node kinds."),
+        includeDiagnostics: z
+          .boolean()
+          .optional()
+          .describe("Include doctor and lint findings. Defaults to true."),
+      },
+      annotations: { readOnlyHint: true },
+    },
+    async (input) =>
+      safeToolResult(async () => {
+        const result = await mapApp({ cwd, strict: true });
+        return jsonResult(
+          projectAppMap(result, {
+            feature: input.feature,
+            kinds: input.kinds,
+            includeDiagnostics: input.includeDiagnostics,
+          }),
+        );
+      }),
+  );
+
+  server.registerTool(
+    "explain",
+    {
+      description:
+        "Explain one mapped Beignet concept or diagnostic using deterministic source evidence. Supports every app-map node kind and returns relationships, relevant conventions, findings, suggested files, and follow-up commands without changing the app.",
+      inputSchema: {
+        kind: z.enum(explainTargetKinds).describe("Mapped concept to explain."),
+        target: z
+          .string()
+          .min(1)
+          .describe(
+            "Stable ID, runtime name, declaration name, source selector, applicable concept alias, or diagnostic code.",
+          ),
+      },
+      annotations: { readOnlyHint: true },
+    },
+    async (input) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await explainApp({ cwd, kind: input.kind, target: input.target }),
+        ),
+      ),
+  );
+
+  server.registerTool(
+    "check",
+    {
+      description:
+        "Run the full Beignet app validation loop: Beignet lint, strict doctor, and the app's lint, typecheck, and test scripts. Returns the same versioned JSON as beignet check --json, including every step, bounded failure output, durations, and overall ok status. Does not apply Beignet fixes, but app-owned scripts run with their normal side effects.",
+      inputSchema: {
+        preflight: z
+          .boolean()
+          .optional()
+          .describe(
+            "Include the environment preflight check before app package scripts. Defaults to false.",
+          ),
+        timeoutMs: z
+          .number()
+          .int()
+          .min(1_000)
+          .max(60 * 60 * 1_000)
+          .optional()
+          .describe(
+            "Maximum duration for each app package script in milliseconds. Defaults to 600000 (10 minutes).",
+          ),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input, extra) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await checkApp({
+            cwd,
+            preflight: input.preflight ?? false,
+            scriptTimeoutMs: input.timeoutMs ?? defaultMcpCheckTimeoutMs,
+            signal: extra.signal,
+          }),
+        ),
+      ),
+  );
+
+  server.registerTool(
+    "db",
+    {
+      description:
+        "Run one app-owned database lifecycle command and return exactly the versioned beignet db <command> --json result. Supports generate, migrate, seed, and reset; captures a bounded output tail, stops after the configured timeout, and cancels the complete child process tree with the MCP request. Dry runs validate prerequisites and report the command without executing it.",
+      inputSchema: {
+        command: z
+          .enum(databaseCommandChoices)
+          .describe("Database lifecycle command to run."),
+        dryRun: z
+          .boolean()
+          .optional()
+          .describe(
+            "Validate prerequisites and report the app-owned script without executing it. This does not simulate SQL or data changes.",
+          ),
+        timeoutMs: z
+          .number()
+          .int()
+          .min(1_000)
+          .max(60 * 60 * 1_000)
+          .optional()
+          .describe(
+            "Maximum command duration in milliseconds. Defaults to 600000 (10 minutes).",
+          ),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+      },
+    },
+    async (input, extra) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await runDatabaseCommand({
+            command: input.command,
+            cwd,
+            captureOutput: true,
+            maxOutputBytes: defaultDatabaseCommandMaxOutputBytes,
+            signal: extra.signal,
+            timeoutMs: input.timeoutMs ?? defaultDatabaseCommandTimeoutMs,
+            dryRun: input.dryRun,
+          }),
+        ),
+      ),
+  );
+
+  server.registerTool(
+    "db_schema_sync",
+    {
+      description:
+        "Idempotently sync app-owned Drizzle schema re-exports for Beignet provider tables and return exactly the versioned beignet db schema sync --json result. Supports dry-run planning and never generates or applies SQL migrations.",
+      inputSchema: {
+        dialect: z
+          .enum(databaseSchemaDialectChoices)
+          .optional()
+          .describe(
+            "Drizzle dialect. Inferred from registered providers or drizzle.config.* when omitted.",
+          ),
+        tables: z
+          .array(z.enum(databaseSchemaTableChoices))
+          .min(1)
+          .optional()
+          .describe(
+            "Beignet provider tables to re-export. Defaults to audit, idempotency, and outbox.",
+          ),
+        output: z
+          .string()
+          .min(1)
+          .optional()
+          .describe(
+            "App-relative schema output. Defaults to infra/db/schema/beignet.ts.",
+          ),
+        dryRun: z
+          .boolean()
+          .optional()
+          .describe("Preview schema source changes without writing files."),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (input, extra) =>
+      safeToolResult(async () =>
+        jsonResult(
+          await syncDatabaseSchema({
+            cwd,
+            dialect: input.dialect,
+            tables: input.tables,
+            output: input.output,
+            dryRun: input.dryRun,
+            signal: extra.signal,
+          }),
+        ),
+      ),
+  );
+
   server.registerTool(
     "routes",
     {
@@ -363,7 +589,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "doctor",
     {
       description:
-        "Check app wiring and Beignet conventions, returning diagnostics, the detected convention, and applied fixes as JSON. Strict mode (the default) is the CI bar and includes CI-oriented warnings. Read-only; use doctor_fix to repair registration drift.",
+        "Check app wiring and Beignet conventions, returning diagnostics and the detected convention as JSON. Strict mode (the default) is the CI bar and includes CI-oriented warnings. Read-only; use doctor_fix_plan before a guarded doctor_fix repair.",
       inputSchema: {
         strict: z
           .boolean()
@@ -383,28 +609,82 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
       }),
   );
 
+  server.registerTool(
+    "doctor_fix_plan",
+    {
+      description:
+        "Plan every currently available low-risk doctor repair without changing files. Returns stable operation IDs, exact unified patches, file hashes, and a plan ID for guarded doctor_fix application.",
+      inputSchema: {
+        strict: z
+          .boolean()
+          .optional()
+          .describe("Include CI-oriented warnings. Defaults to true."),
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (input) =>
+      safeToolResult(async () => {
+        return jsonResult(
+          await planDoctorFixes({ cwd, strict: input.strict ?? true }),
+        );
+      }),
+  );
+
   server.registerTool(
     "doctor_fix",
     {
       description:
-        "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.",
+        "Apply low-risk doctor repairs, then re-check the app. With no planId, preserves the legacy apply-all behavior. Pass the planId returned by doctor_fix_plan for stale-file protection, optionally with fixIds to select repair operations.",
       inputSchema: {
         strict: z
           .boolean()
           .optional()
           .describe("Include CI-oriented warnings. Defaults to true."),
+        planId: z
+          .string()
+          .min(1)
+          .optional()
+          .describe("Plan ID returned by doctor_fix_plan."),
+        fixIds: z
+          .array(z.enum(doctorFixOperationIds))
+          .min(1)
+          .optional()
+          .describe("Repair operation IDs to apply. Requires planId."),
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
       },
     },
     async (input) =>
       safeToolResult(async () => {
         const strict = input.strict ?? true;
-        const fixes = await applyDoctorFixes({ cwd, strict });
-        const result = await inspectApp({ cwd, strict });
-        return jsonResult({
-          diagnostics: result.diagnostics,
-          convention: result.convention,
-          fixes,
-        });
+        if (input.fixIds && !input.planId) {
+          throw new Error(
+            "doctor_fix fixIds require planId from doctor_fix_plan.",
+          );
+        }
+        const applied = input.planId
+          ? await applyDoctorFixPlan({
+              cwd,
+              strict,
+              planId: input.planId,
+              ...(input.fixIds ? { fixIds: input.fixIds } : {}),
+            })
+          : await applyDoctorFixesWithResult({ cwd, strict });
+        return jsonResult(
+          createDoctorFixInspectionResult(
+            await inspectApp({ cwd, strict }),
+            applied,
+          ),
+        );
       }),
   );
 

package/src/preflight.ts

@@ -245,6 +245,20 @@ export async function runPreflight(
     }
   }
 
+  const inngestDev = env.INNGEST_DEV?.trim().toLowerCase();
+  if (
+    env.NODE_ENV === "production" &&
+    inngestDev !== undefined &&
+    !["", "0", "false"].includes(inngestDev)
+  ) {
+    findings.push({
+      severity: "error",
+      code: "BEIGNET_PREFLIGHT_INNGEST_DEV_IN_PRODUCTION",
+      message:
+        "INNGEST_DEV enables the local Inngest dev server and must be disabled in production.",
+    });
+  }
+
   const exampleSource = await readFileIfExists(
     path.join(options.cwd, ".env.example"),
   );