dolphin-server-modules 2.8.0 → 2.9.0

package/dist/bin/cli.js

@@ -1,675 +1,283 @@
 #!/usr/bin/env node
-"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;
-    };
-})();
-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 path_1 = __importDefault(require("path"));
-const https_1 = __importDefault(require("https"));
-const server_1 = require("../server/server");
-const core_1 = require("../realtime/core");
+import fs from 'fs';
+import path from 'path';
+import { createServer } from 'http';
+import { AIService } from '../services/ai-service.js';
+import { CLIUI } from '../utils/ui.js';
+import { TEMPLATES } from '../templates/index.js';
 const args = process.argv.slice(2);
-const command = args[0];
-const TEMPLATES = {
-    app: `import { createDolphinServer } from 'dolphin-server-modules/server';
-const app = createDolphinServer();
-
-app.get('/', (ctx) => ctx.json({ message: 'Dolphin Server is running!' }));
-
-app.listen(3000, () => console.log('🐬 Dolphin swimming on port 3000'));`,
-    mongoose: `import mongoose from 'mongoose';
-import { createMongooseAdapter } from 'dolphin-server-modules/adapters/mongoose';
-
-export async function connectDB(models = {}) {
-    const uri = process.env.MONGO_URI || 'mongodb://localhost:27017/dolphin_db';
-    await mongoose.connect(uri);
-    console.log('✅ MongoDB Connected');
-    
-    return createMongooseAdapter({
-        models: { ...models }
-    });
-}`,
-    sequelize: `import { Sequelize } from 'sequelize';
-// Note: This is a skeleton for Dolphin Sequelize Adapter
-export async function connectDB() {
-    const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASS, {
-        host: process.env.DB_HOST,
-        dialect: 'mysql' // or 'postgres', 'sqlite'
+const command = args[0] || 'help';
+// Simple .env loader
+const envPath = path.join(process.cwd(), '.env');
+if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, 'utf8');
+    envContent.split('\n').forEach(line => {
+        const [key, ...valueParts] = line.split('=');
+        if (key && valueParts.length > 0) {
+            process.env[key.trim()] = valueParts.join('=').trim();
+        }
     });
-    
-    try {
-        await sequelize.authenticate();
-        console.log('✅ SQL Database Connected');
-    } catch (error) {
-        console.error('❌ Unable to connect to the database:', error);
-    }
-    
-    return sequelize;
-}`,
-    auth: `import { createDolphinAuthController } from 'dolphin-server-modules/auth-controller';
-import { createDolphinRouter } from 'dolphin-server-modules/router';
-
-export function setupAuth(dbAdapter, config) {
-    const router = createDolphinRouter();
-    const auth = createDolphinAuthController(dbAdapter, config);
-    
-    router.post('/register', auth.register);
-    router.post('/login', auth.login);
-    router.post('/refresh', auth.refresh);
-    router.get('/me', auth.requireAuth, (ctx) => ctx.json(ctx.req.user));
-    
-    return router;
-}`,
-    crud: (name) => `import { createCRUD } from 'dolphin-server-modules/crud';
-
-export function setup${name}CRUD(dbAdapter) {
-    const service = createCRUD(dbAdapter, { enforceOwnership: false });
-    const COLLECTION = '${name}';
-    
-    return {
-        getAll: async (ctx) => ctx.json(await service.read(COLLECTION, ctx.query)),
-        getOne: async (ctx) => ctx.json(await service.readOne(COLLECTION, ctx.params.id)),
-        create: async (ctx) => ctx.json(await service.create(COLLECTION, ctx.body)),
-        update: async (ctx) => ctx.json(await service.updateOne(COLLECTION, ctx.params.id, ctx.body)),
-        delete: async (ctx) => ctx.json(await service.deleteOne(COLLECTION, ctx.params.id))
-    };
-}`,
-    authModel: `import mongoose from 'mongoose';
-
-const UserSchema = new mongoose.Schema({
-    email: { type: String, required: true, unique: true },
-    password: { type: String, required: true },
-    name: { type: String },
-    role: { type: String, default: 'user' },
-    is2FAEnabled: { type: Boolean, default: false },
-    twoFASecret: { type: String },
-    recoveryCodes: [{ type: String }],
-    createdAt: { type: Date, default: Date.now }
-});
-
-const RefreshTokenSchema = new mongoose.Schema({
-    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
-    token: { type: String, required: true },
-    expiresAt: { type: Date, required: true },
-    createdAt: { type: Date, default: Date.now }
-});
-
-export const User = mongoose.model('User', UserSchema);
-export const RefreshToken = mongoose.model('RefreshToken', RefreshTokenSchema);`
+}
+const aiConfig = {
+    apiKey: (process.env.DOLPHIN_AI_KEY || process.env.GEMINI_API_KEY || '').trim(),
+    baseUrl: process.env.DOLPHIN_AI_BASE_URL,
+    model: process.env.DOLPHIN_AI_MODEL
 };
