create-aziz-app 2.0.14 → 3.0.0

package/template/scripts/dev-server.js

@@ -1,188 +1,239 @@
 #!/usr/bin/env node
 
-const fs = require('fs');
+const fs   = require('fs');
 const path = require('path');
 const http = require('http');
-const { exec } = require('child_process');
+const crypto = require('crypto');
 
 const PORT = process.env.PORT || 3000;
+const ROOT = process.cwd();
 const clients = new Set();
 const apiHandlers = {};
 
-console.log('🚀 Dev server starting...\n');
+console.log('🚀 Aziz.js dev server starting...\n');
+
+// ─── Route Manifest ──────────────────────────────────────────
+// Scans app/ folder and builds a list of pages and layouts
+
+function buildRouteManifest() {
+    const manifest = [];
+    const appDir = path.join(ROOT, 'app');
+    if (!fs.existsSync(appDir)) return manifest;
+
+    function scan(dir, routeBase) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+
+            if (entry.isDirectory()) {
+                // Dynamic route: [slug] → :slug
+                const segment = entry.name.startsWith('[') && entry.name.endsWith(']')
+                    ? ':' + entry.name.slice(1, -1)
+                    : entry.name;
+                scan(fullPath, routeBase === '/' ? '/' + segment : routeBase + '/' + segment);
+            } else if (entry.name === 'page.js' || entry.name === 'page.jsx') {
+                manifest.push({
+                    type: 'page',
+                    pathname: routeBase || '/',
+                    filePath: '/app' + (routeBase === '/' ? '' : routeBase) + '/' + entry.name
+                });
+            } else if (entry.name === 'layout.js' || entry.name === 'layout.jsx') {
+                manifest.push({
+                    type: 'layout',
+                    pathname: routeBase || '/',
+                    filePath: '/app' + (routeBase === '/' ? '' : routeBase) + '/' + entry.name
+                });
+            }
+        }
+    }
 
