fragment-ts 1.0.0

package/bin/frg.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { CLI } from '../src/cli/cli';
+
+const cli = new CLI();
+cli.run(process.argv.slice(2));

package/dist/app.d.ts

@@ -0,0 +1,15 @@
+import { Express } from 'express';
+import './controllers/health.controller';
+import './auth/auth.controller';
+import './services/health.service';
+import './repositories/user.repository';
+import './repositories/session.repository';
+import './auth/auth.service';
+import './core/openai/openai-client';
+export declare class FragmentApplication {
+    private app;
+    constructor();
+    initialize(): Promise<Express>;
+    private registerControllers;
+    getExpressApp(): Express;
+}

package/dist/app.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FragmentApplication = void 0;
+const express_1 = __importDefault(require("express"));
+const di_container_1 = require("./core/container/di-container");
+const config_loader_1 = require("./core/config/config-loader");
+const data_source_1 = require("./database/data-source");
+const logging_middleware_1 = require("./middlewares/logging.middleware");
+const auth_middleware_1 = require("./auth/auth.middleware");
+const controller_decorator_1 = require("./core/decorators/controller.decorator");
+const route_decorator_1 = require("./core/decorators/route.decorator");
+const auth_guard_decorator_1 = require("./core/decorators/auth-guard.decorator");
+const middleware_decorator_1 = require("./core/decorators/middleware.decorator");
+// Import all controllers, services, repositories
+require("./controllers/health.controller");
+require("./auth/auth.controller");
+require("./services/health.service");
+require("./repositories/user.repository");
+require("./repositories/session.repository");
+require("./auth/auth.service");
+require("./core/openai/openai-client");
+class FragmentApplication {
+    constructor() {
+        this.app = (0, express_1.default)();
+    }
+    async initialize() {
+        // Load configuration
+        config_loader_1.ConfigLoader.load(true);
+        // Initialize database
+        const dataSource = (0, data_source_1.initializeDataSource)();
+        await dataSource.initialize();
+        console.log('✅ Database connected');
+        // Middleware
+        this.app.use(express_1.default.json());
+        this.app.use(express_1.default.urlencoded({ extended: true }));
+        this.app.use(logging_middleware_1.loggingMiddleware);
+        // Register all controllers
+        this.registerControllers();
+        // Error handling
+        this.app.use((err, req, res, next) => {
+            console.error(err.stack);
+            res.status(500).json({ error: 'Internal server error' });
+        });
+        return this.app;
+    }
+    registerControllers() {
+        const registeredClasses = di_container_1.DIContainer.getRegisteredClasses();
+        registeredClasses.forEach((controllerClass) => {
+            const isController = Reflect.getMetadata(controller_decorator_1.CONTROLLER_METADATA, controllerClass);
+            if (!isController)
+                return;
+            const basePath = Reflect.getMetadata(controller_decorator_1.CONTROLLER_PATH, controllerClass) || '';
+            const routes = Reflect.getMetadata(route_decorator_1.ROUTE_METADATA, controllerClass) || [];
+            const classMiddlewares = Reflect.getMetadata(middleware_decorator_1.MIDDLEWARE_METADATA, controllerClass) || [];
+            const classAuthGuard = Reflect.getMetadata(auth_guard_decorator_1.AUTH_GUARD_METADATA, controllerClass);
+            const controllerInstance = di_container_1.DIContainer.resolve(controllerClass);
+            routes.forEach((route) => {
+                const fullPath = basePath + route.path;
+                const handler = controllerInstance[route.handlerName].bind(controllerInstance);
+                const middlewares = [...classMiddlewares];
+                const methodAuthGuard = Reflect.getMetadata(auth_guard_decorator_1.AUTH_GUARD_METADATA, controllerClass, route.handlerName);
+                if (classAuthGuard || methodAuthGuard) {
+                    middlewares.push(auth_middleware_1.authMiddleware);
+                }
+                const methodMiddlewares = Reflect.getMetadata(middleware_decorator_1.MIDDLEWARE_METADATA, controllerClass, route.handlerName) || [];
+                middlewares.push(...methodMiddlewares);
+                const asyncHandler = async (req, res, next) => {
+                    try {
+                        const result = await handler(req, res, next);
+                        if (result && !res.headersSent) {
+                            res.json(result);
+                        }
+                    }
+                    catch (error) {
+                        next(error);
+                    }
+                };
+                this.app[route.method](fullPath, ...middlewares, asyncHandler);
+                console.log(`📍 ${route.method.toUpperCase().padEnd(6)} ${fullPath}`);
+            });
+        });
+    }
+    getExpressApp() {
+        return this.app;
+    }
+}
+exports.FragmentApplication = FragmentApplication;