-function loadEnv() {
-    const envPath = path_1.default.join(process.cwd(), '.env');
-    if (fs_1.default.existsSync(envPath)) {
-        const content = fs_1.default.readFileSync(envPath, 'utf8');
-        content.split(/\r?\n/).forEach(line => {
-            const trimmedLine = line.trim();
-            if (!trimmedLine || trimmedLine.startsWith('#'))
-                return;
-            const [key, ...valueParts] = trimmedLine.split('=');
-            if (key && valueParts.length > 0) {
-                const value = valueParts.join('=').trim().replace(/^["']|["']$/g, '');
-                process.env[key.trim()] = value;
-            }
-        });
-    }
+if (!aiConfig.apiKey && ['generate', 'generate-full', 'chat'].includes(command)) {
+    CLIUI.error('API Key not found! Please set DOLPHIN_AI_KEY or GEMINI_API_KEY in your .env file.');
+    process.exit(1);
 }
+const ai = new AIService(aiConfig);
 async function run() {
-    loadEnv();
     switch (command) {
+        case 'serve':
+            const port = parseInt(args.find(arg => arg.startsWith('--port='))?.split('=')[1] || '3000');
+            CLIUI.heading(`Dolphin Dev Server starting on port ${port}`);
+            const server = createServer((req, res) => {
+                res.writeHead(200, { 'Content-Type': 'text/plain' });
+                res.end('Dolphin Server is swimming!\n');
+            });
+            server.listen(port, () => {
+                CLIUI.success(`Server is live at http://localhost:${port}`);
+            });
+            break;
         case 'generate':
-            const requestedModel = args.find(arg => arg.startsWith('--model='))?.split('=')[1] || 'gemini-flash-latest';
-            const prompt = args.filter(arg => !arg.startsWith('--')).slice(1).join(' ');
-            const apiKey = (process.env.GEMINI_API_KEY || '').trim();
-            if (!apiKey) {
-                console.log('❌ Error: GEMINI_API_KEY environment variable is not set.');
-                console.log('💡 Get a free key at: https://aistudio.google.com/app/apikey');
-                break;
+            const prompt = args.slice(1).join(' ');
+            if (!prompt)
+                return CLIUI.error('Usage: dolphin generate "your prompt"');
+            CLIUI.startSpinner('AI is generating code');
+            try {
+                const response = await ai.request(prompt, "Return ONLY raw JavaScript code. No markdown.");
+                const cleanCode = response.replace(/```javascript|```js|```/g, '').trim();
+                fs.writeFileSync(path.join(process.cwd(), 'ai-generated.js'), cleanCode);
+                CLIUI.stopSpinner(true, 'File generated: ai-generated.js');
             }
-            if (!prompt) {
-                console.log('❌ Please provide a prompt. Example: dolphin generate "a library management system"');
-                break;
+            catch (e) {
+                CLIUI.stopSpinner(false, e.message);
             }
-            const fallbackModels = ['gemini-flash-latest', 'gemini-2.0-flash', 'gemini-2.5-flash', 'gemini-pro-latest'];
-            const modelsToTry = [requestedModel, ...fallbackModels.filter(m => m !== requestedModel)];
-            const versions = ['v1beta', 'v1'];
-            const tryGenerate = (modelIndex, versionIndex) => {
-                if (modelIndex >= modelsToTry.length) {
-                    console.log('❌ All AI models failed. Please ensure Generative Language API is enabled in Google AI Studio for your key.');
-                    return;
-                }
-                if (versionIndex >= versions.length) {
-                    return tryGenerate(modelIndex + 1, 0);
-                }
-                const currentModel = modelsToTry[modelIndex];
-                const currentVersion = versions[versionIndex];
-                console.log(`🤖 AI (${currentModel} via ${currentVersion}) is swimming with Dolphin...`);
-                const aiData = JSON.stringify({
-                    contents: [{ parts: [{ text: `Generate a production-ready Node.js file using dolphin-server-modules. 
-                    Rules:
-                    1. Use ESM 'import' instead of 'require'.
-                    2. Use 'const app = createDolphinServer();' from 'dolphin-server-modules/server'.
-                    3. Use unified context '(ctx) => { ... }' instead of '(req, res)'.
-                    4. Return objects directly for JSON response.
-                    5. No markdown backticks, no explanations.
-                    Context: ${prompt}. Return ONLY raw JS code.` }] }]
-                });
-                const options = {
-                    hostname: 'generativelanguage.googleapis.com',
-                    path: `/${currentVersion}/models/${currentModel}:generateContent?key=${encodeURIComponent(apiKey)}`,
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' }
-                };
-                const req = https_1.default.request(options, (res) => {
-                    let body = '';
-                    res.on('data', (d) => body += d);
-                    res.on('end', () => {
-                        try {
-                            const json = JSON.parse(body);
-                            if (json.error) {
-                                console.log(`⚠️ ${currentModel} (${currentVersion}) unavailable. Error: ${json.error.status}. Trying next...`);
-                                tryGenerate(modelIndex, versionIndex + 1);
-                                return;
-                            }
-                            const rawCode = json.candidates?.[0]?.content?.parts?.[0]?.text || '';
-                            if (rawCode) {
-                                const codeMatch = rawCode.match(/(\/\*[\s\S]*?\*\/|\/\/.*|[\s\S])*?(import|const|let|var|app|function)[\s\S]*/);
-                                const code = (codeMatch ? codeMatch[0] : rawCode).replace(/```javascript|```js|```/g, '').trim();
-                                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'ai-generated-app.js'), code);
-                                console.log(`✅ Success! Code generated using ${currentModel} in ai-generated-app.js`);
-                            }
-                            else {
-                                tryGenerate(modelIndex, versionIndex + 1);
-                            }
-                        }
-                        catch (e) {
-                            tryGenerate(modelIndex, versionIndex + 1);
-                        }
-                    });
-                });
-                req.on('error', () => tryGenerate(modelIndex, versionIndex + 1));
-                req.write(aiData);
-                req.end();
-            };
-            tryGenerate(0, 0);
             break;
         case 'generate-full':
