@thinksoftai/cli 1.6.11 → 1.6.13

package/dist/commands/export.js

@@ -0,0 +1,1228 @@
+"use strict";
+/**
+ * Export command - export app as self-hosted backend code
+ */
+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 });
+exports.exportBackend = exportBackend;
+const inquirer_1 = __importDefault(require("inquirer"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const api = __importStar(require("../utils/api"));
+const config = __importStar(require("../utils/config"));
+const logger = __importStar(require("../utils/logger"));
+async function exportBackend(options = {}) {
+    if (!config.isLoggedIn()) {
+        logger.error('Not logged in');
+        logger.info('Use "thinksoft login" to authenticate');
+        return;
+    }
+    const appId = options.app || config.getProjectConfig()?.appId;
+    if (!appId) {
+        logger.error('App ID is required');
+        logger.info('Use "thinksoft export --app <appId>" or run from a project with thinksoft.json');
+        return;
+    }
+    logger.header('Export Backend Code');
+    logger.keyValue('App ID', appId);
+    logger.newLine();
+    // Fetch app data
+    const spinner = (0, ora_1.default)('Fetching app data...').start();
+    const exportData = await api.getExportData(appId);
+    if (exportData.error) {
+        spinner.fail('Failed to fetch app data');
+        logger.error(exportData.error);
+        return;
+    }
+    spinner.succeed(`App data fetched: ${exportData.tables?.length || 0} tables, ${exportData.agents?.length || 0} agents`);
+    // Interactive prompts
+    const answers = await inquirer_1.default.prompt([
+        {
+            type: 'list',
+            name: 'format',
+            message: 'Export format:',
+            choices: [
+                { name: 'Node.js + Express + PostgreSQL', value: 'node-express' },
+                { name: 'PostgreSQL Only (schema + triggers)', value: 'postgres-only' }
+            ],
+            default: options.format || 'node-express'
+        },
+        {
+            type: 'confirm',
+            name: 'includeRules',
+            message: 'Include business rules as code?',
+            default: options.includeRules !== false
+        },
+        {
+            type: 'input',
+            name: 'baseUrl',
+            message: 'Base URL for API:',
+            default: '/api/v1'
+        },
+        {
+            type: 'confirm',
+            name: 'customizeEndpoints',
+            message: 'Customize endpoint paths?',
+            default: false
+        }
+    ]);
+    // Customize endpoints if requested
+    const endpointConfig = {};
+    if (answers.customizeEndpoints && exportData.tables) {
+        for (const table of exportData.tables) {
+            const { customPath } = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'customPath',
+                    message: `Endpoint for ${table.name}:`,
+                    default: `/${table.slug}`
+                }
+            ]);
+            endpointConfig[table.slug] = { path: customPath };
+        }
+    }
+    else if (exportData.tables) {
+        // Set default endpoints
+        for (const table of exportData.tables) {
+            endpointConfig[table.slug] = { path: `/${table.slug}` };
+        }
+    }
+    // Chat option (only for node-express)
+    let chatOption = 'none';
+    if (answers.format === 'node-express') {
+        const chatAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'chatOption',
+                message: 'Include AI chat capability?',
+                choices: [
+                    { name: 'No - Action chips only (no setup needed)', value: 'none' },
+                    { name: 'Yes - OpenAI (requires API key)', value: 'openai' },
+                    { name: 'Yes - Simple keyword matching (no AI)', value: 'simple' }
+                ],
+                default: 'none'
+            }
+        ]);
+        chatOption = chatAnswer.chatOption;
+    }
+    // Output directory
+    const appSlug = exportData.app?.name?.toLowerCase().replace(/\s+/g, '-') || appId.toLowerCase();
+    const { outputDir } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'outputDir',
+            message: 'Output directory:',
+            default: options.output || `./${appSlug}-backend`
+        }
+    ]);
+    // Generate files
+    const generatorSpinner = (0, ora_1.default)('Generating files...').start();
+    try {
+        const fileCount = await generateExport(exportData, {
+            ...answers,
+            chatOption,
+            baseUrl: answers.baseUrl
+        }, endpointConfig, outputDir);
+        generatorSpinner.succeed(`Generated ${fileCount} files`);
+        // Success message
+        logger.newLine();
+        logger.success('Export complete!');
+        logger.newLine();
+        logger.info('Next steps:');
+        logger.log(`  cd ${outputDir}`);
+        logger.log('  npm install');
+        logger.log('  cp .env.example .env');
+        logger.log('  # Edit .env with your database credentials');
+        if (answers.format === 'node-express') {
+            logger.log('  npm run db:setup');
+            logger.log('  npm start');
+            logger.newLine();
+            logger.log(chalk_1.default.gray(`  API will be available at http://localhost:3000${answers.baseUrl}`));
+        }
+        else {
+            logger.log('  # Run schema.sql in your PostgreSQL database');
+        }
+    }
+    catch (error) {
+        generatorSpinner.fail('Export failed');
+        logger.error(error.message || error);
+    }
+}
+async function generateExport(data, config, endpoints, outputDir) {
+    let fileCount = 0;
+    // Create base directory
+    fs.mkdirSync(outputDir, { recursive: true });
+    if (config.format === 'postgres-only') {
+        // PostgreSQL only - just schema and triggers
+        fs.mkdirSync(path.join(outputDir, 'database'), { recursive: true });
+        // Generate schema
+        const schema = generateSchema(data.tables);
+        fs.writeFileSync(path.join(outputDir, 'database/schema.sql'), schema);
+        fileCount++;
+        // Generate triggers if rules included
+        if (config.includeRules && data.rules?.length > 0) {
+            const triggers = generateTriggers(data.rules);
+            fs.writeFileSync(path.join(outputDir, 'database/triggers.sql'), triggers);
+            fileCount++;
+        }
+        // Generate README
+        const readme = generatePostgresReadme(data.app);
+        fs.writeFileSync(path.join(outputDir, 'README.md'), readme);
+        fileCount++;
+    }
+    else {
+        // Full Node.js + Express export
+        const dirs = [
+            'database',
+            'database/migrations',
+            'src',
+            'src/controllers',
+            'src/routes',
+            'src/middleware',
+            'src/validators',
+            'src/hooks',
+            'src/events',
+            'agents',
+            'client'
+        ];
+        for (const dir of dirs) {
+            fs.mkdirSync(path.join(outputDir, dir), { recursive: true });
+        }
+        // Database files
+        const schema = generateSchema(data.tables);
+        fs.writeFileSync(path.join(outputDir, 'database/schema.sql'), schema);
+        fileCount++;
+        if (config.includeRules && data.rules?.length > 0) {
+            const triggers = generateTriggers(data.rules);
+            fs.writeFileSync(path.join(outputDir, 'database/triggers.sql'), triggers);
+            fileCount++;
+        }
+        // Controllers
+        for (const table of data.tables || []) {
+            const controller = generateController(table, config.includeRules);
+            fs.writeFileSync(path.join(outputDir, `src/controllers/${table.slug}.js`), controller);
+            fileCount++;
+        }
+        // Validators
+        for (const table of data.tables || []) {
+            const validator = generateValidator(table);
+            fs.writeFileSync(path.join(outputDir, `src/validators/${table.slug}.js`), validator);
+            fileCount++;
+        }
+        // Hooks (if rules included)
+        if (config.includeRules) {
+            for (const table of data.tables || []) {
+                const tableRules = (data.rules || []).filter((r) => r.table_slug === table.slug);
+                const hooks = generateHooks(table, tableRules);
+                fs.writeFileSync(path.join(outputDir, `src/hooks/${table.slug}.js`), hooks);
+                fileCount++;
+            }
+        }
+        // Routes
+        const routes = generateRoutes(data.tables, endpoints, config.baseUrl);
+        fs.writeFileSync(path.join(outputDir, 'src/routes/index.js'), routes);
+        fileCount++;
+        // Agent routes
+        const agentRoutes = generateAgentRoutes();
+        fs.writeFileSync(path.join(outputDir, 'src/routes/agents.js'), agentRoutes);
+        fileCount++;
+        // Agents
+        const agentConfig = generateAgentConfig(data.agents);
+        fs.writeFileSync(path.join(outputDir, 'agents/config.json'), agentConfig);
+        fileCount++;
+        const agentActions = generateAgentActions();
+        fs.writeFileSync(path.join(outputDir, 'agents/actions.js'), agentActions);
+        fileCount++;
+        // Agent middleware
+        const agentMiddleware = generateAgentMiddleware();
+        fs.writeFileSync(path.join(outputDir, 'src/middleware/agentAuth.js'), agentMiddleware);
+        fileCount++;
+        // Chat (if enabled)
+        if (config.chatOption !== 'none') {
+            const chat = generateChat(config.chatOption);
+            fs.writeFileSync(path.join(outputDir, 'agents/chat.js'), chat);
+            fileCount++;
+        }
+        // Frontend client
+        const client = generateClient(data.tables, endpoints, config.baseUrl);
+        fs.writeFileSync(path.join(outputDir, 'client/api.js'), client);
+        fileCount++;
+        // Events
+        const events = generateEvents(data.tables);
+        fs.writeFileSync(path.join(outputDir, 'src/events/index.js'), events);
+        fileCount++;
+        // Main files
+        const indexJs = generateIndex(config.baseUrl);
+        fs.writeFileSync(path.join(outputDir, 'src/index.js'), indexJs);
+        fileCount++;
+        const dbJs = generateDb();
+        fs.writeFileSync(path.join(outputDir, 'src/db.js'), dbJs);
+        fileCount++;
+        const authMiddleware = generateAuthMiddleware();
+        fs.writeFileSync(path.join(outputDir, 'src/middleware/auth.js'), authMiddleware);
+        fileCount++;
+        // Config files
+        const apiConfig = generateApiConfig(data.tables, endpoints, config);
+        fs.writeFileSync(path.join(outputDir, 'api.config.json'), apiConfig);
+        fileCount++;
+        const packageJson = generatePackageJson(data.app, config);
+        fs.writeFileSync(path.join(outputDir, 'package.json'), packageJson);
+        fileCount++;
+        // Docker
+        const dockerCompose = generateDockerCompose(data.app);
+        fs.writeFileSync(path.join(outputDir, 'docker-compose.yml'), dockerCompose);
+        fileCount++;
+        const dockerfile = generateDockerfile();
+        fs.writeFileSync(path.join(outputDir, 'Dockerfile'), dockerfile);
+        fileCount++;
+        // Env and readme
+        const envExample = generateEnvExample(config);
+        fs.writeFileSync(path.join(outputDir, '.env.example'), envExample);
+        fileCount++;
+        const readme = generateReadme(data.app, config);
+        fs.writeFileSync(path.join(outputDir, 'README.md'), readme);
+        fileCount++;
+    }
+    return fileCount;
+}
+// ============================================
+// Generator Functions
+// ============================================
+function generateSchema(tables) {
+    let sql = '-- Auto-generated PostgreSQL schema\n';
+    sql += '-- Generated by ThinkSoft CLI\n\n';
+    sql += 'CREATE EXTENSION IF NOT EXISTS "pgcrypto";\n\n';
+    const typeMap = {
+        'text': 'VARCHAR(255)',
+        'textarea': 'TEXT',
+        'number': 'DECIMAL(10,2)',
+        'integer': 'INTEGER',
+        'email': 'VARCHAR(255)',
+        'phone': 'VARCHAR(50)',
+        'url': 'VARCHAR(500)',
+        'date': 'DATE',
+        'datetime': 'TIMESTAMP',
+        'time': 'TIME',
+        'boolean': 'BOOLEAN DEFAULT FALSE',
+        'file': 'VARCHAR(500)',
+        'image': 'VARCHAR(500)',
+        'location': 'JSONB',
+        'json': 'JSONB',
+        'multiselect': 'TEXT[]',
+        'select': 'VARCHAR(100)',
+        'radio': 'VARCHAR(100)'
+    };
+    for (const table of tables || []) {
+        sql += `-- Table: ${table.name}\n`;
+        sql += `CREATE TABLE ${table.slug} (\n`;
+        sql += `  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n`;
+        for (const field of table.fields || []) {
+            let fieldType = typeMap[field.type] || 'TEXT';
+            // Handle select/radio with CHECK constraint
+            if ((field.type === 'select' || field.type === 'radio') && field.options?.length) {
+                const options = field.options.map((o) => `'${o}'`).join(', ');
+                fieldType = `VARCHAR(100) CHECK (${field.slug} IN (${options}))`;
+            }
+            // Handle reference
+            if (field.type === 'reference' && field.reference_table) {
+                fieldType = `UUID REFERENCES ${field.reference_table}(id)`;
+            }
+            // Add NOT NULL for required
+            if (field.required && !fieldType.includes('DEFAULT')) {
+                fieldType += ' NOT NULL';
+            }
+            sql += `  ${field.slug} ${fieldType},\n`;
+        }
+        sql += `  created_at TIMESTAMP DEFAULT NOW(),\n`;
+        sql += `  updated_at TIMESTAMP DEFAULT NOW()\n`;
+        sql += `);\n\n`;
+    }
+    // Add updated_at trigger
+    sql += `-- Auto-update updated_at timestamp\n`;
+    sql += `CREATE OR REPLACE FUNCTION update_timestamp()\n`;
+    sql += `RETURNS TRIGGER AS $$\n`;
+    sql += `BEGIN\n`;
+    sql += `  NEW.updated_at = NOW();\n`;
+    sql += `  RETURN NEW;\n`;
+    sql += `END;\n`;
+    sql += `$$ LANGUAGE plpgsql;\n\n`;
+    for (const table of tables || []) {
+        sql += `CREATE TRIGGER ${table.slug}_updated_at\n`;
+        sql += `BEFORE UPDATE ON ${table.slug}\n`;
+        sql += `FOR EACH ROW EXECUTE FUNCTION update_timestamp();\n\n`;
+    }
+    return sql;
+}
+function generateTriggers(rules) {
+    let sql = '-- Auto-generated database triggers from business rules\n';
+    sql += '-- Generated by ThinkSoft CLI\n\n';
+    // Group by table
+    const rulesByTable = {};
+    for (const rule of rules || []) {
+        if (!rulesByTable[rule.table_slug]) {
+            rulesByTable[rule.table_slug] = [];
+        }
+        rulesByTable[rule.table_slug].push(rule);
+    }
+    for (const [table, tableRules] of Object.entries(rulesByTable)) {
+        sql += `-- Rules for ${table}\n`;
+        sql += `CREATE OR REPLACE FUNCTION ${table}_rules()\n`;
+        sql += `RETURNS TRIGGER AS $$\n`;
+        sql += `BEGIN\n`;
+        for (const rule of tableRules) {
+            sql += `  -- ${rule.name}\n`;
+            // Add rule logic here based on conditions/actions
+        }
+        sql += `  RETURN NEW;\n`;
+        sql += `END;\n`;
+        sql += `$$ LANGUAGE plpgsql;\n\n`;
+    }
+    return sql;
+}
+function generateController(table, includeHooks) {
+    return `/**
+ * ${table.name} Controller
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const db = require('../db');
+${includeHooks ? `const hooks = require('../hooks/${table.slug}');` : ''}
+const eventBus = require('../events');
+
+module.exports = {
+  list: async (req, res) => {
+    try {
+      const { limit = 50, offset = 0 } = req.query;
+      const data = await db.query(
+        'SELECT * FROM ${table.slug} ORDER BY created_at DESC LIMIT $1 OFFSET $2',
+        [limit, offset]
+      );
+      res.json({ data: data.rows });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  },
+
+  get: async (req, res) => {
+    try {
+      const { id } = req.params;
+      const result = await db.query('SELECT * FROM ${table.slug} WHERE id = $1', [id]);
+      if (result.rows.length === 0) {
+        return res.status(404).json({ error: 'Not found' });
+      }
+      res.json({ data: result.rows[0] });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  },
+
+  create: async (req, res) => {
+    try {
+      let data = req.body;
+      ${includeHooks ? `if (hooks.beforeCreate) data = await hooks.beforeCreate(data, db);` : ''}
+
+      const fields = Object.keys(data);
+      const values = Object.values(data);
+      const placeholders = fields.map((_, i) => '$' + (i + 1));
+
+      const result = await db.query(
+        \`INSERT INTO ${table.slug} (\${fields.join(', ')}) VALUES (\${placeholders.join(', ')}) RETURNING *\`,
+        values
+      );
+
+      const record = result.rows[0];
+      ${includeHooks ? `if (hooks.afterCreate) await hooks.afterCreate(record, db);` : ''}
+      eventBus.emit('${table.slug}.created', { new: record });
+
+      res.status(201).json({ data: record });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  },
+
+  update: async (req, res) => {
+    try {
+      const { id } = req.params;
+      let data = req.body;
+
+      const oldResult = await db.query('SELECT * FROM ${table.slug} WHERE id = $1', [id]);
+      if (oldResult.rows.length === 0) {
+        return res.status(404).json({ error: 'Not found' });
+      }
+      const oldRecord = oldResult.rows[0];
+
+      ${includeHooks ? `if (hooks.beforeUpdate) data = await hooks.beforeUpdate(oldRecord, data, db);` : ''}
+
+      const fields = Object.keys(data);
+      const values = Object.values(data);
+      const setClause = fields.map((f, i) => \`\${f} = $\${i + 1}\`).join(', ');
+
+      const result = await db.query(
+        \`UPDATE ${table.slug} SET \${setClause} WHERE id = $\${fields.length + 1} RETURNING *\`,
+        [...values, id]
+      );
+
+      const record = result.rows[0];
+      ${includeHooks ? `if (hooks.afterUpdate) await hooks.afterUpdate(oldRecord, record, db);` : ''}
+      eventBus.emit('${table.slug}.updated', { old: oldRecord, new: record });
+
+      res.json({ data: record });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  },
+
+  delete: async (req, res) => {
+    try {
+      const { id } = req.params;
+
+      const oldResult = await db.query('SELECT * FROM ${table.slug} WHERE id = $1', [id]);
+      if (oldResult.rows.length === 0) {
+        return res.status(404).json({ error: 'Not found' });
+      }
+      const oldRecord = oldResult.rows[0];
+
+      ${includeHooks ? `if (hooks.beforeDelete) await hooks.beforeDelete(oldRecord, db);` : ''}
+
+      await db.query('DELETE FROM ${table.slug} WHERE id = $1', [id]);
+
+      ${includeHooks ? `if (hooks.afterDelete) await hooks.afterDelete(oldRecord, db);` : ''}
+      eventBus.emit('${table.slug}.deleted', { old: oldRecord });
+
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  }
+};
+`;
+}
+function generateValidator(table) {
+    let schemaFields = '';
+    for (const field of table.fields || []) {
+        let validator = 'Joi.string()';
+        switch (field.type) {
+            case 'number':
+            case 'integer':
+                validator = 'Joi.number()';
+                break;
+            case 'boolean':
+                validator = 'Joi.boolean()';
+                break;
+            case 'email':
+                validator = 'Joi.string().email()';
+                break;
+            case 'date':
+            case 'datetime':
+                validator = 'Joi.date()';
+                break;
+            case 'select':
+            case 'radio':
+                if (field.options?.length) {
+                    validator = `Joi.string().valid(${field.options.map((o) => `'${o}'`).join(', ')})`;
+                }
+                break;
+        }
+        if (field.required) {
+            validator += '.required()';
+        }
+        else {
+            validator += '.optional().allow(null, \'\')';
+        }
+        schemaFields += `  ${field.slug}: ${validator},\n`;
+    }
+    return `/**
+ * ${table.name} Validator
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const Joi = require('joi');
+
+const schema = Joi.object({
+${schemaFields}});
+
+const validate = (req, res, next) => {
+  const { error, value } = schema.validate(req.body, { stripUnknown: true });
+
+  if (error) {
+    return res.status(400).json({
+      error: 'Validation failed',
+      details: error.details.map(d => d.message)
+    });
+  }
+
+  req.body = value;
+  next();
+};
+
+module.exports = { schema, validate };
+`;
+}
+function generateHooks(table, rules) {
+    return `/**
+ * ${table.name} Hooks
+ * Auto-generated by ThinkSoft CLI
+ */
+
+module.exports = {
+  beforeCreate: async (data, db) => {
+    // Add custom logic here
+    return data;
+  },
+
+  afterCreate: async (record, db) => {
+    // Add custom logic here
+  },
+
+  beforeUpdate: async (oldRecord, data, db) => {
+    // Add custom logic here
+    return data;
+  },
+
+  afterUpdate: async (oldRecord, newRecord, db) => {
+    // Add custom logic here
+  },
+
+  beforeDelete: async (record, db) => {
+    // Add custom logic here
+  },
+
+  afterDelete: async (record, db) => {
+    // Add custom logic here
+  }
+};
+`;
+}
+function generateRoutes(tables, endpoints, baseUrl) {
+    let routes = `/**
+ * API Routes
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+
+`;
+    for (const table of tables || []) {
+        const endpoint = endpoints[table.slug]?.path || `/${table.slug}`;
+        routes += `// ${table.name}\n`;
+        routes += `const ${table.slug}Controller = require('../controllers/${table.slug}');\n`;
+        routes += `const ${table.slug}Validator = require('../validators/${table.slug}');\n\n`;
+        routes += `router.get('${endpoint}', authenticate, ${table.slug}Controller.list);\n`;
+        routes += `router.get('${endpoint}/:id', authenticate, ${table.slug}Controller.get);\n`;
+        routes += `router.post('${endpoint}', authenticate, ${table.slug}Validator.validate, ${table.slug}Controller.create);\n`;
+        routes += `router.put('${endpoint}/:id', authenticate, ${table.slug}Validator.validate, ${table.slug}Controller.update);\n`;
+        routes += `router.delete('${endpoint}/:id', authenticate, ${table.slug}Controller.delete);\n\n`;
+    }
+    routes += `module.exports = router;\n`;
+    return routes;
+}
+function generateAgentRoutes() {
+    return `/**
+ * Agent Routes
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const express = require('express');
+const router = express.Router();
+const { authenticate } = require('../middleware/auth');
+const agentAuth = require('../middleware/agentAuth');
+const { getActionChips, executeAction } = require('../../agents/actions');
+const agentConfig = require('../../agents/config.json');
+
+// Get agent info
+router.get('/:agent', authenticate, (req, res) => {
+  const agent = agentConfig[req.params.agent];
+  if (!agent) {
+    return res.status(404).json({ error: 'Agent not found' });
+  }
+  res.json({
+    name: agent.name,
+    description: agent.description,
+    welcome_message: agent.welcome_message,
+    action_chips: agent.action_chips
+  });
+});
+
+// Execute action chip
+router.post('/:agent/action', authenticate, async (req, res) => {
+  try {
+    const { action } = req.body;
+    const result = await executeAction(req.params.agent, action, req.user?.id);
+    res.json(result);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// Agent-scoped CRUD
+router.get('/:agent/:table', authenticate, agentAuth, async (req, res) => {
+  const controller = require(\`../controllers/\${req.params.table}\`);
+  return controller.list(req, res);
+});
+
+router.get('/:agent/:table/:id', authenticate, agentAuth, async (req, res) => {
+  const controller = require(\`../controllers/\${req.params.table}\`);
+  return controller.get(req, res);
+});
+
+router.post('/:agent/:table', authenticate, agentAuth, async (req, res) => {
+  const controller = require(\`../controllers/\${req.params.table}\`);
+  return controller.create(req, res);
+});
+
+router.put('/:agent/:table/:id', authenticate, agentAuth, async (req, res) => {
+  const controller = require(\`../controllers/\${req.params.table}\`);
+  return controller.update(req, res);
+});
+
+module.exports = router;
+`;
+}
+function generateAgentConfig(agents) {
+    const config = {};
+    for (const agent of agents || []) {
+        config[agent.slug] = {
+            name: agent.name,
+            slug: agent.slug,
+            description: agent.description,
+            welcome_message: agent.welcome_message,
+            auth_type: agent.auth_type || 'authenticated',
+            permissions: agent.permissions || {},
+            user_filter: agent.user_filter || {},
+            action_chips: (agent.action_chips || []).map((chip) => ({
+                label: chip.label,
+                icon: chip.icon,
+                action: chip.action,
+                table: chip.table,
+                display: chip.display || 'table',
+                filter: chip.filter,
+                fields: chip.fields
+            }))
+        };
+    }
+    return JSON.stringify(config, null, 2);
+}
+function generateAgentActions() {
+    return `/**
+ * Agent Actions Handler
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const agentConfig = require('./config.json');
+const db = require('../src/db');
+
+const getActionChips = (agentSlug) => {
+  const agent = agentConfig[agentSlug];
+  return agent?.action_chips || [];
+};
+
+const executeAction = async (agentSlug, actionLabel, userId) => {
+  const agent = agentConfig[agentSlug];
+  if (!agent) throw new Error('Agent not found');
+
+  const chip = agent.action_chips.find(c => c.label === actionLabel);
+  if (!chip) throw new Error('Action not found');
+
+  let filter = chip.filter;
+  if (filter && userId) {
+    filter = filter.replace(/:current_user_id/g, userId);
+  }
+
+  switch (chip.action) {
+    case 'list':
+      const listResult = await db.query(
+        \`SELECT * FROM \${chip.table}\${filter ? ' WHERE ' + filter : ''} ORDER BY created_at DESC LIMIT 50\`
+      );
+      return {
+        type: 'list',
+        display: chip.display || 'table',
+        title: chip.label,
+        table: chip.table,
+        data: listResult.rows
+      };
+
+    case 'get':
+      const getResult = await db.query(
+        \`SELECT * FROM \${chip.table} WHERE \${filter || 'TRUE'} LIMIT 1\`
+      );
+      return {
+        type: 'record',
+        display: chip.display || 'card',
+        title: chip.label,
+        table: chip.table,
+        data: getResult.rows[0]
+      };
+
+    case 'create':
+      return {
+        type: 'form',
+        display: 'form',
+        title: chip.label,
+        table: chip.table,
+        mode: 'create'
+      };
+
+    default:
+      throw new Error('Unknown action: ' + chip.action);
+  }
+};
+
+module.exports = { getActionChips, executeAction };
+`;
+}
+function generateAgentMiddleware() {
+    return `/**
+ * Agent Permission Middleware
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const agentConfig = require('../../agents/config.json');
+
+const agentAuth = (req, res, next) => {
+  const agent = agentConfig[req.params.agent];
+  if (!agent) {
+    return res.status(404).json({ error: 'Agent not found' });
+  }
+
+  const table = req.params.table;
+  const permissions = agent.permissions[table];
+
+  if (!permissions) {
+    return res.status(403).json({ error: 'No access to this table' });
+  }
+
+  const method = req.method;
+  const allowed =
+    (method === 'GET' && permissions.read) ||
+    (method === 'POST' && permissions.create) ||
+    (method === 'PUT' && permissions.update) ||
+    (method === 'DELETE' && permissions.delete);
+
+  if (!allowed) {
+    return res.status(403).json({ error: 'Permission denied' });
+  }
+
+  if (agent.user_filter?.[table] && req.user) {
+    req.userFilter = agent.user_filter[table].replace(/:current_user_id/g, req.user.id);
+  }
+
+  req.agent = agent;
+  next();
+};
+
+module.exports = agentAuth;
+`;
+}
+function generateChat(option) {
+    if (option === 'openai') {
+        return `/**
+ * Agent Chat (OpenAI)
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const { OpenAI } = require('openai');
+const agentConfig = require('./config.json');
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const chat = async (agentSlug, message, history = []) => {
+  const agent = agentConfig[agentSlug];
+  if (!agent) throw new Error('Agent not found');
+
+  const systemPrompt = \`You are \${agent.name}. \${agent.description}
+Available actions: \${agent.action_chips.map(c => c.label).join(', ')}\`;
+
+  const response = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [
+      { role: 'system', content: systemPrompt },
+      ...history,
+      { role: 'user', content: message }
+    ]
+  });
+
+  return { message: response.choices[0].message.content };
+};
+
+module.exports = { chat };
+`;
+    }
+    return `/**
+ * Agent Chat (Simple Keyword Matching)
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const agentConfig = require('./config.json');
+
+const chat = async (agentSlug, message) => {
+  const agent = agentConfig[agentSlug];
+  if (!agent) throw new Error('Agent not found');
+
+  const lowerMessage = message.toLowerCase();
+
+  for (const chip of agent.action_chips) {
+    if (lowerMessage.includes(chip.label.toLowerCase())) {
+      return {
+        message: \`I can help you with \${chip.label}!\`,
+        action: chip.label
+      };
+    }
+  }
+
+  return {
+    message: \`I can help you with: \${agent.action_chips.map(c => c.label).join(', ')}\`,
+    action: null
+  };
+};
+
+module.exports = { chat };
+`;
+}
+function generateClient(tables, endpoints, baseUrl) {
+    let code = `/**
+ * API Client
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const API_BASE = process.env.REACT_APP_API_URL || 'http://localhost:3000${baseUrl}';
+
+const getHeaders = () => ({
+  'Content-Type': 'application/json',
+  ...(localStorage.getItem('token') && {
+    'Authorization': \`Bearer \${localStorage.getItem('token')}\`
+  })
+});
+
+const handleResponse = async (response) => {
+  const data = await response.json();
+  if (!response.ok) throw new Error(data.error || 'Request failed');
+  return data;
+};
+
+const api = {
+`;
+    for (const table of tables || []) {
+        const path = endpoints[table.slug]?.path || `/${table.slug}`;
+        code += `  ${table.slug}: {
+    list: (params = {}) => fetch(\`\${API_BASE}${path}?\${new URLSearchParams(params)}\`, { headers: getHeaders() }).then(handleResponse),
+    get: (id) => fetch(\`\${API_BASE}${path}/\${id}\`, { headers: getHeaders() }).then(handleResponse),
+    create: (data) => fetch(\`\${API_BASE}${path}\`, { method: 'POST', headers: getHeaders(), body: JSON.stringify(data) }).then(handleResponse),
+    update: (id, data) => fetch(\`\${API_BASE}${path}/\${id}\`, { method: 'PUT', headers: getHeaders(), body: JSON.stringify(data) }).then(handleResponse),
+    delete: (id) => fetch(\`\${API_BASE}${path}/\${id}\`, { method: 'DELETE', headers: getHeaders() }).then(handleResponse),
+  },
+`;
+    }
+    code += `};
+
+export default api;
+`;
+    return code;
+}
+function generateEvents(tables) {
+    return `/**
+ * Event Bus
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const EventEmitter = require('events');
+const eventBus = new EventEmitter();
+
+// Add event listeners here
+// eventBus.on('orders.created', async ({ new: record }) => { ... });
+
+module.exports = eventBus;
+`;
+}
+function generateIndex(baseUrl) {
+    return `/**
+ * Server Entry Point
+ * Auto-generated by ThinkSoft CLI
+ */
+
+require('dotenv').config();
+const express = require('express');
+const cors = require('cors');
+const routes = require('./routes');
+const agentRoutes = require('./routes/agents');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(cors());
+app.use(express.json());
+
+// Routes
+app.use('${baseUrl}', routes);
+app.use('${baseUrl}/agent', agentRoutes);
+
+// Health check
+app.get('/health', (req, res) => res.json({ status: 'ok' }));
+
+app.listen(PORT, () => {
+  console.log(\`Server running on http://localhost:\${PORT}\`);
+  console.log(\`API available at http://localhost:\${PORT}${baseUrl}\`);
+});
+`;
+}
+function generateDb() {
+    return `/**
+ * Database Connection
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const { Pool } = require('pg');
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+module.exports = {
+  query: (text, params) => pool.query(text, params),
+  pool
+};
+`;
+}
+function generateAuthMiddleware() {
+    return `/**
+ * Authentication Middleware
+ * Auto-generated by ThinkSoft CLI
+ */
+
+const jwt = require('jsonwebtoken');
+
+const authenticate = (req, res, next) => {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({ error: 'No token provided' });
+  }
+
+  const token = authHeader.split(' ')[1];
+
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+    req.user = decoded;
+    next();
+  } catch (error) {
+    return res.status(401).json({ error: 'Invalid token' });
+  }
+};
+
+module.exports = { authenticate };
+`;
+}
+function generateApiConfig(tables, endpoints, config) {
+    const apiConfig = {
+        baseUrl: config.baseUrl,
+        auth: { type: 'jwt' },
+        endpoints: {}
+    };
+    for (const table of tables || []) {
+        apiConfig.endpoints[table.slug] = {
+            path: endpoints[table.slug]?.path || `/${table.slug}`,
+            methods: ['GET', 'POST', 'PUT', 'DELETE'],
+            auth: true
+        };
+    }
+    return JSON.stringify(apiConfig, null, 2);
+}
+function generatePackageJson(app, config) {
+    const pkg = {
+        name: app?.name?.toLowerCase().replace(/\s+/g, '-') + '-backend' || 'thinksoft-backend',
+        version: '1.0.0',
+        description: app?.description || 'Auto-generated backend by ThinkSoft CLI',
+        main: 'src/index.js',
+        scripts: {
+            start: 'node src/index.js',
+            dev: 'nodemon src/index.js',
+            'db:setup': 'psql $DATABASE_URL -f database/schema.sql'
+        },
+        dependencies: {
+            express: '^4.18.2',
+            cors: '^2.8.5',
+            pg: '^8.11.3',
+            dotenv: '^16.3.1',
+            jsonwebtoken: '^9.0.2',
+            joi: '^17.11.0'
+        },
+        devDependencies: {
+            nodemon: '^3.0.2'
+        }
+    };
+    if (config.chatOption === 'openai') {
+        pkg.dependencies.openai = '^4.20.0';
+    }
+    return JSON.stringify(pkg, null, 2);
+}
+function generateDockerCompose(app) {
+    const name = app?.name?.toLowerCase().replace(/\s+/g, '-') || 'app';
+    return `version: '3.8'
+
+services:
+  db:
+    image: postgres:15
+    environment:
+      POSTGRES_DB: ${name}
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./database/schema.sql:/docker-entrypoint-initdb.d/01-schema.sql
+    ports:
+      - "5432:5432"
+
+  api:
+    build: .
+    depends_on:
+      - db
+    environment:
+      DATABASE_URL: postgresql://postgres:postgres@db:5432/${name}
+      JWT_SECRET: your-secret-key-change-in-production
+      PORT: 3000
+    ports:
+      - "3000:3000"
+
+volumes:
+  postgres_data:
+`;
+}
+function generateDockerfile() {
+    return `FROM node:18-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install --production
+
+COPY . .
+
+EXPOSE 3000
+
+CMD ["node", "src/index.js"]
+`;
+}
+function generateEnvExample(config) {
+    let env = `# Database
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/myapp
+
+# Server
+PORT=3000
+NODE_ENV=development
+
+# Authentication
+JWT_SECRET=your-secret-key-change-in-production
+JWT_EXPIRES_IN=7d
+`;
+    if (config.chatOption === 'openai') {
+        env += `
+# OpenAI (for AI chat)
+OPENAI_API_KEY=sk-...
+`;
+    }
+    return env;
+}
+function generateReadme(app, config) {
+    return `# ${app?.name || 'ThinkSoft'} Backend
+
+Auto-generated backend by ThinkSoft CLI.
+
+## Quick Start
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Set up environment
+cp .env.example .env
+# Edit .env with your database credentials
+
+# Set up database
+npm run db:setup
+
+# Start server
+npm start
+\`\`\`
+
+## Docker
+
+\`\`\`bash
+docker-compose up -d
+\`\`\`
+
+## API Endpoints
+
+Base URL: \`http://localhost:3000${config.baseUrl}\`
+
+See \`api.config.json\` for all endpoints.
+
+## Frontend Client
+
+Copy \`client/api.js\` to your frontend project:
+
+\`\`\`javascript
+import api from './api';
+
+// List records
+const orders = await api.orders.list();
+
+// Create record
+await api.orders.create({ ... });
+\`\`\`
+`;
+}
+function generatePostgresReadme(app) {
+    return `# ${app?.name || 'ThinkSoft'} Database Schema
+
+Auto-generated PostgreSQL schema by ThinkSoft CLI.
+
+## Setup
+
+\`\`\`bash
+# Run schema
+psql -d your_database -f database/schema.sql
+
+# Run triggers (if included)
+psql -d your_database -f database/triggers.sql
+\`\`\`
+`;
+}
+//# sourceMappingURL=export.js.map