@hazeljs/cli 0.5.3 → 0.6.0

package/dist/utils/packages-registry.js

@@ -0,0 +1,371 @@
+"use strict";
+/**
+ * Single source of truth for all HazelJS package metadata.
+ * Used by: `hazel add`, `hazel new --interactive`, and `scaffoldPackageBoilerplate`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGES_BY_NAME = exports.HAZEL_PACKAGES = void 0;
+exports.findPackage = findPackage;
+exports.HAZEL_PACKAGES = [
+    {
+        shortName: 'ai',
+        npm: '@hazeljs/ai',
+        label: 'AI Integration (@hazeljs/ai)',
+        hint: 'import { AIModule } from "@hazeljs/ai";',
+        moduleImport: "import { AIModule } from '@hazeljs/ai';",
+        moduleExpression: 'AIModule',
+        setupTemplate: null,
+    },
+    {
+        shortName: 'agent',
+        npm: '@hazeljs/agent',
+        label: 'AI Agents (@hazeljs/agent)',
+        hint: 'import { AgentModule } from "@hazeljs/agent";',
+        moduleImport: "import { AgentModule } from '@hazeljs/agent';",
+        moduleExpression: 'AgentModule',
+        setupTemplate: null,
+    },
+    {
+        shortName: 'audit',
+        npm: '@hazeljs/audit',
+        label: 'Audit Logging (@hazeljs/audit)',
+        hint: 'import { AuditModule, ConsoleAuditTransport } from "@hazeljs/audit";\n  // AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })',
+        moduleImport: "import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';",
+        moduleExpression: "AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })",
+        setupTemplate: `import { AuditModule, ConsoleAuditTransport } from '@hazeljs/audit';
+
+// Add AuditModule.forRoot(...) to your HazelModule imports.
+export const auditImports = [AuditModule.forRoot({ transports: [new ConsoleAuditTransport()] })];
+`,
+    },
+    {
+        shortName: 'auth',
+        npm: '@hazeljs/auth',
+        label: 'Authentication (@hazeljs/auth)',
+        hint: 'import { JwtModule } from "@hazeljs/auth";\n  // JwtModule.forRoot({ secret: "your-secret", expiresIn: "1d" })',
+        moduleImport: "import { JwtModule } from '@hazeljs/auth';",
+        moduleExpression: "JwtModule.forRoot({ secret: process.env.JWT_SECRET || 'change-me', expiresIn: '1d' })",
+        setupTemplate: null,
+    },
+    {
+        shortName: 'oauth',
+        npm: '@hazeljs/oauth',
+        label: 'OAuth - Google/Microsoft/GitHub (@hazeljs/oauth)',
+        hint: 'import { OAuthModule } from "@hazeljs/oauth";\n  // OAuthModule.forRoot({ providers: { google: {...}, microsoft: {...}, github: {...} } })',
+        moduleImport: "import { OAuthModule } from '@hazeljs/oauth';",
+        moduleExpression: "OAuthModule.forRoot({ providers: { google: { clientId: process.env.GOOGLE_CLIENT_ID!, clientSecret: process.env.GOOGLE_CLIENT_SECRET!, redirectUri: process.env.OAUTH_REDIRECT_URI! } } })",
+        setupTemplate: `import { OAuthModule } from '@hazeljs/oauth';
+
+// Example (Google). Put secrets in env vars:
+// GOOGLE_CLIENT_ID=...
+// GOOGLE_CLIENT_SECRET=...
+// OAUTH_REDIRECT_URI=...
+export const oauthImports = [
+  OAuthModule.forRoot({
+    providers: {
+      google: {
+        clientId: process.env.GOOGLE_CLIENT_ID!,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+        redirectUri: process.env.OAUTH_REDIRECT_URI!,
+      },
+    },
+  }),
+];
+`,
+    },
+    {
+        shortName: 'cache',
+        npm: '@hazeljs/cache',
+        label: 'Caching (@hazeljs/cache)',
+        hint: 'import { CacheModule } from "@hazeljs/cache";',
+        moduleImport: "import { CacheModule } from '@hazeljs/cache';",
+        moduleExpression: 'CacheModule',
+        setupTemplate: null,
+    },
+    {
+        shortName: 'config',
+        npm: '@hazeljs/config',
+        label: 'Configuration (@hazeljs/config)',
+        hint: 'import { ConfigModule } from "@hazeljs/config";\n  // ConfigModule.forRoot({ envFilePath: ".env" })',
+        moduleImport: "import { ConfigModule } from '@hazeljs/config';",
+        moduleExpression: "ConfigModule.forRoot({ envFilePath: '.env' })",
+        setupTemplate: null,
+    },
+    {
+        shortName: 'cron',
+        npm: '@hazeljs/cron',
+        label: 'Cron Jobs (@hazeljs/cron)',
+        hint: 'import { CronModule } from "@hazeljs/cron";',
+        moduleImport: "import { CronModule } from '@hazeljs/cron';",
+        moduleExpression: 'CronModule',
+        setupTemplate: null,
+    },
+    {
+        shortName: 'data',
+        npm: '@hazeljs/data',
+        label: 'Data/ETL (@hazeljs/data)',
+        hint: 'import { DataModule } from "@hazeljs/data";',
+        moduleImport: "import { DataModule } from '@hazeljs/data';",
+        moduleExpression: 'DataModule.forRoot()',
+        setupTemplate: `import { DataModule } from '@hazeljs/data';
+
+// Add DataModule.forRoot() to your HazelModule imports.
+export const dataImports = [DataModule.forRoot()];
+`,
+    },
+    {
+        shortName: 'discovery',
+        npm: '@hazeljs/discovery',
+        label: 'Service Discovery (@hazeljs/discovery)',
+        hint: 'import { ServiceRegistry, DiscoveryClient } from "@hazeljs/discovery";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: null,
+    },
+    {
+        shortName: 'event-emitter',
+        npm: '@hazeljs/event-emitter',
+        label: 'Event Emitter (@hazeljs/event-emitter)',
+        hint: 'import { EventEmitterModule } from "@hazeljs/event-emitter";',
+        moduleImport: "import { EventEmitterModule } from '@hazeljs/event-emitter';",
+        moduleExpression: 'EventEmitterModule.forRoot()',
+        setupTemplate: `import { EventEmitterModule } from '@hazeljs/event-emitter';
+
+// Add EventEmitterModule.forRoot() to your HazelModule imports.
+export const eventEmitterImports = [EventEmitterModule.forRoot()];
+`,
+    },
+    {
+        shortName: 'gateway',
+        npm: '@hazeljs/gateway',
+        label: 'API Gateway (@hazeljs/gateway)',
+        hint: 'import { GatewayModule } from "@hazeljs/gateway";',
+        moduleImport: "import { GatewayModule } from '@hazeljs/gateway';",
+        moduleExpression: 'GatewayModule',
+        setupTemplate: `import { GatewayModule } from '@hazeljs/gateway';
+
+// Add GatewayModule to your HazelModule imports.
+export const gatewayImports = [GatewayModule];
+`,
+    },
+    {
+        shortName: 'guardrails',
+        npm: '@hazeljs/guardrails',
+        label: 'Guardrails (@hazeljs/guardrails)',
+        hint: 'import { GuardrailsModule } from "@hazeljs/guardrails";\n  // GuardrailsModule.forRoot({ redactPIIByDefault: true })',
+        moduleImport: "import { GuardrailsModule } from '@hazeljs/guardrails';",
+        moduleExpression: "GuardrailsModule.forRoot({ redactPIIByDefault: true })",
+        setupTemplate: null,
+    },
+    {
+        shortName: 'graphql',
+        npm: '@hazeljs/graphql',
+        label: 'GraphQL (@hazeljs/graphql)',
+        hint: 'import { GraphQLModule } from "@hazeljs/graphql";',
+        moduleImport: "import { GraphQLModule } from '@hazeljs/graphql';",
+        moduleExpression: 'GraphQLModule',
+        setupTemplate: `import { GraphQLModule } from '@hazeljs/graphql';
+
+// Add GraphQLModule to your HazelModule imports.
+export const graphqlImports = [GraphQLModule];
+`,
+    },
+    {
+        shortName: 'grpc',
+        npm: '@hazeljs/grpc',
+        label: 'gRPC (@hazeljs/grpc)',
+        hint: 'import { GrpcModule } from "@hazeljs/grpc";',
+        moduleImport: "import { GrpcModule } from '@hazeljs/grpc';",
+        moduleExpression: 'GrpcModule',
+        setupTemplate: `import { GrpcModule } from '@hazeljs/grpc';
+
+// Add GrpcModule to your HazelModule imports. Define services in your module.
+export const grpcImports = [GrpcModule];
+`,
+    },
+    {
+        shortName: 'kafka',
+        npm: '@hazeljs/kafka',
+        label: 'Kafka (@hazeljs/kafka)',
+        hint: 'import { KafkaModule } from "@hazeljs/kafka";',
+        moduleImport: "import { KafkaModule } from '@hazeljs/kafka';",
+        moduleExpression: 'KafkaModule',
+        setupTemplate: `import { KafkaModule } from '@hazeljs/kafka';
+
+// Add KafkaModule to your HazelModule imports and configure brokers via env/config.
+export const kafkaImports = [KafkaModule];
+`,
+    },
+    {
+        shortName: 'messaging',
+        npm: '@hazeljs/messaging',
+        label: 'Messaging - WhatsApp/Telegram (@hazeljs/messaging)',
+        hint: 'import { MessagingModule } from "@hazeljs/messaging";',
+        moduleImport: "import { MessagingModule } from '@hazeljs/messaging';",
+        moduleExpression: 'MessagingModule',
+        setupTemplate: `import { MessagingModule } from '@hazeljs/messaging';
+
+// Add MessagingModule to your HazelModule imports. Configure channels (WhatsApp/Telegram) via env/config.
+export const messagingImports = [MessagingModule];
+`,
+    },
+    {
+        shortName: 'ml',
+        npm: '@hazeljs/ml',
+        label: 'Machine Learning (@hazeljs/ml)',
+        hint: 'import { MLModule } from "@hazeljs/ml";',
+        moduleImport: "import { MLModule } from '@hazeljs/ml';",
+        moduleExpression: 'MLModule.forRoot()',
+        setupTemplate: `import { MLModule } from '@hazeljs/ml';
+
+// Add MLModule.forRoot() to your HazelModule imports.
+export const mlImports = [MLModule.forRoot()];
+`,
+    },
+    {
+        shortName: 'mcp',
+        npm: '@hazeljs/mcp',
+        label: 'MCP - Model Context Protocol (@hazeljs/mcp)',
+        hint: 'import { createMcpServer } from "@hazeljs/mcp";\n  // createMcpServer({ name, version, toolRegistry }).listenStdio();',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { createMcpServer } from '@hazeljs/mcp';
+
+// Minimal MCP server example:
+const server = createMcpServer({ name: 'hazel-mcp', version: '0.1.0' });
+server.start();
+`,
+    },
+    {
+        shortName: 'pdf-to-audio',
+        npm: '@hazeljs/pdf-to-audio',
+        label: 'PDF to Audio (@hazeljs/pdf-to-audio)',
+        hint: 'import { PdfToAudioModule } from "@hazeljs/pdf-to-audio";\n  // PdfToAudioModule converts PDFs to audio via TTS',
+        moduleImport: "import { PdfToAudioModule } from '@hazeljs/pdf-to-audio';",
+        moduleExpression: 'PdfToAudioModule',
+        setupTemplate: `import { PdfToAudioModule } from '@hazeljs/pdf-to-audio';
+
+// Add PdfToAudioModule to your HazelModule imports.
+export const pdfToAudioImports = [PdfToAudioModule];
+`,
+    },
+    {
+        shortName: 'prompts',
+        npm: '@hazeljs/prompts',
+        label: 'Prompts - typed templates (@hazeljs/prompts)',
+        hint: 'import { PromptTemplate, PromptRegistry } from "@hazeljs/prompts";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { PromptTemplate } from '@hazeljs/prompts';
+
+export const helloPrompt = new PromptTemplate({
+  name: 'hello',
+  template: 'Hello {{name}}',
+});
+`,
+    },
+    {
+        shortName: 'prisma',
+        npm: '@hazeljs/prisma',
+        label: 'Prisma ORM (@hazeljs/prisma)',
+        hint: 'import { PrismaModule } from "@hazeljs/prisma";',
+        moduleImport: "import { PrismaModule } from '@hazeljs/prisma';",
+        moduleExpression: 'PrismaModule',
+        setupTemplate: `import { PrismaModule } from '@hazeljs/prisma';
+
+// Add PrismaModule to your HazelModule imports.
+export const prismaImports = [PrismaModule];
+`,
+    },
+    {
+        shortName: 'typeorm',
+        npm: '@hazeljs/typeorm',
+        label: 'TypeORM (@hazeljs/typeorm)',
+        hint: 'import { TypeOrmModule } from "@hazeljs/typeorm";',
+        moduleImport: "import { TypeOrmModule } from '@hazeljs/typeorm';",
+        moduleExpression: 'TypeOrmModule',
+        setupTemplate: `import { TypeOrmModule } from '@hazeljs/typeorm';
+
+// Add TypeOrmModule to your HazelModule imports.
+export const typeormImports = [TypeOrmModule];
+`,
+    },
+    {
+        shortName: 'queue',
+        npm: '@hazeljs/queue',
+        label: 'Queue/BullMQ (@hazeljs/queue)',
+        hint: 'import { QueueModule } from "@hazeljs/queue";',
+        moduleImport: "import { QueueModule } from '@hazeljs/queue';",
+        moduleExpression: 'QueueModule',
+        setupTemplate: `import { QueueModule } from '@hazeljs/queue';
+
+// Add QueueModule to your HazelModule imports. Configure Redis / BullMQ via env/config.
+export const queueImports = [QueueModule];
+`,
+    },
+    {
+        shortName: 'rag',
+        npm: '@hazeljs/rag',
+        label: 'RAG/Vector Search (@hazeljs/rag)',
+        hint: 'import { RAGPipeline } from "@hazeljs/rag";',
+        moduleImport: "import { RAGModule } from '@hazeljs/rag';",
+        moduleExpression: 'RAGModule',
+        setupTemplate: null,
+    },
+    {
+        shortName: 'resilience',
+        npm: '@hazeljs/resilience',
+        label: 'Resilience - Circuit Breaker (@hazeljs/resilience)',
+        hint: 'import { CircuitBreaker, WithRetry, WithTimeout } from "@hazeljs/resilience";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: `import { CircuitBreaker, WithRetry } from '@hazeljs/resilience';
+
+export class ExampleResilienceService {
+  @WithRetry({ retries: 3 })
+  @CircuitBreaker({ failureThreshold: 5, resetTimeoutMs: 10000 })
+  async callRemote(): Promise<string> {
+    return 'ok';
+  }
+}
+`,
+    },
+    {
+        shortName: 'serverless',
+        npm: '@hazeljs/serverless',
+        label: 'Serverless (@hazeljs/serverless)',
+        hint: 'import { createLambdaHandler } from "@hazeljs/serverless";',
+        moduleImport: null,
+        moduleExpression: null,
+        setupTemplate: null,
+    },
+    {
+        shortName: 'swagger',
+        npm: '@hazeljs/swagger',
+        label: 'Swagger/OpenAPI (@hazeljs/swagger)',
+        hint: 'import { SwaggerModule } from "@hazeljs/swagger";',
+        moduleImport: "import { SwaggerModule } from '@hazeljs/swagger';",
+        moduleExpression: 'SwaggerModule',
+        setupTemplate: `import { SwaggerModule } from '@hazeljs/swagger';
+import { AppModule } from './app.module';
+
+// Setup Swagger once before creating your app:
+SwaggerModule.setRootModule(AppModule);
+`,
+    },
+    {
+        shortName: 'websocket',
+        npm: '@hazeljs/websocket',
+        label: 'WebSocket (@hazeljs/websocket)',
+        hint: 'import { WebSocketModule } from "@hazeljs/websocket";',
+        moduleImport: "import { WebSocketModule } from '@hazeljs/websocket';",
+        moduleExpression: 'WebSocketModule',
+        setupTemplate: null,
+    },
+];
+/** Lookup by short name (e.g. 'ai') or full npm name (e.g. '@hazeljs/ai') */
+function findPackage(nameOrNpm) {
+    return exports.HAZEL_PACKAGES.find((p) => p.shortName === nameOrNpm || p.npm === nameOrNpm);
+}
+/** Map of shortName → HazelPackageMeta for quick lookup */
+exports.PACKAGES_BY_NAME = Object.fromEntries(exports.HAZEL_PACKAGES.map((p) => [p.shortName, p]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cli",
-  "version": "0.5.3",
+  "version": "0.6.0",
   "description": "Command-line interface for scaffolding and generating HazelJS applications and components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,10 +22,8 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
-    "form-data": "^4.0.0",
     "inquirer": "^8.2.6",
-    "mustache": "^4.2.0",
-    "ora": "^5.4.1"
+    "mustache": "^4.2.0"
   },
   "devDependencies": {
     "@types/inquirer": "^8.2.6",
@@ -70,5 +68,5 @@
     "type": "opencollective",
     "url": "https://opencollective.com/hazeljs"
   },
-  "gitHead": "dd6ca4e3f2221c07b3b2c80c649ae8018b9c2526"
+  "gitHead": "27bc86031befce190871d3f07be4156544f37f94"
 }

