@thinksoftai/cli 1.1.1 → 1.3.0

package/dist/commands/dev.js

@@ -0,0 +1,1241 @@
+"use strict";
+/**
+ * Dev command - AI-assisted frontend development with auto-setup
+ */
+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.dev = dev;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const child_process_1 = require("child_process");
+const config = __importStar(require("../utils/config"));
+const logger = __importStar(require("../utils/logger"));
+const api = __importStar(require("../utils/api"));
+const BASE_URL = 'https://thinksoftai.com/api/v1';
+async function dev(options) {
+    if (!config.isLoggedIn()) {
+        logger.error('Not logged in');
+        logger.info('Use "thinksoft login" to authenticate');
+        return;
+    }
+    // Check if project exists
+    const hasProject = fs.existsSync(path.join(process.cwd(), 'package.json'));
+    let projectConfig = config.getProjectConfig();
+    let appId = options.app || projectConfig?.appId;
+    let framework = projectConfig?.framework || 'react';
+    // --init flag: Generate frontend directly without requiring existing project
+    if (options.init) {
+        if (!appId) {
+            // Need to select an app first
+            const appsResult = await api.listApps();
+            if (appsResult.error || !appsResult.apps?.length) {
+                logger.error('No apps found. Create one first:');
+                logger.info('thinksoft create "Your app description"');
+                return;
+            }
+            const { selectedApp } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'selectedApp',
+                    message: 'Select an app to generate frontend for:',
+                    choices: appsResult.apps.map((a) => ({
+                        name: `${a.name} (${a.short_id})`,
+                        value: a.short_id
+                    }))
+                }]);
+            appId = selectedApp;
+        }
+        showDevBanner(appId, framework);
+        await runInitWithSuggestion(appId, framework);
+        return;
+    }
+    // Auto-setup flow (for interactive dev mode)
+    if (!hasProject) {
+        console.log();
+        console.log(chalk_1.default.yellow('📁 No project detected in current directory.'));
+        console.log();
+        // Need appId for setup
+        if (!appId) {
+            // List user's apps and let them choose
+            const appsResult = await api.listApps();
+            if (appsResult.error || !appsResult.apps?.length) {
+                logger.error('No apps found. Create one first:');
+                logger.info('thinksoft create "Your app description"');
+                return;
+            }
+            const { selectedApp } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'selectedApp',
+                    message: 'Select an app to develop:',
+                    choices: appsResult.apps.map((a) => ({
+                        name: `${a.name} (${a.short_id})`,
+                        value: a.short_id
+                    }))
+                }]);
+            appId = selectedApp;
+        }
+        // Ask to create project
+        const { createProject } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'createProject',
+                message: 'Create a new project?',
+                default: true
+            }]);
+        if (!createProject) {
+            logger.info('Run "thinksoft dev" in an existing project directory');
+            return;
+        }
+        // Select framework
+        const { selectedFramework } = await inquirer_1.default.prompt([{
+                type: 'list',
+                name: 'selectedFramework',
+                message: 'Select framework:',
+                choices: [
+                    { name: 'React (Vite)', value: 'react' },
+                    { name: 'Next.js', value: 'nextjs' },
+                    { name: 'Vue (Vite)', value: 'vue' }
+                ]
+            }]);
+        framework = selectedFramework;
+        // Get project name
+        const defaultName = (appId || 'my-app').toLowerCase().replace(/[^a-z0-9]/g, '-') + '-app';
+        const { projectName } = await inquirer_1.default.prompt([{
+                type: 'input',
+                name: 'projectName',
+                message: 'Project name:',
+                default: defaultName
+            }]);
+        // Run setup
+        const setupSuccess = await setupProject(projectName, framework, appId);
+        if (!setupSuccess) {
+            return;
+        }
+        // Update projectConfig after setup
+        projectConfig = config.getProjectConfig();
+    }
+    else if (!projectConfig) {
+        // Has package.json but no thinksoft.json
+        console.log();
+        console.log(chalk_1.default.yellow('📋 Existing project found, but not linked to ThinkSoft.'));
+        console.log();
+        if (!appId) {
+            // List user's apps
+            const appsResult = await api.listApps();
+            if (appsResult.error || !appsResult.apps?.length) {
+                logger.error('No apps found. Create one first:');
+                logger.info('thinksoft create "Your app description"');
+                return;
+            }
+            const { selectedApp } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'selectedApp',
+                    message: 'Select an app to link:',
+                    choices: appsResult.apps.map((a) => ({
+                        name: `${a.name} (${a.short_id})`,
+                        value: a.short_id
+                    }))
+                }]);
+            appId = selectedApp;
+        }
+        // Detect framework from package.json
+        framework = detectFramework();
+        // Create thinksoft.json
+        config.saveProjectConfig({
+            appId: appId,
+            name: appId,
+            framework,
+            outputDir: framework === 'nextjs' ? '.next' : 'dist'
+        });
+        logger.success('Project linked to ThinkSoft');
+        // Create SDK client file if not exists
+        createSdkClientFile(appId, framework);
+        // Install SDK if not installed
+        await installSdkIfNeeded();
+        projectConfig = config.getProjectConfig();
+    }
+    if (!appId) {
+        logger.error('No app ID found');
+        return;
+    }
+    // Show dev banner
+    showDevBanner(appId, framework);
+    // If --init flag, run suggestion-based initialization
+    if (options.init) {
+        await runInitWithSuggestion(appId, framework);
+        return;
+    }
+    // Start interactive prompt
+    await runDevPrompt(appId, framework);
+}
+/**
+ * Setup a new project with selected framework
+ */
+async function setupProject(name, framework, appId) {
+    console.log();
+    // Step 1: Create project
+    const createSpinner = (0, ora_1.default)(`Creating ${framework} project...`).start();
+    try {
+        switch (framework) {
+            case 'react':
+                (0, child_process_1.execSync)(`npm create vite@latest ${name} -- --template react-ts`, {
+                    stdio: 'pipe',
+                    cwd: process.cwd()
+                });
+                break;
+            case 'nextjs':
+                (0, child_process_1.execSync)(`npx create-next-app@latest ${name} --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" --no-git`, {
+                    stdio: 'pipe',
+                    cwd: process.cwd()
+                });
+                break;
+            case 'vue':
+                (0, child_process_1.execSync)(`npm create vite@latest ${name} -- --template vue-ts`, {
+                    stdio: 'pipe',
+                    cwd: process.cwd()
+                });
+                break;
+        }
+        createSpinner.succeed('Project created');
+    }
+    catch (err) {
+        createSpinner.fail('Failed to create project');
+        console.log(chalk_1.default.red(err.message));
+        return false;
+    }
+    // Change to project directory
+    const projectPath = path.join(process.cwd(), name);
+    process.chdir(projectPath);
+    // Step 2: Install dependencies
+    const installSpinner = (0, ora_1.default)('Installing dependencies...').start();
+    try {
+        (0, child_process_1.execSync)('npm install', { stdio: 'pipe' });
+        (0, child_process_1.execSync)('npm install @thinksoftai/sdk', { stdio: 'pipe' });
+        // Install Tailwind for React/Vue (Next.js includes it)
+        if (framework === 'react' || framework === 'vue') {
+            (0, child_process_1.execSync)('npm install -D tailwindcss postcss autoprefixer', { stdio: 'pipe' });
+            (0, child_process_1.execSync)('npx tailwindcss init -p', { stdio: 'pipe' });
+        }
+        installSpinner.succeed('@thinksoftai/sdk installed');
+    }
+    catch (err) {
+        installSpinner.fail('Failed to install dependencies');
+        console.log(chalk_1.default.red(err.message));
+        return false;
+    }
+    // Step 3: Configure project
+    const configSpinner = (0, ora_1.default)('Configuring project...').start();
+    try {
+        // Create thinksoft.json
+        config.saveProjectConfig({
+            appId,
+            name,
+            framework,
+            outputDir: framework === 'nextjs' ? '.next' : 'dist'
+        });
+        // Create SDK client file
+        createSdkClientFile(appId, framework);
+        // Create basic App shell (for React/Vue)
+        if (framework === 'react') {
+            createReactAppShell(name);
+        }
+        configSpinner.succeed('Project configured');
+    }
+    catch (err) {
+        configSpinner.fail('Failed to configure project');
+        console.log(chalk_1.default.red(err.message));
+        return false;
+    }
+    console.log();
+    logger.success(`Project "${name}" ready!`);
+    console.log();
+    return true;
+}
+/**
+ * Detect framework from existing package.json
+ */
+function detectFramework() {
+    try {
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['next'])
+            return 'nextjs';
+        if (deps['vue'])
+            return 'vue';
+        return 'react';
+    }
+    catch {
+        return 'react';
+    }
+}
+/**
+ * Install SDK if not already installed
+ */
+async function installSdkIfNeeded() {
+    try {
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (!deps['@thinksoftai/sdk']) {
+            const spinner = (0, ora_1.default)('Installing @thinksoftai/sdk...').start();
+            try {
+                (0, child_process_1.execSync)('npm install @thinksoftai/sdk', { stdio: 'pipe' });
+                spinner.succeed('@thinksoftai/sdk installed');
+            }
+            catch (err) {
+                spinner.fail('Failed to install SDK');
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Create SDK client file
+ */
+function createSdkClientFile(appId, framework) {
+    const libDir = framework === 'nextjs'
+        ? path.join(process.cwd(), 'lib')
+        : path.join(process.cwd(), 'src', 'lib');
+    if (!fs.existsSync(libDir)) {
+        fs.mkdirSync(libDir, { recursive: true });
+    }
+    const clientPath = path.join(libDir, 'thinksoft.ts');
+    if (!fs.existsSync(clientPath)) {
+        const content = `import { ThinkSoft } from '@thinksoftai/sdk'
+
+// Initialize ThinkSoft client
+export const client = new ThinkSoft({
+  appId: '${appId}'
+})
+
+// Re-export for convenience
+export { ThinkSoft }
+`;
+        fs.writeFileSync(clientPath, content);
+        console.log(chalk_1.default.green(`  ✔ ${framework === 'nextjs' ? 'lib' : 'src/lib'}/thinksoft.ts created`));
+    }
+}
+/**
+ * Create basic React App shell with Tailwind
+ */
+function createReactAppShell(name) {
+    const appPath = path.join(process.cwd(), 'src', 'App.tsx');
+    const content = `import './index.css'
+
+function App() {
+  return (
+    <div className="min-h-screen bg-gray-100">
+      <header className="bg-white shadow">
+        <div className="max-w-7xl mx-auto py-6 px-4">
+          <h1 className="text-3xl font-bold text-gray-900">
+            ${name}
+          </h1>
+        </div>
+      </header>
+      <main className="max-w-7xl mx-auto py-6 px-4">
+        {/* Your components will be generated here */}
+        <p className="text-gray-600">
+          Use <code className="bg-gray-200 px-2 py-1 rounded">thinksoft dev</code> to start building!
+        </p>
+      </main>
+    </div>
+  )
+}
+
+export default App
+`;
+    fs.writeFileSync(appPath, content);
+    // Update Tailwind config
+    const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'tailwind.config.js'), tailwindConfig);
+    // Update index.css with Tailwind directives
+    const indexCss = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'src', 'index.css'), indexCss);
+}
+function showDevBanner(appId, framework) {
+    console.log();
+    console.log(chalk_1.default.magenta('╔═══════════════════════════════════════════════════════╗'));
+    console.log(chalk_1.default.magenta('║') + chalk_1.default.white.bold('  ThinkSoft Dev - AI-Assisted Development              ') + chalk_1.default.magenta('║'));
+    console.log(chalk_1.default.magenta('║') + chalk_1.default.gray(`  App: ${appId} | Framework: ${framework}`.padEnd(55)) + chalk_1.default.magenta('║'));
+    console.log(chalk_1.default.magenta('╠═══════════════════════════════════════════════════════╣'));
+    console.log(chalk_1.default.magenta('║') + chalk_1.default.gray('  Describe what you want to build. Type ') + chalk_1.default.yellow('help') + chalk_1.default.gray(' or ') + chalk_1.default.yellow('quit') + chalk_1.default.gray('   ') + chalk_1.default.magenta('║'));
+    console.log(chalk_1.default.magenta('╚═══════════════════════════════════════════════════════╝'));
+    console.log();
+}
+function showDevHelp() {
+    console.log();
+    console.log(chalk_1.default.cyan.bold('ThinkSoft Dev Commands:'));
+    console.log();
+    console.log(chalk_1.default.yellow('  <prompt>') + chalk_1.default.white('       Describe what you want to build'));
+    console.log(chalk_1.default.yellow('  help') + chalk_1.default.white('           Show this help message'));
+    console.log(chalk_1.default.yellow('  files') + chalk_1.default.white('          List files in src/ directory'));
+    console.log(chalk_1.default.yellow('  clear') + chalk_1.default.white('          Clear screen'));
+    console.log(chalk_1.default.yellow('  quit / exit') + chalk_1.default.white('    Exit dev mode'));
+    console.log();
+    console.log(chalk_1.default.gray('Examples:'));
+    console.log(chalk_1.default.gray('  dev> Create a dashboard showing all leads with status filters'));
+    console.log(chalk_1.default.gray('  dev> Add a form to create new contacts'));
+    console.log(chalk_1.default.gray('  dev> Update LeadsPage to include a search bar'));
+    console.log();
+}
+async function runDevPrompt(appId, framework) {
+    let isRunning = true;
+    const createPrompt = () => {
+        if (!isRunning)
+            return;
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(chalk_1.default.magenta('dev> '), async (input) => {
+            rl.close();
+            const trimmed = input.trim();
+            if (!trimmed) {
+                setTimeout(() => createPrompt(), 50);
+                return;
+            }
+            const command = trimmed.toLowerCase();
+            if (command === 'quit' || command === 'exit') {
+                console.log(chalk_1.default.cyan('\nGoodbye! Run "npm run build && thinksoft deploy" when ready.\n'));
+                isRunning = false;
+                return;
+            }
+            if (command === 'help') {
+                showDevHelp();
+                setTimeout(() => createPrompt(), 50);
+                return;
+            }
+            if (command === 'files') {
+                listSrcFiles();
+                setTimeout(() => createPrompt(), 50);
+                return;
+            }
+            if (command === 'clear') {
+                console.clear();
+                showDevBanner(appId, framework);
+                setTimeout(() => createPrompt(), 50);
+                return;
+            }
+            // Generate code
+            await generateCode(appId, framework, trimmed);
+            setTimeout(() => createPrompt(), 50);
+        });
+    };
+    createPrompt();
+}
+function listSrcFiles() {
+    const srcPath = path.join(process.cwd(), 'src');
+    if (!fs.existsSync(srcPath)) {
+        console.log(chalk_1.default.yellow('\nNo src/ directory found\n'));
+        return;
+    }
+    console.log(chalk_1.default.cyan('\nFiles in src/:'));
+    listFilesRecursive(srcPath, 0);
+    console.log();
+}
+function listFilesRecursive(dirPath, depth) {
+    const items = fs.readdirSync(dirPath);
+    for (const item of items) {
+        const fullPath = path.join(dirPath, item);
+        const stat = fs.statSync(fullPath);
+        const indent = '  '.repeat(depth + 1);
+        if (stat.isDirectory()) {
+            console.log(chalk_1.default.blue(`${indent}📁 ${item}/`));
+            listFilesRecursive(fullPath, depth + 1);
+        }
+        else {
+            console.log(chalk_1.default.gray(`${indent}📄 ${item}`));
+        }
+    }
+}
+/**
+ * Analyze user prompt and return implementation plan
+ */
+async function analyzePrompt(appId, userPrompt, existingFiles) {
+    const token = config.getToken();
+    if (!token) {
+        return null;
+    }
+    try {
+        const response = await fetch(`${BASE_URL}/dev/analyze`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                appId,
+                prompt: userPrompt,
+                existingFiles: existingFiles.map(f => ({ path: f.path })) // Only send paths for analyze
+            })
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const result = await response.json();
+        return result.plan || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Display the implementation plan
+ */
+function showPlan(plan) {
+    console.log();
+    console.log(chalk_1.default.cyan('┌─────────────────────────────────────────────────────────┐'));
+    console.log(chalk_1.default.cyan('│') + chalk_1.default.white.bold(' Plan                                                     ') + chalk_1.default.cyan('│'));
+    console.log(chalk_1.default.cyan('└─────────────────────────────────────────────────────────┘'));
+    console.log();
+    // Summary
+    console.log(chalk_1.default.white('  ' + plan.summary));
+    console.log();
+    // Tables
+    if (plan.tables_needed && plan.tables_needed.length > 0) {
+        console.log(chalk_1.default.gray('  Tables: ') + chalk_1.default.yellow(plan.tables_needed.join(', ')));
+        console.log();
+    }
+    // Files
+    console.log(chalk_1.default.gray('  Files:'));
+    for (const file of plan.files) {
+        const icon = file.action === 'create' ? '✨' : '📝';
+        const actionColor = file.action === 'create' ? chalk_1.default.green : chalk_1.default.blue;
+        console.log(`    ${icon} ${actionColor(file.path)}`);
+        console.log(chalk_1.default.gray(`       ${file.purpose}`));
+    }
+    // Questions (if any)
+    if (plan.questions && plan.questions.length > 0) {
+        console.log();
+        console.log(chalk_1.default.yellow('  ⚠️  Questions:'));
+        for (const q of plan.questions) {
+            console.log(chalk_1.default.yellow(`    • ${q}`));
+        }
+    }
+    console.log();
+}
+/**
+ * Main flow: Analyze prompt, show plan, generate code
+ */
+async function handleUserPrompt(appId, framework, userPrompt) {
+    console.log();
+    // Step 1: Analyze prompt
+    const analyzeSpinner = (0, ora_1.default)('Analyzing request...').start();
+    const existingFiles = collectExistingFiles();
+    const plan = await analyzePrompt(appId, userPrompt, existingFiles);
+    if (!plan) {
+        analyzeSpinner.text = 'Generating code...';
+        // Fallback to direct generation if analyze fails
+        await generateCodeDirect(appId, framework, userPrompt, existingFiles, null, analyzeSpinner);
+        return;
+    }
+    analyzeSpinner.succeed('Analysis complete');
+    // Step 2: Show plan
+    showPlan(plan);
+    // Step 3: Confirm if complex
+    let proceed = true;
+    if (plan.complexity === 'complex') {
+        const { confirmed } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'confirmed',
+                message: 'Proceed with this plan?',
+                default: true
+            }]);
+        proceed = confirmed;
+    }
+    if (!proceed) {
+        console.log(chalk_1.default.yellow('  Cancelled. Try rephrasing your request.'));
+        console.log();
+        return;
+    }
+    // Step 4: Generate code with plan
+    const generateSpinner = (0, ora_1.default)('Generating code...').start();
+    await generateCodeDirect(appId, framework, userPrompt, existingFiles, plan, generateSpinner);
+}
+/**
+ * Generate code (internal function used by handleUserPrompt)
+ */
+async function generateCodeDirect(appId, framework, userPrompt, existingFiles, plan, spinner) {
+    try {
+        const token = config.getToken();
+        if (!token) {
+            spinner.fail('Not authenticated');
+            return;
+        }
+        spinner.text = `Generating code (${existingFiles.length} files for context)...`;
+        // Make request to Firebase Function
+        const response = await fetch(`${BASE_URL}/dev/generate`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                appId,
+                prompt: userPrompt,
+                framework,
+                existingFiles,
+                plan // Include plan for better generation
+            })
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            spinner.fail('Generation failed');
+            console.log(chalk_1.default.red(`Error: ${errorData.error || `HTTP ${response.status}`}`));
+            return;
+        }
+        const result = await response.json();
+        if (!result.success || !result.files || result.files.length === 0) {
+            spinner.fail('No files generated');
+            if (result.error) {
+                console.log(chalk_1.default.red(`Error: ${result.error}`));
+            }
+            return;
+        }
+        spinner.succeed(`Generated ${result.files.length} file(s)`);
+        console.log();
+        // Write files
+        for (const file of result.files) {
+            writeGeneratedFile(file);
+        }
+        // Install dependencies if any
+        if (result.dependencies && result.dependencies.length > 0) {
+            console.log();
+            await installDependencies(result.dependencies);
+        }
+        console.log();
+        console.log(chalk_1.default.gray(`Tokens used: ${result.tokensUsed || 'N/A'}`));
+        console.log();
+    }
+    catch (err) {
+        spinner.fail('Generation failed');
+        console.log(chalk_1.default.red(`Error: ${err.message}`));
+    }
+}
+/**
+ * Legacy generateCode function (for backwards compatibility)
+ */
+async function generateCode(appId, framework, userPrompt) {
+    await handleUserPrompt(appId, framework, userPrompt);
+}
+function collectExistingFiles() {
+    const files = [];
+    const srcPath = path.join(process.cwd(), 'src');
+    if (!fs.existsSync(srcPath)) {
+        return files;
+    }
+    // Collect relevant files (tsx, ts, jsx, js)
+    collectFilesRecursive(srcPath, 'src', files);
+    // Limit to reasonable context size (first 20 files, max 500 lines each)
+    return files.slice(0, 20).map(f => ({
+        path: f.path,
+        content: f.content.split('\n').slice(0, 500).join('\n')
+    }));
+}
+function collectFilesRecursive(dirPath, prefix, files) {
+    const items = fs.readdirSync(dirPath);
+    for (const item of items) {
+        const fullPath = path.join(dirPath, item);
+        const relativePath = `${prefix}/${item}`;
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            // Skip node_modules and hidden directories
+            if (item !== 'node_modules' && !item.startsWith('.')) {
+                collectFilesRecursive(fullPath, relativePath, files);
+            }
+        }
+        else {
+            // Include TypeScript/JavaScript files
+            if (/\.(tsx?|jsx?)$/.test(item)) {
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    files.push({ path: relativePath, content });
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+        }
+    }
+}
+// Track current project directory for file operations
+let projectBaseDir = process.cwd();
+function setProjectBaseDir(dir) {
+    projectBaseDir = dir;
+}
+function getProjectBaseDir() {
+    return projectBaseDir;
+}
+function writeGeneratedFile(file) {
+    const fullPath = path.join(projectBaseDir, file.path);
+    const dir = path.dirname(fullPath);
+    // Create directory if needed
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Check if file exists
+    const exists = fs.existsSync(fullPath);
+    const action = exists ? 'Updated' : 'Created';
+    // Write file
+    fs.writeFileSync(fullPath, file.content);
+    const icon = exists ? '📝' : '✨';
+    console.log(chalk_1.default.green(`${icon} ${action}: ${file.path}`));
+}
+/**
+ * Run initialization with AI-generated suggestion
+ */
+async function runInitWithSuggestion(appId, framework) {
+    console.log();
+    console.log(chalk_1.default.cyan('🧠 Analyzing your app to suggest a purpose-built frontend...'));
+    console.log();
+    const spinner = (0, ora_1.default)('Generating intelligent suggestion...').start();
+    // Fetch suggestion from API
+    const suggestion = await fetchFrontendSuggestion(appId);
+    if (!suggestion) {
+        spinner.fail('Failed to generate suggestion');
+        console.log(chalk_1.default.yellow('  Try running without --init flag for manual development'));
+        return;
+    }
+    spinner.succeed('Analysis complete!');
+    console.log();
+    // Display reasoning
+    displaySuggestionReasoning(suggestion);
+    // Display suggested frontend apps
+    displaySuggestedApps(suggestion);
+    // Ask user to confirm
+    const { proceed } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'proceed',
+            message: 'Generate this frontend?',
+            default: true
+        }]);
+    if (!proceed) {
+        console.log(chalk_1.default.yellow('\n  Cancelled. Run "thinksoft dev" for manual development.\n'));
+        return;
+    }
+    // Let user select which app to generate (if multiple)
+    let selectedApp;
+    let projectDir = '';
+    if (suggestion.frontend_apps.length > 1) {
+        const { appChoice } = await inquirer_1.default.prompt([{
+                type: 'list',
+                name: 'appChoice',
+                message: 'Which frontend app to generate?',
+                choices: [
+                    ...suggestion.frontend_apps.map(app => ({
+                        name: `${app.name} (${app.audience})`,
+                        value: app.slug
+                    })),
+                    { name: 'All apps', value: '__all__' }
+                ]
+            }]);
+        if (appChoice === '__all__') {
+            // Generate all apps
+            const projectDirs = [];
+            for (const app of suggestion.frontend_apps) {
+                const dir = await generateFrontendApp(appId, framework, app, suggestion.shared_components);
+                projectDirs.push(dir);
+            }
+            // Show summary for all generated apps
+            console.log();
+            console.log(chalk_1.default.green('✨ All frontend apps generated successfully!'));
+            console.log();
+            console.log(chalk_1.default.gray('Generated projects:'));
+            for (const dir of projectDirs) {
+                const dirName = path.basename(dir);
+                console.log(chalk_1.default.gray(`  • ${dirName}/`));
+            }
+            console.log();
+            console.log(chalk_1.default.gray('Next steps for each project:'));
+            console.log(chalk_1.default.white('  1. cd <project-folder>'));
+            console.log(chalk_1.default.white('  2. npm install'));
+            console.log(chalk_1.default.white('  3. npm run dev'));
+            console.log();
+            return;
+        }
+        else {
+            selectedApp = suggestion.frontend_apps.find(a => a.slug === appChoice);
+            projectDir = await generateFrontendApp(appId, framework, selectedApp, suggestion.shared_components);
+        }
+    }
+    else {
+        selectedApp = suggestion.frontend_apps[0];
+        projectDir = await generateFrontendApp(appId, framework, selectedApp, suggestion.shared_components);
+    }
+    const projectName = path.basename(projectDir);
+    console.log();
+    console.log(chalk_1.default.green('✨ Frontend generated successfully!'));
+    console.log();
+    console.log(chalk_1.default.cyan('┌─────────────────────────────────────────────────────────────┐'));
+    console.log(chalk_1.default.cyan('│') + chalk_1.default.white.bold(' Next Steps                                                   ') + chalk_1.default.cyan('│'));
+    console.log(chalk_1.default.cyan('└─────────────────────────────────────────────────────────────┘'));
+    console.log();
+    console.log(chalk_1.default.white(`  1. cd ${projectName}`));
+    console.log(chalk_1.default.white('  2. npm install'));
+    console.log(chalk_1.default.white('  3. npm run dev'));
+    console.log();
+    console.log(chalk_1.default.gray('  To deploy:'));
+    console.log(chalk_1.default.white('  4. npm run build'));
+    console.log(chalk_1.default.white('  5. npm run deploy'));
+    console.log();
+}
+/**
+ * Fetch frontend suggestion from API
+ */
+async function fetchFrontendSuggestion(appId) {
+    const token = config.getToken();
+    if (!token) {
+        return null;
+    }
+    try {
+        const response = await fetch(`${BASE_URL}/dev/suggest`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ appId })
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const result = await response.json();
+        return result.suggestion || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Display reasoning analysis
+ */
+function displaySuggestionReasoning(suggestion) {
+    const reasoning = suggestion.reasoning;
+    console.log(chalk_1.default.cyan('┌─────────────────────────────────────────────────────────────┐'));
+    console.log(chalk_1.default.cyan('│') + chalk_1.default.white.bold(' AI Analysis                                                  ') + chalk_1.default.cyan('│'));
+    console.log(chalk_1.default.cyan('└─────────────────────────────────────────────────────────────┘'));
+    console.log();
+    // Purpose
+    console.log(chalk_1.default.white.bold('  Purpose:'));
+    console.log(chalk_1.default.gray(`    ${reasoning.inferred_purpose}`));
+    console.log();
+    // Target Users
+    console.log(chalk_1.default.white.bold('  Target Users:'));
+    for (const user of reasoning.target_users) {
+        const typeLabel = user.type === 'primary' ? chalk_1.default.green('●') : chalk_1.default.gray('○');
+        console.log(`    ${typeLabel} ${chalk_1.default.white(user.who)}`);
+        console.log(chalk_1.default.gray(`      Needs: ${user.needs}`));
+    }
+    console.log();
+    // Key Workflows
+    console.log(chalk_1.default.white.bold('  Key Workflows:'));
+    for (const workflow of reasoning.key_workflows) {
+        console.log(chalk_1.default.gray(`    → ${workflow}`));
+    }
+    console.log();
+    // UI Approach
+    console.log(chalk_1.default.white.bold('  UI Approach:'));
+    console.log(chalk_1.default.gray(`    ${reasoning.ui_approach}`));
+    console.log();
+}
+/**
+ * Display suggested frontend apps
+ */
+function displaySuggestedApps(suggestion) {
+    console.log(chalk_1.default.cyan('┌─────────────────────────────────────────────────────────────┐'));
+    console.log(chalk_1.default.cyan('│') + chalk_1.default.white.bold(' Suggested Frontend                                           ') + chalk_1.default.cyan('│'));
+    console.log(chalk_1.default.cyan('└─────────────────────────────────────────────────────────────┘'));
+    console.log();
+    for (const app of suggestion.frontend_apps) {
+        console.log(chalk_1.default.yellow.bold(`  📱 ${app.name}`));
+        console.log(chalk_1.default.gray(`     ${app.description}`));
+        console.log(chalk_1.default.gray(`     Audience: ${app.audience}`));
+        console.log();
+        console.log(chalk_1.default.white('     Pages:'));
+        for (const page of app.pages.slice(0, 6)) {
+            console.log(chalk_1.default.green(`       ✦ ${page.name}`));
+            console.log(chalk_1.default.gray(`         ${page.purpose}`));
+            if (page.key_features && page.key_features.length > 0) {
+                console.log(chalk_1.default.gray(`         Features: ${page.key_features.join(', ')}`));
+            }
+        }
+        if (app.pages.length > 6) {
+            console.log(chalk_1.default.gray(`       ... and ${app.pages.length - 6} more pages`));
+        }
+        console.log();
+    }
+    // Summary
+    console.log(chalk_1.default.white.bold('  Summary:'));
+    console.log(chalk_1.default.gray(`    ${suggestion.summary}`));
+    console.log();
+    // Dependencies
+    if (suggestion.dependencies && suggestion.dependencies.length > 0) {
+        console.log(chalk_1.default.white.bold('  Dependencies:'));
+        console.log(chalk_1.default.gray(`    ${suggestion.dependencies.join(', ')}`));
+        console.log();
+    }
+}
+/**
+ * Generate a frontend app from suggestion
+ */
+async function generateFrontendApp(appId, framework, app, sharedComponents) {
+    // Create project directory based on app slug
+    const projectDir = path.join(process.cwd(), app.slug);
+    console.log();
+    console.log(chalk_1.default.cyan(`📦 Creating project: ${chalk_1.default.white.bold(app.slug)}/`));
+    console.log(chalk_1.default.gray(`   ${app.name}`));
+    console.log();
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(projectDir)) {
+        fs.mkdirSync(projectDir, { recursive: true });
+    }
+    // Set the project base directory for all file operations
+    setProjectBaseDir(projectDir);
+    // Initialize project with package.json
+    await initializeProject(projectDir, app.name, appId, framework);
+    // Build a comprehensive prompt for code generation
+    const pagesDescription = app.pages.map(p => `- ${p.name} (${p.path}): ${p.purpose}. Features: ${p.key_features.join(', ')}`).join('\n');
+    const componentsDescription = [
+        ...app.components.map(c => `- ${c.name}: ${c.purpose}`),
+        ...sharedComponents.map(c => `- ${c.name}: ${c.purpose}`)
+    ].join('\n');
+    const navDescription = app.navigation.map(n => `- ${n.label} → ${n.path}`).join('\n');
+    const prompt = `Generate a complete ${app.name} frontend with the following specifications:
+
+## App Purpose
+${app.description}
+Audience: ${app.audience}
+
+## Pages to Generate
+${pagesDescription}
+
+## Components Needed
+${componentsDescription}
+
+## Navigation Structure
+${navDescription}
+
+## Requirements
+- Create ALL pages listed above as complete, working files
+- Use ThinkSoft SDK for all data operations
+- Include proper TypeScript types
+- Use Tailwind CSS for styling
+- Handle loading, error, and empty states
+- Make it responsive and mobile-friendly
+- Generate the navigation/sidebar component
+- Generate an App.tsx that sets up routing
+
+Generate production-ready code for all files.`;
+    // Use the existing generateCode flow with this comprehensive prompt
+    const existingFiles = collectExistingFiles();
+    // Create a plan from the suggestion
+    const plan = {
+        complexity: 'complex',
+        intent: 'build_feature',
+        summary: app.description,
+        tables_needed: [...new Set(app.pages.flatMap(p => p.tables))],
+        files: [
+            ...app.pages.map(p => ({
+                path: p.path,
+                action: 'create',
+                purpose: p.purpose
+            })),
+            ...app.components.map(c => ({
+                path: c.path || `src/components/${c.name}.tsx`,
+                action: 'create',
+                purpose: c.purpose
+            })),
+            ...sharedComponents.map(c => ({
+                path: c.path || `src/components/${c.name}.tsx`,
+                action: 'create',
+                purpose: c.purpose
+            })),
+            { path: 'src/App.tsx', action: 'create', purpose: 'Main app with routing' },
+            { path: 'src/components/Sidebar.tsx', action: 'create', purpose: 'Navigation sidebar' }
+        ]
+    };
+    const spinner = (0, ora_1.default)('Generating code...').start();
+    await generateCodeDirect(appId, framework, prompt, existingFiles, plan, spinner);
+    // Reset base dir to current working directory
+    setProjectBaseDir(process.cwd());
+    return projectDir;
+}
+/**
+ * Initialize a new project with package.json and config files
+ */
+async function initializeProject(projectDir, appName, appId, framework) {
+    const pkgPath = path.join(projectDir, 'package.json');
+    // Check if package.json already exists
+    if (fs.existsSync(pkgPath)) {
+        console.log(chalk_1.default.gray('  package.json already exists, skipping initialization'));
+        return;
+    }
+    const slugName = path.basename(projectDir);
+    // Create package.json
+    const packageJson = {
+        name: slugName,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'vite',
+            build: 'tsc && vite build',
+            preview: 'vite preview',
+            deploy: `thinksoft deploy --app ${appId}`
+        },
+        dependencies: {
+            '@thinksoftai/sdk': '^1.0.0',
+            'react': '^18.2.0',
+            'react-dom': '^18.2.0',
+            'react-router-dom': '^6.20.0',
+            'lucide-react': '^0.294.0'
+        },
+        devDependencies: {
+            '@types/react': '^18.2.0',
+            '@types/react-dom': '^18.2.0',
+            '@vitejs/plugin-react': '^4.2.0',
+            'autoprefixer': '^10.4.16',
+            'postcss': '^8.4.32',
+            'tailwindcss': '^3.3.6',
+            'typescript': '^5.3.0',
+            'vite': '^5.0.0'
+        }
+    };
+    fs.writeFileSync(pkgPath, JSON.stringify(packageJson, null, 2));
+    console.log(chalk_1.default.green('  ✨ Created: package.json'));
+    // Create thinksoft.json
+    const thinksoftJson = {
+        appId,
+        name: appName,
+        framework,
+        outputDir: 'dist'
+    };
+    fs.writeFileSync(path.join(projectDir, 'thinksoft.json'), JSON.stringify(thinksoftJson, null, 2));
+    console.log(chalk_1.default.green('  ✨ Created: thinksoft.json'));
+    // Create vite.config.ts
+    const viteConfig = `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+})
+`;
+    fs.writeFileSync(path.join(projectDir, 'vite.config.ts'), viteConfig);
+    console.log(chalk_1.default.green('  ✨ Created: vite.config.ts'));
+    // Create tsconfig.json
+    const tsConfig = {
+        compilerOptions: {
+            target: 'ES2020',
+            useDefineForClassFields: true,
+            lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+            module: 'ESNext',
+            skipLibCheck: true,
+            moduleResolution: 'bundler',
+            allowImportingTsExtensions: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+            jsx: 'react-jsx',
+            strict: true,
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            noFallthroughCasesInSwitch: true,
+            baseUrl: '.',
+            paths: {
+                '@/*': ['./src/*']
+            }
+        },
+        include: ['src'],
+        references: [{ path: './tsconfig.node.json' }]
+    };
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+    console.log(chalk_1.default.green('  ✨ Created: tsconfig.json'));
+    // Create tsconfig.node.json
+    const tsConfigNode = {
+        compilerOptions: {
+            composite: true,
+            skipLibCheck: true,
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            allowSyntheticDefaultImports: true
+        },
+        include: ['vite.config.ts']
+    };
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.node.json'), JSON.stringify(tsConfigNode, null, 2));
+    // Create tailwind.config.js
+    const tailwindConfig = `/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./index.html', './src/**/*.{js,ts,jsx,tsx}'],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}
+`;
+    fs.writeFileSync(path.join(projectDir, 'tailwind.config.js'), tailwindConfig);
+    console.log(chalk_1.default.green('  ✨ Created: tailwind.config.js'));
+    // Create postcss.config.js
+    const postcssConfig = `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
+`;
+    fs.writeFileSync(path.join(projectDir, 'postcss.config.js'), postcssConfig);
+    // Create index.html
+    const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${appName}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+    fs.writeFileSync(path.join(projectDir, 'index.html'), indexHtml);
+    console.log(chalk_1.default.green('  ✨ Created: index.html'));
+    // Create src/main.tsx
+    const srcDir = path.join(projectDir, 'src');
+    if (!fs.existsSync(srcDir)) {
+        fs.mkdirSync(srcDir, { recursive: true });
+    }
+    const mainTsx = `import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { BrowserRouter } from 'react-router-dom'
+import App from './App'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <BrowserRouter>
+      <App />
+    </BrowserRouter>
+  </React.StrictMode>,
+)
+`;
+    fs.writeFileSync(path.join(srcDir, 'main.tsx'), mainTsx);
+    console.log(chalk_1.default.green('  ✨ Created: src/main.tsx'));
+    // Create src/index.css with Tailwind
+    const indexCss = `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+    fs.writeFileSync(path.join(srcDir, 'index.css'), indexCss);
+    console.log(chalk_1.default.green('  ✨ Created: src/index.css'));
+    console.log();
+}
+/**
+ * Install npm dependencies
+ */
+async function installDependencies(dependencies) {
+    if (dependencies.length === 0)
+        return;
+    // Check which packages are already installed
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    let installedPackages = new Set();
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        installedPackages = new Set(Object.keys(allDeps));
+    }
+    catch {
+        // If can't read package.json, try to install all
+    }
+    // Filter out already installed packages
+    const toInstall = dependencies.filter(dep => {
+        // Extract package name (without version)
+        const pkgName = dep.startsWith('@')
+            ? dep.split('/').slice(0, 2).join('/').split('@').slice(0, 2).join('@')
+            : dep.split('@')[0];
+        return !installedPackages.has(pkgName);
+    });
+    if (toInstall.length === 0) {
+        console.log(chalk_1.default.gray('  All dependencies already installed'));
+        return;
+    }
+    console.log(chalk_1.default.cyan('📦 Installing dependencies:'));
+    for (const dep of toInstall) {
+        console.log(chalk_1.default.gray(`   • ${dep}`));
+    }
+    console.log();
+    const spinner = (0, ora_1.default)('Installing packages...').start();
+    try {
+        const packagesStr = toInstall.join(' ');
+        (0, child_process_1.execSync)(`npm install ${packagesStr}`, {
+            stdio: 'pipe',
+            cwd: process.cwd()
+        });
+        spinner.succeed(`Installed ${toInstall.length} package(s)`);
+    }
+    catch (err) {
+        spinner.fail('Failed to install some packages');
+        console.log(chalk_1.default.yellow('  You may need to install manually:'));
+        console.log(chalk_1.default.yellow(`  npm install ${toInstall.join(' ')}`));
+    }
+}
+//# sourceMappingURL=dev.js.map