autowiki 1.2.1

package/lib/scanner.js

@@ -0,0 +1,178 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function parseFrontmatter(content) {
+  if (!content.startsWith('---')) {
+    return { frontmatter: {}, body: content };
+  }
+
+  const lines = content.split('\n');
+  let endLine = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      endLine = i;
+      break;
+    }
+  }
+
+  if (endLine === -1) {
+    return { frontmatter: {}, body: content };
+  }
+
+  const yamlLines = lines.slice(1, endLine);
+  const body = lines.slice(endLine + 1).join('\n').trim();
+  const frontmatter = {};
+  let currentKey = null;
+  let arrayMode = false;
+
+  for (const line of yamlLines) {
+    // Multi-line array item: "  - value"
+    const arrayItem = line.match(/^\s+-\s+(.+)$/);
+    if (arrayItem && currentKey && arrayMode) {
+      if (!Array.isArray(frontmatter[currentKey])) {
+        frontmatter[currentKey] = [];
+      }
+      let val = arrayItem[1].trim();
+      if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+        val = val.slice(1, -1);
+      }
+      frontmatter[currentKey].push(val);
+      continue;
+    }
+
+    // Key: value pair
+    const kv = line.match(/^([\w-]+):\s*(.*)$/);
+    if (kv) {
+      currentKey = kv[1];
+      let value = kv[2].trim();
+
+      if (!value) {
+        arrayMode = true;
+        frontmatter[currentKey] = [];
+        continue;
+      }
+
+      arrayMode = false;
+
+      // Inline array: [a, b, c]
+      if (value.startsWith('[') && value.endsWith(']')) {
+        frontmatter[currentKey] = value.slice(1, -1)
+          .split(',')
+          .map(s => {
+            s = s.trim();
+            if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+              s = s.slice(1, -1);
+            }
+            return s;
+          })
+          .filter(Boolean);
+        continue;
+      }
+
+      // Scalar value
+      if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+      frontmatter[currentKey] = value;
+    }
+  }
+
+  return { frontmatter, body };
+}
+
+function stripMarkdown(text) {
+  return text
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`]+`/g, '')
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/\*([^*]+)\*/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    .replace(/\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g, (_, t, d) => d || t)
+    .replace(/^\s*[-*+]\s+/gm, '')
+    .replace(/^\s*\d+\.\s+/gm, '')
+    .replace(/^\s*>\s+/gm, '')
+    .replace(/\|[^|\n]+/g, '')
+    .replace(/[-=]{3,}/g, '')
+    .replace(/\n{2,}/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function scanWikiDir(wikiDir) {
+  const pages = [];
+  const titleToSlug = {};
+
+  // Try to load .index.json for aliases
+  let indexData = null;
+  const indexPath = path.join(wikiDir, '.index.json');
+  if (fs.existsSync(indexPath)) {
+    try {
+      indexData = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  // Scan directory recursively
+  function scan(dir, prefix) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        scan(fullPath, prefix + entry.name + '/');
+      } else if (entry.name.endsWith('.md')) {
+        const slug = prefix + entry.name.replace(/\.md$/, '');
+        const content = fs.readFileSync(fullPath, 'utf-8');
+        const { frontmatter, body } = parseFrontmatter(content);
+        const title = frontmatter.title || slug;
+        const type = frontmatter.type || 'page';
+        const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
+        const related = Array.isArray(frontmatter.related) ? frontmatter.related : [];
+        const excerpt = stripMarkdown(body).slice(0, 300);
+
+        pages.push({ slug, title, type, tags, related, excerpt });
+
+        // Build title-to-slug map
+        titleToSlug[title.toLowerCase()] = slug;
+        titleToSlug[slug.toLowerCase()] = slug;
+
+        // Add aliases from index
+        if (indexData && indexData.pages && indexData.pages[slug]) {
+          const aliases = indexData.pages[slug].aliases || [];
+          for (const alias of aliases) {
+            titleToSlug[alias.toLowerCase()] = slug;
+          }
+        }
+      }
+    }
+  }
+
+  scan(wikiDir, '');
+
+  // Sort pages: overview first, then alphabetically by title
+  pages.sort((a, b) => {
+    if (a.type === 'overview') return -1;
+    if (b.type === 'overview') return 1;
+    return a.title.localeCompare(b.title);
+  });
+
+  // Build search index
+  const searchIndex = pages.map(p => ({
+    s: p.slug,
+    t: p.title,
+    y: p.type,
+    x: p.excerpt,
+  }));
+
+  // Determine wiki title (from overview page or fallback)
+  const overviewPage = pages.find(p => p.type === 'overview');
+  const wikiTitle = overviewPage ? overviewPage.title : 'Wiki';
+
+  return { pages, titleToSlug, searchIndex, wikiTitle };
+}
+
+module.exports = { scanWikiDir, parseFrontmatter };