package/dist/commands/build.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function buildCommand(program: Command): void;

package/dist/commands/build.js

@@ -1,52 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildCommand = buildCommand;
-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"));
-function buildCommand(program) {
-    program
-        .command('build')
-        .description('Build the HazelJS project')
-        .option('-w, --watch', 'Watch mode')
-        .option('-p, --production', 'Production build')
-        .action((options) => {
-        try {
-            const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
-            if (!fs_1.default.existsSync(packageJsonPath)) {
-                console.log(chalk_1.default.red('✗ No package.json found'));
-                console.log(chalk_1.default.gray('Run this command from your project root'));
-                process.exit(1);
-            }
-            const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
-            if (!packageJson.scripts?.build) {
-                console.log(chalk_1.default.yellow('⚠ No build script found in package.json'));
-                console.log(chalk_1.default.gray('\nAdd a build script to your package.json:'));
-                console.log(chalk_1.default.gray('  "scripts": {'));
-                console.log(chalk_1.default.gray('    "build": "tsc"'));
-                console.log(chalk_1.default.gray('  }'));
-                process.exit(1);
-            }
-            console.log(chalk_1.default.blue('🔨 Building project...\n'));
-            let command = 'npm run build';
-            if (options.watch) {
-                command = 'npm run build -- --watch';
-            }
-            if (options.production) {
-                process.env.NODE_ENV = 'production';
-            }
-            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
-            if (!options.watch) {
-                console.log(chalk_1.default.green('\n✓ Build completed successfully'));
-            }
-        }
-        catch {
-            console.error(chalk_1.default.red('\n✗ Build failed'));
-            process.exit(1);
-        }
-    });
-}

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runAgent(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateAgent(program: Command): void;

package/dist/commands/generate-agent.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runAgent = runAgent;
-exports.generateAgent = generateAgent;
-const generator_1 = require("../utils/generator");
-const AGENT_TEMPLATE = `import { Agent, Tool } from '@hazeljs/agent';
-
-@Agent({
-  name: '{{fileName}}',
-  description: '{{description}}',
-  systemPrompt: 'You are a helpful {{className}} agent.',
-  enableMemory: true,
-  enableRAG: true,
-})
-export class {{className}}Agent {
-  @Tool({
-    description: 'Example tool for {{fileName}}',
-    parameters: [
-      {
-        name: 'input',
-        type: 'string',
-        description: 'Input parameter',
-        required: true,
-      },
-    ],
-  })
-  async exampleTool(input: { input: string }): Promise<{ result: string }> {
-    // Implement your tool logic here
-    return {
-      result: \`Processed: \${input.input}\`,
-    };
-  }
-}
-`;
-class AgentGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'agent';
-    }
-    getDefaultTemplate() {
-        return AGENT_TEMPLATE;
-    }
-}
-async function runAgent(name, options) {
-    const generator = new AgentGenerator();
-    return generator.generate({
-        name,
-        path: options.path,
-        dryRun: options.dryRun,
-        data: { description: `A ${name} agent` },
-    });
-}
-function generateAgent(program) {
-    program
-        .command('agent <name>')
-        .description('Generate a new AI agent with @Agent and @Tool decorators')
-        .option('-p, --path <path>', 'Path where the agent should be generated')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runAgent(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

package/dist/commands/generate-agent.test.js

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_agent_1 = require("./generate-agent");
-jest.mock('fs');
-describe('generateAgent', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should generate an agent file with correct suffix', async () => {
-        (0, generate_agent_1.generateAgent)(program);
-        await program.parseAsync(['node', 'test', 'agent', 'research']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('research.agent.ts'), expect.stringContaining('ResearchAgent'));
-    });
-    it('should import from @hazeljs/agent', async () => {
-        (0, generate_agent_1.generateAgent)(program);
-        await program.parseAsync(['node', 'test', 'agent', 'research']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain("from '@hazeljs/agent'");
-        expect(writtenContent).toContain('@Agent');
-        expect(writtenContent).toContain('@Tool');
-    });
-});