-            const fullRequestedModel = args.find(arg => arg.startsWith('--model='))?.split('=')[1] || 'gemini-1.5-flash';
-            const fullPrompt = args.filter(arg => !arg.startsWith('--')).slice(1).join(' ');
-            const fullApiKey = (process.env.GEMINI_API_KEY || '').trim();
-            if (!fullApiKey) {
-                console.log('❌ Error: GEMINI_API_KEY environment variable is not set.');
-                break;
+            const fullPrompt = args.slice(1).join(' ');
+            if (!fullPrompt)
+                return CLIUI.error('Usage: dolphin generate-full "project description"');
+            CLIUI.startSpinner('Architecting full project structure');
+            try {
+                const systemPrompt = `You are a Dolphin Framework expert. Generate a production-ready backend project.
+Dolphin Patterns:
+- controllers/ (Logic)
+- models/ (Schemas: can be Mongoose or Sequelize)
+- config/db.js (DB connection logic)
+- .env (Environment variables)
+Dolphin supports both Mongoose (MongoDB) and Sequelize (MySQL/PostgreSQL).
+Choose the appropriate adapter based on the user's request.
+Return ONLY a JSON object where keys are file paths and values are code content. No markdown.`;
+                const response = await ai.request(fullPrompt, systemPrompt);
+                const files = JSON.parse(response.replace(/```json|```/g, '').trim());
+                Object.entries(files).forEach(([fPath, content]) => {
+                    const fullPath = path.join(process.cwd(), fPath);
+                    // Don't overwrite existing .env files to protect API keys
+                    if (fPath === '.env' && fs.existsSync(fullPath)) {
+                        console.log(`  ⚠️ Skipped: .env (file already exists)`);
+                        return;
+                    }
+                    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+                    fs.writeFileSync(fullPath, content);
+                    console.log(`  📄 Created: ${fPath}`);
+                });
+                CLIUI.stopSpinner(true, 'Project architected successfully!');
             }
-            if (!fullPrompt) {
-                console.log('❌ Please provide a prompt. Example: dolphin generate-full "a laundry management system"');
-                break;
+            catch (e) {
+                CLIUI.stopSpinner(false, e.message);
             }
-            console.log(`🤖 AI is architecting a full production-grade system...`);
-            const tryGenerateFull = (modelIndex, versionIndex) => {
-                const modelsToTry = ['gemini-1.5-flash-latest', 'gemini-flash-latest', 'gemini-1.5-pro-latest', 'gemini-pro-latest'];
-                const versions = ['v1beta', 'v1'];
-                if (modelIndex >= modelsToTry.length) {
-                    console.log('❌ All AI models failed for full architecture. Please check your prompt or API limits.');
-                    return;
-                }
-                if (versionIndex >= versions.length) {
-                    return tryGenerateFull(modelIndex + 1, 0);
-                }
-                const currentModel = modelsToTry[modelIndex];
-                const currentVersion = versions[versionIndex];
-                console.log(`🤖 AI (${currentModel} via ${currentVersion}) is architecting...`);
-                const aiData = JSON.stringify({
-                    contents: [{ parts: [{ text: `Generate a full production-ready modular Node.js project structure using dolphin-server-modules. 
-                    Rules:
-                    1. Return ONLY a valid JSON object.
-                    2. Keys are file paths (e.g., "routes/user.js", "models/User.js", "app.js").
-                    3. Values are the file contents as strings.
-                    4. Use ESM 'import'.
-                    5. Use 'const app = createDolphinServer();' from 'dolphin-server-modules/server' to initialize the app.
-                    6. Use 'createMongooseAdapter' from 'dolphin-server-modules/adapters/mongoose' for DB connectivity.
-                    7. Use 'createDolphinAuthController' from 'dolphin-server-modules/auth-controller' for all authentication logic.
-                    8. Use 'createCRUD' from 'dolphin-server-modules/crud' to generate standard API services.
-                    9. Create REAL Mongoose schemas in the models/ folder and export them to be used by the adapter.
-                    10. Use Dolphin unified context '(ctx) => { ... }' for all route handlers.
-                    11. Return objects directly for JSON response (e.g., return { success: true, data }).
-                    12. Include folders: models, controllers, routes, middleware, config, services.
-                    13. Ensure 'app.js' connects everything: DB -> Adapter -> Auth/CRUD -> Router -> Server.
-                    Context: ${fullPrompt}. 
-                    Return ONLY the JSON. No markdown backticks, no text before or after.` }] }]
-                });
-                const options = {
-                    hostname: 'generativelanguage.googleapis.com',
-                    path: `/${currentVersion}/models/${currentModel}:generateContent?key=${encodeURIComponent(fullApiKey)}`,
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' }
-                };
-                const req = https_1.default.request(options, (res) => {
-                    let body = '';
-                    res.on('data', (d) => body += d);
-                    res.on('end', () => {
+            break;
+        case 'chat':
+            CLIUI.heading('🐬 Dolphin Autonomous Agent Mode');
+            const readline = await import('readline');
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const agentSystemPrompt = `You are the Dolphin Autonomous Agent. 
+You have FULL ACCESS to the filesystem and shell.
+To perform actions, return a JSON block with "tool" and "params".
+Available Tools:
+1. {"tool": "read", "path": "file_path"} - Read a file
+2. {"tool": "write", "path": "path", "content": "..."} - Create/Edit a file
+3. {"tool": "list", "path": "dir"} - List files
+4. {"tool": "shell", "cmd": "..."} - Run a terminal command
+5. {"tool": "done", "msg": "..."} - Final answer
+
+Rules:
+- Always check the folder structure before writing.
+- If you see an error, fix it using the "write" tool.
+- You can call multiple tools one after another.
+- Use ESM (import/export).`;
+            const chatLoop = () => {
+                rl.question('\n💬 You: ', async (input) => {
+                    if (input.toLowerCase() === 'exit')
+                        return rl.close();
+                    let currentPrompt = input;
+                    let isRunning = true;
+                    while (isRunning) {
+                        CLIUI.startSpinner('Agent is thinking');
                         try {
-                            const json = JSON.parse(body);
-                            if (json.error) {
-                                console.log(`⚠️ ${currentModel} (${currentVersion}) error: ${json.error.message}. Trying next...`);
-                                return tryGenerateFull(modelIndex, versionIndex + 1);
+                            const response = await ai.request(currentPrompt, agentSystemPrompt);
+                            CLIUI.stopSpinner();
+                            // Try to parse tool call(s)
+                            let toolCalls = [];
+                            try {
+                                const jsonMatch = response.match(/\[[\s\S]*\]|\{[\s\S]*\}/);
+                                if (jsonMatch) {
+                                    const parsed = JSON.parse(jsonMatch[0]);
+                                    toolCalls = Array.isArray(parsed) ? parsed : [parsed];
+                                }
                             }
-                            const rawJson = json.candidates?.[0]?.content?.parts?.[0]?.text || '';
-                            const cleanJson = rawJson.replace(/```json|```/g, '').trim();
-                            const jsonMatch = cleanJson.match(/\{[\s\S]*\}/);
-                            if (jsonMatch) {
-                                try {
-                                    const files = JSON.parse(jsonMatch[0]);
-                                    Object.keys(files).forEach(filePath => {
-                                        const fullPath = path_1.default.join(process.cwd(), filePath);
-                                        const dirPath = path_1.default.dirname(fullPath);
-                                        if (!fs_1.default.existsSync(dirPath)) {
-                                            fs_1.default.mkdirSync(dirPath, { recursive: true });
-                                        }
-                                        fs_1.default.writeFileSync(fullPath, files[filePath]);
-                                        console.log(`📄 Generated: ${filePath}`);
-                                    });
-                                    console.log('✅ Full project architected successfully! 🐬');
+                            catch (e) { }
+                            if (toolCalls.length > 0) {
+                                let results = '';
+                                for (const toolCall of toolCalls) {
+                                    if (!toolCall.tool)
+                                        continue;
+                                    switch (toolCall.tool) {
+                                        case 'read':
+                                            const rPath = path.join(process.cwd(), toolCall.path);
+                                            if (fs.existsSync(rPath)) {
+                                                const content = fs.readFileSync(rPath, 'utf8');
+                                                console.log(`📖 Read ${toolCall.path}`);
+                                                results += `Content of ${toolCall.path}:\n${content}\n\n`;
+                                            }
+                                            else {
+                                                results += `Error: ${toolCall.path} not found.\n`;
+                                            }
+                                            break;
+                                        case 'write':
+                                            const wPath = path.join(process.cwd(), toolCall.path);
+                                            fs.mkdirSync(path.dirname(wPath), { recursive: true });
+                                            fs.writeFileSync(wPath, toolCall.content);
+                                            console.log(`📝 Wrote to ${toolCall.path}`);
+                                            results += `Successfully wrote ${toolCall.path}.\n`;
+                                            break;
+                                        case 'list':
+                                            const lPath = path.join(process.cwd(), toolCall.path || '.');
+                                            if (fs.existsSync(lPath)) {
+                                                const files = fs.readdirSync(lPath);
+                                                console.log(`📁 Files in ${toolCall.path || '.'}: ${files.join(', ')}`);
+                                                results += `Files in ${toolCall.path || '.'}:\n${files.join('\n')}\n`;
+                                            }
+                                            else {
+                                                results += `Error: Directory ${toolCall.path} not found.\n`;
+                                            }
+                                            break;
+                                        case 'shell':
+                                            console.log(`💻 Running: ${toolCall.cmd}`);
+                                            const { execSync } = await import('child_process');
+                                            try {
+                                                const output = execSync(toolCall.cmd).toString();
+                                                results += `Shell Output of "${toolCall.cmd}":\n${output}\n`;
+                                            }
+                                            catch (err) {
+                                                results += `Shell Error of "${toolCall.cmd}":\n${err.message}\n`;
+                                            }
+                                            break;
+                                        case 'done':
+                                            console.log(`✔ ${toolCall.msg || 'Task complete'}`);
+                                            isRunning = false;
+                                            break;
+                                    }
                                 }
-                                catch (e) {
-                                    console.log('❌ Error parsing project JSON. Trying next model...');
-                                    tryGenerateFull(modelIndex, versionIndex + 1);
+                                if (results) {
+                                    currentPrompt = `Results of actions:\n${results}\n\nWhat next?`;
+                                    continue; // Let the agent think again with results
                                 }
                             }
                             else {
-                                console.log('❌ AI failed to return valid JSON. Trying next model...');
-                                tryGenerateFull(modelIndex, versionIndex + 1);
-                            }
-                        }
-                        catch (e) {
-                            console.log('❌ Unexpected error. Trying next model...');
-                            tryGenerateFull(modelIndex, versionIndex + 1);
-                        }
-                    });
-                });
-                req.on('error', () => tryGenerateFull(modelIndex, versionIndex + 1));
-                req.write(aiData);
-                req.end();
-            };
-            tryGenerateFull(0, 0);
-            break;
-        case 'modify':
-            const fileToModify = args[1];
-            const modifyPrompt = args.slice(2).join(' ');
-            const modifyApiKey = (process.env.GEMINI_API_KEY || '').trim();
-            if (!modifyApiKey || !fileToModify || !modifyPrompt) {
-                console.log('❌ Usage: dolphin modify <filename> "your instructions"');
-                break;
-            }
-            const filePath = path_1.default.join(process.cwd(), fileToModify);
-            if (!fs_1.default.existsSync(filePath)) {
-                console.log(`❌ File not found: ${fileToModify}`);
-                break;
-            }
-            const currentCode = fs_1.default.readFileSync(filePath, 'utf8');
-            console.log(`🛠️ Modifying ${fileToModify}...`);
-            const tryModify = (modelIndex, versionIndex) => {
-                const models = ['gemini-1.5-flash-latest', 'gemini-flash-latest', 'gemini-1.5-pro-latest'];
-                const versions = ['v1beta', 'v1'];
-                if (modelIndex >= models.length) {
-                    console.log('❌ Modification failed after trying all models.');
-                    return;
-                }
-                if (versionIndex >= versions.length) {
-                    return tryModify(modelIndex + 1, 0);
-                }
-                const model = models[modelIndex];
-                const version = versions[versionIndex];
-                const aiData = JSON.stringify({
-                    contents: [{ parts: [{ text: `You are an expert Dolphin Framework developer. 
-                    Task: Modify the following code based on the instructions.
-                    Instructions: ${modifyPrompt}
-                    Current Code:
-                    ${currentCode}
-                    
-                    Rules:
-                    1. Return ONLY the updated code.
-                    2. No markdown, no explanations.
-                    3. Maintain Dolphin Framework standards (ctx usage, createDolphinServer, etc.).` }] }]
-                });
-                const options = {
-                    hostname: 'generativelanguage.googleapis.com',
-                    path: `/${version}/models/${model}:generateContent?key=${encodeURIComponent(modifyApiKey)}`,
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' }
-                };
-                const req = https_1.default.request(options, (res) => {
-                    let body = '';
-                    res.on('data', (d) => body += d);
-                    res.on('end', () => {
-                        try {
-                            const json = JSON.parse(body);
-                            if (json.error) {
-                                return tryModify(modelIndex, versionIndex + 1);
-                            }
-                            const rawCode = json.candidates?.[0]?.content?.parts?.[0]?.text || '';
-                            if (rawCode) {
-                                const newCode = rawCode.replace(/```javascript|```js|```/g, '').trim();
-                                fs_1.default.writeFileSync(filePath, newCode);
-                                console.log(`✅ ${fileToModify} updated successfully!`);
-                            }
-                            else {
-                                tryModify(modelIndex, versionIndex + 1);
+                                console.log(`🤖 AI: ${response}`);
+                                isRunning = false;
                             }
                         }
                         catch (e) {
-                            tryModify(modelIndex, versionIndex + 1);
+                            CLIUI.stopSpinner(false, e.message);
+                            isRunning = false;
                         }
-                    });
+                    }
+                    chatLoop();
                 });
-                req.on('error', () => tryModify(modelIndex, versionIndex + 1));
-                req.write(aiData);
-                req.end();
             };
-            tryModify(0, 0);
-            break;
-        case 'chat':
-            console.log('🐬 Welcome to Dolphin AI Agent! I can write files and run commands.');
-            console.log('💡 Try: "Create a new model for Blog" or "Show me current files"');
-            console.log('💬 Type "exit" to quit.\n');
-            const agentApiKey = (process.env.GEMINI_API_KEY || '').trim();
-            if (!agentApiKey) {
-                console.log('❌ GEMINI_API_KEY not set.');
-                break;
-            }
-            Promise.resolve().then(() => __importStar(require('readline'))).then(readline => {
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout
-                });
-                const ask = () => {
-                    rl.question('💬 You: ', (input) => {
-                        if (input.toLowerCase() === 'exit')
-                            return rl.close();
-                        const systemPrompt = `You are the Dolphin Framework AI Agent. 
-                        You have access to the user's filesystem and shell.
-                        
-                        To read a file: 
-                        FILE_READ: <path>
-                        
-                        To create or modify a file:
-                        FILE_WRITE: <path>
-                        <content>
-                        END_FILE
-                        
-                        To run a command:
-                        SHELL_RUN: <command>
-                        
-                        Current working directory: ${process.cwd()}
-                        Always use Dolphin Framework standards. If you need to modify a file, READ it first.`;
-                        const aiData = JSON.stringify({
-                            contents: [{ parts: [{ text: systemPrompt + "\nUser: " + input }] }]
-                        });
-                        const askAI = (modelIndex, versionIndex) => {
-                            const models = ['gemini-flash-latest', 'gemini-1.5-flash', 'gemini-pro-latest'];
-                            const versions = ['v1beta', 'v1'];
-                            if (modelIndex >= models.length) {
-                                console.log('🤖 Dolphin: Sorry, I am having trouble connecting right now.');
-                                return ask();
-                            }
-                            if (versionIndex >= versions.length)
-                                return askAI(modelIndex + 1, 0);
-                            const currentModel = models[modelIndex];
-                            const currentVersion = versions[versionIndex];
-                            const options = {
-                                hostname: 'generativelanguage.googleapis.com',
-                                path: `/${currentVersion}/models/${currentModel}:generateContent?key=${encodeURIComponent(agentApiKey)}`,
-                                method: 'POST',
-                                headers: { 'Content-Type': 'application/json' }
-                            };
-                            const req = https_1.default.request(options, (res) => {
-                                let body = '';
-                                res.on('data', (d) => body += d);
-                                res.on('end', async () => {
-                                    try {
-                                        const json = JSON.parse(body);
-                                        const reply = json.candidates?.[0]?.content?.parts?.[0]?.text || '';
-                                        if (!reply)
-                                            return askAI(modelIndex, versionIndex + 1);
-                                        // Handle FILE_WRITE
-                                        if (reply.includes('FILE_WRITE:')) {
-                                            const match = reply.match(/FILE_WRITE: (.*?)\n([\s\S]*?)END_FILE/);
-                                            if (match) {
-                                                const fPath = match[1].trim();
-                                                const content = match[2].trim().replace(/```javascript|```js|```/g, '');
-                                                const fullPath = path_1.default.join(process.cwd(), fPath);
-                                                const dir = path_1.default.dirname(fullPath);
-                                                if (!fs_1.default.existsSync(dir))
-                                                    fs_1.default.mkdirSync(dir, { recursive: true });
-                                                fs_1.default.writeFileSync(fullPath, content);
-                                                console.log(`🤖 Dolphin Agent: Created/Updated file [${fPath}]`);
-                                            }
-                                        }
-                                        // Handle SHELL_RUN
-                                        if (reply.includes('SHELL_RUN:')) {
-                                            const cmdMatch = reply.match(/SHELL_RUN: (.*)/);
-                                            if (cmdMatch) {
-                                                const cmd = cmdMatch[1].trim();
-                                                console.log(`🤖 Dolphin Agent: Executing [${cmd}]...`);
-                                                try {
-                                                    const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-                                                    execSync(cmd, { stdio: 'inherit' });
-                                                }
-                                                catch (e) {
-                                                    console.log(`❌ Command failed: ${cmd}`);
-                                                }
-                                            }
-                                        }
-                                        // Handle FILE_READ
-                                        if (reply.includes('FILE_READ:')) {
-                                            const readMatch = reply.match(/FILE_READ: (.*)/);
-                                            if (readMatch) {
-                                                const rPath = readMatch[1].trim();
-                                                const fullRPath = path_1.default.join(process.cwd(), rPath);
-                                                if (fs_1.default.existsSync(fullRPath)) {
-                                                    const content = fs_1.default.readFileSync(fullRPath, 'utf8');
-                                                    console.log(`🤖 Dolphin Agent: Read file [${rPath}]`);
-                                                    // We send the content back as a follow-up user message
-                                                    input = `Content of ${rPath}:\n${content}\nNow proceed with my previous request.`;
-                                                    return askAI(0, 0);
-                                                }
-                                            }
-                                        }
-                                        console.log(`🤖 Dolphin: ${reply.split('FILE_WRITE:')[0].split('SHELL_RUN:')[0].split('FILE_READ:')[0].trim()}\n`);
-                                        ask();
-                                    }
-                                    catch (e) {
-                                        askAI(modelIndex, versionIndex + 1);
-                                    }
-                                });
-                            });
-                            req.on('error', () => askAI(modelIndex, versionIndex + 1));
-                            req.write(aiData);
-                            req.end();
-                        };
-                        askAI(0, 0);
-                    });
-                };
-                ask();
-            });
-            break;
-        case 'clean':
-            const filesToClean = ['ai-generated-app.js', 'ai-test-output.js'];
-            filesToClean.forEach(file => {
-                const filePath = path_1.default.join(process.cwd(), file);
-                if (fs_1.default.existsSync(filePath)) {
-                    fs_1.default.unlinkSync(filePath);
-                    console.log(`🗑️ Deleted: ${file}`);
-                }
-            });
-            console.log('✅ Cleanup complete.');
-            break;
-        case 'serve':
-            let portStr = args.find(arg => arg.startsWith('--port='))?.split('=')[1];
-            if (!portStr) {
-                const portIdx = args.indexOf('--port');
-                if (portIdx !== -1 && args[portIdx + 1])
-                    portStr = args[portIdx + 1];
-            }
-            const port = parseInt(portStr || '3000');
-            const rt = new core_1.RealtimeCore({ debug: true });
-            const server = (0, server_1.createDolphinServer)({ realtime: rt });
-            server.get('/', (ctx) => ctx.html('<h1>Dolphin CLI Static Server</h1>'));
-            server.listen(port, () => console.log(`✅ Dolphin Server running at http://localhost:${port}`));
+            chatLoop();
             break;
         case 'init':
-            console.log('🏗️ Initializing Dolphin Project...');
-            fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'app.js'), TEMPLATES.app);
-            if (!fs_1.default.existsSync(path_1.default.join(process.cwd(), 'package.json'))) {
-                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'package.json'), JSON.stringify({
-                    name: path_1.default.basename(process.cwd()),
-                    version: '1.0.0',
-                    main: 'app.js',
-                    type: 'module',
-                    dependencies: {
-                        "dolphin-server-modules": "^2.2.2",
-                        "mongoose": "^8.0.0",
-                        "zod": "^3.22.0"
-                    }
-                }, null, 2));
-                console.log('✅ Created package.json with core dependencies.');
-            }
-            else {
-                console.log('⚠️ package.json already exists. Skipping...');
-            }
-            if (!fs_1.default.existsSync(path_1.default.join(process.cwd(), '.gitignore'))) {
-                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), '.gitignore'), '.env\nnode_modules\ndist\n.DS_Store');
-                console.log('✅ Created .gitignore');
-            }
+        case 'init-prod':
+            CLIUI.heading('Scaffolding Production Project');
+            const dirs = ['models', 'controllers', 'routes', 'middleware', 'services', 'config'];
+            dirs.forEach(dir => {
+                const p = path.join(process.cwd(), dir);
+                if (!fs.existsSync(p))
+                    fs.mkdirSync(p, { recursive: true });
+            });
+            fs.writeFileSync(path.join(process.cwd(), 'app.js'), TEMPLATES.app);
+            CLIUI.success('Folders and app.js created.');
             break;
         case 'add':
