@fluojs/cli 1.0.0-beta.1

package/dist/commands/new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new.d.ts","sourceRoot":"","sources":["../../src/commands/new.ts"],"names":[],"mappings":"AAMA,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAUnF,OAAO,KAAK,EAAoB,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE3E,KAAK,SAAS,GAAG;IACf,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC,CAAC;AAuBF;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC5B,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAiSD;;;;GAIG;AACH,wBAAgB,QAAQ,IAAI,MAAM,CA0BjC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,wBAA6B,GAAG,OAAO,CAAC,MAAM,CAAC,CAiG3G"}

package/dist/commands/new.js

@@ -0,0 +1,353 @@
+import { resolve } from 'node:path';
+import { spinner as clackSpinner, log as clackLog } from '@clack/prompts';
+import { renderAliasList, renderHelpTable } from '../help.js';
+import { installDependencies } from '../new/install.js';
+import { collectBootstrapAnswers } from '../new/prompt.js';
+import { scaffoldBootstrapApp } from '../new/scaffold.js';
+import { SUPPORTED_BOOTSTRAP_PLATFORMS, SUPPORTED_BOOTSTRAP_RUNTIMES, SUPPORTED_BOOTSTRAP_SHAPES, SUPPORTED_BOOTSTRAP_TOOLING_PRESETS, SUPPORTED_BOOTSTRAP_TOPOLOGY_MODES, SUPPORTED_BOOTSTRAP_TRANSPORTS } from '../new/starter-profiles.js';
+function shouldUseInteractiveShell(runtime) {
+  return runtime.prompt === undefined && runtime.stdout === undefined && runtime.stderr === undefined && (runtime.interactive ?? true) && Boolean(runtime.stdin?.isTTY ?? process.stdin.isTTY);
+}
+function extractDependencyInstallationOutput(error) {
+  if (!(error instanceof Error) || !('output' in error)) {
+    return undefined;
+  }
+  const output = error.output;
+  return typeof output === 'string' && output.trim().length > 0 ? output : undefined;
+}
+function isHelpFlag(value) {
+  return value === '--help' || value === '-h';
+}
+
+/**
+ * Runtime dependency overrides for the programmatic `fluo new` entry point.
+ */
+
+const NEW_OPTION_HELP = [{
+  aliases: [],
+  description: 'Provide the project name without using the positional argument.',
+  option: '--name <project-name>'
+}, {
+  aliases: [],
+  description: 'Select the scaffold shape explicitly (application for HTTP, microservice for the transport-driven starter path, mixed for the API + microservice starter).',
+  option: '--shape <application|microservice|mixed>'
+}, {
+  aliases: [],
+  description: 'Select the transport path explicitly (http for applications, tcp for the runnable microservice starter, plus shipped microservice starter transports).',
+  option: '--transport <http|tcp|redis-streams|nats|kafka|rabbitmq|mqtt|grpc>'
+}, {
+  aliases: [],
+  description: 'Select the runtime explicitly (node, bun, deno, or cloudflare-workers for application starters; node for microservice and mixed starters).',
+  option: '--runtime <node|bun|deno|cloudflare-workers>'
+}, {
+  aliases: [],
+  description: 'Select the platform adapter explicitly (fastify, express, or nodejs on node; bun/deno/cloudflare-workers on their native runtimes; none for microservices).',
+  option: '--platform <fastify|express|nodejs|bun|deno|cloudflare-workers|none>'
+}, {
+  aliases: [],
+  description: 'Select the starter tooling preset explicitly (currently only standard).',
+  option: '--tooling <standard>'
+}, {
+  aliases: [],
+  description: 'Select the starter topology mode explicitly (currently only single-package).',
+  option: '--topology <single-package>'
+}, {
+  aliases: [],
+  description: 'Choose which package manager installs the starter dependencies.',
+  option: '--package-manager <pnpm|npm|yarn|bun>'
+}, {
+  aliases: [],
+  description: 'Write the new app to a custom target directory (always overrides positional name path).',
+  option: '--target-directory <path>'
+}, {
+  aliases: [],
+  description: 'Overwrite files in a non-empty target directory without prompting.',
+  option: '--force'
+}, {
+  aliases: [],
+  description: 'Install starter dependencies after writing files.',
+  option: '--install'
+}, {
+  aliases: [],
+  description: 'Skip starter dependency installation.',
+  option: '--no-install'
+}, {
+  aliases: [],
+  description: 'Initialize a git repository in the generated starter.',
+  option: '--git'
+}, {
+  aliases: [],
+  description: 'Skip git repository initialization in the generated starter.',
+  option: '--no-git'
+}, {
+  aliases: ['-h'],
+  description: 'Show help for the new command.',
+  option: '--help'
+}];
+const SUPPORTED_PACKAGE_MANAGERS = new Set(['bun', 'npm', 'pnpm', 'yarn']);
+const SUPPORTED_SHAPES = new Set(SUPPORTED_BOOTSTRAP_SHAPES);
+const SUPPORTED_TRANSPORTS = new Set(SUPPORTED_BOOTSTRAP_TRANSPORTS);
+const SUPPORTED_RUNTIMES = new Set(SUPPORTED_BOOTSTRAP_RUNTIMES);
+const SUPPORTED_PLATFORMS = new Set(SUPPORTED_BOOTSTRAP_PLATFORMS);
+const SUPPORTED_TOOLING_PRESETS = new Set(SUPPORTED_BOOTSTRAP_TOOLING_PRESETS);
+const SUPPORTED_TOPOLOGY_MODES = new Set(SUPPORTED_BOOTSTRAP_TOPOLOGY_MODES);
+function readOptionValue(argv, index, option) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('-')) {
+    throw new Error(`Expected ${option} to have a value.`);
+  }
+  return value;
+}
+function setBooleanSelection(currentValue, nextValue, positiveFlag, negativeFlag) {
+  if (currentValue !== undefined) {
+    throw new Error(`Duplicate ${nextValue ? positiveFlag : negativeFlag} option.`);
+  }
+  return nextValue;
+}
+function parseArgs(argv) {
+  const parsed = {};
+  let hasExplicitTargetDirectory = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    switch (arg) {
+      case '--name':
+        if (parsed.projectName) {
+          throw new Error('Duplicate --name option.');
+        }
+        parsed.projectName = readOptionValue(argv, index, '--name');
+        index += 1;
+        break;
+      case '--package-manager':
+        if (parsed.packageManager) {
+          throw new Error('Duplicate --package-manager option.');
+        }
+        parsed.packageManager = readOptionValue(argv, index, '--package-manager');
+        if (!SUPPORTED_PACKAGE_MANAGERS.has(parsed.packageManager)) {
+          throw new Error(`Invalid --package-manager value "${parsed.packageManager}". Use one of: pnpm, npm, yarn, bun.`);
+        }
+        index += 1;
+        break;
+      case '--shape':
+        if (parsed.shape) {
+          throw new Error('Duplicate --shape option.');
+        }
+        parsed.shape = readOptionValue(argv, index, '--shape');
+        if (!SUPPORTED_SHAPES.has(parsed.shape)) {
+          throw new Error(`Invalid --shape value "${parsed.shape}". Use one of: application, microservice, mixed.`);
+        }
+        index += 1;
+        break;
+      case '--transport':
+        if (parsed.transport) {
+          throw new Error('Duplicate --transport option.');
+        }
+        parsed.transport = readOptionValue(argv, index, '--transport');
+        if (!SUPPORTED_TRANSPORTS.has(parsed.transport)) {
+          throw new Error('Invalid --transport value "' + parsed.transport + '". Use one of: ' + 'http, tcp, redis-streams, nats, kafka, rabbitmq, mqtt, grpc.');
+        }
+        index += 1;
+        break;
+      case '--runtime':
+        if (parsed.runtime) {
+          throw new Error('Duplicate --runtime option.');
+        }
+        parsed.runtime = readOptionValue(argv, index, '--runtime');
+        if (!SUPPORTED_RUNTIMES.has(parsed.runtime)) {
+          throw new Error(`Invalid --runtime value "${parsed.runtime}". Use one of: bun, cloudflare-workers, deno, node.`);
+        }
+        index += 1;
+        break;
+      case '--platform':
+        if (parsed.platform) {
+          throw new Error('Duplicate --platform option.');
+        }
+        parsed.platform = readOptionValue(argv, index, '--platform');
+        if (!SUPPORTED_PLATFORMS.has(parsed.platform)) {
+          throw new Error('Invalid --platform value "' + parsed.platform + '". Use one of: bun, cloudflare-workers, deno, fastify, express, nodejs, none.');
+        }
+        index += 1;
+        break;
+      case '--tooling':
+        if (parsed.tooling) {
+          throw new Error('Duplicate --tooling option.');
+        }
+        parsed.tooling = readOptionValue(argv, index, '--tooling');
+        if (!SUPPORTED_TOOLING_PRESETS.has(parsed.tooling)) {
+          throw new Error(`Invalid --tooling value "${parsed.tooling}". Use: standard.`);
+        }
+        index += 1;
+        break;
+      case '--topology':
+        {
+          const topologyMode = readOptionValue(argv, index, '--topology');
+          if (parsed.topology) {
+            throw new Error('Duplicate --topology option.');
+          }
+          if (!SUPPORTED_TOPOLOGY_MODES.has(topologyMode)) {
+            throw new Error(`Invalid --topology value "${topologyMode}". Use: single-package.`);
+          }
+          parsed.topology = {
+            deferred: true,
+            mode: topologyMode
+          };
+          index += 1;
+          break;
+        }
+      case '--target-directory':
+        if (hasExplicitTargetDirectory) {
+          throw new Error('Duplicate --target-directory option.');
+        }
+        parsed.targetDirectory = readOptionValue(argv, index, '--target-directory');
+        hasExplicitTargetDirectory = true;
+        index += 1;
+        break;
+      case '--force':
+        parsed.force = true;
+        break;
+      case '--install':
+        parsed.installDependencies = setBooleanSelection(parsed.installDependencies, true, '--install', '--no-install');
+        break;
+      case '--no-install':
+        parsed.installDependencies = setBooleanSelection(parsed.installDependencies, false, '--install', '--no-install');
+        break;
+      case '--git':
+        parsed.initializeGit = setBooleanSelection(parsed.initializeGit, true, '--git', '--no-git');
+        break;
+      case '--no-git':
+        parsed.initializeGit = setBooleanSelection(parsed.initializeGit, false, '--git', '--no-git');
+        break;
+      default:
+        if (arg.startsWith('-')) {
+          throw new Error(`Unknown option for new command: ${arg}`);
+        }
+        if (parsed.projectName) {
+          throw new Error(`Unexpected positional argument: ${arg}`);
+        }
+        parsed.projectName = arg;
+        if (!hasExplicitTargetDirectory) {
+          parsed.targetDirectory = `./${arg}`;
+        }
+        break;
+    }
+  }
+  return parsed;
+}
+
+/**
+ * Renders CLI help text for `fluo new`.
+ *
+ * @returns Stable help output for the scaffolding command.
+ */
+export function newUsage() {
+  return ['Usage: fluo new|create [project-name] [options]', '', 'Options', renderHelpTable(NEW_OPTION_HELP, [{
+    header: 'Option',
+    render: entry => entry.option
+  }, {
+    header: 'Aliases',
+    render: entry => renderAliasList(entry.aliases)
+  }, {
+    header: 'Description',
+    render: entry => entry.description
+  }]), '', 'Next steps:', '  cd <app-name>', '  pnpm dev  # or npm run dev / yarn dev / bun run dev', '', 'Docs: https://github.com/fluojs/fluo/tree/main/docs/getting-started/quick-start.md'].join('\n');
+}
+
+/**
+ * Executes `fluo new` with parsed arguments and scaffold options.
+ *
+ * @example
+ * ```ts
+ * import { runNewCommand } from '@fluojs/cli';
+ *
+ * const exitCode = await runNewCommand(['starter-app', '--package-manager', 'pnpm'], {
+ *   cwd: '/workspace',
+ *   skipInstall: true,
+ * });
+ * ```
+ *
+ * @param argv Command arguments after the `new` or `create` token.
+ * @param runtime Optional runtime overrides for prompt resolution, stream output, and scaffold execution.
+ * @returns `0` when scaffolding succeeds, otherwise `1` after reporting the failure to `stderr`.
+ */
+export async function runNewCommand(argv, runtime = {}) {
+  const stdout = runtime.stdout ?? process.stdout;
+  const stderr = runtime.stderr ?? process.stderr;
+  try {
+    if (argv.some(isHelpFlag)) {
+      stdout.write(`${newUsage()}\n`);
+      return 0;
+    }
+    const parsed = parseArgs(argv);
+    const partialAnswers = {
+      ...parsed,
+      initializeGit: parsed.initializeGit ?? runtime.initializeGit,
+      installDependencies: parsed.installDependencies ?? runtime.installDependencies ?? (runtime.skipInstall === true ? false : undefined)
+    };
+    if (!partialAnswers.projectName && !(runtime.interactive ?? runtime.prompt ?? runtime.stdin?.isTTY ?? process.stdin.isTTY)) {
+      throw new Error(newUsage());
+    }
+    const answers = await collectBootstrapAnswers(partialAnswers, runtime.cwd ?? process.cwd(), runtime.userAgent, {
+      interactive: runtime.interactive,
+      prompt: runtime.prompt,
+      stdin: runtime.stdin,
+      stdout
+    });
+    const targetDirectory = resolve(runtime.cwd ?? process.cwd(), answers.targetDirectory);
+    const options = {
+      ...answers,
+      dependencySource: runtime.dependencySource,
+      force: parsed.force ?? runtime.force,
+      initializeGit: answers.initializeGit,
+      installDependencies: false,
+      repoRoot: runtime.repoRoot,
+      skipInstall: true,
+      targetDirectory
+    };
+    const isInteractiveShell = shouldUseInteractiveShell(runtime);
+    let scaffoldSpinner;
+    if (!answers.installDependencies && !isInteractiveShell) {
+      stdout.write('Skipping dependency installation.\n');
+    }
+    if (isInteractiveShell) {
+      scaffoldSpinner = clackSpinner();
+      scaffoldSpinner.start('Scaffolding project files');
+    }
+    await scaffoldBootstrapApp(options);
+    if (scaffoldSpinner) {
+      scaffoldSpinner.stop('Project files written');
+    }
+    if (answers.installDependencies) {
+      if (!isInteractiveShell) {
+        stdout.write(`Installing dependencies with ${answers.packageManager}...\n`);
+        await installDependencies(targetDirectory, answers.packageManager, {
+          stderr
+        });
+      } else {
+        const installSpinner = clackSpinner();
+        installSpinner.start(`Installing dependencies with ${answers.packageManager}`);
+        try {
+          await installDependencies(targetDirectory, answers.packageManager, {
+            stderr,
+            stdio: 'capture'
+          });
+          installSpinner.stop('Dependencies installed');
+        } catch (error) {
+          installSpinner.error('Dependency installation failed');
+          const output = extractDependencyInstallationOutput(error);
+          if (output) {
+            stderr.write(`\n[fluo] Full installation log:\n${output}${output.endsWith('\n') ? '' : '\n'}`);
+          }
+          throw error;
+        }
+      }
+    } else if (isInteractiveShell) {
+      clackLog.step('Dependency installation skipped');
+    }
+    stdout.write('Done.\n');
+    stdout.write(`Next steps:\n  cd ${answers.targetDirectory}\n  ${answers.packageManager === 'npm' ? 'npm run dev' : answers.packageManager === 'bun' ? 'bun run dev' : `${answers.packageManager} dev`}\n`);
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    stderr.write(`${message}\n`);
+    return 1;
+  }
+}