package/dist/commands/generate-ai-service.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runAIService(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateAIService(program: Command): void;

package/dist/commands/generate-ai-service.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runAIService = runAIService;
-exports.generateAIService = generateAIService;
-const generator_1 = require("../utils/generator");
-const AI_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
-import { AIService, AIFunction, AIPrompt } from '@hazeljs/ai';
-
-@Service()
-export class {{className}}AIService {
-  constructor(private readonly aiService: AIService) {}
-
-  @AIFunction({
-    provider: 'openai',
-    model: 'gpt-4',
-    streaming: false,
-  })
-  async {{camelName}}Task(@AIPrompt() prompt: string): Promise<unknown> {
-    const result = await this.aiService.complete({
-      provider: 'openai',
-      model: 'gpt-4',
-      messages: [{ role: 'user', content: prompt }],
-    });
-
-    return result;
-  }
-}
-`;
-class AIServiceGenerator extends generator_1.Generator {
-    constructor() {
-        super(...arguments);
-        this.suffix = 'ai-service';
-    }
-    getDefaultTemplate() {
-        return AI_SERVICE_TEMPLATE;
-    }
-}
-async function runAIService(name, options) {
-    const generator = new AIServiceGenerator();
-    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
-}
-function generateAIService(program) {
-    program
-        .command('ai-service <name>')
-        .description('Generate a new AI service with decorators')
-        .alias('ai')
-        .option('-p, --path <path>', 'Path where the AI service should be generated')
-        .option('--dry-run', 'Preview files without writing them')
-        .option('--json', 'Output result as JSON')
-        .action(async (name, options) => {
-        const result = await runAIService(name, options);
-        (0, generator_1.printGenerateResult)(result, { json: options.json });
-    });
-}

package/dist/commands/generate-ai-service.test.d.ts

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

package/dist/commands/generate-ai-service.test.js

@@ -1,41 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const commander_1 = require("commander");
-const generate_ai_service_1 = require("./generate-ai-service");
-jest.mock('fs');
-describe('generateAIService', () => {
-    const mockFs = fs_1.default;
-    let program;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.writeFileSync.mockImplementation(() => { });
-        jest.spyOn(console, 'log').mockImplementation();
-        program = new commander_1.Command();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it('should register the ai-service command with alias', () => {
-        (0, generate_ai_service_1.generateAIService)(program);
-        const cmd = program.commands.find(c => c.name() === 'ai-service');
-        expect(cmd).toBeDefined();
-        expect(cmd?.alias()).toBe('ai');
-    });
-    it('should generate an AI service file with correct suffix', async () => {
-        (0, generate_ai_service_1.generateAIService)(program);
-        await program.parseAsync(['node', 'test', 'ai-service', 'chat']);
-        expect(mockFs.writeFileSync).toHaveBeenCalledWith(expect.stringContaining('chat.ai-service.ts'), expect.stringContaining('ChatAIService'));
-    });
-    it('should import from @hazeljs/ai', async () => {
-        (0, generate_ai_service_1.generateAIService)(program);
-        await program.parseAsync(['node', 'test', 'ai-service', 'chat']);
-        const writtenContent = mockFs.writeFileSync.mock.calls[0][1];
-        expect(writtenContent).toContain("from '@hazeljs/ai'");
-        expect(writtenContent).toContain('AIFunction');
-    });
-});

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
-export declare function runCache(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
-export declare function generateCache(command: Command): void;