dolphin-server-modules 2.11.0 → 2.11.2

package/dist/bin/cli.js

@@ -2,54 +2,266 @@
 import fs from 'fs';
 import path from 'path';
 import { createServer } from 'http';
+import net from 'net';
+import { fileURLToPath } from 'url';
 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] || '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();
-        }
+// Version — package.json बाट dynamic पढ्ने
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf8'));
+const VERSION = pkg.version;
+// .env loader
+const envFilePath = path.join(process.cwd(), '.env');
+if (fs.existsSync(envFilePath)) {
+    fs.readFileSync(envFilePath, 'utf8').split('\n').forEach(line => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            return;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1)
+            return;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, '');
+        if (key && !process.env[key])
+            process.env[key] = value;
     });
 }
 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
+    model: process.env.DOLPHIN_AI_MODEL,
 };
 const useOllama = process.env.USE_OLLAMA === 'true';
 const hasAnyKey = aiConfig.apiKey || process.env.GROQ_API_KEY || process.env.OPENAI_API_KEY;
 if (!hasAnyKey && !useOllama && ['generate', 'generate-full', 'chat'].includes(command)) {
-    CLIUI.error('API Key not found! Please set DOLPHIN_AI_KEY, GEMINI_API_KEY, or GROQ_API_KEY in your .env file.');
+    CLIUI.error('API Key फेला परेन! .env मा DOLPHIN_AI_KEY, GEMINI_API_KEY, वा GROQ_API_KEY राख्नुहोस्।');
     process.exit(1);
 }
 const ai = new AIService(aiConfig);
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+function writeFile(filePath, content, label) {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, content);
+    console.log(`  📄 Created: ${label || path.relative(process.cwd(), filePath)}`);
+}
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/** TCP port check — live connection test गर्ने */
+function checkTcpPort(host, port, timeoutMs = 4000) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => { socket.destroy(); resolve(true); });
+        socket.once('error', () => { socket.destroy(); resolve(false); });
+        socket.once('timeout', () => { socket.destroy(); resolve(false); });
+        socket.connect(port, host);
+    });
+}
+/** URI बाट host र port निकाल्ने */
+function parseUri(uri) {
+    try {
+        const u = new URL(uri);
+        const defaults = {
+            'mongodb:': 27017, 'mongodb+srv:': 27017,
+            'redis:': 6379, 'rediss:': 6380,
+        };
+        return {
+            host: u.hostname || 'localhost',
+            port: parseInt(u.port || '') || defaults[u.protocol] || 3000,
+        };
+    }
+    catch {
+        return { host: 'localhost', port: 27017 };
+    }
+}
+/**
+ * Automatically registers the newly created Mongoose model in the entry file (e.g. app.js)
+ * where createMongooseAdapter is called, by adding the model import and inserting it into
+ * the adapter initialization parameters.
+ */
+function registerModelInAdapter(modelName) {
+    const entryFiles = ['app.js', 'app.ts', 'server.js', 'server.ts', 'index.js', 'index.ts'];
+    let foundFile = '';
+    let content = '';
+    for (const file of entryFiles) {
+        const fullPath = path.join(process.cwd(), file);
+        if (fs.existsSync(fullPath)) {
+            const txt = fs.readFileSync(fullPath, 'utf8');
+            if (txt.includes('createMongooseAdapter')) {
+                foundFile = fullPath;
+                content = txt;
+                break;
+            }
+        }
+    }
+    if (!foundFile) {
+        console.log(`  ⚠️  Could not find any file calling createMongooseAdapter to register ${modelName}.`);
+        return;
+    }
+    // 1. Add Import
+    if (content.includes(`models/${modelName}.js`) || content.includes(`models/${modelName}`)) {
+        console.log(`  ⚠️  ${modelName} is already imported in ${path.basename(foundFile)}`);
+    }
+    else {
+        const importLine = `import { ${modelName} } from './models/${modelName}.js';\n`;
+        const modelImportRegex = /import\s+{[^}]+}\s+from\s+['"].\/models\/[^'"]+['"];/g;
+        const matches = [...content.matchAll(modelImportRegex)];
+        if (matches.length > 0) {
+            const lastMatch = matches[matches.length - 1];
+            const insertPos = lastMatch.index + lastMatch[0].length;
+            content = content.slice(0, insertPos) + '\n' + importLine + content.slice(insertPos);
+        }
+        else {
+            const firstImportIdx = content.indexOf('import ');
+            if (firstImportIdx !== -1) {
+                content = content.slice(0, firstImportIdx) + importLine + content.slice(firstImportIdx);
+            }
+            else {
+                content = importLine + content;
+            }
+        }
+    }
+    // 2. Add to createMongooseAdapter arguments
+    const adapterCallRegex = /createMongooseAdapter\s*\(\s*\{([\s\S]*?)\}\s*\)/;
+    const match = content.match(adapterCallRegex);
+    if (match) {
+        const innerContent = match[1];
+        if (innerContent.includes(modelName)) {
+            console.log(`  ⚠️  ${modelName} already registered in createMongooseAdapter`);
+        }
+        else {
+            let updatedInner = '';
+            if (innerContent.includes('models:')) {
+                const modelsRegex = /models\s*:\s*\{\s*([\s\S]*?)\s*\}/;
+                const modelsMatch = innerContent.match(modelsRegex);
+                if (modelsMatch) {
+                    const existingModels = modelsMatch[1].trim();
+                    const updatedModels = existingModels ? `${modelName}, ${existingModels}` : modelName;
+                    updatedInner = innerContent.replace(modelsRegex, `models: { ${updatedModels} }`);
+                }
+                else {
+                    updatedInner = innerContent.trim() + `, models: { ${modelName} }`;
+                }
+            }
+            else {
+                const trimmedInner = innerContent.trim();
+                updatedInner = trimmedInner ? `${trimmedInner}, models: { ${modelName} }` : `models: { ${modelName} }`;
+            }
+            content = content.replace(adapterCallRegex, `createMongooseAdapter({ ${updatedInner} })`);
+            fs.writeFileSync(foundFile, content);
+            console.log(`  ✅ Registered: ${modelName} registered in ${path.relative(process.cwd(), foundFile)}`);
+        }
+    }
+    else {
+        console.log(`  ⚠️  Could not parse createMongooseAdapter call in ${path.basename(foundFile)}`);
+    }
+}
+// ─── Commands ─────────────────────────────────────────────────────────────────
 async function run() {
     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}`);
+        // ── serve ────────────────────────────────────────────────────────────
+        case 'serve': {
+            const port = parseInt(args.find(a => a.startsWith('--port='))?.split('=')[1] || '3000');
+            CLIUI.heading(`Dolphin Dev Server — port ${port}`);
             const server = createServer((req, res) => {
                 res.writeHead(200, { 'Content-Type': 'text/plain' });
-                res.end('Dolphin Server is swimming!\n');
+                res.end('🐬 Dolphin Server is swimming!\n');
             });
             server.listen(port, () => {
                 CLIUI.success(`Server is live at http://localhost:${port}`);