package/dist/generator-types.d.ts

@@ -0,0 +1,21 @@
+/** Describes one file emitted by a generator factory before it is written to disk. */
+export interface GeneratedFile {
+    content: string;
+    path: string;
+}
+/** Optional generation flags that influence overwrite behavior and sibling-aware templates. */
+export interface GenerateOptions {
+    force?: boolean;
+    hasRepo?: boolean;
+    hasService?: boolean;
+}
+/**
+ * Produces the in-memory files for one schematic/resource pair.
+ */
+export type GeneratorFactory = (name: string, options?: GenerateOptions) => GeneratedFile[];
+/** Registry shape used by generator manifests to bind a factory to CLI metadata. */
+export interface GeneratorRegistration {
+    factory: GeneratorFactory;
+    description?: string;
+}
+//# sourceMappingURL=generator-types.d.ts.map

package/dist/generator-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator-types.d.ts","sourceRoot":"","sources":["../src/generator-types.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,+FAA+F;AAC/F,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,aAAa,EAAE,CAAC;AAE5F,oFAAoF;AACpF,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/generator-types.js

@@ -0,0 +1 @@
+export {};

package/dist/generators/controller.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateOptions, GeneratedFile } from '../types.js';
+export declare function generateControllerFiles(name: string, options?: GenerateOptions): GeneratedFile[];
+//# sourceMappingURL=controller.d.ts.map

