fragment-ts 1.0.0

package/dist/cli/templates/service.template.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceTemplate = serviceTemplate;
+function serviceTemplate(name) {
+    const className = name.endsWith('Service') ? name : `${name}Service`;
+    const repoName = name.replace('Service', '') + 'Repository';
+    return `import { Service } from '../core/decorators/service.decorator';
+import { Autowire } from '../core/decorators/autowire.decorator';
+import { ${repoName} } from '../repositories/${name.toLowerCase()}.repository';
+
+@Service()
+export class ${className} {
+  constructor(
+    @Autowire() private ${repoName.charAt(0).toLowerCase() + repoName.slice(1)}: ${repoName}
+  ) {}
+
+  async findAll() {
+    // Implement business logic
+    return [];
+  }
+
+  async findById(id: number) {
+    // Implement business logic
+    return null;
+  }
+
+  async create(data: any) {
+    // Implement business logic
+    return data;
+  }
+
+  async update(id: number, data: any) {
+    // Implement business logic
+    return data;
+  }
+
+  async delete(id: number) {
+    // Implement business logic
+    return true;
+  }
+}
+`;
+}

package/dist/cli/utils/file-generator.d.ts

@@ -0,0 +1,9 @@
+export declare class FileGenerator {
+    static createDirectory(dirPath: string): void;
+    static writeFile(filePath: string, content: string): void;
+    static fileExists(filePath: string): boolean;
+    static readFile(filePath: string): string;
+    static toCamelCase(str: string): string;
+    static toPascalCase(str: string): string;
+    static toKebabCase(str: string): string;
+}

package/dist/cli/utils/file-generator.js

