@hazeljs/cli 0.5.4 → 0.6.0

package/dist/commands/add.js

@@ -6,130 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addCommand = addCommand;
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
 const inquirer_1 = __importDefault(require("inquirer"));
-const HAZEL_PACKAGES = {
-    ai: {
-        npm: '@hazeljs/ai',
-        hint: 'import { AIModule } from "@hazeljs/ai";',
-    },
-    agent: {
-        npm: '@hazeljs/agent',
-        hint: 'import { AgentModule } from "@hazeljs/agent";',
-    },
-    audit: {
-        npm: '@hazeljs/audit',
-        hint: 'import { AuditModule, ConsoleAuditTransport } from "@hazeljs/audit";\n  // AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })',
-    },
-    auth: {
-        npm: '@hazeljs/auth',
-        hint: 'import { JwtModule } from "@hazeljs/auth";\n  // JwtModule.forRoot({ secret: "your-secret", expiresIn: "1d" })',
-    },
-    oauth: {
-        npm: '@hazeljs/oauth',
-        hint: 'import { OAuthModule } from "@hazeljs/oauth";\n  // OAuthModule.forRoot({ providers: { google: {...}, microsoft: {...}, github: {...} } })',
-    },
-    cache: {
-        npm: '@hazeljs/cache',
-        hint: 'import { CacheModule } from "@hazeljs/cache";',
-    },
-    config: {
-        npm: '@hazeljs/config',
-        hint: 'import { ConfigModule } from "@hazeljs/config";\n  // ConfigModule.forRoot({ envFilePath: ".env" })',
-    },
-    cron: {
-        npm: '@hazeljs/cron',
-        hint: 'import { CronModule } from "@hazeljs/cron";',
-    },
-    data: {
-        npm: '@hazeljs/data',
-        hint: 'import { DataModule } from "@hazeljs/data";',
-    },
-    discovery: {
-        npm: '@hazeljs/discovery',
-        hint: 'import { ServiceRegistry, DiscoveryClient } from "@hazeljs/discovery";',
-    },
-    'event-emitter': {
-        npm: '@hazeljs/event-emitter',
-        hint: 'import { EventEmitterModule } from "@hazeljs/event-emitter";',
-    },
-    gateway: {
-        npm: '@hazeljs/gateway',
-        hint: 'import { GatewayModule } from "@hazeljs/gateway";',
-    },
-    guardrails: {
-        npm: '@hazeljs/guardrails',
-        hint: 'import { GuardrailsModule } from "@hazeljs/guardrails";\n  // GuardrailsModule.forRoot({ redactPIIByDefault: true })',
-    },
-    graphql: {
-        npm: '@hazeljs/graphql',
-        hint: 'import { GraphQLModule } from "@hazeljs/graphql";',
-    },
-    grpc: {
-        npm: '@hazeljs/grpc',
-        hint: 'import { GrpcModule } from "@hazeljs/grpc";',
-    },
-    kafka: {
-        npm: '@hazeljs/kafka',
-        hint: 'import { KafkaModule } from "@hazeljs/kafka";',
-    },
-    messaging: {
-        npm: '@hazeljs/messaging',
-        hint: 'import { MessagingModule } from "@hazeljs/messaging";',
-    },
-    mcp: {
-        npm: '@hazeljs/mcp',
-        hint: 'import { createMcpServer } from "@hazeljs/mcp";\n  // createMcpServer({ name, version, toolRegistry }).listenStdio();',
-    },
-    ml: {
-        npm: '@hazeljs/ml',
-        hint: 'import { MLModule } from "@hazeljs/ml";',
-    },
-    prompts: {
-        npm: '@hazeljs/prompts',
-        hint: 'import { PromptTemplate, PromptRegistry } from "@hazeljs/prompts";',
-    },
-    prisma: {
-        npm: '@hazeljs/prisma',
-        hint: 'import { PrismaModule } from "@hazeljs/prisma";',
-    },
-    typeorm: {
-        npm: '@hazeljs/typeorm',
-        hint: 'import { TypeOrmModule } from "@hazeljs/typeorm";',
-    },
-    queue: {
-        npm: '@hazeljs/queue',
-        hint: 'import { QueueModule } from "@hazeljs/queue";',
-    },
-    rag: {
-        npm: '@hazeljs/rag',
-        hint: 'import { RAGPipeline } from "@hazeljs/rag";',
-    },
-    resilience: {
-        npm: '@hazeljs/resilience',
-        hint: 'import { CircuitBreaker, WithRetry, WithTimeout } from "@hazeljs/resilience";',
-    },
-    'pdf-to-audio': {
-        npm: '@hazeljs/pdf-to-audio',
-        hint: 'import { PdfToAudioModule } from "@hazeljs/pdf-to-audio";\n  // PdfToAudioModule converts PDFs to audio via TTS',
-    },
-    serverless: {
-        npm: '@hazeljs/serverless',
-        hint: 'import { createLambdaHandler } from "@hazeljs/serverless";',
-    },
-    swagger: {
-        npm: '@hazeljs/swagger',
-        hint: 'import { SwaggerModule } from "@hazeljs/swagger";',
-    },
-    websocket: {
-        npm: '@hazeljs/websocket',
-        hint: 'import { WebSocketModule } from "@hazeljs/websocket";',
-    },
-};
+const packages_registry_1 = require("../utils/packages-registry");
+const generator_1 = require("../utils/generator");
 function addCommand(program) {
     program
         .command('add [package]')
-        .description('Add a HazelJS package to your project')
+        .description('Add a HazelJS package to your project (optionally generate a setup file with --setup)')
         .option('--dev', 'Install as dev dependency')
+        .option('--setup', 'Also generate a minimal setup/starter file in src/')
+        .option('--setup-path <path>', 'Path for the setup file', 'src')
         .action(async (packageName, options) => {
         try {
             let selectedPackage = packageName;
@@ -140,21 +28,21 @@ function addCommand(program) {
                         type: 'list',
                         name: 'package',
                         message: 'Which HazelJS package would you like to add?',
-                        choices: Object.keys(HAZEL_PACKAGES).map((key) => ({
-                            name: `${key} - ${HAZEL_PACKAGES[key].npm}`,
-                            value: key,
+                        choices: packages_registry_1.HAZEL_PACKAGES.map((p) => ({
+                            name: `${p.shortName} - ${p.npm}`,
+                            value: p.shortName,
                         })),
                     },
                 ]);
                 selectedPackage = pkg;
             }
             // Get the package info
-            const pkgInfo = HAZEL_PACKAGES[selectedPackage];
+            const pkgInfo = (0, packages_registry_1.findPackage)(selectedPackage);
             if (!pkgInfo) {
                 console.log(chalk_1.default.yellow(`Unknown package: ${selectedPackage}`));
                 console.log(chalk_1.default.gray('\nAvailable packages:'));
-                Object.keys(HAZEL_PACKAGES).forEach((key) => {
-                    console.log(chalk_1.default.gray(`  - ${key}: ${HAZEL_PACKAGES[key].npm}`));
+                packages_registry_1.HAZEL_PACKAGES.forEach((p) => {
+                    console.log(chalk_1.default.gray(`  - ${p.shortName}: ${p.npm}`));
                 });
                 return;
             }
@@ -163,10 +51,22 @@ function addCommand(program) {
             const command = `npm install ${pkgInfo.npm} ${devFlag}`.trim();
             (0, child_process_1.execSync)(command, { stdio: 'inherit' });
             console.log(chalk_1.default.green(`\n\u2713 Successfully installed ${pkgInfo.npm}`));
+            // Generate setup file if requested
+            if (options?.setup && pkgInfo.setupTemplate) {
+                const setupDir = path_1.default.join(process.cwd(), options.setupPath || 'src');
+                const setupFile = path_1.default.join(setupDir, `${(0, generator_1.toKebabCase)(pkgInfo.shortName)}.setup.ts`);
+                if (!fs_1.default.existsSync(setupDir))
+                    fs_1.default.mkdirSync(setupDir, { recursive: true });
+                fs_1.default.writeFileSync(setupFile, pkgInfo.setupTemplate);
+                console.log(chalk_1.default.green(`\u2713 Generated setup file: ${setupFile}`));
+            }
+            else if (options?.setup && !pkgInfo.setupTemplate) {
+                console.log(chalk_1.default.gray('\nNo setup template available for this package.'));
+            }
             // Show usage hints
             console.log(chalk_1.default.gray('\nUsage:'));
             console.log(chalk_1.default.gray(`  ${pkgInfo.hint}`));
-            console.log(chalk_1.default.gray(`\nDocumentation: https://hazeljs.ai/docs/packages/${selectedPackage}`));
+            console.log(chalk_1.default.gray(`\nDocumentation: https://hazeljs.ai/docs/packages/${pkgInfo.shortName}`));
         }
         catch (error) {
             console.error(chalk_1.default.red('Error installing package:'), error);

package/dist/commands/generate-app.js

@@ -12,6 +12,7 @@ const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
 const generator_1 = require("../utils/generator");
+const packages_registry_1 = require("../utils/packages-registry");
 function copyRecursiveSync(src, dest) {
     if (fs_1.default.existsSync(src)) {
         fs_1.default.mkdirSync(dest, { recursive: true });
@@ -61,7 +62,7 @@ function createSkeletonAtDest(destPath, appName, description) {
                 'lint:fix': 'eslint "src/**/*.ts" --fix',
                 format: 'prettier --write "src/**/*.ts"',
             },
-            dependencies: { '@hazeljs/core': '^0.2.0', 'reflect-metadata': '^0.2.2' },
+            dependencies: { '@hazeljs/core': '^0.2.0' },
             devDependencies: {
                 '@types/jest': '^29.5.12',
                 '@types/node': '^20.0.0',
@@ -78,8 +79,7 @@ function createSkeletonAtDest(destPath, appName, description) {
             },
         };
         fs_1.default.writeFileSync(path_1.default.join(destPath, 'package.json'), JSON.stringify(packageJson, null, 2));
-        const indexContent = `import 'reflect-metadata';
-import { HazelApp, HazelModule, Controller, Get } from '@hazeljs/core';
+        const indexContent = `import { HazelApp, HazelModule, Controller, Get } from '@hazeljs/core';
 
 @Controller('/')
 export class AppController {
@@ -134,114 +134,21 @@ function scaffoldPackageBoilerplate(destPath, packages) {
     // Always include the default HelloController
     imports.push("import { HelloController } from './hello.controller';");
     controllers.push('HelloController');
+    // Special handling for config: create .env files
     if (packages.includes('@hazeljs/config')) {
-        imports.push("import { ConfigModule } from '@hazeljs/config';");
-        moduleImports.push("ConfigModule.forRoot({ envFilePath: '.env' })");
-        // Create .env file
         fs_1.default.writeFileSync(path_1.default.join(destPath, '.env'), 'PORT=3000\nNODE_ENV=development\n');
         fs_1.default.writeFileSync(path_1.default.join(destPath, '.env.example'), 'PORT=3000\nNODE_ENV=development\n');
         console.log(chalk_1.default.green('  ✓ Created .env and .env.example'));
     }
-    if (packages.includes('@hazeljs/swagger')) {
-        imports.push("import { SwaggerModule } from '@hazeljs/swagger';");
-        moduleImports.push('SwaggerModule');
-    }
-    if (packages.includes('@hazeljs/prisma')) {
-        imports.push("import { PrismaModule } from '@hazeljs/prisma';");
-        moduleImports.push('PrismaModule');
-    }
-    if (packages.includes('@hazeljs/typeorm')) {
-        imports.push("import { TypeOrmModule } from '@hazeljs/typeorm';");
-        moduleImports.push('TypeOrmModule');
-    }
-    if (packages.includes('@hazeljs/audit')) {
-        imports.push("import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';");
-        moduleImports.push("AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })");
-    }
-    if (packages.includes('@hazeljs/auth')) {
-        imports.push("import { JwtModule } from '@hazeljs/auth';");
-        moduleImports.push("JwtModule.forRoot({ secret: process.env.JWT_SECRET || 'change-me', expiresIn: '1d' })");
-    }
-    if (packages.includes('@hazeljs/oauth')) {
-        imports.push("import { OAuthModule } from '@hazeljs/oauth';");
-        moduleImports.push("OAuthModule.forRoot({ providers: { google: { clientId: process.env.GOOGLE_CLIENT_ID!, clientSecret: process.env.GOOGLE_CLIENT_SECRET!, redirectUri: process.env.OAUTH_REDIRECT_URI! } } })");
-    }
-    if (packages.includes('@hazeljs/cache')) {
-        imports.push("import { CacheModule } from '@hazeljs/cache';");
-        moduleImports.push('CacheModule');
-    }
-    if (packages.includes('@hazeljs/cron')) {
-        imports.push("import { CronModule } from '@hazeljs/cron';");
-        moduleImports.push('CronModule');
-    }
-    if (packages.includes('@hazeljs/websocket')) {
-        imports.push("import { WebSocketModule } from '@hazeljs/websocket';");
-        moduleImports.push('WebSocketModule');
-    }
-    if (packages.includes('@hazeljs/ai')) {
-        imports.push("import { AIModule } from '@hazeljs/ai';");
-        moduleImports.push('AIModule');
-    }
-    if (packages.includes('@hazeljs/agent')) {
-        imports.push("import { AgentModule } from '@hazeljs/agent';");
-        moduleImports.push('AgentModule');
-    }
-    if (packages.includes('@hazeljs/rag')) {
-        imports.push("import { RAGModule } from '@hazeljs/rag';");
-        moduleImports.push('RAGModule');
-    }
-    if (packages.includes('@hazeljs/discovery')) {
-        // Discovery uses ServiceRegistry/DiscoveryClient programmatically - no module import
-    }
-    if (packages.includes('@hazeljs/prompts')) {
-        // Prompts is a library (PromptTemplate, PromptRegistry) - no module import
-    }
-    if (packages.includes('@hazeljs/mcp')) {
-        // MCP uses createMcpServer() programmatically - no module import
-    }
-    if (packages.includes('@hazeljs/pdf-to-audio')) {
-        imports.push("import { PdfToAudioModule } from '@hazeljs/pdf-to-audio';");
-        moduleImports.push('PdfToAudioModule');
-    }
-    if (packages.includes('@hazeljs/data')) {
-        imports.push("import { DataModule } from '@hazeljs/data';");
-        moduleImports.push('DataModule.forRoot()');
-    }
-    if (packages.includes('@hazeljs/event-emitter')) {
-        imports.push("import { EventEmitterModule } from '@hazeljs/event-emitter';");
-        moduleImports.push('EventEmitterModule.forRoot()');
-    }
-    if (packages.includes('@hazeljs/gateway')) {
-        imports.push("import { GatewayModule } from '@hazeljs/gateway';");
-        moduleImports.push('GatewayModule');
-    }
-    if (packages.includes('@hazeljs/graphql')) {
-        imports.push("import { GraphQLModule } from '@hazeljs/graphql';");
-        moduleImports.push('GraphQLModule');
-    }
-    if (packages.includes('@hazeljs/grpc')) {
-        imports.push("import { GrpcModule } from '@hazeljs/grpc';");
-        moduleImports.push('GrpcModule');
-    }
-    if (packages.includes('@hazeljs/kafka')) {
-        imports.push("import { KafkaModule } from '@hazeljs/kafka';");
-        moduleImports.push('KafkaModule');
-    }
-    if (packages.includes('@hazeljs/messaging')) {
-        imports.push("import { MessagingModule } from '@hazeljs/messaging';");
-        moduleImports.push('MessagingModule');
-    }
-    if (packages.includes('@hazeljs/ml')) {
-        imports.push("import { MLModule } from '@hazeljs/ml';");
-        moduleImports.push('MLModule.forRoot()');
-    }
-    if (packages.includes('@hazeljs/queue')) {
-        imports.push("import { QueueModule } from '@hazeljs/queue';");
-        moduleImports.push('QueueModule');
-    }
-    if (packages.includes('@hazeljs/resilience')) {
-        // Resilience is a library of decorators, not a module - no import needed in app.module
-        // User can import { CircuitBreaker, WithRetry } in their services
+    // Data-driven: derive imports from centralized registry
+    for (const npmName of packages) {
+        const meta = (0, packages_registry_1.findPackage)(npmName);
+        if (!meta)
+            continue;
+        if (meta.moduleImport)
+            imports.push(meta.moduleImport);
+        if (meta.moduleExpression)
+            moduleImports.push(meta.moduleExpression);
     }
     // Generate the enhanced app.module.ts
     const importsSection = moduleImports.length > 0
@@ -258,8 +165,7 @@ export class AppModule {}
     console.log(chalk_1.default.green('  ✓ Updated app.module.ts with package imports'));
     // Update index.ts / main.ts if swagger is selected
     if (packages.includes('@hazeljs/swagger')) {
-        const mainContent = `import 'reflect-metadata';
-import { HazelApp } from '@hazeljs/core';
+        const mainContent = `import { HazelApp } from '@hazeljs/core';
 import { SwaggerModule } from '@hazeljs/swagger';
 import { AppModule } from './app.module';
 
@@ -329,36 +235,7 @@ function generateApp(program) {
                         type: 'checkbox',
                         name: 'packages',
                         message: 'Select additional HazelJS packages to install:',
-                        choices: [
-                            { name: 'AI Integration (@hazeljs/ai)', value: '@hazeljs/ai' },
-                            { name: 'AI Agents (@hazeljs/agent)', value: '@hazeljs/agent' },
-                            { name: 'Audit Logging (@hazeljs/audit)', value: '@hazeljs/audit' },
-                            { name: 'Authentication (@hazeljs/auth)', value: '@hazeljs/auth' },
-                            { name: 'OAuth - Google/Microsoft/GitHub (@hazeljs/oauth)', value: '@hazeljs/oauth' },
-                            { name: 'Caching (@hazeljs/cache)', value: '@hazeljs/cache' },
-                            { name: 'Configuration (@hazeljs/config)', value: '@hazeljs/config' },
-                            { name: 'Cron Jobs (@hazeljs/cron)', value: '@hazeljs/cron' },
-                            { name: 'Data/ETL (@hazeljs/data)', value: '@hazeljs/data' },
-                            { name: 'Service Discovery (@hazeljs/discovery)', value: '@hazeljs/discovery' },
-                            { name: 'Event Emitter (@hazeljs/event-emitter)', value: '@hazeljs/event-emitter' },
-                            { name: 'API Gateway (@hazeljs/gateway)', value: '@hazeljs/gateway' },
-                            { name: 'GraphQL (@hazeljs/graphql)', value: '@hazeljs/graphql' },
-                            { name: 'gRPC (@hazeljs/grpc)', value: '@hazeljs/grpc' },
-                            { name: 'Kafka (@hazeljs/kafka)', value: '@hazeljs/kafka' },
-                            { name: 'Messaging - WhatsApp/Telegram (@hazeljs/messaging)', value: '@hazeljs/messaging' },
-                            { name: 'Machine Learning (@hazeljs/ml)', value: '@hazeljs/ml' },
-                            { name: 'MCP - Model Context Protocol (@hazeljs/mcp)', value: '@hazeljs/mcp' },
-                            { name: 'PDF to Audio (@hazeljs/pdf-to-audio)', value: '@hazeljs/pdf-to-audio' },
-                            { name: 'Prompts - typed templates (@hazeljs/prompts)', value: '@hazeljs/prompts' },
-                            { name: 'Prisma ORM (@hazeljs/prisma)', value: '@hazeljs/prisma' },
-                            { name: 'TypeORM (@hazeljs/typeorm)', value: '@hazeljs/typeorm' },
-                            { name: 'Queue/BullMQ (@hazeljs/queue)', value: '@hazeljs/queue' },
-                            { name: 'RAG/Vector Search (@hazeljs/rag)', value: '@hazeljs/rag' },
-                            { name: 'Resilience - Circuit Breaker (@hazeljs/resilience)', value: '@hazeljs/resilience' },
-                            { name: 'Serverless (@hazeljs/serverless)', value: '@hazeljs/serverless' },
-                            { name: 'Swagger/OpenAPI (@hazeljs/swagger)', value: '@hazeljs/swagger' },
-                            { name: 'WebSocket (@hazeljs/websocket)', value: '@hazeljs/websocket' },
-                        ],
+                        choices: packages_registry_1.HAZEL_PACKAGES.map((p) => ({ name: p.label, value: p.npm })),
                     },
                 ]);
                 projectConfig = { ...projectConfig, ...answers };
@@ -384,97 +261,7 @@ function generateApp(program) {
             }
             else {
                 console.log(chalk_1.default.yellow(`⚠ ${options.template} template not found, creating basic structure...`));
-                // Create basic structure
-                fs_1.default.mkdirSync(destPath, { recursive: true });
-                fs_1.default.mkdirSync(path_1.default.join(destPath, 'src'), { recursive: true });
-                // Create package.json
-                const packageJson = {
-                    name: projectConfig.name,
-                    version: '0.1.0',
-                    description: projectConfig.description,
-                    main: 'dist/index.js',
-                    scripts: {
-                        build: 'tsc',
-                        start: 'node dist/index.js',
-                        dev: 'ts-node-dev --respawn --transpile-only src/index.ts',
-                        test: 'jest',
-                        lint: 'eslint "src/**/*.ts"',
-                        'lint:fix': 'eslint "src/**/*.ts" --fix',
-                        format: 'prettier --write "src/**/*.ts"',
-                    },
-                    dependencies: {
-                        '@hazeljs/core': '^0.2.0',
-                        'reflect-metadata': '^0.2.2',
-                    },
-                    devDependencies: {
-                        '@types/jest': '^29.5.12',
-                        '@types/node': '^20.0.0',
-                        '@typescript-eslint/eslint-plugin': '^8.18.2',
-                        '@typescript-eslint/parser': '^8.18.2',
-                        'eslint': '^8.56.0',
-                        'eslint-config-prettier': '^9.1.0',
-                        'eslint-plugin-prettier': '^5.1.3',
-                        'jest': '^29.7.0',
-                        'prettier': '^3.2.5',
-                        'ts-jest': '^29.1.2',
-                        'ts-node-dev': '^2.0.0',
-                        'typescript': '^5.3.3',
-                    },
-                    author: projectConfig.author,
-                    license: projectConfig.license,
-                };
-                fs_1.default.writeFileSync(path_1.default.join(destPath, 'package.json'), JSON.stringify(packageJson, null, 2));
-                // Create basic index.ts
-                const indexContent = `import 'reflect-metadata';
-import { HazelApp, HazelModule, Controller, Get } from '@hazeljs/core';
-
-@Controller('/')
-export class AppController {
-  @Get()
-  hello() {
-    return { message: 'Hello from HazelJS!' };
-  }
-}
-
-@HazelModule({
-  controllers: [AppController],
-})
-export class AppModule {}
-
-async function bootstrap() {
-  const app = new HazelApp(AppModule);
-
-  app.enableCors({
-    origin: '*',
-    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
-  });
-
-  const port = parseInt(process.env.PORT || '3000', 10);
-  await app.listen(port);
-}
-
-bootstrap();
-`;
-                fs_1.default.writeFileSync(path_1.default.join(destPath, 'src', 'index.ts'), indexContent);
-                // Create tsconfig.json
-                const tsConfig = {
-                    compilerOptions: {
-                        target: 'ES2020',
-                        module: 'commonjs',
-                        lib: ['ES2020'],
-                        outDir: './dist',
-                        rootDir: './src',
-                        strict: true,
-                        esModuleInterop: true,
-                        skipLibCheck: true,
-                        forceConsistentCasingInFileNames: true,
-                        experimentalDecorators: true,
-                        emitDecoratorMetadata: true,
-                    },
-                    include: ['src/**/*'],
-                    exclude: ['node_modules', 'dist'],
-                };
-                fs_1.default.writeFileSync(path_1.default.join(destPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+                createSkeletonAtDest(destPath, projectConfig.name, projectConfig.description);
                 console.log(chalk_1.default.green('✓ Basic structure created'));
             }
             // Initialize git
@@ -531,7 +318,7 @@ coverage/
             }
             console.log(chalk_1.default.gray('  npm run dev'));
             console.log(chalk_1.default.gray('\nDocumentation: https://hazeljs.ai/docs'));
-            console.log(chalk_1.default.gray('Discord: https://discord.gg/xe495BvE\n'));
+            console.log(chalk_1.default.gray('Discord: https://discord.com/channels/1448263814238965833/1448263814859456575\n'));
         }
         catch (error) {
             console.error(chalk_1.default.red('\n✗ Failed to create project:'), error);

package/dist/commands/generate-simple.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Config-driven generator factory for simple single-file generators.
+ * Replaces 12+ individual generator files with one data-driven approach.
+ */
+import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export interface SimpleGeneratorConfig {
+    type: string;
+    description: string;
+    suffix: string;
+    template: string;
+    alias?: string;
+    defaultPath?: string;
+    nameRequired: boolean;
+    /** Extra template data injected at generation time */
+    extraData?: (name: string) => Record<string, string>;
+    /** Next steps shown after generation */
+    nextSteps?: string[];
+    /** Extra CLI options beyond --path, --dry-run, --json */
+    extraOptions?: string[];
+}
+export declare const SIMPLE_GENERATORS: SimpleGeneratorConfig[];
+export declare function runSimpleGenerator(config: SimpleGeneratorConfig, name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
+/** Register all simple generators as sub-commands of the generate command */
+export declare function registerSimpleGenerators(generateCommand: Command): void;
+/** Lookup a simple generator config by type */
+export declare function findSimpleGenerator(type: string): SimpleGeneratorConfig | undefined;