-// Load API routes from api/ folder
-function loadApiRoutes() {
-    const apiDir = path.join(process.cwd(), 'api');
-    if (!fs.existsSync(apiDir)) {
-        console.log('⚠️  No api/ folder found\n');
-        return;
+    scan(appDir, '/');
+    return manifest;
+}
+
+// ─── Bare Import Rewriter ─────────────────────────────────────
+// Transforms: import X from 'mongoose'  →  import X from '/_modules/mongoose'
+// Transforms: import X from '@/lib/db'  →  import X from '/lib/db.js'
+
+function rewriteImports(code, filePath) {
+    // Rewrite @/ alias to absolute path
+    code = code.replace(
+        /from\s+['"]@\/([^'"]+)['"]/g,
+        (_, p) => `from '/${p}'`
+    );
+
+    // Rewrite bare specifiers (not starting with /, ./, ../)
+    code = code.replace(
+        /from\s+['"]([^'"./][^'"]*)['"]/g,
+        (match, specifier) => `from '/_modules/${specifier}'`
+    );
+
+    // Same for dynamic imports
+    code = code.replace(
+        /import\s*\(\s*['"]([^'"./][^'"]*)['"]\s*\)/g,
+        (_, specifier) => `import('/_modules/${specifier}')`
+    );
+
+    return code;
+}
+
+// ─── Module Resolver ─────────────────────────────────────────
+// Serves node_modules files for bare imports
+
+function resolveNodeModule(specifier) {
+    // Try to find the package in node_modules
+    const parts = specifier.split('/');
+    const pkgName = parts[0].startsWith('@') ? parts[0] + '/' + parts[1] : parts[0];
+    const subPath = parts[0].startsWith('@') ? parts.slice(2).join('/') : parts.slice(1).join('/');
+
+    const nodeModulesDir = path.join(ROOT, 'node_modules');
+
+    // Try package.json to find main/module entry
+    const pkgJsonPath = path.join(nodeModulesDir, pkgName, 'package.json');
+    if (!fs.existsSync(pkgJsonPath)) {
+        return null;
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+
+    if (subPath) {
+        // Specific file requested
+        const candidates = [
+            path.join(nodeModulesDir, pkgName, subPath),
+            path.join(nodeModulesDir, pkgName, subPath + '.js'),
+            path.join(nodeModulesDir, pkgName, subPath + '/index.js'),
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(c)) return c;
+        }
+        return null;
     }
 
+    // Use module > browser > main priority
+    const entry = pkg.module || pkg.browser || pkg.main || 'index.js';
+    const entryPath = path.join(nodeModulesDir, pkgName, entry);
+    return fs.existsSync(entryPath) ? entryPath : null;
+}
+
+// ─── JSX Transform ───────────────────────────────────────────
+// Adds /** @jsx h */ pragma if file uses JSX and doesn't have it
+
+function ensureJsxPragma(code) {
+    if (code.includes('@jsx') || !code.includes('<')) return code;
+    // Simple heuristic: if it has JSX-like syntax, add pragma
+    if (/<[A-Z]|<[a-z]+[\s/>]/.test(code)) {
+        return '/** @jsx h */\n' + code;
+    }
+    return code;
+}
+
+// ─── API Route Loader ─────────────────────────────────────────
+
+function loadApiRoutes() {
+    const apiDir = path.join(ROOT, 'api');
+    if (!fs.existsSync(apiDir)) return;
+
     const files = fs.readdirSync(apiDir).filter(f => f.endsWith('.js'));
-    console.log(`📡 Loading ${files.length} API routes...\n`);
+    console.log(`📡 Loading ${files.length} API route(s):`);
 
     files.forEach(file => {
         const routeName = path.basename(file, '.js');
-        const filePath = path.join(apiDir, file);
-        
+        const filePath  = path.join(apiDir, file);
+
         try {
-            // Clear require cache to allow hot reload
             delete require.cache[require.resolve(filePath)];
-            
-            // Load the API module
-            const module = require(filePath);
-            
-            // Support both styles:
-            // 1. Default export function (old style)
-            // 2. Named exports: GET, POST, PUT, DELETE (new Next.js App Router style)
-            
-            if (module.GET || module.POST || module.PUT || module.DELETE || module.PATCH) {
-                // New style: Named exports
+            const mod = require(filePath);
+
+            if (mod.GET || mod.POST || mod.PUT || mod.DELETE || mod.PATCH) {
                 const methods = {};
-                if (module.GET) methods.GET = module.GET;
-                if (module.POST) methods.POST = module.POST;
-                if (module.PUT) methods.PUT = module.PUT;
-                if (module.DELETE) methods.DELETE = module.DELETE;
-                if (module.PATCH) methods.PATCH = module.PATCH;
-                
+                ['GET','POST','PUT','DELETE','PATCH'].forEach(m => { if (mod[m]) methods[m] = mod[m]; });
                 apiHandlers[routeName] = methods;
                 console.log(`   ✅ /api/${routeName} [${Object.keys(methods).join(', ')}]`);
             } else {
-                // Old style: Default export
-                const handler = module.default || module;
-                
+                const handler = mod.default || mod;
                 if (typeof handler === 'function') {
                     apiHandlers[routeName] = handler;
                     console.log(`   ✅ /api/${routeName}`);
-                } else {
-                    console.log(`   ⚠️  /api/${routeName} - No handler function exported`);
                 }
             }
-        } catch (error) {
-            console.error(`   ❌ /api/${routeName} - ${error.message}`);
+        } catch (err) {
+            console.error(`   ❌ /api/${routeName} — ${err.message}`);
         }
     });
-    
+
     console.log('');
 }
-}
 
-// Parse request body
+// ─── Request Helpers ─────────────────────────────────────────
+
 function parseBody(req) {
     return new Promise((resolve, reject) => {
         let body = '';
-        req.on('data', chunk => {
-            body += chunk.toString();
-        });
+        req.on('data', c => body += c);
         req.on('end', () => {
             try {
-                if (body && req.headers['content-type']?.includes('application/json')) {
-                    resolve(JSON.parse(body));
-                } else {
-                    resolve(body);
-                }
-            } catch (e) {
-                resolve(body);
-            }
+                resolve(body && req.headers['content-type']?.includes('application/json')
+                    ? JSON.parse(body) : body);
+            } catch { resolve(body); }
         });
         req.on('error', reject);
     });
 }
 
-// Parse query string
 function parseQuery(url) {
-    const query = {};
-    const queryString = url.split('?')[1];
-    if (queryString) {
-        queryString.split('&').forEach(param => {
-            const [key, value] = param.split('=');
-            query[decodeURIComponent(key)] = decodeURIComponent(value || '');
-        });
-    }
-    return query;
+    const q = {};
+    const qs = url.split('?')[1];
+    if (qs) qs.split('&').forEach(p => {
+        const [k, v] = p.split('=');
+        q[decodeURIComponent(k)] = decodeURIComponent(v || '');
+    });
+    return q;
 }
 
-// Handle API requests
+// ─── API Request Handler ──────────────────────────────────────
+
 async function handleApiRequest(req, res) {
-    const urlPath = req.url.split('?')[0];
+    const urlPath   = req.url.split('?')[0];
     const routeName = urlPath.replace('/api/', '');
-    
-    const handler = apiHandlers[routeName];
-    
+    const handler   = apiHandlers[routeName];
+
     if (!handler) {
         res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'API route not found' }));