package/dist/generators/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/generators/controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKlE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,aAAa,EAAE,CAkBpG"}

package/dist/generators/controller.js

@@ -0,0 +1,22 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateControllerFiles(name, options = {}) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}Controller`;
+  const service = `${resource}Service`;
+  const vars = {
+    hasService: options.hasService ?? false,
+    kebab,
+    resource,
+    pascal,
+    service
+  };
+  return [{
+    content: renderTemplate('controller.ts.ejs', vars),
+    path: `${kebab}.controller.ts`
+  }, {
+    content: renderTemplate('controller.test.ts.ejs', vars),
+    path: `${kebab}.controller.test.ts`
+  }];
+}

package/dist/generators/guard.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedFile } from '../types.js';
+export declare function generateGuardFiles(name: string): GeneratedFile[];
+//# sourceMappingURL=guard.d.ts.map

package/dist/generators/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/generators/guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAShE"}

package/dist/generators/guard.js

@@ -0,0 +1,15 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateGuardFiles(name) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}Guard`;
+  return [{
+    content: renderTemplate('guard.ts.ejs', {
+      kebab,
+      resource,
+      pascal
+    }),
+    path: `${kebab}.guard.ts`
+  }];
+}

package/dist/generators/interceptor.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedFile } from '../types.js';
+export declare function generateInterceptorFiles(name: string): GeneratedFile[];
+//# sourceMappingURL=interceptor.d.ts.map