@@ -0,0 +1,67 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileGenerator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class FileGenerator {
+    static createDirectory(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    static writeFile(filePath, content) {
+        const dir = path.dirname(filePath);
+        this.createDirectory(dir);
+        fs.writeFileSync(filePath, content, 'utf-8');
+    }
+    static fileExists(filePath) {
+        return fs.existsSync(filePath);
+    }
+    static readFile(filePath) {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    static toCamelCase(str) {
+        return str.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+    }
+    static toPascalCase(str) {
+        const camel = this.toCamelCase(str);
+        return camel.charAt(0).toUpperCase() + camel.slice(1);
+    }
+    static toKebabCase(str) {
+        return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    }
+}
+exports.FileGenerator = FileGenerator;

package/dist/cli/utils/logger.d.ts

@@ -0,0 +1,14 @@
+import { Ora } from 'ora';
+export declare class CLILogger {
+    static success(message: string): void;
+    static error(message: string): void;
+    static info(message: string): void;
+    static warning(message: string): void;
+    static title(message: string): void;
+    static section(message: string): void;
+    static spinner(text: string): Ora;
+    static box(title: string, content: string[]): void;
+    static table(data: {
+        [key: string]: string;
+    }): void;
+}

package/dist/cli/utils/logger.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLILogger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+class CLILogger {
+    static success(message) {
+        console.log(chalk_1.default.green('✓'), message);
+    }
+    static error(message) {
+        console.log(chalk_1.default.red('✗'), message);
+    }
+    static info(message) {
+        console.log(chalk_1.default.blue('ℹ'), message);
+    }
+    static warning(message) {
+        console.log(chalk_1.default.yellow('⚠'), message);
+    }
+    static title(message) {
+        console.log(chalk_1.default.bold.cyan(`\n${message}\n`));
+    }
+    static section(message) {
+        console.log(chalk_1.default.bold(`\n${message}`));
+    }
+    static spinner(text) {
+        return (0, ora_1.default)(text).start();
+    }
+    static box(title, content) {
+        const maxLength = Math.max(title.length, ...content.map(c => c.length)) + 4;
+        const border = '═'.repeat(maxLength);
+        console.log(chalk_1.default.cyan(`╔${border}╗`));
+        console.log(chalk_1.default.cyan('║') + chalk_1.default.bold(` ${title.padEnd(maxLength)} `) + chalk_1.default.cyan('║'));
+        console.log(chalk_1.default.cyan(`╠${border}╣`));
+        content.forEach(line => {
+            console.log(chalk_1.default.cyan('║') + ` ${line.padEnd(maxLength)} ` + chalk_1.default.cyan('║'));
+        });
+        console.log(chalk_1.default.cyan(`╚${border}╝`));
+    }
+    static table(data) {
+        const maxKeyLength = Math.max(...Object.keys(data).map(k => k.length));
+        Object.entries(data).forEach(([key, value]) => {
+            console.log(`  ${chalk_1.default.cyan(key.padEnd(maxKeyLength))} : ${value}`);
+        });
+    }
+}
+exports.CLILogger = CLILogger;

package/dist/controllers/health.controller.d.ts

@@ -0,0 +1,13 @@
+import { HealthService } from '../services/health.service';
+export declare class HealthController {
+    private healthService;
+    constructor(healthService: HealthService);
+    getStatus(): Promise<{
+        status: string;
+        timestamp: string;
+        database: string;
+    }>;
+    getHealthTip(): Promise<{
+        tip: string;
+    }>;
+}

package/dist/controllers/health.controller.js

@@ -0,0 +1,50 @@
+"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.HealthController = 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 health_service_1 = require("../services/health.service");
+let HealthController = class HealthController {
+    constructor(healthService) {
+        this.healthService = healthService;
+    }
+    async getStatus() {
+        return await this.healthService.getStatus();
+    }
+    async getHealthTip() {
+        return await this.healthService.generateHealthTip();
+    }
+};
+exports.HealthController = HealthController;
+__decorate([
+    (0, route_decorator_1.Get)('/'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "getStatus", null);
+__decorate([
+    (0, route_decorator_1.Get)('/tip'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HealthController.prototype, "getHealthTip", null);
+exports.HealthController = HealthController = __decorate([
+    (0, controller_decorator_1.Controller)('/api/health'),
+    (0, injectable_decorator_1.Injectable)(),
+    __param(0, (0, autowire_decorator_1.Autowire)()),
+    __metadata("design:paramtypes", [health_service_1.HealthService])
+], HealthController);

package/dist/core/config/config-loader.d.ts

@@ -0,0 +1,31 @@
+export interface AppConfig {
+    app: {
+        name: string;
+        port: number;
+        env: string;
+    };
+    database: {
+        type: string;
+        host: string;
+        port: number;
+        username: string;
+        password: string;
+        database: string;
+        synchronize: boolean;
+        logging: boolean;
+    };
+    openai: {
+        apiKey: string;
+        model: string;
+    };
+    auth: {
+        tokenExpiry: string;
+        sessionExpiry: string;
+    };
+}
+export declare class ConfigLoader {
+    private static config;
+    static load(useYaml?: boolean): AppConfig;
+    private static mergeEnvVariables;
+    static get(): AppConfig;
+}

package/dist/core/config/config-loader.js

@@ -0,0 +1,98 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+class ConfigLoader {
+    static load(useYaml = true) {
+        if (this.config) {
+            return this.config;
+        }
+        const configDir = path.join(process.cwd(), 'config');
+        let configPath;
+        if (useYaml) {
+            // Try .lock.yaml first, then .yaml
+            const lockPath = path.join(configDir, 'app.lock.yaml');
+            const yamlPath = path.join(configDir, 'app.yaml');
+            configPath = fs.existsSync(lockPath) ? lockPath : yamlPath;
+            if (!fs.existsSync(configPath)) {
+                throw new Error('Configuration file not found');
+            }
+            const fileContent = fs.readFileSync(configPath, 'utf8');
+            this.config = yaml.load(fileContent);
+        }
+        else {
+            // JSON fallback
+            configPath = path.join(configDir, 'app.json');
+            const fileContent = fs.readFileSync(configPath, 'utf8');
+            this.config = JSON.parse(fileContent);
+        }
+        // Override with environment variables
+        this.config = this.mergeEnvVariables(this.config);
+        return this.config;
+    }
+    static mergeEnvVariables(config) {
+        return {
+            ...config,
+            app: {
+                ...config.app,
+                port: process.env.PORT ? parseInt(process.env.PORT) : config.app.port,
+                env: process.env.NODE_ENV || config.app.env
+            },
+            database: {
+                ...config.database,
+                host: process.env.DB_HOST || config.database.host,
+                port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : config.database.port,
+                username: process.env.DB_USERNAME || config.database.username,
+                password: process.env.DB_PASSWORD || config.database.password,
+                database: process.env.DB_DATABASE || config.database.database
+            },
+            openai: {
+                ...config.openai,
+                apiKey: process.env.OPENAI_API_KEY || config.openai.apiKey
+            }
+        };
+    }
+    static get() {
+        if (!this.config) {
+            throw new Error('Config not loaded. Call ConfigLoader.load() first.');
+        }
+        return this.config;
+    }
+}
+exports.ConfigLoader = ConfigLoader;
+ConfigLoader.config = null;

package/dist/core/container/di-container.d.ts

@@ -0,0 +1,9 @@
+import 'reflect-metadata';
+export declare class DIContainer {
+    private static instances;
+    private static classes;
+    static register(target: any): void;
+    static resolve<T>(target: any): T;
+    static getRegisteredClasses(): any[];
+    static clear(): void;
+}

package/dist/core/container/di-container.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIContainer = void 0;
+require("reflect-metadata");
+const autowire_decorator_1 = require("../decorators/autowire.decorator");
+class DIContainer {
+    static register(target) {
+        this.classes.add(target);
+    }
+    static resolve(target) {
+        // Return existing singleton if available
+        if (this.instances.has(target)) {
+            return this.instances.get(target);
+        }
+        // Get constructor parameter metadata
+        const params = Reflect.getOwnMetadata(autowire_decorator_1.AUTOWIRE_METADATA, target) || [];
+        const sortedParams = params.sort((a, b) => a.index - b.index);
+        // Resolve dependencies recursively
+        const dependencies = sortedParams.map((param) => {
+            return this.resolve(param.type);
+        });
+        // Create instance
+        const instance = new target(...dependencies);
+        this.instances.set(target, instance);
+        return instance;
+    }
+    static getRegisteredClasses() {
+        return Array.from(this.classes);
+    }
+    static clear() {
+        this.instances.clear();
+        this.classes.clear();
+    }
+}
+exports.DIContainer = DIContainer;
+DIContainer.instances = new Map();
+DIContainer.classes = new Set();

package/dist/core/decorators/auth-guard.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export declare const AUTH_GUARD_METADATA = "auth:guard";
+export declare function AuthGuard(): MethodDecorator & ClassDecorator;

package/dist/core/decorators/auth-guard.decorator.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTH_GUARD_METADATA = void 0;
+exports.AuthGuard = AuthGuard;
+require("reflect-metadata");
+exports.AUTH_GUARD_METADATA = 'auth:guard';
+function AuthGuard() {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey) {
+            // method decorator
+            Reflect.defineMetadata(exports.AUTH_GUARD_METADATA, true, target.constructor, propertyKey);
+        }
+        else {
+            // class decorator
+            Reflect.defineMetadata(exports.AUTH_GUARD_METADATA, true, target);
+        }
+    };
+}

package/dist/core/decorators/autowire.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export declare const AUTOWIRE_METADATA = "autowire:metadata";
+export declare function Autowire(): ParameterDecorator;

package/dist/core/decorators/autowire.decorator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTOWIRE_METADATA = void 0;
+exports.Autowire = Autowire;
+require("reflect-metadata");
+exports.AUTOWIRE_METADATA = 'autowire:metadata';
+function Autowire() {
+    return (target, propertyKey, parameterIndex) => {
+        const existingParams = Reflect.getOwnMetadata(exports.AUTOWIRE_METADATA, target) || [];
+        const types = Reflect.getMetadata('design:paramtypes', target) || [];
+        existingParams.push({
+            index: parameterIndex,
+            type: types[parameterIndex]
+        });
+        Reflect.defineMetadata(exports.AUTOWIRE_METADATA, existingParams, target);
+    };
+}

package/dist/core/decorators/controller.decorator.d.ts

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+export declare const CONTROLLER_METADATA = "controller:metadata";
+export declare const CONTROLLER_PATH = "controller:path";
+export declare function Controller(path?: string): ClassDecorator;

package/dist/core/decorators/controller.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTROLLER_PATH = exports.CONTROLLER_METADATA = void 0;
+exports.Controller = Controller;
+require("reflect-metadata");
+const di_container_1 = require("../container/di-container");
+exports.CONTROLLER_METADATA = 'controller:metadata';
+exports.CONTROLLER_PATH = 'controller:path';
+function Controller(path = '') {
+    return (target) => {
+        Reflect.defineMetadata(exports.CONTROLLER_METADATA, true, target);
+        Reflect.defineMetadata(exports.CONTROLLER_PATH, path, target);
+        di_container_1.DIContainer.register(target);
+        return target;
+    };
+}

package/dist/core/decorators/injectable.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export declare const INJECTABLE_METADATA = "injectable:metadata";
+export declare function Injectable(): ClassDecorator;

package/dist/core/decorators/injectable.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INJECTABLE_METADATA = void 0;
+exports.Injectable = Injectable;
+require("reflect-metadata");
+const di_container_1 = require("../container/di-container");
+exports.INJECTABLE_METADATA = 'injectable:metadata';
+function Injectable() {
+    return (target) => {
+        Reflect.defineMetadata(exports.INJECTABLE_METADATA, true, target);
+        di_container_1.DIContainer.register(target);
+        return target;
+    };
+}

package/dist/core/decorators/middleware.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+export declare const MIDDLEWARE_METADATA = "middleware:metadata";
+export declare function Middleware(...middlewares: Function[]): ClassDecorator | MethodDecorator;

package/dist/core/decorators/middleware.decorator.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIDDLEWARE_METADATA = void 0;
+exports.Middleware = Middleware;
+require("reflect-metadata");
+exports.MIDDLEWARE_METADATA = 'middleware:metadata';
+function Middleware(...middlewares) {
+    return (target, propertyKey, descriptor) => {
+        if (propertyKey) {
+            // Method-level middleware
+            const existing = Reflect.getOwnMetadata(exports.MIDDLEWARE_METADATA, target.constructor, propertyKey) || [];
+            Reflect.defineMetadata(exports.MIDDLEWARE_METADATA, [...existing, ...middlewares], target.constructor, propertyKey);
+        }
+        else {
+            // Class-level middleware
+            const existing = Reflect.getOwnMetadata(exports.MIDDLEWARE_METADATA, target) || [];
+            Reflect.defineMetadata(exports.MIDDLEWARE_METADATA, [...existing, ...middlewares], target);
+        }
+    };
+}

package/dist/core/decorators/repository.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Repository(): ClassDecorator;

package/dist/core/decorators/repository.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = Repository;
+const injectable_decorator_1 = require("./injectable.decorator");
+function Repository() {
+    return (0, injectable_decorator_1.Injectable)();
+}

package/dist/core/decorators/route.decorator.d.ts

@@ -0,0 +1,14 @@
+import 'reflect-metadata';
+export declare const ROUTE_METADATA = "route:metadata";
+export declare enum HttpMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    DELETE = "delete",
+    PATCH = "patch"
+}
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;

package/dist/core/decorators/route.decorator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.HttpMethod = exports.ROUTE_METADATA = void 0;
+require("reflect-metadata");
+exports.ROUTE_METADATA = 'route:metadata';
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["GET"] = "get";
+    HttpMethod["POST"] = "post";
+    HttpMethod["PUT"] = "put";
+    HttpMethod["DELETE"] = "delete";
+    HttpMethod["PATCH"] = "patch";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+function createRouteDecorator(method) {
+    return (path = '') => {
+        return (target, propertyKey, descriptor) => {
+            const routes = Reflect.getOwnMetadata(exports.ROUTE_METADATA, target.constructor) || [];
+            routes.push({
+                method,
+                path,
+                handlerName: propertyKey
+            });
+            Reflect.defineMetadata(exports.ROUTE_METADATA, routes, target.constructor);
+            return descriptor;
+        };
+    };
+}
+exports.Get = createRouteDecorator(HttpMethod.GET);
+exports.Post = createRouteDecorator(HttpMethod.POST);
+exports.Put = createRouteDecorator(HttpMethod.PUT);
+exports.Delete = createRouteDecorator(HttpMethod.DELETE);
+exports.Patch = createRouteDecorator(HttpMethod.PATCH);

package/dist/core/decorators/service.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Service(): ClassDecorator;

package/dist/core/decorators/service.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = Service;
+const injectable_decorator_1 = require("./injectable.decorator");
+function Service() {
+    return (0, injectable_decorator_1.Injectable)();
+}

package/dist/core/openai/openai-client.d.ts

@@ -0,0 +1,12 @@
+export declare class OpenAIClient {
+    private apiKey;
+    private model;
+    private baseURL;
+    constructor();
+    complete(prompt: string, options?: {
+        model?: string;
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<string>;
+    streamComplete(prompt: string, onChunk: (chunk: string) => void): Promise<void>;
+}