+        res.end(JSON.stringify({ error: `API route /api/${routeName} not found` }));
         return;
     }
 
     try {
-        // Parse request
-        const body = await parseBody(req);
+        const body  = await parseBody(req);
         const query = parseQuery(req.url);
-        
-        // Check if handler is a function (old style) or object with HTTP methods (new style)
-        let result;
-        
-        if (typeof handler === 'function') {
-            // Old style: default export function
-            const apiReq = {
-                method: req.method,
-                body: body,
-                query: query,
-                headers: req.headers,
-                url: req.url
-            };
 
+        if (typeof handler === 'function') {
+            // Old style
+            const apiReq = { method: req.method, body, query, headers: req.headers, url: req.url };
             const apiRes = {
-                statusCode: 200,
-                headers: {},
-                status(code) {
-                    this.statusCode = code;
-                    return this;
-                },
-                json(data) {
-                    res.writeHead(this.statusCode, {
-                        'Content-Type': 'application/json',
-                        'Access-Control-Allow-Origin': '*',
-                        ...this.headers
-                    });
-                    res.end(JSON.stringify(data));
-                    return this;
+                statusCode: 200, headers: {},
+                status(c) { this.statusCode = c; return this; },
+                json(d) {
+                    res.writeHead(this.statusCode, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...this.headers });
+                    res.end(JSON.stringify(d));
                 },
-                send(data) {
-                    res.writeHead(this.statusCode, {
-                        'Content-Type': 'text/plain',
-                        'Access-Control-Allow-Origin': '*',
-                        ...this.headers
-                    });
-                    res.end(data);
-                    return this;
+                send(d) {
+                    res.writeHead(this.statusCode, { 'Content-Type': 'text/plain', 'Access-Control-Allow-Origin': '*', ...this.headers });
+                    res.end(d);
                 },
-                setHeader(key, value) {
-                    this.headers[key] = value;
-                    return this;
-                }
+                setHeader(k, v) { this.headers[k] = v; return this; }
             };
-
             await handler(apiReq, apiRes);
-        } else if (typeof handler === 'object') {
-            // New style: Named exports (GET, POST, PUT, DELETE)
-            const methodHandler = handler[req.method];
-            
-            if (!methodHandler) {
-                res.writeHead(405, { 
-                    'Content-Type': 'application/json',
-                    'Allow': Object.keys(handler).join(', ')
-                });
-                res.end(JSON.stringify({ 
-                    error: 'Method not allowed',
-                    allowedMethods: Object.keys(handler)
-                }));
+        } else {
+            // New style: named exports
+            const methodFn = handler[req.method];
+            if (!methodFn) {
+                res.writeHead(405, { 'Content-Type': 'application/json', 'Allow': Object.keys(handler).join(', ') });
+                res.end(JSON.stringify({ error: 'Method not allowed', allowed: Object.keys(handler) }));
                 return;
             }
 
-            // Create Next.js-style request object
             const request = {
                 method: req.method,
                 headers: req.headers,
@@ -191,240 +242,217 @@ async function handleApiRequest(req, res) {
                 text: async () => typeof body === 'string' ? body : JSON.stringify(body)
             };
 
-            // Call the handler
-            result = await methodHandler(request);
+            const result = await methodFn(request);
 
-            // Handle NextResponse
             if (result && result.body !== undefined) {
-                const statusCode = result.status || 200;
-                const headers = {
-                    'Access-Control-Allow-Origin': '*',
-                    ...Object.fromEntries(result.headers || [])
-                };
-                
-                res.writeHead(statusCode, headers);
+                const headers = { 'Access-Control-Allow-Origin': '*', ...Object.fromEntries(result.headers || []) };
+                res.writeHead(result.status || 200, headers);
                 res.end(result.body);
             }
         }
-        
-    } catch (error) {
-        console.error(`❌ API Error on /api/${routeName}:`, error);
+    } catch (err) {
+        console.error(`❌ API Error /api/${routeName}:`, err);
         res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: error.message }));
+        res.end(JSON.stringify({ error: err.message }));
     }
 }
 