package/dist/generators/interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../../src/generators/interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAStE"}

package/dist/generators/interceptor.js

@@ -0,0 +1,15 @@
+import { renderTemplate } from './render.js';
+import { toKebabCase, toPascalCase } from './utils.js';
+export function generateInterceptorFiles(name) {
+  const kebab = toKebabCase(name);
+  const resource = toPascalCase(name);
+  const pascal = `${resource}Interceptor`;
+  return [{
+    content: renderTemplate('interceptor.ts.ejs', {
+      kebab,
+      resource,
+      pascal
+    }),
+    path: `${kebab}.interceptor.ts`
+  }];
+}

package/dist/generators/manifest.d.ts

@@ -0,0 +1,121 @@
+import type { GeneratorFactory } from '../generator-types.js';
+export type ModuleArrayKey = 'controllers' | 'providers' | 'middleware';
+type ModuleRegistrationDescriptor = {
+    arrayKey: ModuleArrayKey;
+    classSuffix: string;
+};
+export type GeneratorManifestEntry = {
+    aliases: readonly string[];
+    description: string;
+    factory: GeneratorFactory;
+    kind: string;
+    moduleRegistration?: ModuleRegistrationDescriptor;
+    nextStepHint: string;
+    registryAliases?: readonly string[];
+    schematic: string;
+    wiringBehavior: 'auto-registered' | 'files-only';
+};
+export declare const generatorManifest: readonly [{
+    readonly aliases: readonly ["co"];
+    readonly description: "Generate a controller (auto-registered in the module controllers array).";
+    readonly factory: (name: string, options: import("../generator-types.js").GenerateOptions | undefined) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "controller";
+    readonly moduleRegistration: {
+        readonly arrayKey: "controllers";
+        readonly classSuffix: "Controller";
+    };
+    readonly nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then add route handlers.";
+    readonly schematic: "controller";
+    readonly wiringBehavior: "auto-registered";
+}, {
+    readonly aliases: readonly ["gu"];
+    readonly description: "Generate a guard (auto-registered as a provider in the module).";
+    readonly factory: (name: string) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "guard";
+    readonly moduleRegistration: {
+        readonly arrayKey: "providers";
+        readonly classSuffix: "Guard";
+    };
+    readonly nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then apply the guard to routes.";
+    readonly schematic: "guard";
+    readonly wiringBehavior: "auto-registered";
+}, {
+    readonly aliases: readonly ["in"];
+    readonly description: "Generate an interceptor (auto-registered as a provider in the module).";
+    readonly factory: (name: string) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "interceptor";
+    readonly moduleRegistration: {
+        readonly arrayKey: "providers";
+        readonly classSuffix: "Interceptor";
+    };
+    readonly nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then bind the interceptor to routes.";
+    readonly schematic: "interceptor";
+    readonly wiringBehavior: "auto-registered";
+}, {
+    readonly aliases: readonly ["mi"];
+    readonly description: "Generate a middleware (auto-registered in the module middleware array).";
+    readonly factory: (name: string) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "middleware";
+    readonly moduleRegistration: {
+        readonly arrayKey: "middleware";
+        readonly classSuffix: "Middleware";
+    };
+    readonly nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then configure route matching in forRoutes.";
+    readonly schematic: "middleware";
+    readonly wiringBehavior: "auto-registered";
+}, {
+    readonly aliases: readonly ["mo"];
+    readonly description: "Generate a standalone module (import it in a parent module to activate).";
+    readonly factory: (name: string) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "module";
+    readonly nextStepHint: "Import the new module in a parent module's imports array, then run 'pnpm typecheck'.";
+    readonly schematic: "module";
+    readonly wiringBehavior: "files-only";
+}, {
+    readonly aliases: readonly ["repo"];
+    readonly description: "Generate a persistence-agnostic repository (auto-registered as a provider).";
+    readonly factory: (name: string, options: import("../generator-types.js").GenerateOptions | undefined) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "repo";
+    readonly moduleRegistration: {
+        readonly arrayKey: "providers";
+        readonly classSuffix: "Repo";
+    };
+    readonly nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then add data-access methods to the repo stub.";
+    readonly registryAliases: readonly ["repository"];
+    readonly schematic: "repository";
+    readonly wiringBehavior: "auto-registered";
+}, {
+    readonly aliases: readonly ["req"];
+    readonly description: "Generate a request DTO for route-level data binding and validation (files only — wire it into a controller manually).";
+    readonly factory: (name: string) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "request-dto";
+    readonly nextStepHint: "Import the DTO in a controller and add it as a parameter with @FromBody or @FromQuery.";
+    readonly schematic: "request-dto";
+    readonly wiringBehavior: "files-only";
+}, {
+    readonly aliases: readonly ["res"];
+    readonly description: "Generate a response DTO for typed response payloads (files only — use it as a controller return type).";
+    readonly factory: (name: string) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "response-dto";
+    readonly nextStepHint: "Import the DTO in a controller and use it as the return type for route handlers.";
+    readonly schematic: "response-dto";
+    readonly wiringBehavior: "files-only";
+}, {
+    readonly aliases: readonly ["s"];
+    readonly description: "Generate a service (auto-registered as a provider in the module).";
+    readonly factory: (name: string, options: import("../generator-types.js").GenerateOptions | undefined) => import("../generator-types.js").GeneratedFile[];
+    readonly kind: "service";
+    readonly moduleRegistration: {
+        readonly arrayKey: "providers";
+        readonly classSuffix: "Service";
+    };
+    readonly nextStepHint: "Run 'pnpm typecheck' to verify module wiring, then implement business logic.";
+    readonly schematic: "service";
+    readonly wiringBehavior: "auto-registered";
+}];
+export type GeneratorKind = (typeof generatorManifest)[number]['kind'];
+export type GeneratorDefinition = (typeof generatorManifest)[number];
+export declare function findGeneratorDefinition(kind: GeneratorKind): GeneratorDefinition;
+export declare function resolveGeneratorKind(value: string | undefined): GeneratorKind | undefined;
+export {};
+//# sourceMappingURL=manifest.d.ts.map

package/dist/generators/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/generators/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAY9D,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,WAAW,GAAG,YAAY,CAAC;AAExE,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,CAAC,EAAE,4BAA4B,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,iBAAiB,GAAG,YAAY,CAAC;CAClD,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyFwB,CAAC;AAEvD,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AACvE,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAcrE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,aAAa,GAAG,mBAAmB,CAOhF;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,CAMzF"}