-            const type = args[1]; // adapter, auth, crud
-            const name = args[2] || 'Default';
-            if (type === 'adapter') {
-                if (name === 'mongoose') {
-                    fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'db.js'), TEMPLATES.mongoose);
-                    console.log('✅ Added Mongoose Adapter template to db.js');
-                }
-                else if (name === 'sequelize') {
-                    fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'db-sql.js'), TEMPLATES.sequelize);
-                    console.log('✅ Added Sequelize (SQL) Adapter template to db-sql.js');
+            const subCommand = args[1];
+            if (subCommand === 'adapter') {
+                const type = args[2];
+                if (type === 'mongoose') {
+                    const configDir = path.join(process.cwd(), 'config');
+                    if (!fs.existsSync(configDir))
+                        fs.mkdirSync(configDir, { recursive: true });
+                    fs.writeFileSync(path.join(configDir, 'db.js'), TEMPLATES.mongoose);
+                    CLIUI.success('Mongoose adapter added to config/db.js');
                 }
                 else {
-                    console.log('❌ Unknown adapter. Use "mongoose" or "sequelize".');
+                    CLIUI.error('Unsupported adapter. Try: dolphin add adapter mongoose');
                 }
             }
-            else if (type === 'auth') {
-                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'auth-router.js'), TEMPLATES.auth);
-                console.log('✅ Added Auth Controller template to auth-router.js');
+            else if (subCommand === 'auth') {
+                const controllerDir = path.join(process.cwd(), 'controllers');
+                const modelDir = path.join(process.cwd(), 'models');
+                if (!fs.existsSync(controllerDir))
+                    fs.mkdirSync(controllerDir, { recursive: true });
+                if (!fs.existsSync(modelDir))
+                    fs.mkdirSync(modelDir, { recursive: true });
+                fs.writeFileSync(path.join(controllerDir, 'auth.js'), TEMPLATES.auth);
+                fs.writeFileSync(path.join(modelDir, 'User.js'), TEMPLATES.authModel);
+                CLIUI.success('Auth controller and User model added.');
             }
