@nuraly/lumenjs 0.1.2 → 0.1.4

package/dist/dev-server/plugins/vite-plugin-auto-define.js

@@ -0,0 +1,111 @@
+import path from 'path';
+import { filePathToTagName, dirToLayoutTagName } from '../../shared/utils.js';
+/**
+ * Auto-registers custom elements for page and layout files.
+ *
+ * Scans for the exported class that extends LitElement and appends a
+ * `customElements.define('tag-name', ClassName)` call. The tag name is
+ * derived from the file path using the same convention the router uses:
+ *
+ *   pages/index.ts          → page-index
+ *   pages/docs/routing.ts   → page-docs-routing
+ *   pages/_layout.ts        → layout-root
+ *   pages/docs/_layout.ts   → layout-docs
+ *
+ * This removes the need for `@customElement('...')` in page/layout files.
+ */
+export function autoDefinePlugin(pagesDir) {
+    return {
+        name: 'lumenjs-auto-define',
+        enforce: 'pre',
+        transform(code, id) {
+            if (!id.startsWith(pagesDir) || !id.endsWith('.ts'))
+                return;
+            const relative = path.relative(pagesDir, id).replace(/\\/g, '/');
+            const basename = path.basename(relative, '.ts');
+            // Determine if this is a layout or a page
+            const isLayout = basename === '_layout';
+            if (!isLayout && basename.startsWith('_'))
+                return; // skip other _ files
+            // Derive the tag name
+            const tagName = isLayout
+                ? dirToLayoutTagName(path.dirname(relative) === '.' ? '' : path.dirname(relative))
+                : filePathToTagName(relative);
+            // Find the exported class that extends LitElement or any parent class
+            const classMatch = code.match(/export\s+class\s+(\w+)\s+extends\s+(\w+)\b/);
+            if (!classMatch)
+                return;
+            const className = classMatch[1];
+            // Skip if already has a customElements.define or @customElement for this class
+            if (code.includes(`customElements.define('${tagName}'`))
+                return;
+            // Check for actual decorator usage (not mentions in HTML/text content)
+            if (/^\s*@customElement\s*\(/m.test(code))
+                return;
+            // Append the define call + HMR support
+            const defineCall = `
+if (!customElements.get('${tagName}')) {
+  customElements.define('${tagName}', ${className});
+}
+if (import.meta.hot) {
+  import.meta.hot.accept((newModule) => {
+    if (!newModule) return;
+    const NewClass = newModule.${className};
+    if (!NewClass) return;
+    const OldClass = customElements.get('${tagName}');
+    if (!OldClass) return;
+    const descriptors = Object.getOwnPropertyDescriptors(NewClass.prototype);
+    for (const [key, desc] of Object.entries(descriptors)) {
+      if (key === 'constructor') continue;
+      Object.defineProperty(OldClass.prototype, key, desc);
+    }
+    const newCssText = NewClass.styles?.cssText || '';
+    if (NewClass.styles) {
+      OldClass.styles = NewClass.styles;
+      OldClass.elementStyles = undefined;
+      OldClass.finalized = false;
+      try { OldClass.finalizeStyles(); } catch {}
+    }
+    if (NewClass.properties) {
+      OldClass.properties = NewClass.properties;
+    }
+    function __queryShadowAll(root, sel) {
+      const results = [...root.querySelectorAll(sel)];
+      for (const el of root.querySelectorAll('*')) {
+        if (el.shadowRoot) results.push(...__queryShadowAll(el.shadowRoot, sel));
+      }
+      return results;
+    }
+    __queryShadowAll(document, '${tagName}').forEach((el) => {
+      if (el.renderRoot) {
+        // Update styles: try adoptedStyleSheets first, fall back to <style> tag
+        if (OldClass.elementStyles && OldClass.elementStyles.length > 0) {
+          const sheets = OldClass.elementStyles
+            .filter(s => s instanceof CSSStyleSheet || (s && s.styleSheet))
+            .map(s => s instanceof CSSStyleSheet ? s : s.styleSheet);
+          if (sheets.length && el.renderRoot.adoptedStyleSheets !== undefined) {
+            el.renderRoot.adoptedStyleSheets = sheets;
+          }
+        } else if (newCssText) {
+          const styleEl = el.renderRoot.querySelector('style');
+          if (styleEl) styleEl.textContent = newCssText;
+        }
+        // Clear stale SSR inline styles from child elements
+        el.renderRoot.querySelectorAll('[style]').forEach((child) => {
+          child.removeAttribute('style');
+        });
+        // Clear Lit's template cache to force re-render with new template
+        const childPart = Object.getOwnPropertySymbols(el.renderRoot)
+          .map(s => el.renderRoot[s])
+          .find(v => v && typeof v === 'object' && '_$committedValue' in v);
+        if (childPart) childPart._$committedValue = undefined;
+      }
+      if (el.requestUpdate) el.requestUpdate();
+    });
+  });
+}
+`;
+            return { code: code + defineCall, map: null };
+        },
+    };
+}

package/dist/dev-server/plugins/vite-plugin-communication.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+/**
+ * Vite dev plugin for the communication module.
+ * Initializes DB tables and provides REST API endpoints for conversations/messages.
+ */
+export declare function communicationPlugin(projectDir: string): Plugin;

package/dist/dev-server/plugins/vite-plugin-communication.js

@@ -0,0 +1,205 @@
+import path from 'path';
+import fs from 'fs';
+import crypto from 'crypto';
+import { setProjectDir } from '../../db/context.js';
+import { useDb } from '../../db/index.js';
+import { ensureCommunicationTables } from '../../communication/schema.js';
+import { createCommunicationApiHandlers } from '../../communication/server.js';
+import { fetchLinkPreview, extractUrls } from '../../communication/link-preview.js';
+/**
+ * Vite dev plugin for the communication module.
+ * Initializes DB tables and provides REST API endpoints for conversations/messages.
+ */
+export function communicationPlugin(projectDir) {
+    let db = null;
+    let api = null;
+    async function getApi() {
+        if (api)
+            return api;
+        try {
+            setProjectDir(projectDir);
+            db = useDb();
+            await ensureCommunicationTables(db);
+            api = createCommunicationApiHandlers(db);
+            console.log('[LumenJS] Communication module initialized');
+        }
+        catch (err) {
+            console.warn('[LumenJS Communication] DB init failed:', err?.message);
+        }
+        return api;
+    }
+    const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
+    function readBody(req, maxSize = MAX_BODY_SIZE) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let size = 0;
+            req.on('data', (c) => {
+                size += c.length;
+                if (size > maxSize) {
+                    req.destroy();
+                    reject(new Error('Request body too large'));
+                    return;
+                }
+                chunks.push(c);
+            });
+            req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+            req.on('error', reject);
+        });
+    }
+    function sendJson(res, status, data) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    }
+    return {
+        name: 'lumenjs-communication',
+        configureServer(server) {
+            // REST API for conversations and messages
+            server.middlewares.use(async (req, res, next) => {
+                const url = req.url || '';
+                if (!url.startsWith('/__nk_comm/'))
+                    return next();
+                const commApi = await getApi();
+                if (!commApi) {
+                    sendJson(res, 500, { error: 'Communication module not available' });
+                    return;
+                }
+                const userId = req.nkAuth?.user?.sub;
+                const rest = url.split('?')[0].slice('/__nk_comm/'.length);
+                try {
+                    // GET /__nk_comm/conversations
+                    if (rest === 'conversations' && req.method === 'GET') {
+                        if (!userId) {
+                            sendJson(res, 401, { error: 'Unauthorized' });
+                            return;
+                        }
+                        const data = await commApi.getConversations(userId);
+                        sendJson(res, 200, data);
+                        return;
+                    }
+                    // POST /__nk_comm/conversations
+                    if (rest === 'conversations' && req.method === 'POST') {
+                        if (!userId) {
+                            sendJson(res, 401, { error: 'Unauthorized' });
+                            return;
+                        }
+                        const body = JSON.parse(await readBody(req));
+                        const conv = await commApi.createConversation({ ...body, participantIds: [userId, ...(body.participantIds || [])] });
+                        sendJson(res, 201, conv);
+                        return;
+                    }
+                    // GET /__nk_comm/messages/<conversationId>
+                    if (rest.startsWith('messages/') && req.method === 'GET') {
+                        if (!userId) {
+                            sendJson(res, 401, { error: 'Unauthorized' });
+                            return;
+                        }
+                        const conversationId = rest.slice('messages/'.length);
+                        const data = await commApi.getMessages(conversationId);
+                        sendJson(res, 200, data);
+                        return;
+                    }
+                    // GET /__nk_comm/search?q=...
+                    if (rest === 'search' && req.method === 'GET') {
+                        if (!userId) {
+                            sendJson(res, 401, { error: 'Unauthorized' });
+                            return;
+                        }
+                        const params = new URL(url, 'http://localhost').searchParams;
+                        const data = await commApi.searchMessages(params.get('q') || '');
+                        sendJson(res, 200, data);
+                        return;
+                    }
+                    // POST /__nk_comm/upload — file upload
+                    if (rest === 'upload' && req.method === 'POST') {
+                        if (!userId) {
+                            sendJson(res, 401, { error: 'Unauthorized' });
+                            return;
+                        }
+                        const uploadDir = path.join(projectDir, 'data', 'uploads');
+                        if (!fs.existsSync(uploadDir))
+                            fs.mkdirSync(uploadDir, { recursive: true });
+                        const MAX_UPLOAD_SIZE = 10 * 1024 * 1024; // 10 MB
+                        const chunks = [];
+                        let uploadSize = 0;
+                        req.on('data', (c) => {
+                            uploadSize += c.length;
+                            if (uploadSize > MAX_UPLOAD_SIZE) {
+                                req.destroy();
+                                sendJson(res, 413, { error: 'File too large' });
+                                return;
+                            }
+                            chunks.push(c);
+                        });
+                        req.on('end', () => {
+                            if (uploadSize > MAX_UPLOAD_SIZE)
+                                return;
+                            const body = Buffer.concat(chunks);
+                            const id = crypto.randomUUID();
+                            const contentType = req.headers['content-type'] || '';
+                            // Simple raw upload (client sends encrypted blob or raw file)
+                            const ext = contentType.includes('image') ? '.bin' : '.bin';
+                            const filePath = path.join(uploadDir, `${id}${ext}`);
+                            fs.writeFileSync(filePath, body);
+                            const fileUrl = `/__nk_comm/files/${id}`;
+                            if (db) {
+                                db.run('INSERT INTO attachments (id, filename, mimetype, size, url, uploaded_by, encrypted) VALUES (?, ?, ?, ?, ?, ?, ?)', id, req.headers['x-filename'] || `file-${id}`, contentType, body.length, fileUrl, userId, req.headers['x-encrypted'] === '1' ? 1 : 0).catch(() => { });
+                            }
+                            sendJson(res, 201, { id, url: fileUrl, size: body.length });
+                        });
+                        return;
+                    }
+                    // GET /__nk_comm/files/:id — serve uploaded file
+                    if (rest.startsWith('files/') && req.method === 'GET') {
+                        const fileId = rest.slice('files/'.length);
+                        // Validate fileId contains only safe characters (UUID format)
+                        if (!/^[a-zA-Z0-9._-]+$/.test(fileId)) {
+                            sendJson(res, 400, { error: 'Invalid file ID' });
+                            return;
+                        }
+                        const uploadDir = path.join(projectDir, 'data', 'uploads');
+                        const filePath = path.resolve(uploadDir, `${fileId}.bin`);
+                        if (!filePath.startsWith(uploadDir + path.sep)) {
+                            sendJson(res, 400, { error: 'Invalid file ID' });
+                            return;
+                        }
+                        if (!fs.existsSync(filePath)) {
+                            sendJson(res, 404, { error: 'File not found' });
+                            return;
+                        }
+                        const stat = fs.statSync(filePath);
+                        let contentType = 'application/octet-stream';
+                        if (db) {
+                            const att = await db.get('SELECT mimetype FROM attachments WHERE id = ?', fileId);
+                            if (att)
+                                contentType = att.mimetype;
+                        }
+                        res.writeHead(200, { 'Content-Type': contentType, 'Content-Length': stat.size, 'Cache-Control': 'public, max-age=86400' });
+                        fs.createReadStream(filePath).pipe(res);
+                        return;
+                    }
+                    // POST /__nk_comm/link-preview — fetch link preview
+                    if (rest === 'link-preview' && req.method === 'POST') {
+                        if (!userId) {
+                            sendJson(res, 401, { error: 'Unauthorized' });
+                            return;
+                        }
+                        const body = JSON.parse(await readBody(req));
+                        const urls = extractUrls(body.text || '');
+                        const previews = [];
+                        for (const u of urls) {
+                            const preview = await fetchLinkPreview(u, db);
+                            if (preview)
+                                previews.push(preview);
+                        }
+                        sendJson(res, 200, { previews });
+                        return;
+                    }
+                    sendJson(res, 404, { error: 'Not found' });
+                }
+                catch (err) {
+                    sendJson(res, 500, { error: err?.message || 'Internal error' });
+                }
+            });
+        },
+    };
+}