package/lib/server.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { scanWikiDir, parseFrontmatter } = require('./scanner');
+const { createRenderer } = require('./renderer');
+const { renderPage, render404 } = require('./template');
+
+function startServer(wikiDir, port, autoOpen) {
+  let scanResult = scanWikiDir(wikiDir);
+  let renderer = createRenderer(scanResult.titleToSlug);
+  const pageCache = new Map();
+
+  // Watch for file changes
+  try {
+    fs.watch(wikiDir, { recursive: true }, (eventType, filename) => {
+      if (filename && filename.endsWith('.md')) {
+        pageCache.clear();
+        scanResult = scanWikiDir(wikiDir);
+        renderer = createRenderer(scanResult.titleToSlug);
+      }
+    });
+  } catch (e) {
+    // fs.watch may not be available on all platforms
+  }
+
+  function buildPage(slug) {
+    if (pageCache.has(slug)) return pageCache.get(slug);
+
+    const filePath = path.join(wikiDir, slug + '.md');
+    if (!fs.existsSync(filePath)) return null;
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const { frontmatter, body } = parseFrontmatter(content);
+    const htmlBody = renderer.render(body);
+    const title = frontmatter.title || slug;
+    const type = frontmatter.type || 'page';
+    const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
+    const related = Array.isArray(frontmatter.related) ? frontmatter.related : [];
+
+    const html = renderPage({
+      title,
+      type,
+      tags,
+      related,
+      htmlBody,
+      currentSlug: slug,
+      pages: scanResult.pages,
+      searchIndex: scanResult.searchIndex,
+      wikiTitle: scanResult.wikiTitle,
+      titleToSlug: scanResult.titleToSlug,
+    });
+
+    pageCache.set(slug, html);
+    return html;
+  }
+
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url, `http://localhost:${port}`);
+    let pathname = url.pathname.replace(/^\/+/, '').replace(/\/+$/, '');
+
+    // Default to overview
+    if (!pathname) pathname = 'overview';
+
+    // Ignore favicon requests
+    if (pathname === 'favicon.ico') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // Serve static files (llms.txt, llms-full.txt, etc.)
+    const staticPath = path.join(wikiDir, pathname);
+    if (fs.existsSync(staticPath) && fs.statSync(staticPath).isFile() && !pathname.endsWith('.md')) {
+      const ext = path.extname(pathname);
+      const types = { '.txt': 'text/plain', '.json': 'application/json', '.xml': 'text/xml' };
+      res.writeHead(200, { 'Content-Type': (types[ext] || 'text/plain') + '; charset=utf-8' });
+      res.end(fs.readFileSync(staticPath, 'utf-8'));
+      return;
+    }
+
+    // Render wiki page
+    const html = buildPage(pathname);
+    if (html) {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(html);
+    } else {
+      res.writeHead(404, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(render404(scanResult.wikiTitle, scanResult.pages, scanResult.searchIndex, scanResult.titleToSlug));
+    }
+  });
+
+  server.listen(port, () => {
+    console.log('');
+    console.log(`  Wiki server running at http://localhost:${port}`);
+    console.log(`  Wiki directory: ${wikiDir}`);
+    console.log(`  Pages: ${scanResult.pages.length}`);
+    console.log('');
+    console.log('  Press Ctrl+C to stop');
+    console.log('');
+
+    if (autoOpen) {
+      const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start' : 'xdg-open';
+      require('child_process').exec(`${cmd} http://localhost:${port}`);
+    }
+  });
+}
+
+function exportSite(wikiDir, outputDir) {
+  const scanResult = scanWikiDir(wikiDir);
+  const renderer = createRenderer(scanResult.titleToSlug);
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  console.log(`Exporting wiki to ${outputDir}...`);
+
+  for (const page of scanResult.pages) {
+    const filePath = path.join(wikiDir, page.slug + '.md');
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const { frontmatter, body } = parseFrontmatter(content);
+    const htmlBody = renderer.render(body);
+
+    const html = renderPage({
+      title: page.title,
+      type: page.type,
+      tags: page.tags,
+      related: page.related,
+      htmlBody,
+      currentSlug: page.slug,
+      pages: scanResult.pages,
+      searchIndex: scanResult.searchIndex,
+      wikiTitle: scanResult.wikiTitle,
+      titleToSlug: scanResult.titleToSlug,
+      exportMode: true,
+    });
+
+    const outPath = path.join(outputDir, page.slug + '.html');
+    const outDir = path.dirname(outPath);
+    if (!fs.existsSync(outDir)) {
+      fs.mkdirSync(outDir, { recursive: true });
+    }
+
+    fs.writeFileSync(outPath, html);
+    console.log(`  ${page.slug}.html`);
+  }
+
+  // Copy static files
+  const staticFiles = ['llms.txt', 'llms-full.txt'];
+  for (const file of staticFiles) {
+    const src = path.join(wikiDir, file);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(outputDir, file));
+      console.log(`  ${file}`);
+    }
+  }
+
+  // Create index.html redirect
+  fs.writeFileSync(
+    path.join(outputDir, 'index.html'),
+    '<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0;url=overview.html"></head></html>\n'
+  );
+  console.log('  index.html');
+  console.log('');
+  console.log('Export complete!');
+}
+
+module.exports = { startServer, exportSite };