package/dist/auth/auth.controller.d.ts

@@ -0,0 +1,10 @@
+import { AuthService } from './auth.service';
+import { Request, Response } from 'express';
+export declare class AuthController {
+    private authService;
+    constructor(authService: AuthService);
+    register(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    login(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    logout(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+    getCurrentUser(req: Request, res: Response): Promise<Response<any, Record<string, any>>>;
+}

package/dist/auth/auth.controller.js

@@ -0,0 +1,87 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthController = void 0;
+const controller_decorator_1 = require("../core/decorators/controller.decorator");
+const route_decorator_1 = require("../core/decorators/route.decorator");
+const injectable_decorator_1 = require("../core/decorators/injectable.decorator");
+const autowire_decorator_1 = require("../core/decorators/autowire.decorator");
+const auth_guard_decorator_1 = require("../core/decorators/auth-guard.decorator");
+const auth_service_1 = require("./auth.service");
+let AuthController = class AuthController {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    async register(req, res) {
+        try {
+            const result = await this.authService.register(req.body);
+            return res.json(result);
+        }
+        catch (error) {
+            return res.status(400).json({ error: error.message });
+        }
+    }
+    async login(req, res) {
+        try {
+            const result = await this.authService.login(req.body);
+            return res.json(result);
+        }
+        catch (error) {
+            return res.status(401).json({ error: error.message });
+        }
+    }
+    async logout(req, res) {
+        const token = req.headers.authorization?.replace('Bearer ', '');
+        if (token) {
+            await this.authService.logout(token);
+        }
+        return res.json({ message: 'Logged out successfully' });
+    }
+    async getCurrentUser(req, res) {
+        return res.json({ user: req.user });
+    }
+};
+exports.AuthController = AuthController;
+__decorate([
+    (0, route_decorator_1.Post)('/register'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "register", null);
+__decorate([
+    (0, route_decorator_1.Post)('/login'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "login", null);
+__decorate([
+    (0, route_decorator_1.Post)('/logout'),
+    (0, auth_guard_decorator_1.AuthGuard)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "logout", null);
+__decorate([
+    (0, route_decorator_1.Get)('/me'),
+    (0, auth_guard_decorator_1.AuthGuard)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], AuthController.prototype, "getCurrentUser", null);
+exports.AuthController = AuthController = __decorate([
+    (0, controller_decorator_1.Controller)('/api/auth'),
+    (0, injectable_decorator_1.Injectable)(),
+    __param(0, (0, autowire_decorator_1.Autowire)()),
+    __metadata("design:paramtypes", [auth_service_1.AuthService])
+], AuthController);

package/dist/auth/auth.middleware.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare function authMiddleware(req: Request, res: Response, next: NextFunction): Promise<Response<any, Record<string, any>> | undefined>;

package/dist/auth/auth.middleware.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authMiddleware = authMiddleware;
+const di_container_1 = require("../core/container/di-container");
+const auth_service_1 = require("./auth.service");
+async function authMiddleware(req, res, next) {
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+    const token = authHeader.replace('Bearer ', '');
+    const authService = di_container_1.DIContainer.resolve(auth_service_1.AuthService);
+    try {
+        const user = await authService.validateToken(token);
+        if (!user) {
+            return res.status(401).json({ error: 'Invalid token' });
+        }
+        req.user = user;
+        next();
+    }
+    catch (error) {
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+}

package/dist/auth/auth.service.d.ts

@@ -0,0 +1,20 @@
+import { UserRepository } from '../repositories/user.repository';
+import { SessionRepository } from '../repositories/session.repository';
+import { LoginDTO, RegisterDTO } from './dto/login.dto';
+export declare class AuthService {
+    private userRepository;
+    private sessionRepository;
+    constructor(userRepository: UserRepository, sessionRepository: SessionRepository);
+    register(dto: RegisterDTO): Promise<{
+        user: any;
+        token: string;
+    }>;
+    login(dto: LoginDTO): Promise<{
+        user: any;
+        token: string;
+    }>;
+    logout(token: string): Promise<void>;
+    validateToken(token: string): Promise<any>;
+    private createSession;
+    private parseExpiry;
+}

package/dist/auth/auth.service.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const crypto = __importStar(require("crypto"));
+const bcrypt = __importStar(require("bcrypt"));
+const service_decorator_1 = require("../core/decorators/service.decorator");
+const autowire_decorator_1 = require("../core/decorators/autowire.decorator");
+const user_repository_1 = require("../repositories/user.repository");
+const session_repository_1 = require("../repositories/session.repository");
+const config_loader_1 = require("../core/config/config-loader");
+let AuthService = class AuthService {
+    constructor(userRepository, sessionRepository) {
+        this.userRepository = userRepository;
+        this.sessionRepository = sessionRepository;
+    }
+    async register(dto) {
+        const existingUser = await this.userRepository.findByEmail(dto.email);
+        if (existingUser) {
+            throw new Error('User already exists');
+        }
+        const passwordHash = await bcrypt.hash(dto.password, 10);
+        const user = await this.userRepository.create({
+            name: dto.name,
+            email: dto.email,
+            passwordHash
+        });
+        const token = await this.createSession(user.id);
+        return {
+            user: { id: user.id, name: user.name, email: user.email },
+            token
+        };
+    }
+    async login(dto) {
+        const user = await this.userRepository.findByEmail(dto.email);
+        if (!user) {
+            throw new Error('Invalid credentials');
+        }
+        const isValidPassword = await bcrypt.compare(dto.password, user.passwordHash);
+        if (!isValidPassword) {
+            throw new Error('Invalid credentials');
+        }
+        const token = await this.createSession(user.id);
+        return {
+            user: { id: user.id, name: user.name, email: user.email },
+            token
+        };
+    }
+    async logout(token) {
+        await this.sessionRepository.deleteByToken(token);
+    }
+    async validateToken(token) {
+        const session = await this.sessionRepository.findByToken(token);
+        if (!session) {
+            return null;
+        }
+        return {
+            id: session.user.id,
+            name: session.user.name,
+            email: session.user.email
+        };
+    }
+    async createSession(userId) {
+        const token = crypto.randomBytes(32).toString('hex');
+        const config = config_loader_1.ConfigLoader.get();
+        // Parse token expiry (e.g., "7d" = 7 days)
+        const expiryMs = this.parseExpiry(config.auth.tokenExpiry);
+        const expiresAt = new Date(Date.now() + expiryMs);
+        await this.sessionRepository.create({
+            token,
+            userId,
+            expiresAt
+        });
+        return token;
+    }
+    parseExpiry(expiry) {
+        const match = expiry.match(/^(\d+)([dhms])$/);
+        if (!match) {
+            return 7 * 24 * 60 * 60 * 1000; // default 7 days
+        }
+        const value = parseInt(match[1]);
+        const unit = match[2];
+        const multipliers = {
+            's': 1000,
+            'm': 60 * 1000,
+            'h': 60 * 60 * 1000,
+            'd': 24 * 60 * 60 * 1000
+        };
+        return value * multipliers[unit];
+    }
+};
+exports.AuthService = AuthService;
+exports.AuthService = AuthService = __decorate([
+    (0, service_decorator_1.Service)(),
+    __param(0, (0, autowire_decorator_1.Autowire)()),
+    __param(1, (0, autowire_decorator_1.Autowire)()),
+    __metadata("design:paramtypes", [user_repository_1.UserRepository,
+        session_repository_1.SessionRepository])
+], AuthService);

package/dist/auth/dto/login.dto.d.ts

@@ -0,0 +1,9 @@
+export interface LoginDTO {
+    email: string;
+    password: string;
+}
+export interface RegisterDTO {
+    name: string;
+    email: string;
+    password: string;
+}

package/dist/auth/dto/login.dto.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/cli.d.ts

@@ -0,0 +1,12 @@
+export declare class CLI {
+    private program;
+    private initCommand;
+    private generateCommand;
+    private configCommand;
+    private serveCommand;
+    private buildCommand;
+    private migrateCommand;
+    constructor();
+    private setupCommands;
+    run(args: string[]): void;
+}

package/dist/cli/cli.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const init_command_1 = require("./commands/init.command");
+const generate_command_1 = require("./commands/generate.command");
+const config_command_1 = require("./commands/config.command");
+const serve_command_1 = require("./commands/serve.command");
+const build_command_1 = require("./commands/build.command");
+const migrate_command_1 = require("./commands/migrate.command");
+const logger_1 = require("./utils/logger");
+class CLI {
+    constructor() {
+        this.program = new commander_1.Command();
+        this.initCommand = new init_command_1.InitCommand();
+        this.generateCommand = new generate_command_1.GenerateCommand();
+        this.configCommand = new config_command_1.ConfigCommand();
+        this.serveCommand = new serve_command_1.ServeCommand();
+        this.buildCommand = new build_command_1.BuildCommand();
+        this.migrateCommand = new migrate_command_1.MigrateCommand();
+        this.setupCommands();
+    }
+    setupCommands() {
+        this.program
+            .name('frg')
+            .description('Fragment Framework CLI - Build powerful TypeScript backends')
+            .version('1.0.0');
+        // ASCII Art Banner
+        this.program
+            .addHelpText('beforeAll', () => {
+            return chalk_1.default.cyan(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║   ███████╗██████╗  █████╗  ██████╗ ███╗   ███╗███████╗  ║
+║   ██╔════╝██╔══██╗██╔══██╗██╔════╝ ████╗ ████║██╔════╝  ║
+║   █████╗  ██████╔╝███████║██║  ███╗██╔████╔██║█████╗    ║
+║   ██╔══╝  ██╔══██╗██╔══██║██║   ██║██║╚██╔╝██║██╔══╝    ║
+║   ██║     ██║  ██║██║  ██║╚██████╔╝██║ ╚═╝ ██║███████╗  ║
+║   ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝╚══════╝  ║
+║                                                           ║
+║          TypeScript Backend Framework (v1.0.0)           ║
+╚═══════════════════════════════════════════════════════════╝
+`);
+        });
+        // Init command
+        this.program
+            .command('init [project-name]')
+            .description('Initialize a new Fragment project')
+            .action(async (projectName) => {
+            await this.initCommand.execute(projectName);
+        });
+        // Generate commands
+        const generate = this.program
+            .command('generate')
+            .alias('g')
+            .description('Generate application components');
+        generate
+            .command('controller [name]')
+            .alias('c')
+            .description('Generate a new controller')
+            .action(async (name) => {
+            await this.generateCommand.execute('controller', name);
+        });
+        generate
+            .command('service [name]')
+            .alias('s')
+            .description('Generate a new service')
+            .action(async (name) => {
+            await this.generateCommand.execute('service', name);
+        });
+        generate
+            .command('repository [name]')
+            .alias('r')
+            .description('Generate a new repository')
+            .action(async (name) => {
+            await this.generateCommand.execute('repository', name);
+        });
+        generate
+            .command('entity [name]')
+            .alias('e')
+            .description('Generate a new entity')
+            .action(async (name) => {
+            await this.generateCommand.execute('entity', name);
+        });
+        generate
+            .command('resource [name]')
+            .alias('res')
+            .description('Generate a complete resource (controller, service, repository, entity)')
+            .action(async (name) => {
+            await this.generateCommand.execute('resource', name);
+        });
+        // Config commands
+        const config = this.program
+            .command('config')
+            .description('Configure Fragment application');
+        config
+            .command('ai')
+            .description('Configure OpenAI integration')
+            .action(async () => {
+            await this.configCommand.execute('ai');
+        });
+        config
+            .command('db')
+            .alias('database')
+            .description('Configure database connection')
+            .action(async () => {
+            await this.configCommand.execute('db');
+        });
+        config
+            .command('show')
+            .description('Show current configuration')
+            .action(async () => {
+            await this.configCommand.execute('show');
+        });
+        // Serve command
+        this.program
+            .command('serve')
+            .alias('dev')
+            .description('Start development server')
+            .option('-p, --port <port>', 'Port number', parseInt)
+            .option('--no-watch', 'Disable file watching')
+            .action(async (options) => {
+            await this.serveCommand.execute(options);
+        });
+        // Build command
+        this.program
+            .command('build')
+            .description('Build application for production')
+            .action(async () => {
+            await this.buildCommand.execute();
+        });
+        // Migrate commands
+        const migrate = this.program
+            .command('migrate')
+            .alias('migration')
+            .description('Database migration commands');
+        migrate
+            .command('run')
+            .description('Run pending migrations')
+            .action(async () => {
+            await this.migrateCommand.execute('run');
+        });
+        migrate
+            .command('generate')
+            .alias('create')
+            .description('Generate a new migration')
+            .action(async () => {
+            await this.migrateCommand.execute('generate');
+        });
+        migrate
+            .command('revert')
+            .description('Revert last migration')
+            .action(async () => {
+            await this.migrateCommand.execute('revert');
+        });
+        migrate
+            .command('show')
+            .alias('status')
+            .description('Show migration status')
+            .action(async () => {
+            await this.migrateCommand.execute('show');
+        });
+        // Info command
+        this.program
+            .command('info')
+            .description('Display Fragment CLI information')
+            .action(() => {
+            logger_1.CLILogger.box('Fragment Framework CLI', [
+                'Version: 1.0.0',
+                'TypeScript Backend Framework',
+                'OOP + Decorators + DI',
+                '',
+                'Documentation: https://fragment-framework.dev',
+                'Repository: https://github.com/fragment/framework'
+            ]);
+        });
+    }
+    run(args) {
+        this.program.parse(['node', 'frg', ...args]);
+    }
+}
+exports.CLI = CLI;

package/dist/cli/commands/build.command.d.ts

@@ -0,0 +1,3 @@
+export declare class BuildCommand {
+    execute(): Promise<void>;
+}

package/dist/cli/commands/build.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildCommand = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+class BuildCommand {
+    async execute() {
+        logger_1.CLILogger.title('🔨 Building Fragment Application');
+        const spinner = logger_1.CLILogger.spinner('Compiling TypeScript...');
+        try {
+            (0, child_process_1.execSync)('tsc', { stdio: 'pipe' });
+            spinner.succeed('Build completed successfully');
+            logger_1.CLILogger.success('Output directory: ./dist');
+            logger_1.CLILogger.info('Run "node dist/server.js" to start the production server');
+        }
+        catch (error) {
+            spinner.fail('Build failed');
+            logger_1.CLILogger.error(error.message);
+            process.exit(1);
+        }
+    }
+}
+exports.BuildCommand = BuildCommand;

package/dist/cli/commands/config.command.d.ts

@@ -0,0 +1,6 @@
+export declare class ConfigCommand {
+    execute(target: string): Promise<void>;
+    private configureAI;
+    private configureDatabase;
+    private showConfig;
+}