+                console.log('  Ctrl+C थिचेर रोक्नुहोस्।');
             });
             break;
-        case 'generate':
+        }
+        // ── connect mongoose|redis ───────────────────────────────────────────
+        case 'connect': {
+            const dbType = args[1];
+            const uriArg = args[2];
+            if (dbType === 'mongoose' || dbType === 'mongo' || dbType === 'mongodb') {
+                const uri = uriArg || process.env.MONGO_URI || 'mongodb://localhost:27017';
+                CLIUI.heading('MongoDB Connection Test');
+                console.log(`  URI: ${uri.replace(/:\/\/[^@]+@/, '://***@')}`);
+                // Step 1: TCP check
+                CLIUI.startSpinner('TCP ping...');
+                const { host, port } = parseUri(uri);
+                const tcpOk = await checkTcpPort(host, port);
+                CLIUI.stopSpinner(tcpOk, tcpOk ? `Host reachable: ${host}:${port}` : `Cannot reach ${host}:${port}`);
+                if (!tcpOk) {
+                    console.log('\n  \x1b[33mFix — MongoDB start गर्नुहोस्:\x1b[0m');
+                    console.log('    brew services start mongodb-community  (macOS)');
+                    console.log('    sudo systemctl start mongod             (Linux)');
+                    console.log('    mongod                                  (manual)');
+                    process.exit(1);
+                }
+                // Step 2: Mongoose check
+                CLIUI.startSpinner('Mongoose handshake...');
+                try {
+                    const mongoose = await import('mongoose');
+                    await mongoose.default.connect(uri, { serverSelectionTimeoutMS: 5000 });
+                    const dbHost = mongoose.default.connection.host;
+                    await mongoose.default.disconnect();
+                    CLIUI.stopSpinner(true, `Connected! Host: ${dbHost}`);
+                    CLIUI.success('MongoDB तयार छ। MONGO_URI .env मा राख्नुहोस्।');
+                }
+                catch (e) {
+                    CLIUI.stopSpinner(false, e.message);
+                    CLIUI.error('Mongoose connection failed. URI सही छ?');
+                    process.exit(1);
+                }
+            }
+            else if (dbType === 'redis') {
+                const uri = uriArg || process.env.REDIS_URL || 'redis://localhost:6379';
+                CLIUI.heading('Redis Connection Test');
+                console.log(`  URI: ${uri}`);
+                CLIUI.startSpinner('TCP ping...');
+                const { host, port } = parseUri(uri);
+                const tcpOk = await checkTcpPort(host, port);
+                CLIUI.stopSpinner(tcpOk, tcpOk ? `Host reachable: ${host}:${port}` : `Cannot reach ${host}:${port}`);
+                if (!tcpOk) {
+                    console.log('\n  \x1b[33mFix — Redis start गर्नुहोस्:\x1b[0m');
+                    console.log('    brew services start redis    (macOS)');
+                    console.log('    sudo systemctl start redis   (Linux)');
+                    console.log('    redis-server                 (manual)');
+                    process.exit(1);
+                }
+                CLIUI.startSpinner('Redis PING...');
+                try {
+                    const { createClient } = await import('redis');
+                    const client = createClient({ url: uri });
+                    await client.connect();
+                    const pong = await client.ping();
+                    await client.quit();
+                    CLIUI.stopSpinner(pong === 'PONG', `Redis replied: ${pong}`);
+                    CLIUI.success('Redis तयार छ!');
+                }
+                catch {
+                    CLIUI.stopSpinner(true, 'TCP OK (redis package: npm install redis)');
+                }
+            }
+            else {
+                CLIUI.error('Usage:');
+                console.log('  dolphin connect mongoose [uri]');
+                console.log('  dolphin connect redis    [uri]');
+            }
+            break;
+        }
+        // ── generate ─────────────────────────────────────────────────────────
+        case 'generate': {
             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 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');
@@ -58,202 +270,319 @@ async function run() {
                 CLIUI.stopSpinner(false, e.message);
             }
             break;
-        case 'generate-full':
+        }
+        // ── generate-full ────────────────────────────────────────────────────
+        case 'generate-full': {
             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 using ONLY Dolphin Server modules.
-Dolphin Components:
-- Use 'import' NOT 'require'. This is an ES Module project.
-- Use 'dolphin-server-modules/server' for createDolphinServer()
-- Use 'dolphin-server-modules/adapters/mongoose' for createMongooseAdapter()
-- Use 'dolphin-server-modules/auth-controller' for createDolphinAuthController()
-- Use 'dolphin-server-modules/crud' for createCrudController(dbAdapter, modelName)
-Example usage:
-const app = createDolphinServer();
-const db = createMongooseAdapter(uri);
-const crud = createCrudController(db, "Task");
-app.get("/tasks", crud.getAll);
-app.post("/tasks", crud.create);
-Project Structure:
-- package.json (MUST include "type": "module")
-- index.js (main server)
-- models/ (Mongoose models)
-- .env (env vars)
-
-CRITICAL: Return ONLY a valid JSON object. 
-IMPORTANT: All code content inside JSON strings MUST have escaped newlines (use \\n). 
-Example: { "file.js": "import x from 'y';\\nconsole.log(x);" }
-No markdown. No conversational text.`;
-                const response = await ai.request(fullPrompt, systemPrompt);
-                fs.writeFileSync('debug-ai-response.txt', response);
-                // Robust JSON extraction using stack-based matching
-                let cleaned = "";
-                let i = response.indexOf('{');
-                if (i !== -1) {
-                    let stack = 0;
-                    let inString = false;
-                    let escaped = false;
-                    let start = i;
-                    for (let j = i; j < response.length; j++) {
-                        const char = response[j];
-                        if (char === '"' && !escaped)
-                            inString = !inString;
-                        if (!inString) {
-                            if (char === '{')
-                                stack++;
-                            if (char === '}')
-                                stack--;
-                            if (stack === 0) {
-                                cleaned = response.substring(start, j + 1);
-                                break;
-                            }
-                        }
-                        if (char === '\\' && !escaped)
-                            escaped = true;
-                        else
-                            escaped = false;
-                    }
-                }
-                if (!cleaned)
-                    cleaned = response.replace(/```json|```/g, '').trim();
+                const sysPrompt = `You are a Dolphin Framework expert. Generate a production-ready backend project.
+Use: createDolphinServer(), createMongooseAdapter({User,RefreshToken}), createDolphinAuthController(), createCrudController().
+Return ONLY a JSON object: {filePath: fileContent}. No markdown.`;
+                const response = await ai.request(fullPrompt, sysPrompt);
+                const jsonMatch = response.match(/\{[\s\S]*\}/);
+                const cleaned = jsonMatch ? jsonMatch[0] : response.replace(/```json|```/g, '').trim();
                 let files;
                 try {
                     files = JSON.parse(cleaned);
                 }
-                catch (err) {
-                    // Try to fix unescaped newlines in JSON strings
-                    // This is a common AI error where it puts real newlines inside "..."
-                    const fixed = cleaned.replace(/"([^"]*)"/g, (match, content) => {
-                        return '"' + content.replace(/\n/g, '\\n').replace(/\r/g, '\\r') + '"';
-                    });
-                    files = JSON.parse(fixed);
+                catch {
+                    const sanitized = cleaned.replace(/[\x00-\x1F\x7F-\x9F]/g, (c) => c === '\n' ? '\\n' : c === '\r' ? '\\r' : c === '\t' ? '\\t' : '');
+                    files = JSON.parse(sanitized);
                 }
                 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)`);