-            else if (type === 'crud') {
-                const crudTemplate = typeof TEMPLATES.crud === 'function' ? TEMPLATES.crud(name) : '';
-                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), `${name.toLowerCase()}-crud.js`), crudTemplate);
-                console.log(`✅ Added CRUD Controller template for "${name}" to ${name.toLowerCase()}-crud.js`);
+            else if (subCommand === 'crud') {
+                const name = args[2];
+                if (!name)
+                    return CLIUI.error('Usage: dolphin add crud <ModelName>');
+                const controllerDir = path.join(process.cwd(), 'controllers');
+                const modelDir = path.join(process.cwd(), 'models');
+                if (!fs.existsSync(controllerDir))
+                    fs.mkdirSync(controllerDir, { recursive: true });
+                if (!fs.existsSync(modelDir))
+                    fs.mkdirSync(modelDir, { recursive: true });
+                fs.writeFileSync(path.join(controllerDir, `${name.toLowerCase()}.js`), TEMPLATES.crud(name));
+                fs.writeFileSync(path.join(modelDir, `${name}.js`), TEMPLATES.crudModel(name));
+                CLIUI.success(`CRUD Controller and Model for ${name} generated successfully!`);
+                console.log(`  📄 Created: controllers/${name.toLowerCase()}.js`);
+                console.log(`  📄 Created: models/${name}.js`);
             }
             else {
-                console.log('❌ Unknown type. Use "adapter", "auth", or "crud".');
-            }
-            break;
-        case 'mongo-auth-model':
-            const modelsDir = path_1.default.join(process.cwd(), 'models');
-            if (!fs_1.default.existsSync(modelsDir)) {
-                fs_1.default.mkdirSync(modelsDir);
-            }
-            fs_1.default.writeFileSync(path_1.default.join(modelsDir, 'auth-models.js'), TEMPLATES.authModel);
-            console.log('✅ Generated fixed Auth models (User, RefreshToken) in models/auth-models.js');
-            break;
-        case 'init-prod':
-            console.log('🚀 Scaffolding Production-Ready Dolphin Project...');
-            const dirs = ['models', 'controllers', 'routes', 'middleware', 'services', 'config'];
-            dirs.forEach(dir => {
-                const dirPath = path_1.default.join(process.cwd(), dir);
-                if (!fs_1.default.existsSync(dirPath)) {
-                    fs_1.default.mkdirSync(dirPath);
-                    console.log(`📁 Created: /${dir}`);
-                }
-            });
-            // Create basic files in the structure
-            fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'app.js'), TEMPLATES.app);
-            fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'config', 'db.js'), TEMPLATES.mongoose);
-            if (!fs_1.default.existsSync(path_1.default.join(process.cwd(), 'package.json'))) {
-                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'package.json'), JSON.stringify({
-                    name: path_1.default.basename(process.cwd()),
-                    version: '1.0.0',
-                    main: 'app.js',
-                    type: 'module',
-                    dependencies: {
-                        "dolphin-server-modules": "^2.2.4",
-                        "mongoose": "^8.0.0",
-                        "zod": "^3.22.0"
-                    }
-                }, null, 2));
-            }
-            if (!fs_1.default.existsSync(path_1.default.join(process.cwd(), '.gitignore'))) {
-                fs_1.default.writeFileSync(path_1.default.join(process.cwd(), '.gitignore'), '.env\nnode_modules\ndist\n.DS_Store');
-                console.log('✅ Created .gitignore');
+                CLIUI.error('Usage: dolphin add <adapter|auth|crud>');
             }
