@beignet/cli 0.0.21 → 0.0.23

package/src/make.ts

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import type { MakeFeatureAddon } from "./choices.js";
+import type { MakeFeatureAddon, MakeFeatureRecipe } from "./choices.js";
 import {
   type BeignetConfig,
   clientIndexPath,
@@ -33,8 +33,11 @@ type MakeResourceOptions = {
   softDelete?: boolean;
 };
 
-export type { MakeFeatureAddon } from "./choices.js";
-export { makeFeatureAddonChoices } from "./choices.js";
+export type { MakeFeatureAddon, MakeFeatureRecipe } from "./choices.js";
+export {
+  makeFeatureAddonChoices,
+  makeFeatureRecipeChoices,
+} from "./choices.js";
 
 type NormalizedMakeFeatureAddon =
   | "policy"
@@ -51,6 +54,7 @@ type NormalizedMakeFeatureAddon =
 
 type MakeFeatureOptions = MakeResourceOptions & {
   with?: readonly MakeFeatureAddon[];
+  recipe?: MakeFeatureRecipe;
 };
 
 type MakeContractOptions = {
@@ -490,17 +494,26 @@ export async function makeResource(
 export async function makeFeature(
   options: MakeFeatureOptions,
 ): Promise<MakeFeatureResult> {
-  const addons = normalizeMakeFeatureAddons(options.with ?? []);
+  const addons = normalizeMakeFeatureAddons([
+    ...makeFeatureRecipeAddons(options.recipe),
+    ...(options.with ?? []),
+    ...(options.events ? (["events"] as const) : []),
+  ]);
+  const featureOptions = {
+    ...options,
+    events: addons.includes("event"),
+  };
+
   if (addons.length === 0) {
-    return makeFeatureResource(options);
+    return makeFeatureResource(featureOptions);
   }
 
   if (options.dryRun) {
-    return makeFeatureSlice(options, addons);
+    return makeFeatureSlice(featureOptions, addons);
   }
 
-  await makeFeatureSlice({ ...options, dryRun: true }, addons);
-  return makeFeatureSlice(options, addons);
+  await makeFeatureSlice({ ...featureOptions, dryRun: true }, addons);
+  return makeFeatureSlice(featureOptions, addons);
 }
 
 export async function makePayments(
@@ -718,6 +731,15 @@ function resourceGenerationOptions(
   options: MakeResourceOptions,
   mode: ResourceGenerationMode,
 ): ResourceGenerationOptions {
+  if (mode === "feature") {
+    return {
+      auth: false,
+      tenant: false,
+      events: Boolean(options.events),
+      softDelete: false,
+    };
+  }
+
   if (mode !== "resource") {
     return { auth: false, tenant: false, events: false, softDelete: false };
   }
@@ -831,6 +853,28 @@ function normalizeMakeFeatureAddons(
   return featureAddonOrder.filter((addon) => normalized.has(addon));
 }
 
+function makeFeatureRecipeAddons(
+  recipe: MakeFeatureRecipe | undefined,
+): MakeFeatureAddon[] {
+  if (recipe === "full-slice") {
+    return [
+      "policy",
+      "factories",
+      "seeds",
+      "tasks",
+      "events",
+      "listeners",
+      "jobs",
+      "notifications",
+      "schedules",
+      "ui",
+      "uploads",
+    ];
+  }
+
+  return [];
+}
+
 const featureAddonOrder: readonly NormalizedMakeFeatureAddon[] = [
   "policy",
   "factory",
@@ -1462,8 +1506,11 @@ export async function makeListener(
   if (!options.skipEventAssert) {
     await assertListenerEventExists(targetDir, names.event, config);
   }
+  await updateListenerProviderWiring(targetDir, names, config, {
+    dryRun: true,
+  });
 
-  return makeFeatureArtifact({
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -1478,6 +1525,26 @@ export async function makeListener(
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  const providerResult = await updateListenerProviderWiring(
+    targetDir,
+    names,
+    config,
+    {
+      dryRun: Boolean(options.dryRun),
+    },
+  );
+  if (providerResult === "created")
+    result.createdFiles.push(providersFilePath(config));
+  if (providerResult === "updated")
+    result.updatedFiles.push(providersFilePath(config));
+  if (providerResult === "skipped")
+    result.skippedFiles.push(providersFilePath(config));
+  if (!result.files.includes(providersFilePath(config))) {
+    result.files.push(providersFilePath(config));
+  }
+
+  return result;
 }
 
 async function assertListenerEventExists(
@@ -1496,6 +1563,98 @@ async function assertListenerEventExists(
   }
 }
 
+async function updateListenerProviderWiring(
+  targetDir: string,
+  names: ListenerNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const providersFile = providersFilePath(config);
+  const filePath = path.join(targetDir, providersFile);
+  const original = await readOptionalFile(filePath);
+  if (original === undefined) {
+    throw new Error(
+      `Could not find the generated providers file ${providersFile}. Register listeners manually with registerListeners(...), or restore the generated providers file before running make listener.`,
+    );
+  }
+
+  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") {
+    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);
+  return "updated";
+}
+
 export async function makeSchedule(
   options: MakeScheduleOptions,
 ): Promise<MakeScheduleResult> {
@@ -1570,6 +1729,12 @@ const cronSecretEnvEntry = `\t\tCRON_SECRET: z.string().min(1).optional(),`;
 // slots in directly below it, matching the documented env shape.
 const cronSecretEnvAnchor = `\t\tAPP_URL: z.string().url().default("http://localhost:3000"),`;
 
+type FileChangeSet = {
+  createdFiles: string[];
+  updatedFiles: string[];
+  skippedFiles: string[];
+};
+
 type CronSecretWiringPlan = {
   files: Array<GeneratedFile & { result: "created" | "updated" }>;
   skippedFiles: string[];
@@ -1703,23 +1868,58 @@ async function updateOutboxPortWiring(
   targetDir: string,
   config: ResolvedBeignetConfig,
   options: { dryRun: boolean },
-): Promise<string[]> {
-  const updated = new Set<string>();
+): Promise<FileChangeSet> {
+  const changes: FileChangeSet = {
+    createdFiles: [],
+    updatedFiles: [],
+    skippedFiles: [],
+  };
 
   if (await updateOutboxPorts(targetDir, config, options)) {
-    updated.add(config.paths.ports);
+    changes.updatedFiles.push(config.paths.ports);
   }
   if (await updateOutboxInfrastructurePorts(targetDir, config, options)) {
-    updated.add(config.paths.infrastructurePorts);
+    changes.updatedFiles.push(config.paths.infrastructurePorts);
   }
   if (await updateOutboxDatabaseProvider(targetDir, config, options)) {
-    updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
+    changes.updatedFiles.push(
+      path.join(infrastructureDir(config), "db/provider.ts"),
+    );
   }
   if (await updateOutboxRepositoriesReturnType(targetDir, config, options)) {
-    updated.add(drizzleRepositoriesPath(config));
+    changes.updatedFiles.push(drizzleRepositoriesPath(config));
   }
 
-  return [...updated];
+  const schemaResult = await updateOutboxDrizzleSchema(
+    targetDir,
+    config,
+    options,
+  );
+  if (schemaResult.result === "created") {
+    changes.createdFiles.push(schemaResult.path);
+  }
+  if (schemaResult.result === "updated") {
+    changes.updatedFiles.push(schemaResult.path);
+  }
+  if (schemaResult.result === "skipped") {
+    changes.skippedFiles.push(schemaResult.path);
+  }
+  if (schemaResult.canExport) {
+    const schemaIndexUpdated = await updateOutboxDrizzleSchemaIndex(
+      targetDir,
+      config,
+      options,
+    );
+    if (schemaIndexUpdated) {
+      changes.updatedFiles.push(drizzleSchemaIndexPath(config));
+    }
+  }
+
+  return {
+    createdFiles: uniqueStrings(changes.createdFiles),
+    updatedFiles: uniqueStrings(changes.updatedFiles),
+    skippedFiles: uniqueStrings(changes.skippedFiles),
+  };
 }
 
 async function applyOutboxPortWiring(
@@ -1728,11 +1928,19 @@ async function applyOutboxPortWiring(
   config: ResolvedBeignetConfig,
   options: { dryRun: boolean },
 ): Promise<void> {
-  const updatedFiles = await updateOutboxPortWiring(targetDir, config, options);
-  for (const file of updatedFiles) {
+  const changes = await updateOutboxPortWiring(targetDir, config, options);
+  for (const file of changes.createdFiles) {
+    if (!result.createdFiles.includes(file)) result.createdFiles.push(file);
+    if (!result.files.includes(file)) result.files.push(file);
+  }
+  for (const file of changes.updatedFiles) {
     if (!result.updatedFiles.includes(file)) result.updatedFiles.push(file);
     if (!result.files.includes(file)) result.files.push(file);
   }
+  for (const file of changes.skippedFiles) {
+    if (!result.skippedFiles.includes(file)) result.skippedFiles.push(file);
+    if (!result.files.includes(file)) result.files.push(file);
+  }
 }
 
 async function updateOutboxPorts(
@@ -1862,6 +2070,61 @@ async function updateOutboxRepositoriesReturnType(
   return true;
 }
 
+async function updateOutboxDrizzleSchema(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<{
+  path: string;
+  result?: WriteGeneratedFileResult;
+  canExport: boolean;
+}> {
+  const indexPath = path.join(targetDir, drizzleSchemaIndexPath(config));
+  const schemaPath = outboxDrizzleSchemaFilePath(config);
+  const destination = path.join(targetDir, schemaPath);
+  if (!(await fileExists(indexPath))) {
+    return { path: schemaPath, canExport: false };
+  }
+
+  const database = await detectResourceDatabase(targetDir, config);
+  const content = outboxDrizzleSchemaFile(drizzleDialects[database]);
+  const existing = await readOptionalFile(destination);
+
+  if (existing === undefined) {
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, content);
+    }
+    return { path: schemaPath, result: "created", canExport: true };
+  }
+
+  if (
+    existing === content ||
+    /\bexport\s+const\s+outboxMessages\b/.test(existing)
+  ) {
+    return { path: schemaPath, result: "skipped", canExport: true };
+  }
+
+  return { path: schemaPath, result: "skipped", canExport: false };
+}
+
+async function updateOutboxDrizzleSchemaIndex(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, drizzleSchemaIndexPath(config));
+  if (!(await fileExists(filePath))) return false;
+
+  const original = await readFile(filePath, "utf8");
+  const exportLine = 'export { outboxMessages } from "./outbox-messages";';
+  if (original.includes(exportLine)) return false;
+
+  const next = `${original.trimEnd()}\n${exportLine}\n`;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
 function drizzleOutboxPortFactoryName(database: DatabaseName): string {
   if (database === "postgres") return "createDrizzlePostgresOutboxPort";
   if (database === "mysql") return "createDrizzleMysqlOutboxPort";
@@ -2267,11 +2530,12 @@ export async function makeOutbox(
   createdFiles.push(...cronSecretResult.createdFiles);
   updatedFiles.push(...cronSecretResult.updatedFiles);
   skippedFiles.push(...cronSecretResult.skippedFiles);
-  updatedFiles.push(
-    ...(await updateOutboxPortWiring(targetDir, config, {
-      dryRun: Boolean(options.dryRun),
-    })),
-  );
+  const outboxWiringResult = await updateOutboxPortWiring(targetDir, config, {
+    dryRun: Boolean(options.dryRun),
+  });
+  createdFiles.push(...outboxWiringResult.createdFiles);
+  updatedFiles.push(...outboxWiringResult.updatedFiles);
+  skippedFiles.push(...outboxWiringResult.skippedFiles);
 
   return {
     schemaVersion: 1,
@@ -2286,6 +2550,8 @@ export async function makeOutbox(
       config.paths.infrastructurePorts,
       path.join(infrastructureDir(config), "db/provider.ts"),
       drizzleRepositoriesPath(config),
+      outboxDrizzleSchemaFilePath(config),
+      drizzleSchemaIndexPath(config),
     ],
     createdFiles: uniqueStrings(createdFiles),
     updatedFiles: uniqueStrings(updatedFiles),
@@ -5456,9 +5722,14 @@ function featureUiComponentFiles(
   names: FeatureUiNames,
   config: ResolvedBeignetConfig,
 ): GeneratedFile[] {
+  const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
   const componentPath = featureUiComponentFilePath(names, config);
 
   return [
+    {
+      path: clientQueriesPath,
+      content: featureUiClientQueriesFile(names, config),
+    },
     {
       path: componentPath,
       content: featureUiComponentFile(names, config),
@@ -5721,6 +5992,15 @@ function drizzleResourceSchemaFilePath(
   );
 }
 
+function outboxDrizzleSchemaFilePath(config: ResolvedBeignetConfig): string {
+  return path.join(
+    infrastructureDir(config),
+    "db",
+    "schema",
+    "outbox-messages.ts",
+  );
+}
+
 function drizzleResourceRepositoryFilePath(
   names: ResourceNames,
   config: ResolvedBeignetConfig,
@@ -5826,6 +6106,20 @@ function featureUiDir(
   return path.join(resourceFeatureDir(names, config), "components");
 }
 
+function featureUiClientDir(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(resourceFeatureDir(names, config), "client");
+}
+
+function featureUiClientQueriesFilePath(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(featureUiClientDir(names, config), "queries.ts");
+}
+
 function featureUiComponentFilePath(
   names: FeatureUiNames,
   config: ResolvedBeignetConfig,
@@ -7285,6 +7579,78 @@ ${options.softDelete ? `\tdeletedAt: ${dialect.timestampColumn("deleted_at")},\n
 `;
 }
 
+function outboxDrizzleSchemaFile(dialect: DrizzleDialect): string {
+  if (dialect.subpath === "mysql") {
+    return `import { index, int, longtext, mysqlTable, varchar } from "drizzle-orm/mysql-core";
+
+export const outboxMessages = mysqlTable(
+\t"outbox_messages",
+\t{
+\t\tid: varchar("id", { length: 255 }).primaryKey(),
+\t\tkind: varchar("kind", { length: 32 }).notNull(),
+\t\tname: varchar("name", { length: 255 }).notNull(),
+\t\tpayloadJson: longtext("payload_json").notNull(),
+\t\tstatus: varchar("status", { length: 32 }).notNull(),
+\t\tattempts: int("attempts").notNull().default(0),
+\t\tmaxAttempts: int("max_attempts").notNull().default(3),
+\t\tavailableAt: varchar("available_at", { length: 32 }).notNull(),
+\t\tclaimedAt: varchar("claimed_at", { length: 32 }),
+\t\tlockedUntil: varchar("locked_until", { length: 32 }),
+\t\tclaimToken: varchar("claim_token", { length: 64 }),
+\t\tdeliveredAt: varchar("delivered_at", { length: 32 }),
+\t\tlastErrorJson: longtext("last_error_json"),
+\t\tcreatedAt: varchar("created_at", { length: 32 }).notNull(),
+\t\tupdatedAt: varchar("updated_at", { length: 32 }).notNull(),
+\t},
+\t(table) => ({
+\t\tavailableIdx: index("outbox_messages_available_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.availableAt,
+\t\t),
+\t\tlockedIdx: index("outbox_messages_locked_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.lockedUntil,
+\t\t),
+\t}),
+);
+`;
+  }
+
+  return `import { index, integer, ${dialect.tableFunction}, text } from "${dialect.columnModule}";
+
+export const outboxMessages = ${dialect.tableFunction}(
+\t"outbox_messages",
+\t{
+\t\tid: text("id").primaryKey(),
+\t\tkind: text("kind").notNull(),
+\t\tname: text("name").notNull(),
+\t\tpayloadJson: text("payload_json").notNull(),
+\t\tstatus: text("status").notNull(),
+\t\tattempts: integer("attempts").notNull().default(0),
+\t\tmaxAttempts: integer("max_attempts").notNull().default(3),
+\t\tavailableAt: text("available_at").notNull(),
+\t\tclaimedAt: text("claimed_at"),
+\t\tlockedUntil: text("locked_until"),
+\t\tclaimToken: text("claim_token"),
+\t\tdeliveredAt: text("delivered_at"),
+\t\tlastErrorJson: text("last_error_json"),
+\t\tcreatedAt: text("created_at").notNull(),
+\t\tupdatedAt: text("updated_at").notNull(),
+\t},
+\t(table) => ({
+\t\tavailableIdx: index("outbox_messages_available_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.availableAt,
+\t\t),
+\t\tlockedIdx: index("outbox_messages_locked_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.lockedUntil,
+\t\t),
+\t}),
+);
+`;
+}
+
 function drizzleResourceWhere(
   names: ResourceNames,
   options: ResourceGenerationOptions,
@@ -9569,30 +9935,31 @@ function featureUiComponentFile(
   names: FeatureUiNames,
   config: ResolvedBeignetConfig,
 ): string {
+  const componentPath = featureUiComponentFilePath(names, config);
+  const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
+
   return `"use client";
 
 import { contractErrorMessage } from "@beignet/core/client";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useState } from "react";
-import { rq } from "${aliasModule(clientIndexPath(config))}";
-import { create${names.singularPascal}, list${names.pluralPascal} } from "${aliasModule(
-    resourceContractFilePath(names, config),
-  )}";
+import {
+\tcreate${names.singularPascal}MutationOptions,
+\tinvalidate${names.pluralPascal},
+\tlist${names.pluralPascal}QueryOptions,
+} from "${relativeModule(componentPath, clientQueriesPath)}";
 
 export function ${names.componentExportName}() {
 \tconst [name, setName] = useState("");
 \tconst queryClient = useQueryClient();
-\tconst ${names.pluralCamel}Query = useQuery(
-\t\trq(list${names.pluralPascal}).queryOptions({ query: {} }),
-\t);
-\tconst create${names.singularPascal}Mutation = useMutation(
-\t\trq(create${names.singularPascal}).mutationOptions({
-\t\t\tonSuccess: async () => {
-\t\t\t\tsetName("");
-\t\t\t\tawait rq(list${names.pluralPascal}).invalidate(queryClient);
-\t\t\t},
-\t\t}),
-\t);
+\tconst ${names.pluralCamel}Query = useQuery(list${names.pluralPascal}QueryOptions());
+\tconst create${names.singularPascal}Mutation = useMutation({
+\t\t...create${names.singularPascal}MutationOptions(),
+\t\tonSuccess: async () => {
+\t\t\tsetName("");
+\t\t\tawait invalidate${names.pluralPascal}(queryClient);
+\t\t},
+\t});
 
 \treturn (
 \t\t<section className="${names.pluralKebab}-panel">
@@ -9660,6 +10027,34 @@ export function ${names.componentExportName}() {
 `;
 }
 
+function featureUiClientQueriesFile(
+  names: FeatureUiNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
+  const contractsPath = resourceContractFilePath(names, config);
+
+  return `import type { QueryClient } from "@tanstack/react-query";
+import { rq } from "${aliasModule(clientIndexPath(config))}";
+import {
+\tcreate${names.singularPascal},
+\tlist${names.pluralPascal},
+} from "${relativeModule(clientQueriesPath, contractsPath)}";
+
+export function list${names.pluralPascal}QueryOptions() {
+\treturn rq(list${names.pluralPascal}).queryOptions({ query: {} });
+}
+
+export function create${names.singularPascal}MutationOptions() {
+\treturn rq(create${names.singularPascal}).mutationOptions();
+}
+
+export function invalidate${names.pluralPascal}(queryClient: QueryClient) {
+\treturn rq(list${names.pluralPascal}).invalidate(queryClient);
+}
+`;
+}
+
 function scheduleRouteFile(
   names: ScheduleNames,
   config: ResolvedBeignetConfig,

package/src/mcp.ts

@@ -12,6 +12,7 @@ import {
   makeFactory,
   makeFeature,
   makeFeatureAddonChoices,
+  makeFeatureRecipeChoices,
   makeJob,
   makeListener,
   makeNotification,
@@ -76,6 +77,10 @@ const makeInputSchema = {
     .describe(
       "feature only: add feature-owned artifacts such as policy, factories, seeds, events, listeners, jobs, notifications, schedules, tasks, ui, and uploads.",
     ),
+  recipe: z
+    .enum(makeFeatureRecipeChoices)
+    .optional()
+    .describe("feature only: generate a named recipe such as full-slice."),
   event: z
     .string()
     .optional()
@@ -132,6 +137,7 @@ type MakeToolInput = {
   artifact: MakeArtifact;
   name?: string;
   with?: Array<(typeof makeFeatureAddonChoices)[number]>;
+  recipe?: (typeof makeFeatureRecipeChoices)[number];
   event?: string;
   cron?: string;
   timezone?: string;
@@ -216,7 +222,7 @@ async function runMakeTool(
     case "factory":
       return makeFactory(base);
     case "feature":
-      return makeFeature({ ...base, with: input.with });
+      return makeFeature({ ...base, with: input.with, recipe: input.recipe });
     case "job":
       return makeJob(base);
     case "listener":