package/dist/dev-server/plugins/vite-plugin-editor-api.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+/**
+ * Vite plugin exposing editor API endpoints (only active in editor mode).
+ * Provides file CRUD and AST modification via /__nk_editor/* routes.
+ */
+export declare function editorApiPlugin(projectDir: string): Plugin;

package/dist/dev-server/plugins/vite-plugin-editor-api.js

@@ -0,0 +1,318 @@
+import { EditorFileService } from '../../editor/file-service.js';
+import { AstService } from '../../editor/ast-service.js';
+import { streamAiChat, checkAiStatus, warmUpAiSession } from '../../editor/ai/backend.js';
+import * as snapshotStore from '../../editor/ai/snapshot-store.js';
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+const EDITOR_PREFIX = '/__nk_editor/';
+/**
+ * Vite plugin exposing editor API endpoints (only active in editor mode).
+ * Provides file CRUD and AST modification via /__nk_editor/* routes.
+ */
+export function editorApiPlugin(projectDir) {
+    const fileService = new EditorFileService(projectDir);
+    const astService = new AstService();
+    // Per-file write lock to prevent race conditions
+    const writeLocks = new Map();
+    async function withLock(filePath, fn) {
+        const prev = writeLocks.get(filePath) || Promise.resolve();
+        let resolve;
+        const next = new Promise(r => { resolve = r; });
+        writeLocks.set(filePath, next);
+        try {
+            await prev;
+            return await fn();
+        }
+        finally {
+            resolve();
+            if (writeLocks.get(filePath) === next) {
+                writeLocks.delete(filePath);
+            }
+        }
+    }
+    const MAX_EDITOR_BODY = 5 * 1024 * 1024; // 5 MB
+    function readBody(req, maxSize = MAX_EDITOR_BODY) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let size = 0;
+            req.on('data', (chunk) => {
+                size += chunk.length;
+                if (size > maxSize) {
+                    req.destroy();
+                    reject(new Error('Request body too large'));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+            req.on('error', reject);
+        });
+    }
+    function sendJson(res, status, data) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    }
+    function sendError(res, status, message) {
+        sendJson(res, status, { error: message });
+    }
+    return {
+        name: 'lumenjs-editor-api',
+        configureServer(server) {
+            // Warm up AI session in background so first request is fast
+            warmUpAiSession(projectDir).catch(() => { });
+            server.middlewares.use(async (req, res, next) => {
+                if (!req.url || !req.url.startsWith(EDITOR_PREFIX))
+                    return next();
+                const urlPath = req.url.split('?')[0];
+                const rest = urlPath.slice(EDITOR_PREFIX.length);
+                try {
+                    // GET /__nk_editor/files — list all files
+                    if (rest === 'files' && req.method === 'GET') {
+                        const files = fileService.listFiles();
+                        sendJson(res, 200, { files });
+                        return;
+                    }
+                    // GET /__nk_editor/files/<path> — read file
+                    if (rest.startsWith('files/') && req.method === 'GET') {
+                        const filePath = decodeURIComponent(rest.slice('files/'.length));
+                        const content = fileService.readFile(filePath);
+                        sendJson(res, 200, { content });
+                        return;
+                    }
+                    // PUT /__nk_editor/files/<path> — write file
+                    if (rest.startsWith('files/') && req.method === 'PUT') {
+                        const filePath = decodeURIComponent(rest.slice('files/'.length));
+                        const body = JSON.parse(await readBody(req));
+                        await withLock(filePath, async () => {
+                            fileService.writeFile(filePath, body.content);
+                        });
+                        // Notify i18n HMR when a locale file is written
+                        const localeMatch = filePath.match(/^locales\/([a-z]{2}(?:-[a-zA-Z]+)?)\.json$/);
+                        if (localeMatch) {
+                            server.ws.send({
+                                type: 'custom',
+                                event: 'lumenjs:i18n-update',
+                                data: { locale: localeMatch[1] },
+                            });
+                        }
+                        res.writeHead(204);
+                        res.end();
+                        return;
+                    }
+                    // POST /__nk_editor/ast/<path> — apply AST modification
+                    if (rest.startsWith('ast/') && req.method === 'POST') {
+                        const filePath = decodeURIComponent(rest.slice('ast/'.length));
+                        const mod = JSON.parse(await readBody(req));
+                        const content = await withLock(filePath, async () => {
+                            const source = fileService.readFile(filePath);
+                            const modified = await astService.applyModification(source, mod);
+                            fileService.writeFile(filePath, modified);
+                            return modified;
+                        });
+                        sendJson(res, 200, { content });
+                        return;
+                    }
+                    // GET /__nk_editor/ai/status — check if OpenCode is reachable
+                    if (rest === 'ai/status' && req.method === 'GET') {
+                        const status = await checkAiStatus();
+                        sendJson(res, 200, status);
+                        return;
+                    }
+                    // POST /__nk_editor/ai/chat — proxy to OpenCode with SSE streaming
+                    if (rest === 'ai/chat' && req.method === 'POST') {
+                        const body = JSON.parse(await readBody(req));
+                        const { mode, prompt, context, sessionId, model } = body;
+                        if (!prompt) {
+                            sendError(res, 400, 'Missing prompt');
+                            return;
+                        }
+                        // Snapshot files before AI modifies them
+                        // For element mode, only snapshot the source file (much faster)
+                        // For project mode, snapshot all files
+                        const turnId = crypto.randomUUID();
+                        try {
+                            const fileContents = new Map();
+                            if (mode === 'element' && context?.sourceFile) {
+                                try {
+                                    fileContents.set(context.sourceFile, fileService.readFile(context.sourceFile));
+                                }
+                                catch { /* skip */ }
+                                // Multi-element: also snapshot additional source files
+                                if (context.sourceFiles && Array.isArray(context.sourceFiles)) {
+                                    for (const sf of context.sourceFiles) {
+                                        if (!fileContents.has(sf)) {
+                                            try {
+                                                fileContents.set(sf, fileService.readFile(sf));
+                                            }
+                                            catch { /* skip */ }
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                const files = fileService.listFiles();
+                                for (const f of files) {
+                                    try {
+                                        fileContents.set(f, fileService.readFile(f));
+                                    }
+                                    catch { /* skip */ }
+                                }
+                            }
+                            snapshotStore.save(turnId, fileContents);
+                        }
+                        catch {
+                            // Non-fatal — rollback just won't be available
+                        }
+                        // If element mode with a source file, read its content for richer context
+                        let enrichedContext = context || {};
+                        if (mode === 'element' && context?.sourceFile) {
+                            try {
+                                const fullContent = fileService.readFile(context.sourceFile);
+                                let sourceContent = fullContent;
+                                // Trim to ±20 lines around the target line to reduce token usage
+                                if (context.sourceLine && typeof context.sourceLine === 'number') {
+                                    const lines = fullContent.split('\n');
+                                    const start = Math.max(0, context.sourceLine - 20);
+                                    const end = Math.min(lines.length, context.sourceLine + 20);
+                                    const trimmed = [];
+                                    if (start > 0)
+                                        trimmed.push(`// ... (lines 1-${start} omitted)`);
+                                    trimmed.push(...lines.slice(start, end));
+                                    if (end < lines.length)
+                                        trimmed.push(`// ... (lines ${end + 1}-${lines.length} omitted)`);
+                                    sourceContent = trimmed.join('\n');
+                                }
+                                enrichedContext = { ...context, sourceContent };
+                            }
+                            catch {
+                                // File might not exist, continue without content
+                            }
+                            // Multi-element: read additional source files beyond the primary
+                            if (context.sourceFiles && Array.isArray(context.sourceFiles)) {
+                                const additionalSources = {};
+                                for (const sf of context.sourceFiles) {
+                                    if (sf === context.sourceFile)
+                                        continue; // already read above
+                                    try {
+                                        additionalSources[sf] = fileService.readFile(sf);
+                                    }
+                                    catch { /* skip */ }
+                                }
+                                if (Object.keys(additionalSources).length > 0) {
+                                    enrichedContext = { ...enrichedContext, additionalSources };
+                                }
+                            }
+                        }
+                        // If project has i18n, include locale translations so the AI knows
+                        // to edit locale JSON files instead of hardcoding text in templates.
+                        const localesDir = path.join(projectDir, 'locales');
+                        if (fs.existsSync(localesDir)) {
+                            try {
+                                const localeFiles = fs.readdirSync(localesDir).filter(f => f.endsWith('.json'));
+                                const translations = {};
+                                for (const f of localeFiles) {
+                                    const locale = f.replace('.json', '');
+                                    translations[locale] = JSON.parse(fs.readFileSync(path.join(localesDir, f), 'utf-8'));
+                                }
+                                enrichedContext = { ...enrichedContext, i18n: { translations } };
+                            }
+                            catch {
+                                // Non-fatal
+                            }
+                        }
+                        // Set up SSE response
+                        res.writeHead(200, {
+                            'Content-Type': 'text/event-stream',
+                            'Cache-Control': 'no-cache',
+                            'Connection': 'keep-alive',
+                            'X-Accel-Buffering': 'no',
+                        });
+                        const result = streamAiChat(projectDir, {
+                            mode: mode || 'project',
+                            prompt,
+                            context: enrichedContext,
+                            sessionId,
+                            model: model || 'default',
+                        });
+                        // Handle client disconnect
+                        req.on('close', () => result.abort());
+                        result.onToken((text) => {
+                            res.write(`event: token\ndata: ${JSON.stringify({ text })}\n\n`);
+                        });
+                        result.onDone((fullText) => {
+                            res.write(`event: done\ndata: ${JSON.stringify({ sessionId: result.sessionId, turnId, fullText })}\n\n`);
+                            res.end();
+                        });
+                        result.onError((err) => {
+                            res.write(`event: error\ndata: ${JSON.stringify({ message: err.message })}\n\n`);
+                            res.end();
+                        });
+                        return;
+                    }
+                    // POST /__nk_editor/ai/rollback — restore file snapshots
+                    if (rest === 'ai/rollback' && req.method === 'POST') {
+                        const body = JSON.parse(await readBody(req));
+                        const { turnId } = body;
+                        if (!turnId) {
+                            sendError(res, 400, 'Missing turnId');
+                            return;
+                        }
+                        const files = snapshotStore.restore(turnId);
+                        if (!files) {
+                            sendError(res, 404, 'Snapshot not found');
+                            return;
+                        }
+                        const restoredFiles = [];
+                        for (const [filePath, content] of files) {
+                            try {
+                                fileService.writeFile(filePath, content);
+                                restoredFiles.push(filePath);
+                            }
+                            catch {
+                                // Skip files that can't be written
+                            }
+                        }
+                        sendJson(res, 200, { restored: true, files: restoredFiles });
+                        return;
+                    }
+                    sendError(res, 404, 'Not found');
+                }
+                catch (err) {
+                    const message = err?.message || 'Internal server error';
+                    const status = message === 'Path traversal detected' ? 403 : 500;
+                    sendError(res, status, message);
+                }
+            });
+            // Watch package.json for changes (e.g. after AI runs npm install).
+            // When dependencies change, restart Vite to re-run dependency optimization.
+            const pkgJsonPath = path.join(projectDir, 'package.json');
+            if (fs.existsSync(pkgJsonPath)) {
+                let lastPkgDeps = readDepsHash(pkgJsonPath);
+                const watcher = fs.watch(pkgJsonPath, { persistent: false }, () => {
+                    const currentDeps = readDepsHash(pkgJsonPath);
+                    if (currentDeps !== lastPkgDeps) {
+                        lastPkgDeps = currentDeps;
+                        console.log('[LumenJS] Dependencies changed — restarting dev server...');
+                        server.restart();
+                    }
+                });
+                server.httpServer?.on('close', () => watcher.close());
+            }
+        },
+    };
+}
+/** Hash the dependencies/devDependencies from package.json to detect changes. */
+function readDepsHash(pkgJsonPath) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        const deps = JSON.stringify({
+            d: pkg.dependencies || {},
+            v: pkg.devDependencies || {},
+        });
+        return deps;
+    }
+    catch {
+        return '';
+    }
+}