+                        console.log('  ⚠️  Skipped: .env');
                         return;
                     }
-                    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+                    ensureDir(path.dirname(fullPath));
                     fs.writeFileSync(fullPath, content);
                     console.log(`  📄 Created: ${fPath}`);
                 });
-                // Ensure .env file exists with defaults
-                const envPath = path.join(process.cwd(), '.env');
-                if (!fs.existsSync(envPath)) {
-                    const defaultEnv = `MONGO_URI=mongodb://localhost:27017/dolphin_db
-JWT_SECRET=your_ultra_secret_jwt_key_here
-GEMINI_API_KEY=your_gemini_api_key_here
-GROQ_API_KEY=your_groq_api_key_here
-OPENAI_API_KEY=your_openai_api_key_here
-`;
-                    fs.writeFileSync(envPath, defaultEnv);
-                    console.log(`  📄 Created: .env (with defaults)`);
+                const dotEnv = path.join(process.cwd(), '.env');
+                if (!fs.existsSync(dotEnv)) {
+                    fs.writeFileSync(dotEnv, TEMPLATES.env);
+                    console.log('  📄 Created: .env');
                 }
-                CLIUI.stopSpinner(true, 'Project architected successfully!');
+                CLIUI.stopSpinner(true, 'Project architected!');
             }
             catch (e) {
                 CLIUI.stopSpinner(false, e.message);
             }
             break;
