@mgks/docmd 0.1.1 → 0.1.3

package/src/commands/dev.js

@@ -8,6 +8,25 @@ const fs = require('fs-extra');
 const { buildSite } = require('./build'); // Re-use the build logic
 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;
+}
+
 async function startDevServer(configPathOption, options = { preserve: false }) {
   let config = await loadConfig(configPathOption); // Load initial config
   const CWD = process.cwd(); // Current Working Directory where user runs `docmd dev`
@@ -18,6 +37,7 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
       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
     };
   };
 
@@ -47,29 +67,92 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
     console.error('WebSocket Server error:', error);
   });
 
-
   function broadcastReload() {
-    // console.log('Broadcasting reload to', wsClients.size, 'clients');
     wsClients.forEach(client => {
       if (client.readyState === WebSocket.OPEN) {
-        client.send('reload');
+        try {
+          client.send('reload');
+        } catch (error) {
+          console.error('Error sending reload command to client:', error);
+        }
       }
     });
   }
 
-  // Inject live reload script into HTML
+  // Inject live reload script into HTML responses
   app.use((req, res, next) => {
-    if (req.path.endsWith('.html')) {
+    if (req.path.endsWith('.html') || !req.path.includes('.')) {
       const originalSend = res.send;
-      res.send = function (body) {
-        if (typeof body === 'string') {
+      res.send = function(body) {
+        if (typeof body === 'string' && body.includes('</body>')) {
           const liveReloadScript = `
             <script>
-              const socket = new WebSocket(\`ws://\${window.location.host}\`);
-              socket.onmessage = function(event) { if (event.data === 'reload') window.location.reload(); };
-              socket.onerror = function(error) { console.error('WebSocket Client Error:', error); };
-              // socket.onopen = function() { console.log('WebSocket Client Connected'); };
-              // socket.onclose = function() { console.log('WebSocket Client Disconnected'); };
+              (function() {
+                // More robust WebSocket connection with automatic reconnection
+                let socket;
+                let reconnectAttempts = 0;
+                const maxReconnectAttempts = 5;
+                const reconnectDelay = 1000; // Start with 1 second delay
+                
+                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.onopen = function() {
+                    console.log('Live reload connected.');
+                    reconnectAttempts = 0; // Reset reconnect counter on successful connection
+                  };
+                  
+                  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.onerror = function(error) {
+                    console.error('WebSocket error:', error);
+                  };
+                }
+                
+                // 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>
           `;
           body = body.replace('</body>', `${liveReloadScript}</body>`);
@@ -80,6 +163,12 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
     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);
@@ -88,28 +177,45 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
   // Initial build
   console.log('🚀 Performing initial build for dev server...');
   try {
-    await buildSite(configPathOption, { isDev: true, preserve: options.preserve }); // Use the original config path option
+    await buildSite(configPathOption, { isDev: true, preserve: options.preserve, noDoubleProcessing: true }); // Use the original config path option
     console.log('✅ Initial build complete.');
   } 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.
   }
 
+  // Check if user assets directory exists
+  const userAssetsDirExists = await fs.pathExists(paths.userAssetsDir);
 
   // Watch for changes
   const watchedPaths = [
     paths.srcDirToWatch,
     paths.configFileToWatch,
-    DOCMD_TEMPLATES_DIR,
-    DOCMD_ASSETS_DIR
   ];
 
-  console.log(`👀 Watching for changes in:
-    - Source: ${paths.srcDirToWatch}
-    - Config: ${paths.configFileToWatch}
-    - docmd Templates: ${DOCMD_TEMPLATES_DIR} (internal)
-    - docmd Assets: ${DOCMD_ASSETS_DIR} (internal)
-  `);
+  // 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];
+  
+  // Only in development environments, we might want to watch internal files too
+  if (process.env.DOCMD_DEV === 'true') {
+    watchedPaths.push(...internalPaths);
+  }
+
+  console.log(`👀 Watching for changes in:`);
+  console.log(`    - Source: ${formatPathForDisplay(paths.srcDirToWatch, CWD)}`);
+  console.log(`    - Config: ${formatPathForDisplay(paths.configFileToWatch, CWD)}`);
+  if (userAssetsDirExists) {
+    console.log(`    - Assets: ${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)`);
+  }
 
   const watcher = chokidar.watch(watchedPaths, {
     ignored: /(^|[\/\\])\../, // ignore dotfiles
@@ -134,7 +240,7 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
         // 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 ${paths.outputDir} to ${newPaths.outputDir}. Updating static server.`);
+            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.
@@ -143,9 +249,9 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
         paths = newPaths; // Update paths for next build reference
       }
 
-      await buildSite(configPathOption, { isDev: true, preserve: options.preserve }); // Re-build using the potentially updated config path
+      await buildSite(configPathOption, { isDev: true, preserve: options.preserve, noDoubleProcessing: true }); // Re-build using the potentially updated config path
       broadcastReload();
-      console.log('✅ Rebuild complete. Browser should refresh.');
+      console.log('✅ Rebuild complete.');
     } catch (error) {
       console.error('❌ Rebuild failed:', error.message, error.stack);
     }
@@ -153,18 +259,40 @@ async function startDevServer(configPathOption, options = { preserve: false }) {
 
   watcher.on('error', error => console.error(`Watcher error: ${error}`));
 
+  // Try different ports if the default port is in use
   const PORT = process.env.PORT || 3000;
-  server.listen(PORT, async () => {
-    // Check if index.html exists after initial build
-    const indexHtmlPath = path.join(paths.outputDir, 'index.html');
-    if (!await fs.pathExists(indexHtmlPath)) {
-        console.warn(`⚠️  Warning: ${indexHtmlPath} 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.log(`🎉 Dev server started at http://localhost:${PORT}`);
-    console.log(`Serving content from: ${paths.outputDir}`);
-  });
+  const MAX_PORT_ATTEMPTS = 10;
+  let currentPort = PORT;
+  
+  // Function to try starting the server on different ports
+  function tryStartServer(port, attempt = 1) {
+    server.listen(port)
+      .on('listening', async () => {
+        // Check if index.html exists after initial build
+        const indexHtmlPath = path.join(paths.outputDir, 'index.html');
+        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.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}`);
+          process.exit(1);
+        }
+      });
+  }
+  
+  // Start the server with port fallback
+  tryStartServer(currentPort);
 
   // Graceful shutdown
   process.on('SIGINT', () => {

package/src/commands/init.js

@@ -1,5 +1,6 @@
 const fs = require('fs-extra');
 const path = require('path');
+const readline = require('readline');
 
 const defaultConfigContent = `// config.js: basic config for docmd
 module.exports = {
@@ -76,9 +77,18 @@ module.exports = {
   // Icons are kebab-case names from Lucide Icons (https://lucide.dev/)
   navigation: [
       { title: 'Welcome', path: '/', icon: 'home' }, // Corresponds to docs/index.md
+      {
+        title: 'Getting Started',
+        icon: 'rocket',
+        path: '#',
+        children: [
+          { title: 'Documentation', path: 'https://docmd.mgks.dev', icon: 'scroll', external: true },
+          { title: 'Installation', path: 'https://docmd.mgks.dev/getting-started/installation', icon: 'download', external: true },
+          { title: 'Basic Usage', path: 'https://docmd.mgks.dev/getting-started/basic-usage', icon: 'play', external: true },
+        ],
+      },
       // External links:
       { title: 'GitHub', path: 'https://github.com/mgks/docmd', icon: 'github', external: true },
-      { title: 'Documentation', path: 'https://github.com/mgks/docmd', icon: 'scroll', external: true }
   ],
 
   // Footer Configuration
@@ -106,16 +116,117 @@ async function initProject() {
   const docsDir = path.join(baseDir, 'docs');
   const configFile = path.join(baseDir, 'config.js');
   const indexMdFile = path.join(docsDir, 'index.md');
+  const assetsDir = path.join(baseDir, 'assets');
+  const assetsCssDir = path.join(assetsDir, 'css');
+  const assetsJsDir = path.join(assetsDir, 'js');
+  const assetsImagesDir = path.join(assetsDir, 'images');
+  
+  const existingFiles = [];
+  const dirExists = {
+    docs: false,
+    assets: false
+  };
+  
+  // Check each file individually
+  if (await fs.pathExists(configFile)) {
+    existingFiles.push('config.js');
+  }
+  
+  if (await fs.pathExists(docsDir)) {
+    dirExists.docs = true;
+    
+    if (await fs.pathExists(indexMdFile)) {
+      existingFiles.push('docs/index.md');
+    }
+  }
 
-  if (await fs.pathExists(configFile) || await fs.pathExists(docsDir)) {
-    console.warn('⚠️  `docs/` directory or `config.js` already exists. Skipping creation to avoid overwriting.');
-  } else {
+  // Check if assets directory exists
+  if (await fs.pathExists(assetsDir)) {
+    dirExists.assets = true;
+  }
+  
+  // Determine if we should override existing files
+  let shouldOverride = false;
+  if (existingFiles.length > 0) {
+    console.warn('⚠️  The following files already exist:');
+    existingFiles.forEach(file => console.warn(`   - ${file}`));
+    
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    
+    const answer = await new Promise(resolve => {
+      rl.question('Do you want to override these files? (y/N): ', resolve);
+    });
+    
+    rl.close();
+    
+    shouldOverride = answer.toLowerCase() === 'y';
+    
+    if (!shouldOverride) {
+      console.log('⏭️  Skipping existing files. Will only create new files.');
+    }
+  }
+  
+  // Create docs directory if it doesn't exist
+  if (!dirExists.docs) {
     await fs.ensureDir(docsDir);
+    console.log('📁 Created `docs/` directory');
+  } else {
+    console.log('📁 Using existing `docs/` directory');
+  }
+
+  // Create assets directory structure if it doesn't exist
+  if (!dirExists.assets) {
+    await fs.ensureDir(assetsDir);
+    await fs.ensureDir(assetsCssDir);
+    await fs.ensureDir(assetsJsDir);
+    await fs.ensureDir(assetsImagesDir);
+    console.log('📁 Created `assets/` directory with css, js, and images subdirectories');
+  } else {
+    console.log('📁 Using existing `assets/` directory');
+    
+    // Create subdirectories if they don't exist
+    if (!await fs.pathExists(assetsCssDir)) {
+      await fs.ensureDir(assetsCssDir);
+      console.log('📁 Created `assets/css/` directory');
+    }
+    
+    if (!await fs.pathExists(assetsJsDir)) {
+      await fs.ensureDir(assetsJsDir);
+      console.log('📁 Created `assets/js/` directory');
+    }
+    
+    if (!await fs.pathExists(assetsImagesDir)) {
+      await fs.ensureDir(assetsImagesDir);
+      console.log('📁 Created `assets/images/` directory');
+    }
+  }
+  
+  // Write config file if it doesn't exist or user confirmed override
+  if (!await fs.pathExists(configFile)) {
     await fs.writeFile(configFile, defaultConfigContent, 'utf8');
-    await fs.writeFile(indexMdFile, defaultIndexMdContent, 'utf8');
     console.log('📄 Created `config.js`');
-    console.log('📁 Created `docs/` directory with a sample `index.md`');
+  } else if (shouldOverride) {
+    await fs.writeFile(configFile, defaultConfigContent, 'utf8');
+    console.log('📄 Updated `config.js`');
+  } else {
+    console.log('⏭️  Skipped existing `config.js`');
+  }
+  
+  // Write index.md file if it doesn't exist or user confirmed override
+  if (!await fs.pathExists(indexMdFile)) {
+    await fs.writeFile(indexMdFile, defaultIndexMdContent, 'utf8');
+    console.log('📄 Created `docs/index.md`');
+  } else if (shouldOverride) {
+    await fs.writeFile(indexMdFile, defaultIndexMdContent, 'utf8');
+    console.log('📄 Updated `docs/index.md`');
+  } else {
+    console.log('⏭️  Skipped existing `docs/index.md`');
   }
+  
+  console.log('✅ Project initialization complete!');
 }
 
 module.exports = { initProject };

package/src/core/file-processor.js

@@ -5,6 +5,21 @@ const matter = require('gray-matter');
 const hljs = require('highlight.js');
 const container = require('markdown-it-container');
 const attrs = require('markdown-it-attrs');
+const path = require('path'); // Add path module for findMarkdownFiles
+
+// Function to format paths for display (relative to CWD)
+function formatPathForDisplay(absolutePath) {
+  const CWD = process.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;
+}
 
 const md = new MarkdownIt({
   html: true,
@@ -335,7 +350,7 @@ function extractHeadingsFromHtml(htmlContent) {
   return headings;
 }
 
-async function processMarkdownFile(filePath) {
+async function processMarkdownFile(filePath, options = { isDev: false }) {
   const rawContent = await fs.readFile(filePath, 'utf8');
   let frontmatter, markdownContent;
 
@@ -346,21 +361,43 @@ async function processMarkdownFile(filePath) {
   } catch (e) {
     if (e.name === 'YAMLException') {
       // Provide more specific error for YAML parsing issues
-      const errorMessage = `Error parsing YAML frontmatter in ${filePath}: ${e.reason || e.message}${e.mark ? ` at line ${e.mark.line + 1}, column ${e.mark.column + 1}` : ''}. Please check the syntax.`;
+      const errorMessage = `Error parsing YAML frontmatter in ${formatPathForDisplay(filePath)}: ${e.reason || e.message}${e.mark ? ` at line ${e.mark.line + 1}, column ${e.mark.column + 1}` : ''}. Please check the syntax.`;
       console.error(`❌ ${errorMessage}`);
       throw new Error(errorMessage); // Propagate error to stop build/dev
     }
     // For other errors from gray-matter or unknown errors
-    console.error(`❌ Error processing frontmatter in ${filePath}: ${e.message}`);
+    console.error(`❌ Error processing frontmatter in ${formatPathForDisplay(filePath)}: ${e.message}`);
     throw e;
   }
 
   if (!frontmatter.title) {
-    console.warn(`⚠️ Warning: Markdown file ${filePath} is missing a 'title' in its frontmatter. Using filename as fallback.`);
+    console.warn(`⚠️ Warning: Markdown file ${formatPathForDisplay(filePath)} is missing a 'title' in its frontmatter. Using filename as fallback.`);
     // Fallback title, or you could make it an error
     // frontmatter.title = path.basename(filePath, path.extname(filePath));
   }
 
+  // Special handling for no-style pages with HTML content
+  if (frontmatter.noStyle === true) {
+    // Only log when not in dev mode to reduce console output during dev
+    if (!options.isDev) {
+      console.log(`📄 Processing no-style page: ${formatPathForDisplay(filePath)} - Using raw HTML content`);
+    }
+    
+    // For no-style pages, we'll use the raw content directly
+    // No markdown processing, no HTML escaping
+    const htmlContent = markdownContent;
+    
+    // Extract headings for table of contents (if needed)
+    const headings = extractHeadingsFromHtml(htmlContent);
+
+    return {
+      frontmatter,
+      htmlContent,
+      headings,
+    };
+  }
+
+  // Regular processing for standard pages
   // Check if this is a documentation example showing how to use containers
   const isContainerDocumentation = markdownContent.includes('containerName [optionalTitleOrType]') || 
                                   markdownContent.includes('## Callouts') || 
@@ -413,4 +450,29 @@ async function processMarkdownFile(filePath) {
   };
 }
 
-module.exports = { processMarkdownFile, mdInstance: md, extractHeadingsFromHtml }; // Export mdInstance if needed by plugins for consistency
+// Add findMarkdownFiles function
+/**
+ * Recursively finds all Markdown files in a directory and its subdirectories
+ * @param {string} dir - Directory to search in
+ * @returns {Promise<string[]>} - Array of file paths
+ */
+async function findMarkdownFiles(dir) {
+  let files = [];
+  const items = await fs.readdir(dir, { withFileTypes: true });
+  for (const item of items) {
+    const fullPath = path.join(dir, item.name);
+    if (item.isDirectory()) {
+      files = files.concat(await findMarkdownFiles(fullPath));
+    } else if (item.isFile() && (item.name.endsWith('.md') || item.name.endsWith('.markdown'))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+module.exports = { 
+  processMarkdownFile, 
+  mdInstance: md, 
+  extractHeadingsFromHtml,
+  findMarkdownFiles // Export the findMarkdownFiles function
+};

package/src/core/html-generator.js

@@ -18,7 +18,7 @@ async function processPluginHooks(config, pageData, relativePathToRoot) {
     // 1. Favicon (built-in handling)
     if (config.favicon) {
         const faviconPath = config.favicon.startsWith('/') ? config.favicon.substring(1) : config.favicon;
-        faviconLinkHtml = `  <link rel="icon" href="${relativePathToRoot}${faviconPath}">\n`;
+        faviconLinkHtml = `<link rel="shortcut icon" href="${relativePathToRoot}${faviconPath}" type="image/x-icon">\n`;
     }
 
     // 2. Theme CSS (built-in handling for theme.name)
@@ -75,9 +75,21 @@ async function generateHtmlPage(templateData) {
         footerHtml = mdInstance.renderInline(config.footer);
     }
 
-    const layoutTemplatePath = path.join(__dirname, '..', 'templates', 'layout.ejs');
+    // Determine which template to use based on frontmatter
+    let templateName = 'layout.ejs';
+    if (frontmatter.noStyle === true) {
+        templateName = 'no-style.ejs';
+        
+        // For no-style pages, ensure we're passing the raw HTML content
+        // without any additional processing or escaping
+        if (content.includes('&lt;') || content.includes('&gt;')) {
+            console.warn(`⚠️ Warning: HTML content in no-style page appears to be escaped. This may cause rendering issues.`);
+        }
+    }
+
+    const layoutTemplatePath = path.join(__dirname, '..', 'templates', templateName);
     if (!await fs.pathExists(layoutTemplatePath)) {
-        throw new Error(`Layout template not found: ${layoutTemplatePath}`);
+        throw new Error(`Template not found: ${layoutTemplatePath}`);
     }
     const layoutTemplate = await fs.readFile(layoutTemplatePath, 'utf8');
 
@@ -105,6 +117,7 @@ async function generateHtmlPage(templateData) {
         currentPagePath, // Pass the current page path for active state detection
         headings: headings || [], // Pass headings for TOC, default to empty array if not provided
         isActivePage, // Flag to determine if TOC should be shown
+        frontmatter, // Pass the entire frontmatter for no-style template
         ...pluginOutputs, // Spread all plugin generated HTML strings
     };
 

package/src/plugins/sitemap.js

@@ -1,16 +1,34 @@
 const fs = require('fs-extra');
 const path = require('path');
 
+// Function to format paths for display (relative to CWD)
+function formatPathForDisplay(absolutePath) {
+  const CWD = process.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;
+}
+
 /**
  * Generate sitemap.xml in the output directory root
  * @param {Object} config - The full configuration object
  * @param {Array} pages - Array of page objects with data about each processed page
  * @param {string} outputDir - Path to the output directory
+ * @param {Object} options - Additional options
+ * @param {boolean} options.isDev - Whether running in development mode
  */
-async function generateSitemap(config, pages, outputDir) {
+async function generateSitemap(config, pages, outputDir, options = { isDev: false }) {
   // Skip if no siteUrl is defined (sitemap needs absolute URLs)
   if (!config.siteUrl) {
-    console.warn('⚠️ No siteUrl defined in config. Skipping sitemap generation.');
+    if (!options.isDev) {
+      console.warn('⚠️ No siteUrl defined in config. Skipping sitemap generation.');
+    }
     return;
   }
 
@@ -94,7 +112,10 @@ async function generateSitemap(config, pages, outputDir) {
   const sitemapPath = path.join(outputDir, 'sitemap.xml');
   await fs.writeFile(sitemapPath, sitemapXml);
   
-  console.log(`✅ Generated sitemap at ${sitemapPath}`);
+  // Only show sitemap generation message in production mode or if DOCMD_DEV is true
+  if (!options.isDev || process.env.DOCMD_DEV === 'true') {
+    console.log(`✅ Generated sitemap at ${formatPathForDisplay(sitemapPath)}`);
+  }
 }
 
 module.exports = { generateSitemap }; 

package/src/templates/layout.ejs

@@ -100,7 +100,7 @@
                     <%- footerHtml || '' %>
                 </div>
                 <div class="branding-footer">
-                    Build with 💜 <a href="https://docmd.mgks.dev" target="_blank" rel="noopener">docmd.</a>
+                    Build with <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M19 14c1.49-1.46 3-3.21 3-5.5A5.5 5.5 0 0 0 16.5 3c-1.76 0-3 .5-4.5 2-1.5-1.5-2.74-2-4.5-2A5.5 5.5 0 0 0 2 8.5c0 2.3 1.5 4.05 3 5.5l7 7Z"></path><path d="M12 5 9.04 7.96a2.17 2.17 0 0 0 0 3.08c.82.82 2.13.85 3 .07l2.07-1.9a2.82 2.82 0 0 1 3.79 0l2.96 2.66"></path><path d="m18 15-2-2"></path><path d="m15 18-2-2"></path></svg> <a href="https://docmd.mgks.dev" target="_blank" rel="noopener">docmd.</a>
                 </div>
             </div>
         </footer>