barodoc 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Barocss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-KI3NAGJ3.js

@@ -0,0 +1,140 @@
+// src/runtime/project.ts
+import fs from "fs-extra";
+import path from "path";
+import pc from "picocolors";
+var BARODOC_DIR = ".barodoc";
+function isCustomProject(dir) {
+  return fs.existsSync(path.join(dir, "astro.config.mjs")) || fs.existsSync(path.join(dir, "astro.config.ts")) || fs.existsSync(path.join(dir, "astro.config.js"));
+}
+async function loadProjectConfig(dir, configFile) {
+  const configPath = configFile ? path.resolve(dir, configFile) : path.join(dir, "barodoc.config.json");
+  if (fs.existsSync(configPath)) {
+    const content = await fs.readFile(configPath, "utf-8");
+    return {
+      config: JSON.parse(content),
+      configPath
+    };
+  }
+  return {
+    config: getDefaultConfig(),
+    configPath: null
+  };
+}
+function getDefaultConfig() {
+  return {
+    name: "Documentation",
+    navigation: [],
+    i18n: {
+      defaultLocale: "en",
+      locales: ["en"]
+    },
+    search: {
+      enabled: true
+    }
+  };
+}
+async function createProject(options) {
+  const { root, docsDir, config, configPath } = options;
+  const projectDir = path.join(root, BARODOC_DIR);
+  console.log(pc.dim(`Creating temporary project in ${BARODOC_DIR}/`));
+  await fs.remove(projectDir);
+  await fs.ensureDir(projectDir);
+  await fs.writeJSON(
+    path.join(projectDir, "package.json"),
+    {
+      name: "barodoc-temp",
+      type: "module",
+      private: true
+    },
+    { spaces: 2 }
+  );
+  const astroConfig = generateAstroConfig(config, configPath || null, docsDir);
+  await fs.writeFile(path.join(projectDir, "astro.config.mjs"), astroConfig);
+  await fs.writeJSON(
+    path.join(projectDir, "tsconfig.json"),
+    {
+      extends: "astro/tsconfigs/strict",
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "react"
+      }
+    },
+    { spaces: 2 }
+  );
+  const tempConfigPath = path.join(projectDir, "barodoc.config.json");
+  await fs.writeJSON(tempConfigPath, config, { spaces: 2 });
+  const contentDir = path.join(projectDir, "src/content");
+  await fs.ensureDir(contentDir);
+  await fs.writeFile(
+    path.join(contentDir, "config.ts"),
+    generateContentConfig()
+  );
+  const docsAbsolute = path.resolve(root, docsDir);
+  const docsLink = path.join(contentDir, "docs");
+  if (fs.existsSync(docsAbsolute)) {
+    await fs.symlink(docsAbsolute, docsLink, "dir");
+  } else {
+    await fs.ensureDir(docsLink);
+  }
+  const publicDir = path.join(root, "public");
+  const publicLink = path.join(projectDir, "public");
+  if (fs.existsSync(publicDir)) {
+    await fs.symlink(publicDir, publicLink, "dir");
+  } else {
+    await fs.ensureDir(publicLink);
+  }
+  return projectDir;
+}
+async function cleanupProject(root) {
+  const projectDir = path.join(root, BARODOC_DIR);
+  await fs.remove(projectDir);
+}
+function generateAstroConfig(config, configPath, docsDir) {
+  return `import { defineConfig } from "astro/config";
+import barodoc from "@barodoc/core";
+import docsTheme from "@barodoc/theme-docs";
+
+export default defineConfig({
+  integrations: [
+    barodoc({
+      config: "./barodoc.config.json",
+      theme: docsTheme(),
+    }),
+  ],
+});
+`;
+}
+function generateContentConfig() {
+  return `import { defineCollection, z } from "astro:content";
+
+const docsCollection = defineCollection({
+  type: "content",
+  schema: z.object({
+    title: z.string(),
+    description: z.string().optional(),
+  }),
+});
+
+export const collections = {
+  docs: docsCollection,
+};
+`;
+}
+function findDocsDir(root) {
+  const candidates = ["docs", "content", "src/content/docs"];
+  for (const candidate of candidates) {
+    const fullPath = path.join(root, candidate);
+    if (fs.existsSync(fullPath)) {
+      return candidate;
+    }
+  }
+  return "docs";
+}
+
+export {
+  isCustomProject,
+  loadProjectConfig,
+  createProject,
+  cleanupProject,
+  findDocsDir
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+import {
+  cleanupProject,
+  createProject,
+  findDocsDir,
+  isCustomProject,
+  loadProjectConfig
+} from "./chunk-KI3NAGJ3.js";
+
+// src/cli.ts
+import cac from "cac";
+import pc5 from "picocolors";
+
+// package.json
+var version = "0.0.1";
+
+// src/commands/serve.ts
+import path from "path";
+import pc from "picocolors";
+import { execa } from "execa";
+async function serve(dir, options) {
+  const root = path.resolve(process.cwd(), dir);
+  console.log();
+  console.log(pc.bold(pc.cyan("  barodoc serve")));
+  console.log();
+  if (isCustomProject(root)) {
+    console.log(pc.dim("Detected custom Astro project"));
+    console.log(pc.dim("Running astro dev..."));
+    console.log();
+    await runAstroDev(root, options);
+    return;
+  }
+  console.log(pc.dim("Quick mode - creating temporary project..."));
+  const docsDir = findDocsDir(root);
+  const { config } = await loadProjectConfig(root, options.config);
+  const projectDir = await createProject({
+    root,
+    docsDir,
+    config,
+    configPath: options.config
+  });
+  console.log(pc.green("\u2713 Project created"));
+  console.log();
+  await runAstroDev(projectDir, options);
+}
+async function runAstroDev(projectDir, options) {
+  const args = ["astro", "dev"];
+  if (options.port) {
+    args.push("--port", String(options.port));
+  }
+  if (options.host) {
+    args.push("--host");
+  }
+  try {
+    await execa("npx", args, {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    if (error.signal === "SIGINT") {
+      console.log();
+      console.log(pc.dim("Shutting down..."));
+    } else {
+      throw error;
+    }
+  }
+}
+
+// src/commands/build.ts
+import path2 from "path";
+import pc2 from "picocolors";
+import fs from "fs-extra";
+import { execa as execa2 } from "execa";
+async function build(dir, options) {
+  const root = path2.resolve(process.cwd(), dir);
+  const outputDir = path2.resolve(process.cwd(), options.output);
+  console.log();
+  console.log(pc2.bold(pc2.cyan("  barodoc build")));
+  console.log();
+  if (isCustomProject(root)) {
+    console.log(pc2.dim("Detected custom Astro project"));
+    console.log(pc2.dim("Running astro build..."));
+    console.log();
+    await runAstroBuild(root, outputDir);
+    return;
+  }
+  console.log(pc2.dim("Quick mode - creating temporary project..."));
+  const docsDir = findDocsDir(root);
+  const { config } = await loadProjectConfig(root, options.config);
+  const projectDir = await createProject({
+    root,
+    docsDir,
+    config,
+    configPath: options.config
+  });
+  console.log(pc2.green("\u2713 Project created"));
+  console.log();
+  try {
+    await runAstroBuild(projectDir, path2.join(projectDir, "dist"));
+    const tempDist = path2.join(projectDir, "dist");
+    if (await fs.pathExists(tempDist)) {
+      await fs.ensureDir(outputDir);
+      await fs.copy(tempDist, outputDir);
+      console.log();
+      console.log(pc2.green(`\u2713 Build output copied to ${options.output}/`));
+    }
+  } finally {
+    console.log(pc2.dim("Cleaning up..."));
+    await cleanupProject(root);
+  }
+  console.log();
+  console.log(pc2.green("Build complete!"));
+  console.log();
+  console.log(`  ${pc2.dim("Output:")} ${outputDir}`);
+  console.log(`  ${pc2.dim("Preview:")} barodoc preview ${dir}`);
+  console.log();
+}
+async function runAstroBuild(projectDir, outputDir) {
+  console.log(pc2.dim("Building site..."));
+  await execa2("npx", ["astro", "build"], {
+    cwd: projectDir,
+    stdio: "inherit"
+  });
+  console.log();
+  console.log(pc2.dim("Generating search index..."));
+  try {
+    await execa2("npx", ["pagefind", "--site", "dist"], {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+  } catch {
+    console.log(pc2.yellow("\u26A0 Pagefind not available, skipping search index"));
+  }
+}
+
+// src/commands/create.ts
+import path3 from "path";
+import pc3 from "picocolors";
+import fs2 from "fs-extra";
+async function create(name) {
+  const targetDir = path3.resolve(process.cwd(), name);
+  console.log();
+  console.log(pc3.bold(pc3.cyan("  barodoc create")));
+  console.log();
+  if (await fs2.pathExists(targetDir)) {
+    console.log(pc3.red(`Error: Directory "${name}" already exists.`));
+    process.exit(1);
+  }
+  console.log(pc3.dim(`Creating project in ${name}/`));
+  await fs2.ensureDir(path3.join(targetDir, "docs/en"));
+  await fs2.ensureDir(path3.join(targetDir, "public"));
+  await fs2.writeJSON(
+    path3.join(targetDir, "barodoc.config.json"),
+    {
+      name,
+      logo: "/logo.svg",
+      navigation: [
+        {
+          group: "Getting Started",
+          pages: ["introduction", "quickstart"]
+        }
+      ],
+      i18n: {
+        defaultLocale: "en",
+        locales: ["en"]
+      },
+      topbar: {
+        github: ""
+      }
+    },
+    { spaces: 2 }
+  );
+  await fs2.writeFile(
+    path3.join(targetDir, "docs/en/introduction.md"),
+    `# Introduction
+
+Welcome to your documentation site!
+
+## Getting Started
+
+Edit this file at \`docs/en/introduction.md\` to customize your documentation.
+
+## Features
+
+- Write documentation in Markdown
+- Dark mode support
+- Full-text search
+- i18n support
+`
+  );
+  await fs2.writeFile(
+    path3.join(targetDir, "docs/en/quickstart.md"),
+    `# Quick Start
+
+## Development
+
+\`\`\`bash
+barodoc serve
+\`\`\`
+
+## Build
+
+\`\`\`bash
+barodoc build
+\`\`\`
+
+## Preview
+
+\`\`\`bash
+barodoc preview
+\`\`\`
+`
+  );
+  await fs2.writeFile(
+    path3.join(targetDir, "public/logo.svg"),
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" width="32" height="32">
+  <rect x="10" y="20" width="80" height="60" rx="8" fill="currentColor" opacity="0.1"/>
+  <rect x="18" y="32" width="40" height="4" rx="2" fill="currentColor"/>
+  <rect x="18" y="42" width="64" height="3" rx="1.5" fill="currentColor" opacity="0.5"/>
+  <rect x="18" y="50" width="56" height="3" rx="1.5" fill="currentColor" opacity="0.5"/>
+  <rect x="18" y="58" width="48" height="3" rx="1.5" fill="currentColor" opacity="0.5"/>
+</svg>
+`
+  );
+  await fs2.writeFile(
+    path3.join(targetDir, ".gitignore"),
+    `.barodoc/
+dist/
+node_modules/
+.DS_Store
+`
+  );
+  console.log(pc3.green("\u2713 Project created!"));
+  console.log();
+  console.log("Next steps:");
+  console.log();
+  console.log(`  ${pc3.cyan(`cd ${name}`)}`);
+  console.log(`  ${pc3.cyan("barodoc serve")}`);
+  console.log();
+}
+
+// src/commands/preview.ts
+import path4 from "path";
+import pc4 from "picocolors";
+import fs3 from "fs-extra";
+import { execa as execa3 } from "execa";
+async function preview(dir, options) {
+  const root = path4.resolve(process.cwd(), dir);
+  const distDir = path4.resolve(root, options.output);
+  console.log();
+  console.log(pc4.bold(pc4.cyan("  barodoc preview")));
+  console.log();
+  if (!await fs3.pathExists(distDir)) {
+    console.log(
+      pc4.red(`Error: Build directory not found: ${options.output}/`)
+    );
+    console.log();
+    console.log(`Run ${pc4.cyan("barodoc build")} first to create a build.`);
+    console.log();
+    process.exit(1);
+  }
+  console.log(pc4.dim(`Serving from ${options.output}/`));
+  console.log();
+  try {
+    await execa3(
+      "npx",
+      ["serve", distDir, "-l", String(options.port)],
+      {
+        stdio: "inherit"
+      }
+    );
+  } catch (error) {
+    if (error.signal === "SIGINT") {
+      console.log();
+      console.log(pc4.dim("Shutting down..."));
+    } else {
+      throw error;
+    }
+  }
+}
+
+// src/cli.ts
+var cli = cac("barodoc");
+cli.command("serve [dir]", "Start development server").option("-p, --port <port>", "Port to listen on", { default: 4321 }).option("-h, --host", "Expose to network").option("-c, --config <file>", "Config file path").action(async (dir = ".", options) => {
+  await serve(dir, options);
+});
+cli.command("build [dir]", "Build for production").option("-o, --output <dir>", "Output directory", { default: "dist" }).option("-c, --config <file>", "Config file path").action(async (dir = ".", options) => {
+  await build(dir, options);
+});
+cli.command("preview [dir]", "Preview production build").option("-p, --port <port>", "Port to listen on", { default: 4321 }).option("-o, --output <dir>", "Build output directory", { default: "dist" }).action(async (dir = ".", options) => {
+  await preview(dir, options);
+});
+cli.command("create <name>", "Create a new Barodoc project").action(async (name) => {
+  await create(name);
+});
+cli.help();
+cli.version(version);
+cli.parse();
+if (!process.argv.slice(2).length) {
+  console.log();
+  console.log(pc5.bold(pc5.cyan("  barodoc")));
+  console.log(pc5.dim("  Documentation framework powered by Astro"));
+  console.log();
+  cli.outputHelp();
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { BarodocConfig } from '@barodoc/core';
+export * from '@barodoc/core';
+
+interface ProjectOptions {
+    root: string;
+    docsDir: string;
+    config: BarodocConfig;
+    configPath?: string;
+}
+/**
+ * Create temporary Astro project for quick mode
+ */
+declare function createProject(options: ProjectOptions): Promise<string>;
+/**
+ * Clean up temporary project
+ */
+declare function cleanupProject(root: string): Promise<void>;
+
+interface ExtractedFrontmatter {
+    title: string;
+    description?: string;
+    [key: string]: unknown;
+}
+/**
+ * Extract frontmatter from markdown content
+ * If no frontmatter exists, extract title from first heading
+ */
+declare function extractFrontmatter(content: string): {
+    data: ExtractedFrontmatter;
+    content: string;
+};
+/**
+ * Process markdown file for content collection
+ */
+declare function processMarkdown(filePath: string, content: string): {
+    frontmatter: ExtractedFrontmatter;
+    body: string;
+};
+
+export { cleanupProject, createProject, extractFrontmatter, processMarkdown };

package/dist/index.js

@@ -0,0 +1,62 @@
+import {
+  cleanupProject,
+  createProject
+} from "./chunk-KI3NAGJ3.js";
+
+// src/index.ts
+export * from "@barodoc/core";
+
+// src/runtime/content.ts
+import matter from "gray-matter";
+function extractFrontmatter(content) {
+  const { data, content: body } = matter(content);
+  if (data.title) {
+    return {
+      data,
+      content: body
+    };
+  }
+  const titleMatch = body.match(/^#\s+(.+)$/m);
+  const title = titleMatch?.[1] || "Untitled";
+  const description = extractFirstParagraph(body);
+  return {
+    data: {
+      ...data,
+      title,
+      description
+    },
+    content: body
+  };
+}
+function extractFirstParagraph(content) {
+  const lines = content.split("\n");
+  let inParagraph = false;
+  let paragraph = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("```")) break;
+    if (trimmed.startsWith("-") || trimmed.startsWith("*")) continue;
+    if (trimmed.startsWith(">")) continue;
+    if (trimmed === "") {
+      if (inParagraph) break;
+      continue;
+    }
+    inParagraph = true;
+    paragraph += (paragraph ? " " : "") + trimmed;
+  }
+  return paragraph || void 0;
+}
+function processMarkdown(filePath, content) {
+  const { data, content: body } = extractFrontmatter(content);
+  return {
+    frontmatter: data,
+    body
+  };
+}
+export {
+  cleanupProject,
+  createProject,
+  extractFrontmatter,
+  processMarkdown
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "barodoc",
+  "version": "0.0.1",
+  "description": "Documentation framework powered by Astro",
+  "type": "module",
+  "bin": {
+    "barodoc": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "cac": "^6.7.14",
+    "chokidar": "^4.0.0",
+    "execa": "^9.5.0",
+    "fs-extra": "^11.2.0",
+    "gray-matter": "^4.0.3",
+    "picocolors": "^1.1.1",
+    "@barodoc/core": "0.0.1",
+    "@barodoc/theme-docs": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "documentation",
+    "astro",
+    "mdx",
+    "cli",
+    "barodoc"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/barocss/barodoc.git",
+    "directory": "packages/barodoc"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}