-        case 'chat':
-            import('../ai/dolphin-agent/index.js').then(agentModule => {
-                const agent = agentModule.initAgentHook({ framework: 'dolphin', autoGenerateEnv: false, ...aiConfig });
-                agent.interactiveChat();
-            }).catch(err => {
-                CLIUI.error(`[Dolphin-Agent] Failed to start chat: ${err.message}`);
-            });
+        }
+        // ── chat ─────────────────────────────────────────────────────────────
+        case 'chat': {
+            import('../ai/dolphin-agent/index.js')
+                .then(m => { const a = m.initAgentHook({ framework: 'dolphin', autoGenerateEnv: false }); a.interactiveChat(); })
+                .catch(err => CLIUI.error(`[Dolphin-Agent] ${err.message}`));
             break;
+        }
+        // ── init / init-prod ─────────────────────────────────────────────────
         case 'init':
-        case 'init-prod':
-            CLIUI.heading('Scaffolding Production Project');
+        case 'init-prod': {
+            CLIUI.heading('Production Project Scaffold');
             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.');
-            import('../ai/dolphin-agent/index.js').then(agentModule => {
-                agentModule.initAgentHook({ framework: 'dolphin', autoGenerateEnv: true, ...aiConfig });
-            }).catch(err => {
-                CLIUI.error(`[Dolphin-Agent] Initialization failed: ${err.message}`);
+            dirs.forEach(d => { ensureDir(path.join(process.cwd(), d)); console.log(`  📁 ${d}/`); });
+            const files = [
+                ['app.js', TEMPLATES.app],
+                ['config/db.js', TEMPLATES.mongoose],
+                ['.env', TEMPLATES.env],
+                ['.gitignore', 'node_modules/\ndist/\n.env\n*.log\n'],
+            ];
+            files.forEach(([rel, content]) => {
+                const full = path.join(process.cwd(), rel);
+                if (!fs.existsSync(full)) {
+                    fs.writeFileSync(full, content);
+                    console.log(`  📄 Created: ${rel}`);
+                }
             });
+            CLIUI.success('Structure ready!');
+            console.log('\n  Next steps:');
+            console.log('  1. npm install dolphin-server-modules mongoose');
+            console.log('  2. dolphin connect mongoose     — DB test');
+            console.log('  3. node app.js                  — Server start');
+            import('../ai/dolphin-agent/index.js')
+                .then(m => m.initAgentHook({ framework: 'dolphin', autoGenerateEnv: true }))
+                .catch(() => { });
             break;
-        case 'add':
-            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');
+        }
+        // ── add ──────────────────────────────────────────────────────────────
+        case 'add': {
+            const sub = args[1];
+            const name = args[2];
+            // add adapter
+            if (sub === 'adapter') {
+                const type = name || '';
+                const configDir = path.join(process.cwd(), 'config');
+                if (['mongoose', 'mongo', 'mongodb'].includes(type)) {
+                    writeFile(path.join(configDir, 'db.js'), TEMPLATES.mongoose, 'config/db.js');
+                    CLIUI.success('Mongoose adapter added!');
+                    console.log('\n  Usage: import { connectDB } from \'./config/db.js\';');
+                    console.log('         connectDB(process.env.MONGO_URI);');
+                }
+                else if (['sequelize', 'mysql', 'postgres', 'sql'].includes(type)) {
+                    writeFile(path.join(configDir, 'db.js'), TEMPLATES.sequelize, 'config/db.js');
+                    CLIUI.success('Sequelize adapter added!');
+                    console.log('\n  MySQL:      npm install sequelize mysql2');
+                    console.log('  PostgreSQL: npm install sequelize pg pg-hstore');
+                }
+                else if (type === 'redis') {
+                    writeFile(path.join(configDir, 'redis.js'), TEMPLATES.redis, 'config/redis.js');
+                    CLIUI.success('Redis adapter added!');
+                    console.log('\n  Install: npm install redis');
+                    console.log('  Usage:   import { connectRedis, cache } from \'./config/redis.js\';');
                 }
                 else {
-                    CLIUI.error('Unsupported adapter. Try: dolphin add adapter mongoose');
+                    CLIUI.error('Unknown adapter. Available: mongoose | sequelize | redis');
+                    console.log('  Examples:');
+                    console.log('    dolphin add adapter mongoose');
+                    console.log('    dolphin add adapter sequelize');
+                    console.log('    dolphin add adapter redis');
                 }
+                // add auth
             }
-            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 (sub === 'auth') {
+                writeFile(path.join(process.cwd(), 'controllers', 'auth.js'), TEMPLATES.auth, 'controllers/auth.js');
+                writeFile(path.join(process.cwd(), 'models', 'User.js'), TEMPLATES.authModel, 'models/User.js');
+                CLIUI.success('Auth controller + User model added!');
+                console.log('\n  app.js मा थप्नुहोस्:');
+                console.log('  import { auth } from \'./controllers/auth.js\';');
+                console.log('  app.post(\'/api/auth/register\', auth.register);');
+                console.log('  app.post(\'/api/auth/login\', auth.login);');
+                // add crud
             }
-            else if (subCommand === 'crud') {
-                const name = args[2];
+            else if (sub === 'crud') {
                 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`);
+                const N = capitalize(name);
+                writeFile(path.join(process.cwd(), 'controllers', `${N.toLowerCase()}.js`), TEMPLATES.crud(N), `controllers/${N.toLowerCase()}.js`);
+                writeFile(path.join(process.cwd(), 'models', `${N}.js`), TEMPLATES.crudModel(N), `models/${N}.js`);
+                CLIUI.success(`CRUD for ${N} generated!`);
+                // add model
+            }
+            else if (sub === 'model') {
+                if (!name)
+                    return CLIUI.error('Usage: dolphin add model <ModelName> [--adapter]');
+                const N = capitalize(name);
+                writeFile(path.join(process.cwd(), 'models', `${N}.js`), TEMPLATES.model(N), `models/${N}.js`);
+                CLIUI.success(`${N} model added!`);
+                if (args.includes('--adapter') || args.includes('-a')) {
+                    registerModelInAdapter(N);
+                }
+                // add model-adapter
+            }
+            else if (sub === 'model-adapter') {
+                if (!name)
+                    return CLIUI.error('Usage: dolphin add model-adapter <ModelName>');
+                const N = capitalize(name);
+                writeFile(path.join(process.cwd(), 'models', `${N}.js`), TEMPLATES.model(N), `models/${N}.js`);
+                CLIUI.success(`${N} model added!`);
+                registerModelInAdapter(N);
+                // add middleware
+            }
+            else if (sub === 'middleware' || sub === 'mw') {
+                if (!name)
+                    return CLIUI.error('Usage: dolphin add middleware <Name>');
+                const N = capitalize(name);
+                writeFile(path.join(process.cwd(), 'middleware', `${name.toLowerCase()}.js`), TEMPLATES.middleware(N), `middleware/${name.toLowerCase()}.js`);
+                CLIUI.success(`${N} middleware added!`);
+                console.log(`\n  app.use() मा थप्नुहोस्: import { ${name.toLowerCase()}Middleware } from './middleware/${name.toLowerCase()}.js';`);
+                // add route
+            }
+            else if (sub === 'route' || sub === 'router') {
+                if (!name)
+                    return CLIUI.error('Usage: dolphin add route <Name>');
+                const N = capitalize(name);
+                writeFile(path.join(process.cwd(), 'routes', `${name.toLowerCase()}.js`), TEMPLATES.route(N), `routes/${name.toLowerCase()}.js`);
+                CLIUI.success(`${N} route added!`);
+                console.log(`\n  import { ${name.toLowerCase()}Router } from './routes/${name.toLowerCase()}.js';`);
+                console.log(`  app.use('', ${name.toLowerCase()}Router);`);
+                // add service
+            }
+            else if (sub === 'service' || sub === 'svc') {
+                if (!name)
+                    return CLIUI.error('Usage: dolphin add service <Name>');
+                const N = capitalize(name);
+                writeFile(path.join(process.cwd(), 'services', `${N}.service.js`), TEMPLATES.service(N), `services/${N}.service.js`);
+                CLIUI.success(`${N}Service added!`);
             }
             else {
-                CLIUI.error('Usage: dolphin add <adapter|auth|crud>');
+                CLIUI.error('Usage: dolphin add <subcommand>');
+                console.log('\n  adapter <mongoose|sequelize|redis>   DB adapter');
+                console.log('  auth                                 Auth system');
+                console.log('  crud <ModelName>                     CRUD controller + model');
+                console.log('  model <ModelName> [--adapter]         Mongoose model (optionally registers it)');
+                console.log('  model-adapter <ModelName>            Mongoose model & registers in adapter');
+                console.log('  middleware <Name>                    Middleware');
+                console.log('  route <Name>                         Route file');
+                console.log('  service <Name>                       Service class');
             }
             break;
+        }
+        // ── status ───────────────────────────────────────────────────────────
+        case 'status': {
+            CLIUI.heading('Dolphin Project Status');
+            const cwd = process.cwd();
+            const checks = [
+                { label: 'package.json', file: 'package.json' },
+                { label: '.env', file: '.env' },
+                { label: 'app.js / app.ts', file: 'app.js', alt: 'app.ts' },
+                { label: 'config/db.js', file: 'config/db.js', alt: 'config/db.ts' },
+                { label: 'models/', dir: 'models' },
+                { label: 'controllers/', dir: 'controllers' },
+                { label: 'routes/', dir: 'routes' },
+                { label: 'middleware/', dir: 'middleware' },
+                { label: 'services/', dir: 'services' },
+            ];
+            checks.forEach(({ label, file, alt, dir }) => {
+                let exists = false;
+                if (dir)
+                    exists = fs.existsSync(path.join(cwd, dir));
+                else
+                    exists = fs.existsSync(path.join(cwd, file)) || (alt ? fs.existsSync(path.join(cwd, alt)) : false);
+                const icon = exists ? '\x1b[32m✔\x1b[0m' : '\x1b[33m–\x1b[0m';
+                console.log(`  ${icon}  ${label}`);
+            });
+            const projPkg = path.join(cwd, 'package.json');
+            if (fs.existsSync(projPkg)) {
+                const p = JSON.parse(fs.readFileSync(projPkg, 'utf8'));
+                const dsm = p.dependencies?.['dolphin-server-modules'] || p.devDependencies?.['dolphin-server-modules'];
+                console.log(`\n  dolphin-server-modules: ${dsm || '(package.json मा छैन)'}`);
+            }
+            const dotEnv = path.join(cwd, '.env');
+            if (fs.existsSync(dotEnv)) {
+                const envText = fs.readFileSync(dotEnv, 'utf8');
+                console.log('\n  .env keys:');
+                ['MONGO_URI', 'JWT_SECRET', 'REDIS_URL', 'PORT'].forEach(k => {
+                    const set = envText.includes(k + '=') && !envText.match(new RegExp(k + '=your_'));
+                    console.log(`    ${set ? '\x1b[32m✔\x1b[0m' : '\x1b[33m–\x1b[0m'}  ${k}`);
+                });
+            }
+            console.log(`\n  🐬 Dolphin CLI v${VERSION}`);
+            break;
+        }
+        // ── deploy ───────────────────────────────────────────────────────────
+        case 'deploy': {
+            CLIUI.heading('Production Deployment (PM2)');
+            const entry = fs.existsSync(path.join(process.cwd(), 'dist/index.js')) ? 'dist/index.js'
+                : fs.existsSync(path.join(process.cwd(), 'app.js')) ? 'app.js' : 'index.js';
+            console.log(`
+  \x1b[1mStep 1\x1b[0m — PM2 install:
+  \x1b[36mnpm install -g pm2\x1b[0m
+
+  \x1b[1mStep 2\x1b[0m — Build (TypeScript भए):
+  \x1b[36mnpm run build\x1b[0m
+
+  \x1b[1mStep 3\x1b[0m — Start:
+  \x1b[36mpm2 start ${entry} --name "dolphin-app" --env production\x1b[0m
+
+  \x1b[1mStep 4\x1b[0m — Auto-start on reboot:
+  \x1b[36mpm2 startup && pm2 save\x1b[0m
+
+  \x1b[1mStep 5\x1b[0m — Logs:
+  \x1b[36mpm2 logs dolphin-app\x1b[0m
+
+  ─── ecosystem.config.js (cluster mode) ────────────────
+  module.exports = {
+    apps: [{ name: 'dolphin-app', script: '${entry}',
+      instances: 'max', exec_mode: 'cluster',
+      env_production: { NODE_ENV: 'production', PORT: 3000 }
+    }]
+  };
+  \x1b[36mpm2 start ecosystem.config.js --env production\x1b[0m
+`);
+            break;
+        }
+        // ── version ──────────────────────────────────────────────────────────
         case '-v':
         case '--version':
-            console.log(`🐬 Dolphin CLI v2.9.9`);
+        case 'version':
+            console.log(`🐬 Dolphin CLI v${VERSION}`);
             break;
+        // ── help ─────────────────────────────────────────────────────────────
         case 'help':
         default:
-            CLIUI.heading('Dolphin Framework CLI');
-            console.log(`
-Commands:
-  serve              Start development server
-  generate <prompt>  Quick AI code generation
-  generate-full <p>  Full project architecture
-  chat               Autonomous AI Agent Mode (Full Access)
-  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
-  -v, --version      Show CLI version
-            `);
-            break;
+            CLIUI.heading(`Dolphin Framework CLI  v${VERSION}`);
+            console.log(`
+\x1b[1mServer\x1b[0m
+  serve [--port=N]             Dev server start गर्ने
+
+\x1b[1mScaffolding\x1b[0m
+  init / init-prod             Production project scaffold
+  add adapter <type>           DB adapter  (mongoose|sequelize|redis)
+  add auth                     Auth controller + User model
+  add crud <ModelName>         CRUD controller + Model
+  add model <ModelName>        Mongoose model मात्र (use --adapter or model-adapter to register)
+  add model-adapter <ModelName> Mongoose model + registers in adapter
+  add middleware <Name>        Middleware file
+  add route <Name>             Route file
+  add service <Name>           Service class
+
+\x1b[1mDatabase\x1b[0m
+  connect mongoose [uri]       MongoDB connection test
+  connect redis [uri]          Redis connection test
+
+\x1b[1mAI  (API key चाहिन्छ)\x1b[0m
+  generate <prompt>            Quick AI code generation
+  generate-full <prompt>       Full project AI architecture
+  chat                         Autonomous AI Agent (Cursor mode)
+
+\x1b[1mProject\x1b[0m
+  status                       Project health check
+  deploy                       PM2 deployment guide
+
+\x1b[1mInfo\x1b[0m
+  -v / --version               Version
+  help                         यो help
+`);
     }
 }
 run().catch(err => {
     CLIUI.error(err.message);
+    process.exit(1);
 });
 //# sourceMappingURL=cli.js.map