cokit-cli 1.0.1 → 1.0.3

package/skills/ck-markdown-novel-viewer/scripts/server.cjs

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+
+/**
+ * Markdown Novel Viewer Server
+ * Background HTTP server rendering markdown files with calm, book-like UI
+ *
+ * Universal viewer - pass ANY path and view it:
+ * - Markdown files → novel-reader UI
+ * - Directories → file listing browser
+ *
+ * Usage:
+ *   node server.cjs --file ./plan.md [--port 3456] [--no-open] [--stop] [--host 0.0.0.0]
+ *   node server.cjs --dir ./plans [--port 3456]  # Browse directory
+ *
+ * Options:
+ *   --file <path>   Path to markdown file
+ *   --dir <path>    Path to directory (browse mode)
+ *   --port <number> Server port (default: 3456, auto-increment if busy)
+ *   --host <addr>   Host to bind (default: localhost, use 0.0.0.0 for all interfaces)
+ *   --no-open       Disable auto-open browser (opens by default)
+ *   --stop          Stop all running servers
+ *   --background    Run in background (detached) - legacy mode
+ *   --foreground    Run in foreground (for CC background tasks)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+
+const { findAvailablePort, DEFAULT_PORT } = require('./lib/port-finder.cjs');
+const { writePidFile, stopAllServers, setupShutdownHandlers, findRunningInstances } = require('./lib/process-mgr.cjs');
+const { createHttpServer } = require('./lib/http-server.cjs');
+const { renderMarkdownFile, renderTOCHtml } = require('./lib/markdown-renderer.cjs');
+const { generateNavSidebar, generateNavFooter, detectPlan, getNavigationContext } = require('./lib/plan-navigator.cjs');
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(argv) {
+  const args = {
+    file: null,
+    dir: null,
+    port: DEFAULT_PORT,
+    host: 'localhost',
+    open: true,  // Auto-open browser by default
+    stop: false,
+    background: false,
+    foreground: false,
+    isChild: false
+  };
+
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--file' && argv[i + 1]) {
+      args.file = argv[++i];
+    } else if (arg === '--dir' && argv[i + 1]) {
+      args.dir = argv[++i];
+    } else if (arg === '--port' && argv[i + 1]) {
+      args.port = parseInt(argv[++i], 10);
+    } else if (arg === '--host' && argv[i + 1]) {
+      args.host = argv[++i];
+    } else if (arg === '--open') {
+      args.open = true;
+    } else if (arg === '--no-open') {
+      args.open = false;
+    } else if (arg === '--stop') {
+      args.stop = true;
+    } else if (arg === '--background') {
+      args.background = true;
+    } else if (arg === '--foreground') {
+      args.foreground = true;
+    } else if (arg === '--child') {
+      args.isChild = true;
+    } else if (!arg.startsWith('--') && !args.file && !args.dir) {
+      // Positional argument - could be file or directory
+      args.file = arg;
+    }
+  }
+
+  return args;
+}
+
+/**
+ * Resolve input path - simple logic, no smart detection
+ * @param {string} input - Input path
+ * @param {string} cwd - Current working directory
+ * @returns {{type: 'file'|'directory'|null, path: string|null}}
+ */
+function resolveInput(input, cwd) {
+  if (!input) return { type: null, path: null };
+
+  // Resolve relative to CWD
+  const resolved = path.isAbsolute(input) ? input : path.resolve(cwd, input);
+
+  if (!fs.existsSync(resolved)) {
+    return { type: null, path: null };
+  }
+
+  const stats = fs.statSync(resolved);
+
+  // File mode
+  if (stats.isFile()) {
+    return { type: 'file', path: resolved };
+  }
+
+  // Directory mode - browse, no auto-detection of plan.md
+  if (stats.isDirectory()) {
+    return { type: 'directory', path: resolved };
+  }
+
+  return { type: null, path: null };
+}
+
+/**
+ * Open browser with URL
+ */
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+
+  if (platform === 'darwin') {
+    cmd = `open "${url}"`;
+  } else if (platform === 'win32') {
+    // On Windows, start command treats first quoted arg as window title
+    // Use empty title "" before the URL to prevent this
+    cmd = `start "" "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+
+  try {
+    execSync(cmd, { stdio: 'ignore' });
+  } catch {
+    // Ignore browser open errors
+  }
+}
+
+/**
+ * Generate full HTML page from markdown
+ */
+function generateFullPage(filePath, assetsDir) {
+  const { html, toc, frontmatter, title } = renderMarkdownFile(filePath);
+  const tocHtml = renderTOCHtml(toc);
+  const navSidebar = generateNavSidebar(filePath);
+  const navFooter = generateNavFooter(filePath);
+  const planInfo = detectPlan(filePath);
+  const navContext = getNavigationContext(filePath);
+
+  // Read template
+  const templatePath = path.join(assetsDir, 'template.html');
+  let template = fs.readFileSync(templatePath, 'utf8');
+
+  // Generate back button (links to parent directory browser)
+  const parentDir = path.dirname(filePath);
+  const backButton = `
+    <a href="/browse?dir=${encodeURIComponent(parentDir)}" class="icon-btn back-btn" title="Back to folder">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+        <path d="M19 12H5M12 19l-7-7 7-7"/>
+      </svg>
+    </a>`;
+
+  // Generate header nav (prev/next) for plan files
+  let headerNav = '';
+  if (navContext.prev || navContext.next) {
+    const prevBtn = navContext.prev && fs.existsSync(navContext.prev.file)
+      ? `<a href="/view?file=${encodeURIComponent(navContext.prev.file)}" class="header-nav-btn prev" title="${navContext.prev.name}">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M15 18l-6-6 6-6"/></svg>
+          <span>Prev</span>
+        </a>`
+      : '';
+    const nextBtn = navContext.next && fs.existsSync(navContext.next.file)
+      ? `<a href="/view?file=${encodeURIComponent(navContext.next.file)}" class="header-nav-btn next" title="${navContext.next.name}">
+          <span>Next</span>
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M9 18l6-6-6-6"/></svg>
+        </a>`
+      : '';
+    headerNav = `<div class="header-nav">${prevBtn}${nextBtn}</div>`;
+  }
+
+  // Replace placeholders
+  template = template
+    .replace(/\{\{title\}\}/g, title)
+    .replace('{{toc}}', tocHtml)
+    .replace('{{nav-sidebar}}', navSidebar)
+    .replace('{{nav-footer}}', navFooter)
+    .replace('{{content}}', html)
+    .replace('{{has-plan}}', planInfo.isPlan ? 'has-plan' : '')
+    .replace('{{frontmatter}}', JSON.stringify(frontmatter || {}))
+    .replace('{{back-button}}', backButton)
+    .replace('{{header-nav}}', headerNav);
+
+  return template;
+}
+
+/**
+ * Get local network IP address for remote access
+ * @returns {string|null} - Local IP or null if not found
+ */
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      // Skip internal (loopback) and non-IPv4 addresses
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Build URL with query parameters (fixes path conflicts)
+ * @returns {{url: string, networkUrl: string|null}} - Local and network URLs
+ */
+function buildUrl(host, port, type, filePath) {
+  const displayHost = host === '0.0.0.0' ? 'localhost' : host;
+  const baseUrl = `http://${displayHost}:${port}`;
+
+  let urlPath = '';
+  if (type === 'file') {
+    urlPath = `/view?file=${encodeURIComponent(filePath)}`;
+  } else if (type === 'directory') {
+    urlPath = `/browse?dir=${encodeURIComponent(filePath)}`;
+  }
+
+  const url = baseUrl + urlPath;
+
+  // If binding to all interfaces, provide network URL for remote access
+  let networkUrl = null;
+  if (host === '0.0.0.0') {
+    const localIP = getLocalIP();
+    if (localIP) {
+      networkUrl = `http://${localIP}:${port}${urlPath}`;
+    }
+  }
+
+  return { url, networkUrl };
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = parseArgs(process.argv);
+  const cwd = process.cwd();
+  const assetsDir = path.join(__dirname, '..', 'assets');
+
+  // Handle --stop
+  if (args.stop) {
+    const instances = findRunningInstances();
+    if (instances.length === 0) {
+      console.log('No server running to stop');
+      process.exit(0);
+    }
+    const stopped = stopAllServers();
+    console.log(`Stopped ${stopped} server(s)`);
+    process.exit(0);
+  }
+
+  // Determine input
+  const input = args.dir || args.file;
+
+  // Validate input
+  if (!input) {
+    console.error('Error: --file or --dir argument required');
+    console.error('Usage:');
+    console.error('  node server.cjs --file <path.md> [--port 3456] [--open]');
+    console.error('  node server.cjs --dir <path> [--port 3456] [--open]  # Browse directory');
+    process.exit(1);
+  }
+
+  // Resolve input path - simple logic
+  let resolved = resolveInput(input, cwd);
+
+  // If --dir was explicitly used, force directory mode
+  if (args.dir && resolved.type === null) {
+    const dirPath = path.isAbsolute(args.dir) ? args.dir : path.resolve(cwd, args.dir);
+    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+      resolved = { type: 'directory', path: dirPath };
+    }
+  }
+
+  if (resolved.type === null) {
+    console.error(`Error: Invalid path: ${input}`);
+    console.error('Path must be a file or directory.');
+    process.exit(1);
+  }
+
+  // Background mode - spawn child and exit (legacy mode for manual runs)
+  // Skip if --foreground is set (for Claude Code background tasks)
+  if (args.background && !args.foreground && !args.isChild) {
+    const childArgs = ['--port', String(args.port), '--host', args.host, '--child'];
+    if (resolved.type === 'file') {
+      childArgs.unshift('--file', resolved.path);
+    } else {
+      childArgs.unshift('--dir', resolved.path);
+    }
+    if (args.open) childArgs.push('--open');
+
+    const child = spawn(process.execPath, [__filename, ...childArgs], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: cwd
+    });
+    child.unref();
+
+    // Wait briefly for child to start
+    await new Promise(r => setTimeout(r, 500));
+
+    // Find the port the child is using
+    const instances = findRunningInstances();
+    const instance = instances.find(i => i.port >= args.port);
+    const port = instance ? instance.port : args.port;
+
+    const { url, networkUrl } = buildUrl(args.host, port, resolved.type, resolved.path);
+
+    const result = {
+      success: true,
+      url,
+      path: resolved.path,
+      port,
+      host: args.host,
+      mode: resolved.type
+    };
+    if (networkUrl) result.networkUrl = networkUrl;
+
+    console.log(JSON.stringify(result));
+
+    process.exit(0);
+  }
+
+  // Find available port
+  const port = await findAvailablePort(args.port);
+  if (port !== args.port) {
+    console.error(`Port ${args.port} in use, using ${port}`);
+  }
+
+  // Determine allowed directories for security
+  const allowedDirs = [assetsDir, cwd];
+  if (resolved.path) {
+    const targetDir = resolved.type === 'file' ? path.dirname(resolved.path) : resolved.path;
+    if (!allowedDirs.includes(targetDir)) {
+      allowedDirs.push(targetDir);
+    }
+  }
+
+  // Create server
+  const server = createHttpServer({
+    assetsDir,
+    renderMarkdown: (fp) => generateFullPage(fp, assetsDir),
+    allowedDirs
+  });
+
+  // Start server
+  server.listen(port, args.host, () => {
+    const { url, networkUrl } = buildUrl(args.host, port, resolved.type, resolved.path);
+
+    // Write PID file
+    writePidFile(port, process.pid);
+
+    // Setup shutdown handlers
+    setupShutdownHandlers(port, () => {
+      server.close();
+    });
+
+    // Output for CLI/command integration
+    // In foreground mode (CC background task), always output JSON
+    if (args.foreground || args.isChild || process.env.CLAUDE_COMMAND) {
+      const result = {
+        success: true,
+        url,
+        path: resolved.path,
+        port,
+        host: args.host,
+        mode: resolved.type
+      };
+      if (networkUrl) result.networkUrl = networkUrl;
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(`\nMarkdown Novel Viewer`);
+      console.log(`${'─'.repeat(40)}`);
+      console.log(`URL: ${url}`);
+      if (networkUrl) {
+        console.log(`Network: ${networkUrl}`);
+      }
+      console.log(`Path: ${resolved.path}`);
+      console.log(`Port: ${port}`);
+      console.log(`Host: ${args.host}`);
+      console.log(`Mode: ${resolved.type === 'file' ? 'File Viewer' : 'Directory Browser'}`);
+      console.log(`\nPress Ctrl+C to stop\n`);
+    }
+
+    // Open browser
+    if (args.open) {
+      openBrowser(url);
+    }
+  });
+
+  server.on('error', (err) => {
+    console.error(`Server error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// Run
+main().catch(err => {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+});

package/skills/ck-markdown-novel-viewer/scripts/tests/server.test.cjs

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+/**
+ * Tests for markdown-novel-viewer
+ * Run: node scripts/tests/server.test.cjs
+ */
+
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+
+const { isPortAvailable, findAvailablePort, DEFAULT_PORT } = require('../lib/port-finder.cjs');
+const { writePidFile, readPidFile, removePidFile, findRunningInstances } = require('../lib/process-mgr.cjs');
+const { getMimeType, MIME_TYPES, isPathSafe, sanitizeErrorMessage } = require('../lib/http-server.cjs');
+const { resolveImages, addHeadingIds, generateTOC, renderTOCHtml } = require('../lib/markdown-renderer.cjs');
+const { detectPlan, parsePlanTable, getNavigationContext, generateNavSidebar } = require('../lib/plan-navigator.cjs');
+
+// Test utilities
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ✓ ${name}`);
+  } catch (err) {
+    failed++;
+    console.log(`  ✗ ${name}`);
+    console.log(`    Error: ${err.message}`);
+  }
+}
+
+function assertEqual(actual, expected, message) {
+  if (actual !== expected) {
+    throw new Error(`${message}: expected "${expected}", got "${actual}"`);
+  }
+}
+
+function assertTrue(value, message) {
+  if (!value) {
+    throw new Error(`${message}: expected truthy value`);
+  }
+}
+
+function assertFalse(value, message) {
+  if (value) {
+    throw new Error(`${message}: expected falsy value`);
+  }
+}
+
+function assertIncludes(str, substr, message) {
+  if (!str.includes(substr)) {
+    throw new Error(`${message}: expected to include "${substr}"`);
+  }
+}
+
+// Test suites
+console.log('\n--- Port Finder Tests ---');
+
+test('DEFAULT_PORT is 3456', () => {
+  assertEqual(DEFAULT_PORT, 3456, 'Default port');
+});
+
+test('isPortAvailable returns boolean', () => {
+  // Sync test - function exists
+  assertTrue(typeof isPortAvailable === 'function', 'Should be function');
+});
+
+test('findAvailablePort returns number', () => {
+  // Sync test - actual async behavior tested in integration
+  assertTrue(typeof findAvailablePort === 'function', 'Should be function');
+});
+
+console.log('\n--- Process Manager Tests ---');
+
+test('writePidFile and readPidFile work correctly', () => {
+  const testPort = 9876;
+  const testPid = 12345;
+
+  writePidFile(testPort, testPid);
+  const readPid = readPidFile(testPort);
+  assertEqual(readPid, testPid, 'PID should match');
+
+  removePidFile(testPort);
+  const afterRemove = readPidFile(testPort);
+  assertEqual(afterRemove, null, 'Should be null after remove');
+});
+
+test('findRunningInstances returns array', () => {
+  const instances = findRunningInstances();
+  assertTrue(Array.isArray(instances), 'Should return array');
+});
+
+console.log('\n--- HTTP Server Tests ---');
+
+test('getMimeType returns correct types', () => {
+  assertEqual(getMimeType('test.html'), 'text/html', 'HTML type');
+  assertEqual(getMimeType('test.css'), 'text/css', 'CSS type');
+  assertEqual(getMimeType('test.js'), 'application/javascript', 'JS type');
+  assertEqual(getMimeType('test.png'), 'image/png', 'PNG type');
+  assertEqual(getMimeType('test.jpg'), 'image/jpeg', 'JPG type');
+  assertEqual(getMimeType('test.unknown'), 'application/octet-stream', 'Unknown type');
+});
+
+test('MIME_TYPES has common extensions', () => {
+  assertTrue(MIME_TYPES['.html'], 'Has .html');
+  assertTrue(MIME_TYPES['.css'], 'Has .css');
+  assertTrue(MIME_TYPES['.js'], 'Has .js');
+  assertTrue(MIME_TYPES['.png'], 'Has .png');
+  assertTrue(MIME_TYPES['.md'], 'Has .md');
+});
+
+console.log('\n--- Security Tests ---');
+
+test('isPathSafe blocks path traversal', () => {
+  assertFalse(isPathSafe('/etc/../etc/passwd', ['/home']), 'Should block .. traversal');
+  assertFalse(isPathSafe('/path\0/file', ['/path']), 'Should block null bytes');
+});
+
+test('isPathSafe allows valid paths', () => {
+  assertTrue(isPathSafe('/tmp/test.md', ['/tmp']), 'Should allow path in allowed dir');
+});
+
+test('sanitizeErrorMessage removes paths', () => {
+  const sanitized = sanitizeErrorMessage('Error: /etc/passwd not found');
+  assertFalse(sanitized.includes('/etc/passwd'), 'Should not contain path');
+  assertIncludes(sanitized, '[path]', 'Should replace with placeholder');
+});
+
+console.log('\n--- Markdown Renderer Tests ---');
+
+test('resolveImages converts relative paths', () => {
+  const md = '![Alt](./image.png)';
+  const resolved = resolveImages(md, '/base/path');
+  assertIncludes(resolved, '/file/', 'Should include /file/ route');
+  assertIncludes(resolved, '/base/path', 'Should include base path');
+});
+
+test('resolveImages preserves absolute URLs', () => {
+  const md = '![Alt](https://example.com/image.png)';
+  const resolved = resolveImages(md, '/base/path');
+  assertEqual(resolved, md, 'Should preserve absolute URL');
+});
+
+test('resolveImages handles reference-style definitions', () => {
+  const md = '![Step 1 Initial]\n\n[Step 1 Initial]: ./screenshots/step1.png';
+  const resolved = resolveImages(md, '/base/path');
+  assertIncludes(resolved, '/file/', 'Should include /file/ route in ref definition');
+  assertIncludes(resolved, '/base/path/screenshots/step1.png', 'Should resolve relative path');
+});
+
+test('resolveImages handles reference-style with titles', () => {
+  const md = '[logo]: ./images/logo.png "Company Logo"';
+  const resolved = resolveImages(md, '/project');
+  assertIncludes(resolved, '/file/project/images/logo.png', 'Should resolve path with title');
+});
+
+test('resolveImages handles inline images with titles', () => {
+  const md = '![Alt](./image.png "Title text")';
+  const resolved = resolveImages(md, '/base');
+  assertIncludes(resolved, '/file/base/image.png', 'Should resolve inline with title');
+});
+
+test('addHeadingIds adds id attributes', () => {
+  const html = '<h1>Test Heading</h1><h2>Another</h2>';
+  const withIds = addHeadingIds(html);
+  assertIncludes(withIds, 'id="test-heading"', 'Should add id to h1');
+  assertIncludes(withIds, 'id="another"', 'Should add id to h2');
+});
+
+test('addHeadingIds handles duplicates', () => {
+  const html = '<h1>Test</h1><h2>Test</h2>';
+  const withIds = addHeadingIds(html);
+  assertIncludes(withIds, 'id="test"', 'Should have first id');
+  assertIncludes(withIds, 'id="test-1"', 'Should have unique second id');
+});
+
+test('generateTOC extracts headings', () => {
+  const html = '<h1 id="one">One</h1><h2 id="two">Two</h2><h3 id="three">Three</h3>';
+  const toc = generateTOC(html);
+  assertEqual(toc.length, 3, 'Should find 3 headings');
+  assertEqual(toc[0].level, 1, 'First should be h1');
+  assertEqual(toc[0].id, 'one', 'First id should be "one"');
+});
+
+test('renderTOCHtml generates list', () => {
+  const toc = [{ level: 1, id: 'test', text: 'Test' }];
+  const html = renderTOCHtml(toc);
+  assertIncludes(html, '<ul', 'Should have ul');
+  assertIncludes(html, 'href="#test"', 'Should have anchor');
+  assertIncludes(html, 'Test', 'Should have text');
+});
+
+test('renderTOCHtml handles empty array', () => {
+  const html = renderTOCHtml([]);
+  assertEqual(html, '', 'Should return empty string');
+});
+
+console.log('\n--- Plan Navigator Tests ---');
+
+// Create temp plan structure for testing
+const testPlanDir = '/tmp/test-novel-viewer-plan';
+const testPlanFile = path.join(testPlanDir, 'plan.md');
+const testPhaseFile = path.join(testPlanDir, 'phase-01-test.md');
+
+function setupTestPlan() {
+  if (!fs.existsSync(testPlanDir)) {
+    fs.mkdirSync(testPlanDir, { recursive: true });
+  }
+
+  fs.writeFileSync(testPlanFile, `# Test Plan
+
+| Phase | Name | Status | Link |
+|-------|------|--------|------|
+| 1 | Test Phase | Pending | [phase-01-test.md](./phase-01-test.md) |
+`);
+
+  fs.writeFileSync(testPhaseFile, `# Phase 1: Test Phase
+
+Content here.
+`);
+}
+
+function cleanupTestPlan() {
+  if (fs.existsSync(testPlanDir)) {
+    fs.rmSync(testPlanDir, { recursive: true });
+  }
+}
+
+setupTestPlan();
+
+test('detectPlan identifies plan directory', () => {
+  const result = detectPlan(testPlanFile);
+  assertTrue(result.isPlan, 'Should detect as plan');
+  assertEqual(result.planDir, testPlanDir, 'Should have correct dir');
+  assertTrue(result.phases.length >= 1, 'Should find phases');
+});
+
+test('detectPlan returns false for non-plan', () => {
+  const result = detectPlan('/tmp/random-file.md');
+  assertFalse(result.isPlan, 'Should not be plan');
+});
+
+test('parsePlanTable extracts phases', () => {
+  const phases = parsePlanTable(testPlanFile);
+  assertTrue(phases.length >= 1, 'Should find phases');
+  assertEqual(phases[0].phase, 1, 'First phase number');
+  assertEqual(phases[0].name, 'Test Phase', 'Phase name');
+  assertEqual(phases[0].status, 'pending', 'Status should be lowercase');
+});
+
+test('getNavigationContext returns correct structure', () => {
+  const ctx = getNavigationContext(testPlanFile);
+  assertTrue(ctx.planInfo.isPlan, 'Should be plan');
+  assertTrue(ctx.allPhases.length >= 1, 'Should have phases');
+  assertEqual(ctx.currentIndex, 0, 'Plan.md should be index 0');
+});
+
+test('generateNavSidebar returns HTML', () => {
+  const html = generateNavSidebar(testPlanFile);
+  assertIncludes(html, '<nav', 'Should have nav element');
+  assertIncludes(html, 'phase-list', 'Should have phase list');
+});
+
+test('generateNavSidebar returns empty for non-plan', () => {
+  const html = generateNavSidebar('/tmp/random.md');
+  assertEqual(html, '', 'Should return empty string');
+});
+
+cleanupTestPlan();
+
+// Summary
+console.log('\n--- Test Results ---');
+console.log(`Passed: ${passed}`);
+console.log(`Failed: ${failed}`);
+console.log(`Total: ${passed + failed}`);
+
+if (failed > 0) {
+  process.exit(1);
+}
+
+console.log('\nAll tests passed!');