-// Function to generate imports
-function generateImports() {
-    console.log('🔄 Regenerating imports...');
-    exec('node scripts/generate-imports.js', (error, stdout, stderr) => {
-        if (error) {
-            console.error('❌ Error:', error);
-            return;
-        }
-        console.log(stdout);
-        // Notify all connected clients to reload
-        notifyClients();
-    });
-}
+// ─── HTTP Server ──────────────────────────────────────────────
+
+const MIME = {
+    '.html': 'text/html',
+    '.js':   'text/javascript',
+    '.jsx':  'text/javascript',
+    '.mjs':  'text/javascript',
+    '.css':  'text/css',
+    '.json': 'application/json',
+    '.png':  'image/png',
+    '.jpg':  'image/jpeg',
+    '.svg':  'image/svg+xml',
+    '.ico':  'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2':'font/woff2',
+    '.ttf':  'font/ttf',
+};
+
+const NO_CACHE = {
+    'Cache-Control': 'no-cache, no-store, must-revalidate',
+    'Pragma': 'no-cache',
+    'Expires': '0'
+};
 
-// Notify all clients to reload
-function notifyClients() {
-    const timestamp = new Date().toLocaleTimeString();
-    console.log(`🔄 [${timestamp}] Notifying ${clients.size} browser(s) to reload...`);
-    clients.forEach(client => {
-        try {
-            client.send('reload');
-        } catch (e) {
-            clients.delete(client);
-        }
-    });
-}
-
-// Create HTTP server
 const server = http.createServer(async (req, res) => {
-    // Handle API routes
-    if (req.url.startsWith('/api/')) {
+    const urlWithoutQuery = req.url.split('?')[0];
+
+    // ── CORS preflight
+    if (req.method === 'OPTIONS') {
+        res.writeHead(200, { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type' });
+        res.end();
+        return;
+    }
+
+    // ── API routes
+    if (urlWithoutQuery.startsWith('/api/')) {
         await handleApiRequest(req, res);
         return;
     }
 
-    // Handle CORS preflight
-    if (req.method === 'OPTIONS') {
-        res.writeHead(200, {
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-            'Access-Control-Allow-Headers': 'Content-Type'
-        });
-        res.end();
+    // ── Route manifest (used by router.js to discover pages)
+    if (urlWithoutQuery === '/_framework/routes.json') {
+        const manifest = buildRouteManifest();
+        res.writeHead(200, { 'Content-Type': 'application/json', ...NO_CACHE });
+        res.end(JSON.stringify(manifest));
         return;
     }
 
-    // Strip query parameters for file serving (cache busting)
-    let filePath = '.' + req.url.split('?')[0];
-    if (filePath === './') {
-        filePath = './app.html';
+    // ── node_modules bare imports: /_modules/mongoose → node_modules/mongoose
+    if (urlWithoutQuery.startsWith('/_modules/')) {
+        const specifier = urlWithoutQuery.slice('/_modules/'.length);
+        const filePath  = resolveNodeModule(specifier);
+
+        if (!filePath) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: `Module not found: ${specifier}. Run: npm install ${specifier.split('/')[0]}` }));
+            return;
+        }
+
+        try {
+            let code = fs.readFileSync(filePath, 'utf8');
+            code = rewriteImports(code, filePath);
+            res.writeHead(200, { 'Content-Type': 'text/javascript', ...NO_CACHE });
+            res.end(code);
+        } catch (err) {
+            res.writeHead(500);
+            res.end('Error reading module: ' + err.message);
+        }
+        return;
     }
 
-    const extname = String(path.extname(filePath)).toLowerCase();
-    const mimeTypes = {
-        '.html': 'text/html',
-        '.js': 'text/javascript',
-        '.jsx': 'text/javascript',
-        '.css': 'text/css',
-        '.json': 'application/json',
-        '.png': 'image/png',
-        '.jpg': 'image/jpg',
-        '.gif': 'image/gif',
-        '.svg': 'image/svg+xml',
-        '.wav': 'audio/wav',
-        '.mp4': 'video/mp4',
-        '.woff': 'application/font-woff',
-        '.ttf': 'application/font-ttf',
-        '.eot': 'application/vnd.ms-fontobject',
-        '.otf': 'application/font-otf',
-        '.wasm': 'application/wasm'
-    };
+    // ── Static files
+    let filePath = path.join(ROOT, urlWithoutQuery);
+
+    // Default to index.html
+    if (urlWithoutQuery === '/' || urlWithoutQuery === '') {
+        filePath = path.join(ROOT, 'index.html');
+    }
 
-    const contentType = mimeTypes[extname] || 'application/octet-stream';
+    // SPA fallback: any path without extension → index.html
+    const ext = path.extname(urlWithoutQuery);
+    if (!ext && urlWithoutQuery !== '/') {
+        filePath = path.join(ROOT, 'index.html');
+    }
 
-    fs.readFile(filePath, (error, content) => {
-        if (error) {
-            if (error.code === 'ENOENT') {
-                res.writeHead(404, { 'Content-Type': 'text/html' });
-                res.end('<h1>404 - File Not Found</h1>', 'utf-8');
-            } else {
-                res.writeHead(500);
-                res.end('Server Error: ' + error.code, 'utf-8');
-            }
+    if (!fs.existsSync(filePath)) {
+        // Try with .js extension
+        if (fs.existsSync(filePath + '.js')) {
+            filePath = filePath + '.js';
         } else {
-            // Add cache control headers to prevent caching during development
-            res.writeHead(200, { 
-                'Content-Type': contentType,
-                'Cache-Control': 'no-cache, no-store, must-revalidate',
-                'Pragma': 'no-cache',
-                'Expires': '0'
-            });
-            res.end(content, 'utf-8');
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not found: ' + urlWithoutQuery);
+            return;
         }
-    });
+    }
+
+    try {
+        let content = fs.readFileSync(filePath);
+        const fileExt = path.extname(filePath).toLowerCase();
+        const contentType = MIME[fileExt] || 'application/octet-stream';
+
+        // Transform JS/JSX files: rewrite imports
+        if (fileExt === '.js' || fileExt === '.jsx' || fileExt === '.mjs') {
+            let code = content.toString();
+            code = rewriteImports(code, filePath);
+            content = Buffer.from(code);
+        }
+
+        res.writeHead(200, { 'Content-Type': contentType, ...NO_CACHE });
+        res.end(content);
+    } catch (err) {
+        res.writeHead(500);
+        res.end('Server error: ' + err.message);
+    }
 });
 
-// WebSocket implementation (simple, no external dependencies)
-server.on('upgrade', (req, socket, head) => {
-    // Simple WebSocket handshake
+// ─── WebSocket (live reload) ──────────────────────────────────
+
+server.on('upgrade', (req, socket) => {
     const key = req.headers['sec-websocket-key'];
-    const acceptKey = require('crypto')
-        .createHash('sha1')
+    const accept = crypto.createHash('sha1')
         .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
         .digest('base64');
 
     socket.write(
         'HTTP/1.1 101 Switching Protocols\r\n' +
-        'Upgrade: websocket\r\n' +
-        'Connection: Upgrade\r\n' +
-        `Sec-WebSocket-Accept: ${acceptKey}\r\n` +
-        '\r\n'
+        'Upgrade: websocket\r\nConnection: Upgrade\r\n' +
+        `Sec-WebSocket-Accept: ${accept}\r\n\r\n`
     );
 
-    const timestamp = new Date().toLocaleTimeString();
-    console.log(`🔌 [${timestamp}] Browser connected (${clients.size + 1} total)`);
-
-    // Wrap socket with send method
     const client = {
-        socket: socket,
-        send: function(message) {
-            const buffer = Buffer.from(message);
-            const frame = Buffer.alloc(buffer.length + 2);
-            frame[0] = 0x81; // Text frame
-            frame[1] = buffer.length;
-            buffer.copy(frame, 2);
+        send(msg) {
+            const buf = Buffer.from(msg);
+            const frame = Buffer.alloc(buf.length + 2);
+            frame[0] = 0x81; frame[1] = buf.length;
+            buf.copy(frame, 2);
             socket.write(frame);
         }
     };
 
     clients.add(client);
+    console.log(`🔌 Browser connected (${clients.size} total)`);
 
-    socket.on('close', () => {
-        clients.delete(client);
-        const closeTime = new Date().toLocaleTimeString();
-        console.log(`🔌 [${closeTime}] Browser disconnected (${clients.size} remaining)`);
-    });
+    socket.on('close', () => { clients.delete(client); });
+    socket.on('error', () => { clients.delete(client); });
+});
+
+function notifyClients() {
+    console.log(`🔄 Reloading ${clients.size} browser(s)...`);
+    clients.forEach(c => { try { c.send('reload'); } catch { clients.delete(c); } });
+}
+
+// ─── File Watcher ─────────────────────────────────────────────
 
-    socket.on('error', (err) => {
-        clients.delete(client);
-        console.log('⚠️ Socket error:', err.message);
+const watchDirs = ['app', 'api', 'components', 'lib', 'models', 'styles', '_framework'];
+let reloadTimer = null;
+
+console.log('👀 Watching:');
+watchDirs.forEach(dir => {
+    const full = path.join(ROOT, dir);
+    if (!fs.existsSync(full)) return;
+    console.log(`   - ${dir}/`);
+
+    fs.watch(full, { recursive: true }, (_, filename) => {
+        if (!filename) return;
+        const ext = path.extname(filename);
+        if (!['.js', '.jsx', '.css', '.json'].includes(ext)) return;
+
+        console.log(`\n📝 Changed: ${dir}/${filename}`);
+        clearTimeout(reloadTimer);
+
+        if (dir === 'api') {
+            loadApiRoutes();
+        }
+
+        reloadTimer = setTimeout(notifyClients, 300);
     });
 });
 
-// Function to start server on available port
+// ─── Start ────────────────────────────────────────────────────
+
 function startServer(port) {
     server.listen(port, () => {
-        console.log(`🌐 Server running at http://localhost:${port}/`);
-        console.log(`📱 Open http://localhost:${port}/ in your browser\n`);
-    }).on('error', (err) => {
+        console.log(`\n✅ Dev server running!`);
+        console.log(`🌐 http://localhost:${port}/\n`);
+        console.log('⏹️  Ctrl+C to stop\n');
+    }).on('error', err => {
         if (err.code === 'EADDRINUSE') {
-            console.log(`⚠️  Port ${port} is busy, trying ${port + 1}...`);
+            console.log(`⚠️  Port ${port} busy, trying ${port + 1}...`);
             startServer(port + 1);
         } else {
-            console.error('❌ Server error:', err);
+            console.error('❌', err);
         }
     });
 }
 
-// Watch directories
-const watchDirs = ['api', 'components', 'pages', 'modules', 'styles'];
-
-// Debounce to prevent multiple rapid reloads
-let reloadTimeout = null;
-
-console.log('👀 Watching for changes in:');
-watchDirs.forEach(dir => {
-    if (fs.existsSync(dir)) {
-        console.log(`   - ${dir}/`);
-        fs.watch(dir, { recursive: false }, (eventType, filename) => {
-            if (filename && (filename.endsWith('.js') || filename.endsWith('.jsx') || filename.endsWith('.css'))) {
-                console.log(`\n📝 Detected change: ${dir}/${filename}`);
-                
-                // Clear existing timeout
-                if (reloadTimeout) {
-                    clearTimeout(reloadTimeout);
-                }
-                
-                // Reload API routes if api/ folder changed
-                if (dir === 'api' && filename.endsWith('.js')) {
-                    console.log('🔄 Reloading API routes...');
-                    loadApiRoutes();
-                }
-                
-                // For CSS changes, just reload without regenerating imports
-                if (filename.endsWith('.css')) {
-                    reloadTimeout = setTimeout(() => {
-                        notifyClients();
-                    }, 300);
-                } else {
-                    // For JS/JSX changes, regenerate imports
-                    reloadTimeout = setTimeout(() => {
-                        generateImports();
-                    }, 500);
-                }
-            }
-        });
-    }
-});
-
-console.log('\n✅ Dev server running with live reload!');
-console.log('💡 Create/modify files and browser will auto-refresh');
-console.log('⏹️  Press Ctrl+C to stop\n');
-
-// Load API routes
 loadApiRoutes();
-
-// Start server
 startServer(PORT);
-
-// Generate imports on startup
-generateImports();
-
-// Keep the process running
 process.stdin.resume();