docmk 1.0.0

package/dist/index.js

@@ -0,0 +1,636 @@
+#!/usr/bin/env node
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/scanner/index.ts
+import fs from "fs/promises";
+import path from "path";
+async function scanSkillsDirectory(sourceDir) {
+  try {
+    await fs.access(sourceDir);
+  } catch {
+    throw new Error(`Source directory not found: ${sourceDir}`);
+  }
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+  const directories = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const dirPath = path.join(sourceDir, entry.name);
+      const skillDirectory = await scanDirectory(dirPath, entry.name);
+      directories.push(skillDirectory);
+    }
+  }
+  return directories;
+}
+async function scanDirectory(dirPath, name) {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  const children = [];
+  let skillFile;
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      const subDir = await scanDirectory(entryPath, entry.name);
+      children.push(subDir);
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      const file = await parseMarkdownFile(entryPath, entry.name);
+      if (entry.name === "SKILL.md") {
+        skillFile = file;
+      } else {
+        children.push(file);
+      }
+    }
+  }
+  return {
+    path: dirPath,
+    name,
+    children,
+    skillFile
+  };
+}
+async function parseMarkdownFile(filePath, fileName) {
+  const content = await fs.readFile(filePath, "utf-8");
+  const stats = await fs.stat(filePath);
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  const frontmatter = {};
+  let markdownContent = content;
+  if (frontmatterMatch) {
+    markdownContent = content.slice(frontmatterMatch[0].length);
+    const fmLines = frontmatterMatch[1].split(/\r?\n/);
+    for (const line of fmLines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim().replace(/^["']|["']$/g, "");
+        if (key && value) {
+          frontmatter[key] = value;
+        }
+      }
+    }
+  }
+  return {
+    path: filePath,
+    name: fileName,
+    title: frontmatter.title || fileName.replace(".md", ""),
+    description: frontmatter.description,
+    content: markdownContent,
+    frontmatter,
+    lastModified: stats.mtime.getTime()
+  };
+}
+async function watchSkillsDirectory(sourceDir, callback) {
+  const chokidar = await import("chokidar");
+  const watcher = chokidar.watch(sourceDir, {
+    ignored: /node_modules/,
+    persistent: true,
+    ignoreInitial: true
+  });
+  let debounceTimer;
+  const handleChange = () => {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      try {
+        const directories = await scanSkillsDirectory(sourceDir);
+        callback(directories);
+      } catch (error) {
+        console.error("Error rescanning source directory:", error);
+      }
+    }, 300);
+  };
+  watcher.on("add", handleChange);
+  watcher.on("change", handleChange);
+  watcher.on("unlink", handleChange);
+  watcher.on("addDir", handleChange);
+  watcher.on("unlinkDir", handleChange);
+  return watcher;
+}
+var init_scanner = __esm({
+  "src/scanner/index.ts"() {
+    "use strict";
+  }
+});
+
+// src/parser/index.ts
+import MarkdownIt from "markdown-it";
+import { createHighlighter } from "shiki";
+async function getHighlighter() {
+  if (!highlighter) {
+    highlighter = await createHighlighter({
+      themes: ["github-dark", "github-light"],
+      langs: ["javascript", "typescript", "bash", "shell", "json", "html", "css", "vue", "jsx", "tsx", "python", "markdown", "yaml", "sql", "go", "rust", "java", "c", "cpp"]
+    });
+  }
+  return highlighter;
+}
+async function parseSkillsToConfig(directories, siteConfig) {
+  const files = [];
+  const navigation = await generateNavigation(directories);
+  collectAllFiles(directories, files);
+  for (const file of files) {
+    await enhanceFileContent(file);
+  }
+  return {
+    siteConfig,
+    navigation,
+    files,
+    directories
+  };
+}
+function collectAllFiles(items, files) {
+  for (const item of items) {
+    if ("content" in item) {
+      files.push(item);
+    } else {
+      if (item.skillFile) {
+        files.push(item.skillFile);
+      }
+      collectAllFiles(item.children, files);
+    }
+  }
+}
+async function enhanceFileContent(file) {
+  try {
+    let content = file.content;
+    file.title = file.frontmatter.title || file.title;
+    file.description = file.frontmatter.description || file.description;
+    if (file.frontmatter.title) {
+      const h1Match = content.match(/^\s*#\s+(.+)$/m);
+      if (h1Match) {
+        const h1Text = h1Match[1].trim();
+        if (h1Text === file.frontmatter.title) {
+          content = content.replace(/^\s*#\s+.+\n*/, "");
+        }
+      }
+    }
+    let html = md.render(content);
+    html = await highlightCodeBlocks(html);
+    file.frontmatter.html = html;
+    const headings = extractHeadings(content);
+    file.frontmatter.headings = headings;
+  } catch (error) {
+    console.warn(`Failed to enhance content for ${file.path}:`, error);
+    try {
+      file.frontmatter.html = md.render(file.content);
+    } catch (e) {
+      console.error(`Failed to render markdown for ${file.path}:`, e);
+    }
+  }
+}
+async function highlightCodeBlocks(html) {
+  const hl = await getHighlighter();
+  const codeBlockRegex = /<pre class="shiki-pending" data-lang="([^"]*)"[^>]*><code>([^]*?)<\/code><\/pre>/g;
+  const matches = [...html.matchAll(codeBlockRegex)];
+  for (const match of matches) {
+    const [fullMatch, lang, escapedCode] = match;
+    const code = escapedCode.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+    try {
+      const validLang = hl.getLoadedLanguages().includes(lang) ? lang : "text";
+      const highlighted = hl.codeToHtml(code, {
+        lang: validLang,
+        theme: "github-dark"
+      });
+      html = html.replace(fullMatch, highlighted);
+    } catch (e) {
+      console.warn(`Failed to highlight ${lang}:`, e);
+    }
+  }
+  return html;
+}
+function extractHeadings(content) {
+  const headings = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\\s+(.+)$/);
+    if (match) {
+      const level = match[1].length;
+      const text = match[2].trim();
+      const anchor = text.toLowerCase().replace(/[^\\w\\s-]/g, "").replace(/\\s+/g, "-").trim();
+      headings.push({ level, text, anchor });
+    }
+  }
+  return headings;
+}
+async function generateNavigation(directories) {
+  const navigation = [];
+  for (const dir of directories) {
+    const navItem = {
+      text: dir.skillFile?.title || formatDirName(dir.name),
+      link: dir.skillFile ? getFileRoute(dir.skillFile) : void 0
+    };
+    if (dir.children.length > 0) {
+      navItem.children = [];
+      for (const child of dir.children) {
+        if ("content" in child) {
+          navItem.children.push({
+            text: child.title || formatFileName(child.name),
+            link: getFileRoute(child)
+          });
+        } else {
+          const subNav = await generateNavigation([child]);
+          navItem.children.push(...subNav);
+        }
+      }
+    }
+    navigation.push(navItem);
+  }
+  return navigation;
+}
+function getFileRoute(file) {
+  const filePath = file.path;
+  const patterns = ["my-docs", "docs", "documentation", ".claude/skills"];
+  let relativePath = "";
+  for (const pattern of patterns) {
+    const index = filePath.indexOf(pattern);
+    if (index !== -1) {
+      relativePath = filePath.slice(index + pattern.length);
+      break;
+    }
+  }
+  if (!relativePath) {
+    const segments2 = filePath.split("/").filter(Boolean);
+    if (segments2.length >= 2) {
+      relativePath = "/" + segments2.slice(-2).join("/");
+    } else {
+      return "/";
+    }
+  }
+  const segments = relativePath.split("/").filter(Boolean);
+  if (segments.length === 0) return "/";
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment.endsWith(".md")) {
+    segments[segments.length - 1] = lastSegment.slice(0, -3);
+  }
+  const finalSegment = segments[segments.length - 1];
+  if (finalSegment === "SKILL" || finalSegment === "README") {
+    segments.pop();
+  }
+  return "/" + segments.join("/");
+}
+function formatDirName(name) {
+  return name.split("-").map(
+    (word) => word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(" ");
+}
+function formatFileName(name) {
+  const baseName = name.replace(".md", "");
+  return formatDirName(baseName);
+}
+var highlighter, md;
+var init_parser = __esm({
+  "src/parser/index.ts"() {
+    "use strict";
+    highlighter = null;
+    md = new MarkdownIt({
+      html: true,
+      linkify: true,
+      typographer: true,
+      highlight: function(str, lang) {
+        return `<pre class="shiki-pending" data-lang="${lang || "text"}"><code>${md.utils.escapeHtml(str)}</code></pre>`;
+      }
+    });
+  }
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/dev.ts
+import path3 from "path";
+
+// src/builder/vite-dev.ts
+init_scanner();
+init_parser();
+import { createServer } from "vite";
+import vue from "@vitejs/plugin-vue";
+import path2 from "path";
+async function createViteDevServer(options) {
+  let currentConfig = options.config;
+  const server = await createServer({
+    root: path2.resolve(process.cwd(), "src/client"),
+    server: {
+      port: options.port,
+      host: "localhost"
+    },
+    plugins: [
+      vue(),
+      // Custom plugin to inject config and handle API routes
+      {
+        name: "docgen-dev",
+        configureServer(server2) {
+          server2.middlewares.use("/api/config", (req, res, next) => {
+            if (req.method === "GET") {
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify(currentConfig));
+            } else {
+              next();
+            }
+          });
+          server2.middlewares.use((req, res, next) => {
+            if (req.url === "/" || req.url === "/index.html") {
+              next();
+            } else {
+              next();
+            }
+          });
+        },
+        transformIndexHtml: {
+          order: "pre",
+          handler(html) {
+            const configScript = `
+              <script>
+                // Config will be loaded from /api/config
+                globalThis.__DOCGEN_CONFIG__ = null;
+              </script>
+            `;
+            return html.replace("<head>", `<head>${configScript}`);
+          }
+        }
+      }
+    ],
+    resolve: {
+      alias: {
+        "@": path2.resolve(process.cwd(), "src/client")
+      }
+    },
+    define: {
+      __DOCGEN_CONFIG__: JSON.stringify(currentConfig)
+    }
+  });
+  const watcher = await watchSkillsDirectory(options.skillsDir, async (directories) => {
+    console.log("\u{1F4DD} Skills directory changed, updating configuration...");
+    try {
+      currentConfig = await parseSkillsToConfig(directories, currentConfig.siteConfig);
+      server.ws.send({
+        type: "full-reload"
+      });
+      console.log("\u2705 Configuration updated");
+    } catch (error) {
+      console.error("\u274C Failed to update configuration:", error);
+      server.ws.send({
+        type: "error",
+        err: {
+          message: `Failed to update configuration: ${error.message}`,
+          stack: error.stack
+        }
+      });
+    }
+  });
+  await server.listen();
+  const originalClose = server.close.bind(server);
+  server.close = async () => {
+    await watcher?.close();
+    return originalClose();
+  };
+  return server;
+}
+
+// src/cli/commands/dev.ts
+init_scanner();
+init_parser();
+async function devCommand(options) {
+  console.log("\u{1F680} Starting DocGen development server...");
+  const sourceDir = path3.resolve(process.cwd(), options.dir);
+  const port = parseInt(options.port, 10);
+  try {
+    console.log(`\u{1F4C1} Scanning source directory: ${sourceDir}`);
+    const directories = await scanSkillsDirectory(sourceDir);
+    console.log(`\u2705 Found ${directories.length} directories`);
+    const config = await parseSkillsToConfig(directories, {
+      title: "Documentation",
+      description: "Documentation generated from source directory",
+      baseUrl: "/",
+      skillsDir: sourceDir,
+      outputDir: "dist"
+    });
+    const server = await createViteDevServer({
+      port,
+      skillsDir: sourceDir,
+      config
+    });
+    console.log(`\u{1F389} Dev server running at http://localhost:${port}`);
+    process.on("SIGINT", async () => {
+      console.log("\\n\u{1F44B} Shutting down dev server...");
+      await server.close();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("\u274C Failed to start dev server:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/build.ts
+import path5 from "path";
+
+// src/builder/index.ts
+import { build } from "vite";
+import vue2 from "@vitejs/plugin-vue";
+import path4 from "path";
+import fs2 from "fs/promises";
+async function buildSite(options, config) {
+  console.log("\u{1F3D7}\uFE0F  Building documentation site...");
+  await fs2.mkdir(options.output, { recursive: true });
+  const configPath = path4.join(process.cwd(), "temp-config.json");
+  await fs2.writeFile(configPath, JSON.stringify(config, null, 2));
+  try {
+    await build({
+      root: path4.resolve(process.cwd(), "src/client"),
+      base: config.siteConfig.baseUrl,
+      build: {
+        outDir: options.output,
+        emptyOutDir: true,
+        rollupOptions: {
+          input: {
+            main: path4.resolve(process.cwd(), "src/client/index.html")
+          }
+        }
+      },
+      plugins: [
+        vue2(),
+        // Plugin to inject config during build
+        {
+          name: "docgen-build",
+          transformIndexHtml: {
+            order: "pre",
+            handler(html) {
+              const configJson = JSON.stringify(config);
+              const utf8Encoded = unescape(encodeURIComponent(configJson));
+              const configBase64 = Buffer.from(utf8Encoded, "binary").toString("base64");
+              const configScript = `<script>globalThis.__DOCGEN_CONFIG__=JSON.parse(decodeURIComponent(escape(atob("${configBase64}"))));</script>`;
+              return html.replace("</head>", `${configScript}
+</head>`);
+            }
+          }
+        }
+      ],
+      resolve: {
+        alias: {
+          "@": path4.resolve(process.cwd(), "src/client")
+        }
+      },
+      define: {
+        __DOCGEN_CONFIG__: JSON.stringify(config)
+      }
+    });
+    await generateSitemap(options.output, config);
+    await generateRobotsTxt(options.output, config);
+    await copyAssets(options.output);
+    console.log("\u2705 Build completed successfully!");
+  } finally {
+    try {
+      await fs2.unlink(configPath);
+    } catch {
+    }
+  }
+}
+async function generateSitemap(outputDir, config) {
+  console.log("\u{1F4C4} Generating sitemap...");
+  const baseUrl = config.siteConfig.baseUrl.replace(/\/$/, "");
+  const urls = [];
+  urls.push(`${baseUrl}/`);
+  for (const file of config.files) {
+    const route = getFileRoute2(file.path, config.siteConfig.skillsDir);
+    if (route !== "/") {
+      urls.push(`${baseUrl}${route}`);
+    }
+  }
+  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls.map((url) => `  <url>
+    <loc>${url}</loc>
+    <lastmod>${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.8</priority>
+  </url>`).join("\\n")}
+</urlset>`;
+  await fs2.writeFile(path4.join(outputDir, "sitemap.xml"), sitemap);
+}
+async function generateRobotsTxt(outputDir, config) {
+  console.log("\u{1F916} Generating robots.txt...");
+  const baseUrl = config.siteConfig.baseUrl.replace(/\/$/, "");
+  const robotsTxt = `User-agent: *
+Allow: /
+
+Sitemap: ${baseUrl}/sitemap.xml`;
+  await fs2.writeFile(path4.join(outputDir, "robots.txt"), robotsTxt);
+}
+async function copyAssets(outputDir) {
+  console.log("\u{1F4C1} Copying static assets...");
+  const faviconPath = path4.join(outputDir, "favicon.ico");
+  try {
+    await fs2.access(faviconPath);
+  } catch {
+    const faviconSvg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" rx="4" fill="#3182ce"/>
+  <text x="16" y="22" text-anchor="middle" fill="white" font-family="system-ui" font-size="18" font-weight="bold">D</text>
+</svg>`;
+    await fs2.writeFile(path4.join(outputDir, "favicon.svg"), faviconSvg);
+  }
+}
+function getFileRoute2(filePath, baseDir) {
+  const normalizedFilePath = path4.normalize(filePath);
+  const normalizedBaseDir = path4.normalize(baseDir);
+  if (!normalizedFilePath.startsWith(normalizedBaseDir)) {
+    return "/";
+  }
+  const relativePath = normalizedFilePath.slice(normalizedBaseDir.length);
+  const segments = relativePath.split(path4.sep).filter(Boolean);
+  if (segments.length === 0) return "/";
+  const lastSegment = segments[segments.length - 1];
+  if (lastSegment.endsWith(".md")) {
+    segments[segments.length - 1] = lastSegment.slice(0, -3);
+  }
+  const finalSegment = segments[segments.length - 1];
+  if (finalSegment === "SKILL" || finalSegment === "README") {
+    segments.pop();
+  }
+  return "/" + segments.join("/");
+}
+
+// src/cli/commands/build.ts
+init_scanner();
+init_parser();
+async function buildCommand(options) {
+  console.log("\u{1F3D7}\uFE0F  Building DocGen documentation site...");
+  const sourceDir = path5.resolve(process.cwd(), options.dir);
+  const outputDir = path5.resolve(process.cwd(), options.output);
+  try {
+    console.log(`\u{1F4C1} Scanning source directory: ${sourceDir}`);
+    const directories = await scanSkillsDirectory(sourceDir);
+    console.log(`\u2705 Found ${directories.length} directories`);
+    const config = await parseSkillsToConfig(directories, {
+      title: "Documentation",
+      description: "Documentation generated from source directory",
+      baseUrl: "/",
+      skillsDir: sourceDir,
+      outputDir
+    });
+    console.log(`\u{1F4E6} Building to: ${outputDir}`);
+    await buildSite({
+      input: sourceDir,
+      output: outputDir,
+      mode: "production"
+    }, config);
+    console.log("\u2705 Build completed successfully!");
+    console.log(`\u{1F4C2} Built files are in: ${outputDir}`);
+  } catch (error) {
+    console.error("\u274C Build failed:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/preview.ts
+import path6 from "path";
+import fs3 from "fs/promises";
+import sirv from "sirv";
+import { createServer as createServer2 } from "http";
+async function previewCommand(options) {
+  console.log("\u{1F440} Starting DocGen preview server...");
+  const outputDir = path6.resolve(process.cwd(), options.output);
+  const port = parseInt(options.port, 10);
+  try {
+    try {
+      await fs3.access(outputDir);
+    } catch {
+      console.error(`\u274C Build directory not found: ${outputDir}`);
+      console.log('\u{1F4A1} Run "docgen build" first to generate the static site');
+      process.exit(1);
+    }
+    const serve = sirv(outputDir, {
+      single: true,
+      // SPA mode
+      dev: false,
+      setHeaders: (res, pathname) => {
+        if (pathname.endsWith(".html") || pathname === "/") {
+          res.setHeader("Content-Type", "text/html; charset=utf-8");
+        }
+      }
+    });
+    const server = createServer2(serve);
+    server.listen(port, () => {
+      console.log(`\u{1F389} Preview server running at http://localhost:${port}`);
+      console.log(`\u{1F4C2} Serving files from: ${outputDir}`);
+    });
+    process.on("SIGINT", () => {
+      console.log("\\n\u{1F44B} Shutting down preview server...");
+      server.close(() => {
+        process.exit(0);
+      });
+    });
+  } catch (error) {
+    console.error("\u274C Failed to start preview server:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("docmk").description("CLI tool for generating documentation from any directory").version("1.0.0").argument("[directory]", "Source directory path (starts dev server)", "./docs").option("-p, --port <port>", "Port to run dev server on", "3000").action((directory, options) => {
+  devCommand({ dir: directory, port: options.port });
+});
+program.command("dev").description("Start development server").option("-p, --port <port>", "Port to run dev server on", "3000").option("-d, --dir <directory>", "Source directory path", "./docs").action(devCommand);
+program.command("build").description("Build static documentation site").option("-d, --dir <directory>", "Source directory path", "./docs").option("-o, --output <directory>", "Output directory", "dist").action(buildCommand);
+program.command("preview").description("Preview built documentation site").option("-p, --port <port>", "Port to run preview server on", "4173").option("-o, --output <directory>", "Built site directory", "dist").action(previewCommand);
+program.parse();
+//# sourceMappingURL=index.js.map