-            console.log('✅ Production scaffolding complete. Start swimming! 🐬');
             break;
         case 'help':
         default:
+            CLIUI.heading('Dolphin Framework CLI');
             console.log(`
-🐬 Dolphin Framework CLI
 Commands:
-  serve              Start a basic development server
-  init               Bootstrap a basic Dolphin project
-  init-prod          Scaffold a production-grade folder structure
-  generate <prompt>  AI-powered single-file API generation
-  generate-full <prompt> AI-powered full project architecture (folders + files)
-  modify <file> <prompt> AI-powered file modification/update
-  chat               Interactive AI chat for coding help
-  clean              Remove AI generated files
-  add adapter <type> Add a database adapter (mongoose, sequelize)
-  add auth           Add a pre-configured Auth controller
-  add crud <Name>    Add a pre-configured CRUD controller
-  mongo-auth-model   Generate fixed Mongoose models for Auth (User, RefreshToken)
-  generate "prompt" --model=gemini-1.5-pro (Custom AI model support)
-  
-Options:
-  --port=3000        Specify port for serve command
+  serve              Start development server
+  generate <prompt>  Quick AI code generation
+  generate-full <p>  Full project architecture
+  chat               Interactive AI coding assistant
+  init-prod          Scaffold production folder structure
+  add adapter <t>    Add Mongoose/Sequelize adapter
+  add auth           Add pre-built Auth controller
+  add crud <Name>    Add CRUD controller for a model
             `);
             break;
     }
 }
 run().catch(err => {
-    console.error('❌ CLI Error:', err);
+    CLIUI.error(err.message);
 });
 //# sourceMappingURL=cli.js.map