@mgks/docmd 0.3.3 → 0.3.5

package/src/commands/dev.js

@@ -6,156 +6,93 @@ const WebSocket = require('ws');
 const chokidar = require('chokidar');
 const path = require('path');
 const fs = require('fs-extra');
-const { buildSite } = require('./build'); // Re-use the build logic
+const chalk = require('chalk');
+const os = require('os'); 
+const { buildSite } = require('./build');
 const { loadConfig } = require('../core/config-loader');
 
-/**
- * Format paths for display to make them relative to CWD
- * @param {string} absolutePath - The absolute path to format
- * @param {string} cwd - Current working directory
- * @returns {string} - Formatted relative path
- */
 function formatPathForDisplay(absolutePath, cwd) {
-  // Get the relative path from CWD
   const relativePath = path.relative(cwd, absolutePath);
-  
-  // If it's not a subdirectory, prefix with ./ for clarity
   if (!relativePath.startsWith('..') && !path.isAbsolute(relativePath)) {
     return `./${relativePath}`;
   }
-  
-  // Return the relative path
   return relativePath;
 }
 
+function getNetworkIp() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return null;
+}
+
 async function startDevServer(configPathOption, options = { preserve: false, port: undefined }) {
-  let config = await loadConfig(configPathOption); // Load initial config
-  const CWD = process.cwd(); // Current Working Directory where user runs `docmd dev`
+  let config = await loadConfig(configPathOption);
+  const CWD = process.cwd();
+
+  // Config Fallback for Watcher
+  let actualConfigPath = path.resolve(CWD, configPathOption);
+  if (configPathOption === 'docmd.config.js' && !await fs.pathExists(actualConfigPath)) {
+      const legacyPath = path.resolve(CWD, 'config.js');
+      if (await fs.pathExists(legacyPath)) {
+          actualConfigPath = legacyPath;
+      }
+  }
 
-  // Function to resolve paths based on current config
   const resolveConfigPaths = (currentConfig) => {
     return {
       outputDir: path.resolve(CWD, currentConfig.outputDir),
       srcDirToWatch: path.resolve(CWD, currentConfig.srcDir),
-      configFileToWatch: path.resolve(CWD, configPathOption), // Path to the config file itself
-      userAssetsDir: path.resolve(CWD, 'assets'), // User's assets directory
+      configFileToWatch: actualConfigPath,
+      userAssetsDir: path.resolve(CWD, 'assets'),
     };
   };
 
   let paths = resolveConfigPaths(config);
-
-  // docmd's internal templates and assets (for live dev of docmd itself)
-  const DOCMD_COMMANDS_DIR = path.resolve(__dirname, '..', 'commands');
-  const DOCMD_CORE_DIR = path.resolve(__dirname, '..', 'core');
-  const DOCMD_PLUGINS_DIR = path.resolve(__dirname, '..', 'plugins');
-  const DOCMD_TEMPLATES_DIR = path.resolve(__dirname, '..', 'templates');
-  const DOCMD_ASSETS_DIR = path.resolve(__dirname, '..', 'assets');
-
+  const DOCMD_ROOT = path.resolve(__dirname, '..');
+  
   const app = express();
   const server = http.createServer(app);
   const wss = new WebSocket.Server({ server });
 
-  let wsClients = new Set();
-  wss.on('connection', (ws) => {
-    wsClients.add(ws);
-    // console.log('Client connected to WebSocket. Total clients:', wsClients.size);
-    ws.on('close', () => {
-      wsClients.delete(ws);
-      // console.log('Client disconnected. Total clients:', wsClients.size);
-    });
-    ws.on('error', (error) => {
-        console.error('WebSocket error on client:', error);
-    });
-  });
-  wss.on('error', (error) => {
-    console.error('WebSocket Server error:', error);
-  });
-
   function broadcastReload() {
-    wsClients.forEach(client => {
+    wss.clients.forEach((client) => {
       if (client.readyState === WebSocket.OPEN) {
-        try {
-          client.send('reload');
-        } catch (error) {
-          console.error('Error sending reload command to client:', error);
-        }
+        client.send('reload');
       }
     });
   }
 
-  // Inject live reload script into HTML responses
+  // Inject live reload script
   app.use((req, res, next) => {
-    if (req.path.endsWith('.html') || !req.path.includes('.')) {
+    if (req.path.endsWith('.html') || req.path === '/' || !req.path.includes('.')) {
       const originalSend = res.send;
       res.send = function(body) {
         if (typeof body === 'string' && body.includes('</body>')) {
           const liveReloadScript = `
             <script>
               (function() {
-                // More robust WebSocket connection with automatic reconnection
                 let socket;
-                let reconnectAttempts = 0;
-                const maxReconnectAttempts = 5;
-                const reconnectDelay = 1000; // Start with 1 second delay
-                
+                let reconnectTimer;
                 function connect() {
-                  socket = new WebSocket(\`ws://\${window.location.host}\`);
-                  
-                  socket.onmessage = function(event) { 
-                    if (event.data === 'reload') {
-                      console.log('Received reload signal. Refreshing page...');
-                      window.location.reload(); 
-                    }
-                  };
-                  
+                  socket = new WebSocket('ws://' + window.location.host);
                   socket.onopen = function() {
-                    console.log('Live reload connected.');
-                    reconnectAttempts = 0; // Reset reconnect counter on successful connection
+                    console.log('⚡ docmd live reload connected');
+                    if (reconnectTimer) clearInterval(reconnectTimer);
                   };
-                  
-                  socket.onclose = function() {
-                    if (reconnectAttempts < maxReconnectAttempts) {
-                      reconnectAttempts++;
-                      const delay = reconnectDelay * Math.pow(1.5, reconnectAttempts - 1); // Exponential backoff
-                      console.log(\`Live reload disconnected. Reconnecting in \${delay/1000} seconds...\`);
-                      setTimeout(connect, delay);
-                    } else {
-                      console.log('Live reload disconnected. Max reconnect attempts reached.');
-                    }
+                  socket.onmessage = function(event) {
+                    if (event.data === 'reload') window.location.reload();
                   };
-                  
-                  socket.onerror = function(error) {
-                    console.error('WebSocket error:', error);
+                  socket.onclose = function() {
+                    reconnectTimer = setTimeout(connect, 1000);
                   };
                 }
-                
-                // Initial connection
                 connect();
-                
-                // Backup reload mechanism using polling for browsers with WebSocket issues
-                let lastModified = new Date().getTime();
-                const pollInterval = 2000; // Poll every 2 seconds
-                
-                function checkForChanges() {
-                  fetch(window.location.href, { method: 'HEAD', cache: 'no-store' })
-                    .then(response => {
-                      const serverLastModified = new Date(response.headers.get('Last-Modified')).getTime();
-                      if (serverLastModified > lastModified) {
-                        console.log('Change detected via polling. Refreshing page...');
-                        window.location.reload();
-                      }
-                      lastModified = serverLastModified;
-                    })
-                    .catch(error => console.error('Error checking for changes:', error));
-                }
-                
-                // Only use polling as a fallback if WebSocket fails
-                setTimeout(() => {
-                  if (socket.readyState !== WebSocket.OPEN) {
-                    console.log('WebSocket not connected. Falling back to polling.');
-                    setInterval(checkForChanges, pollInterval);
-                  }
-                }, 5000);
               })();
             </script>
           `;
@@ -167,148 +104,122 @@ async function startDevServer(configPathOption, options = { preserve: false, por
     next();
   });
 
-  // Add Last-Modified header to all responses for polling fallback
-  app.use((req, res, next) => {
-    res.setHeader('Last-Modified', new Date().toUTCString());
-    next();
-  });
-
-  // Serve static files from the output directory
-  // This middleware needs to be dynamic if outputDir changes
   let staticMiddleware = express.static(paths.outputDir);
   app.use((req, res, next) => staticMiddleware(req, res, next));
 
-  // Initial build
-  console.log('🚀 Performing initial build for dev server...');
+  // --- 1. Initial Build ---
+  console.log(chalk.blue('🚀 Performing initial build...'));
   try {
-    await buildSite(configPathOption, { isDev: true, preserve: options.preserve, noDoubleProcessing: true }); // Use the original config path option
-    console.log('✅ Initial build complete.');
+    await buildSite(configPathOption, { isDev: true, preserve: options.preserve, noDoubleProcessing: true });
   } catch (error) {
-      console.error('❌ Initial build failed:', error.message, error.stack);
-      // Optionally, don't start server if initial build fails, or serve a specific error page.
+      console.error(chalk.red('❌ Initial build failed:'), error.message);
   }
 
-  // Check if user assets directory exists
+  // --- 2. Setup Watcher & Logs ---
   const userAssetsDirExists = await fs.pathExists(paths.userAssetsDir);
-
-  // Watch for changes
-  const watchedPaths = [
-    paths.srcDirToWatch,
-    paths.configFileToWatch,
-  ];
-
-  // Add user assets directory to watched paths if it exists
-  if (userAssetsDirExists) {
-    watchedPaths.push(paths.userAssetsDir);
-  }
-
-  // Add internal paths for docmd development (not shown to end users)
-  const internalPaths = [DOCMD_TEMPLATES_DIR, DOCMD_ASSETS_DIR, DOCMD_COMMANDS_DIR, DOCMD_CORE_DIR, DOCMD_PLUGINS_DIR];
+  const watchedPaths = [paths.srcDirToWatch, paths.configFileToWatch];
+  if (userAssetsDirExists) watchedPaths.push(paths.userAssetsDir);
   
-  // Only in development environments, we might want to watch internal files too
   if (process.env.DOCMD_DEV === 'true') {
-    watchedPaths.push(...internalPaths);
+    watchedPaths.push(
+      path.join(DOCMD_ROOT, 'templates'),
+      path.join(DOCMD_ROOT, 'assets'),
+      path.join(DOCMD_ROOT, 'core'),
+      path.join(DOCMD_ROOT, 'plugins')
+    );
   }
   
-  console.log(`👀 Watching for changes in:`);
-  console.log(`    - Source: ${formatPathForDisplay(paths.srcDirToWatch, CWD)}`);
-  console.log(`    - Config: ${formatPathForDisplay(paths.configFileToWatch, CWD)}`);
+  // LOGS: Explicitly print what we are watching
+  console.log(chalk.dim('\n👀 Watching for changes in:'));
+  console.log(chalk.dim(`   - Source: ${chalk.cyan(formatPathForDisplay(paths.srcDirToWatch, CWD))}`));
+  console.log(chalk.dim(`   - Config: ${chalk.cyan(formatPathForDisplay(paths.configFileToWatch, CWD))}`));
   if (userAssetsDirExists) {
-    console.log(`    - Assets: ${formatPathForDisplay(paths.userAssetsDir, CWD)}`);
+    console.log(chalk.dim(`   - Assets: ${chalk.cyan(formatPathForDisplay(paths.userAssetsDir, CWD))}`));
   }
   if (process.env.DOCMD_DEV === 'true') {
-    console.log(`    - docmd Templates: ${formatPathForDisplay(DOCMD_TEMPLATES_DIR, CWD)} (internal)`);
-    console.log(`    - docmd Assets: ${formatPathForDisplay(DOCMD_ASSETS_DIR, CWD)} (internal)`);
+    console.log(chalk.dim(`   - docmd Internal: ${chalk.magenta(formatPathForDisplay(DOCMD_ROOT, CWD))}`));
   }
+  console.log(''); 
 
   const watcher = chokidar.watch(watchedPaths, {
-    ignored: /(^|[\/\\])\../, // ignore dotfiles
+    ignored: /(^|[\/\\])\../,
     persistent: true,
-    ignoreInitial: true, // Don't trigger for initial scan
-    awaitWriteFinish: { // Helps with rapid saves or large file writes
-        stabilityThreshold: 100,
-        pollInterval: 100
-    }
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 100 }
   });
 
   watcher.on('all', async (event, filePath) => {
     const relativeFilePath = path.relative(CWD, filePath);
-    console.log(`🔄 Detected ${event} in ${relativeFilePath}. Rebuilding...`);
+    process.stdout.write(chalk.dim(`↻ Change in ${relativeFilePath}... `));
+    
     try {
       if (filePath === paths.configFileToWatch) {
-        console.log('Config file changed. Reloading configuration...');
-        config = await loadConfig(configPathOption); // Reload config
+        config = await loadConfig(configPathOption);
         const newPaths = resolveConfigPaths(config);
-
-        // Update watcher if srcDir changed - Chokidar doesn't easily support dynamic path changes after init.
-        // For simplicity, we might need to restart the watcher or inform user to restart dev server if srcDir/outputDir change.
-        // For now, we'll at least update the static server path.
         if (newPaths.outputDir !== paths.outputDir) {
-            console.log(`Output directory changed from ${formatPathForDisplay(paths.outputDir, CWD)} to ${formatPathForDisplay(newPaths.outputDir, CWD)}. Updating static server.`);
             staticMiddleware = express.static(newPaths.outputDir);
         }
-        // If srcDirToWatch changes, chokidar won't automatically pick it up.
-        // A full dev server restart would be more robust for such config changes.
-        // For now, the old srcDir will still be watched.
-        paths = newPaths; // Update paths for next build reference
+        paths = newPaths;
       }
 
-      await buildSite(configPathOption, { isDev: true, preserve: options.preserve, noDoubleProcessing: true }); // Re-build using the potentially updated config path
+      await buildSite(configPathOption, { isDev: true, preserve: options.preserve, noDoubleProcessing: true });
       broadcastReload();
-      console.log('✅ Rebuild complete.');
+      process.stdout.write(chalk.green('Done.\n'));
+      
     } catch (error) {
-      console.error('❌ Rebuild failed:', error.message, error.stack);
+      console.error(chalk.red('\n❌ Rebuild failed:'), error.message);
     }
   });
 
-  watcher.on('error', error => console.error(`Watcher error: ${error}`));
-
-  // Try different ports if the default port is in use
   const PORT = options.port || process.env.PORT || 3000;
   const MAX_PORT_ATTEMPTS = 10;
-  let currentPort = parseInt(PORT, 10);
   
-  // Function to try starting the server on different ports
   function tryStartServer(port, attempt = 1) {
-    server.listen(port)
+    // 0.0.0.0 allows network access
+    server.listen(port, '0.0.0.0')
       .on('listening', async () => {
-        // Check if index.html exists after initial build
         const indexHtmlPath = path.join(paths.outputDir, 'index.html');
+        const networkIp = getNetworkIp();
+        
+        // Use 127.0.0.1 explicitly
+        const localUrl = `http://127.0.0.1:${port}`;
+        const networkUrl = networkIp ? `http://${networkIp}:${port}` : null;
+
+        const border = chalk.gray('────────────────────────────────────────');
+        console.log(border);
+        console.log(`  ${chalk.bold.green('SERVER RUNNING')}  ${chalk.dim(`(v${require('../../package.json').version})`)}`);
+        console.log('');
+        console.log(`  ${chalk.bold('Local:')}    ${chalk.cyan(localUrl)}`);
+        if (networkUrl) {
+            console.log(`  ${chalk.bold('Network:')}  ${chalk.cyan(networkUrl)}`);
+        }
+        console.log('');
+        console.log(`  ${chalk.dim('Serving:')}  ${formatPathForDisplay(paths.outputDir, CWD)}`);
+        console.log(border);
+        console.log('');
+
         if (!await fs.pathExists(indexHtmlPath)) {
-            console.warn(`⚠️  Warning: ${formatPathForDisplay(indexHtmlPath, CWD)} not found after initial build.
-            The dev server is running, but you might see a 404 for the root page.
-            Ensure your '${config.srcDir}' directory contains an 'index.md' or your navigation points to existing files.`);
+            console.warn(chalk.yellow(`⚠️  Warning: Root index.html not found.`));
         }
-        console.log(`🎉 Dev server started at http://localhost:${port}`);
-        console.log(`Serving content from: ${formatPathForDisplay(paths.outputDir, CWD)}`);
-        console.log(`Live reload is active. Browser will refresh automatically when files change.`);
       })
       .on('error', (err) => {
         if (err.code === 'EADDRINUSE' && attempt < MAX_PORT_ATTEMPTS) {
-          console.log(`Port ${port} is in use, trying port ${port + 1}...`);
-          server.close();
           tryStartServer(port + 1, attempt + 1);
         } else {
-          console.error(`Failed to start server: ${err.message}`);
+          console.error(chalk.red(`Failed to start server: ${err.message}`));
           process.exit(1);
         }
       });
   }
   
-  // Start the server with port fallback
-  tryStartServer(currentPort);
+  tryStartServer(parseInt(PORT, 10));
 
-  // Graceful shutdown
   process.on('SIGINT', () => {
-    console.log('\n🛑 Shutting down dev server...');
+    console.log(chalk.yellow('\n🛑 Shutting down...'));
     watcher.close();
-    wss.close(() => {
-        server.close(() => {
-            console.log('Server closed.');
-            process.exit(0);
-        });
-    });
+    process.exit(0);
   });
 }
 
+// Ensure this export is here!
 module.exports = { startDevServer };

package/src/commands/init.js

@@ -14,10 +14,10 @@ module.exports = {
 
   // Logo Configuration
   logo: {
-    light: '/assets/images/docmd-logo-light.png', // Path relative to outputDir root
-    dark: '/assets/images/docmd-logo-dark.png',   // Path relative to outputDir root
+    light: 'assets/images/docmd-logo-light.png', // Path relative to outputDir root
+    dark: 'assets/images/docmd-logo-dark.png',   // Path relative to outputDir root
     alt: 'docmd logo',                      // Alt text for the logo
-    href: '/',                              // Link for the logo, defaults to site root
+    href: './',                              // Link for the logo, defaults to site root
   },
 
   // Directory Configuration
@@ -44,14 +44,14 @@ module.exports = {
     positionMode: 'top', // 'top' or 'bottom' for the theme toggle
     codeHighlight: true,    // Enable/disable codeblock highlighting and import of highlight.js
     customCss: [            // Array of paths to custom CSS files
-      // '/assets/css/custom.css', // Custom TOC styles
+      // 'assets/css/custom.css', // Custom TOC styles
     ]
   },
 
   // Custom JavaScript Files
   customJs: [  // Array of paths to custom JS files, loaded at end of body
-    // '/assets/js/custom-script.js', // Paths relative to outputDir root
-    '/assets/js/docmd-image-lightbox.js', // Image lightbox functionality
+    // 'assets/js/custom-script.js', // Paths relative to outputDir root
+    'assets/js/docmd-image-lightbox.js', // Image lightbox functionality
   ],
 
   // Content Processing
@@ -71,7 +71,7 @@ module.exports = {
         // siteName: 'docmd Documentation', // Optional, defaults to config.siteTitle
         // Default image for og:image if not specified in page frontmatter
         // Path relative to outputDir root
-        defaultImage: '/assets/images/docmd-preview.png',
+        defaultImage: 'assets/images/docmd-preview.png',
       },
       twitter: { // For Twitter Cards
         cardType: 'summary_large_image',     // 'summary', 'summary_large_image'
@@ -139,7 +139,7 @@ module.exports = {
 
   // Favicon Configuration
   // Path relative to outputDir root
-  favicon: '/assets/favicon.ico',
+  favicon: 'assets/favicon.ico',
 };
 `;
 

package/src/core/config-loader.js

@@ -5,12 +5,32 @@ const fs = require('fs-extra');
 const { validateConfig } = require('./config-validator');
 
 async function loadConfig(configPath) {
-  const absoluteConfigPath = path.resolve(process.cwd(), configPath);
+  const cwd = process.cwd();
+  let absoluteConfigPath = path.resolve(cwd, configPath);
+
+  // 1. Check if the requested config file exists
   if (!await fs.pathExists(absoluteConfigPath)) {
-    throw new Error(`Configuration file not found at: ${absoluteConfigPath}\nRun "docmd init" to create one.`);
+    // 2. Fallback Logic:
+    // If the user didn't specify a custom path (i.e., using default 'docmd.config.js')
+    // AND 'docmd.config.js' is missing...
+    // Check if legacy 'config.js' exists.
+    if (configPath === 'docmd.config.js') {
+      const legacyPath = path.resolve(cwd, 'config.js');
+      if (await fs.pathExists(legacyPath)) {
+        // console.log('⚠️  Using legacy config.js. Please rename to docmd.config.js'); // Optional warning
+        absoluteConfigPath = legacyPath;
+      } else {
+        // Neither exists
+        throw new Error(`Configuration file not found at: ${absoluteConfigPath}\nRun "docmd init" to create one.`);
+      }
+    } else {
+      // User specified a custom path that doesn't exist
+      throw new Error(`Configuration file not found at: ${absoluteConfigPath}`);
+    }
   }
+
   try {
-    // Clear require cache to always get the freshest config
+    // Clear require cache to always get the freshest config (important for dev mode reloading)
     delete require.cache[require.resolve(absoluteConfigPath)];
     const config = require(absoluteConfigPath);
 

package/src/core/file-processor.js

@@ -34,12 +34,17 @@ function formatPathForDisplay(absolutePath) {
 
 async function processMarkdownFile(filePath, md, config) {
     const rawContent = await fs.readFile(filePath, 'utf8');
+    return processMarkdownContent(rawContent, md, config, filePath);
+}
+
+// Pure logic, no file reading (Used by Live Editor)
+function processMarkdownContent(rawContent, md, config, filePath = 'memory') {
     let frontmatter, markdownContent;
   
     try {
       ({ data: frontmatter, content: markdownContent } = matter(rawContent));
     } catch (e) {
-      console.error(`❌ Error parsing frontmatter in ${formatPathForDisplay(filePath)}:`);
+      console.error(`❌ Error parsing frontmatter in ${filePath === 'memory' ? 'content' : formatPathForDisplay(filePath)}:`);
       console.error(`   ${e.message}`);
       return null;
     }
@@ -70,7 +75,7 @@ async function processMarkdownFile(filePath, md, config) {
   
     return { frontmatter, htmlContent, headings, searchData };
 }
-  
+
 async function findMarkdownFiles(dir) {
     let files = [];
     const items = await fs.readdir(dir, { withFileTypes: true });
@@ -87,6 +92,7 @@ async function findMarkdownFiles(dir) {
 
 module.exports = {
   processMarkdownFile,
+  processMarkdownContent,
   createMarkdownItInstance,
   extractHeadingsFromHtml,
   findMarkdownFiles