openmanual 0.1.0

package/dist/bin.js

@@ -0,0 +1,733 @@
+#!/usr/bin/env node
+
+
+// src/cli/bin.ts
+import { Command as Command4 } from "commander";
+
+// src/cli/commands/build.ts
+import { spawn as spawn2 } from "child_process";
+import { cp, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+import { Command } from "commander";
+
+// src/core/config/loader.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+// src/core/config/schema.ts
+import { z } from "zod";
+var NavbarSchema = z.object({
+  logo: z.string().optional(),
+  github: z.string().url().optional(),
+  links: z.array(
+    z.object({
+      label: z.string(),
+      href: z.string()
+    })
+  ).optional()
+});
+var FooterSchema = z.object({
+  text: z.string().optional()
+});
+var SidebarPageSchema = z.object({
+  slug: z.string(),
+  title: z.string(),
+  icon: z.string().optional()
+});
+var SidebarGroupSchema = z.object({
+  group: z.string(),
+  icon: z.string().optional(),
+  collapsed: z.boolean().optional(),
+  pages: z.array(SidebarPageSchema)
+});
+var ThemeSchema = z.object({
+  primaryHue: z.number().min(0).max(360).optional(),
+  darkMode: z.boolean().optional()
+});
+var SearchSchema = z.object({
+  enabled: z.boolean().optional()
+});
+var MdxSchema = z.object({
+  latex: z.boolean().optional()
+});
+var OpenManualConfigSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().optional(),
+  contentDir: z.string().optional(),
+  outputDir: z.string().optional(),
+  siteUrl: z.string().url().optional(),
+  locale: z.string().optional(),
+  navbar: NavbarSchema.optional(),
+  footer: FooterSchema.optional(),
+  sidebar: z.array(SidebarGroupSchema).optional(),
+  theme: ThemeSchema.optional(),
+  search: SearchSchema.optional(),
+  mdx: MdxSchema.optional()
+});
+
+// src/core/config/loader.ts
+var DEFAULT_CONFIG = {
+  contentDir: "content",
+  outputDir: "dist",
+  locale: "zh",
+  navbar: {},
+  footer: {},
+  theme: {
+    primaryHue: 220,
+    darkMode: true
+  },
+  search: {
+    enabled: true
+  },
+  mdx: {}
+};
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = join(cwd, "openmanual.json");
+  let rawJson;
+  try {
+    rawJson = await readFile(configPath, "utf-8");
+  } catch {
+    throw new Error(`openmanual.json not found in ${cwd}. Please create one.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawJson);
+  } catch {
+    throw new Error("openmanual.json is not valid JSON.");
+  }
+  const result = OpenManualConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const errors = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`openmanual.json validation failed:
+${errors}`);
+  }
+  return mergeDefaults(result.data);
+}
+function mergeDefaults(config) {
+  return {
+    ...config,
+    contentDir: config.contentDir ?? DEFAULT_CONFIG.contentDir ?? "content",
+    outputDir: config.outputDir ?? DEFAULT_CONFIG.outputDir ?? "dist",
+    locale: config.locale ?? DEFAULT_CONFIG.locale ?? "zh",
+    navbar: {
+      ...DEFAULT_CONFIG.navbar,
+      ...config.navbar,
+      logo: config.navbar?.logo ?? config.name
+    },
+    footer: {
+      ...DEFAULT_CONFIG.footer,
+      ...config.footer,
+      text: config.footer?.text ?? `MIT ${(/* @__PURE__ */ new Date()).getFullYear()} \xA9 ${config.name}.`
+    },
+    theme: {
+      ...DEFAULT_CONFIG.theme,
+      ...config.theme
+    },
+    search: {
+      ...DEFAULT_CONFIG.search,
+      ...config.search
+    },
+    mdx: {
+      ...DEFAULT_CONFIG.mdx,
+      ...config.mdx
+    }
+  };
+}
+
+// src/core/generator/index.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/core/generator/global-css.ts
+function generateGlobalCss(ctx) {
+  const { config } = ctx;
+  const primaryHue = config.theme?.primaryHue ?? 220;
+  return `@import 'tailwindcss';
+@import 'fumadocs-ui/style.css';
+
+:root {
+  --primary-hue: ${primaryHue};
+}
+`;
+}
+
+// src/core/generator/layout.ts
+function generateLayout(ctx) {
+  const { config } = ctx;
+  const navTitle = config.navbar?.logo ?? config.name;
+  return `import type { BaseLayoutProps } from 'fumadocs-ui/layouts/shared';
+
+export function baseOptions(): BaseLayoutProps {
+  return {
+    nav: {
+      title: '${navTitle}',
+    },
+  };
+}
+`;
+}
+
+// src/core/generator/lib-source.ts
+function generateLibSource() {
+  return `import { docs } from '@/.source/server';
+import { loader } from 'fumadocs-core/source';
+
+export const source = loader({
+  baseUrl: '/',
+  source: docs.toFumadocsSource(),
+});
+`;
+}
+
+// src/core/generator/next-config.ts
+function generateNextConfig(ctx) {
+  const { config } = ctx;
+  const siteUrl = config.siteUrl ?? "";
+  return `import { createMDX } from 'fumadocs-mdx/next';
+
+const withMDX = createMDX();
+
+/** @type {import('next').NextConfig} */
+const config = {
+  reactStrictMode: true,${siteUrl ? `
+  output: 'export',` : ""}
+  images: {
+    unoptimized: true,
+  },
+};
+
+export default withMDX(config);
+`;
+}
+
+// src/core/generator/package-json.ts
+function generatePackageJson(_ctx) {
+  const pkg = {
+    name: "openmanual-app",
+    type: "module",
+    private: true,
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start"
+    },
+    dependencies: {
+      "@tailwindcss/postcss": "^4.1.15",
+      "fumadocs-core": "^16.7.7",
+      "fumadocs-mdx": "^14.2.11",
+      "fumadocs-ui": "^16.7.7",
+      next: "^16.2.1",
+      postcss: "^8.5.8",
+      react: "^19.1.0",
+      "react-dom": "^19.1.0",
+      tailwindcss: "^4.1.15"
+    }
+  };
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+}
+
+// src/core/generator/page.ts
+function generatePage(_ctx) {
+  return `import { source } from '@/lib/source';
+import { notFound } from 'next/navigation';
+import { DocsPage, DocsBody, DocsTitle, DocsDescription } from 'fumadocs-ui/page';
+import defaultMdxComponents from 'fumadocs-ui/mdx';
+
+export default async function Page({ params }: { params: Promise<{ slug?: string[] }> }) {
+  const { slug } = await params;
+  const page = source.getPage(slug);
+
+  if (!page) {
+    notFound();
+  }
+
+  const MDX = page.data.body;
+
+  return (
+    <DocsPage toc={page.data.toc}>
+      <DocsTitle>{page.data.title}</DocsTitle>
+      {page.data.description && (
+        <DocsDescription>{page.data.description}</DocsDescription>
+      )}
+      <DocsBody>
+        <MDX components={{ ...defaultMdxComponents }} />
+      </DocsBody>
+    </DocsPage>
+  );
+}
+
+export function generateStaticParams() {
+  return source.generateParams();
+}
+`;
+}
+
+// src/core/generator/postcss-config.ts
+function generatePostcssConfig() {
+  return `/** @type {import('postcss-load-config').Config} */
+const config = {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+};
+
+export default config;
+`;
+}
+
+// src/core/generator/provider.ts
+function generateProvider(ctx) {
+  const searchEnabled = ctx.config.search?.enabled !== false;
+  return `'use client';
+
+import { RootProvider } from 'fumadocs-ui/provider/next';
+import type { ReactNode } from 'react';
+
+export function Provider({ children }: { children: ReactNode }) {
+  return (
+    <RootProvider
+      search={{
+        enabled: ${searchEnabled},
+      }}
+    >
+      {children}
+    </RootProvider>
+  );
+}
+`;
+}
+
+// src/core/generator/source-config.ts
+function generateSourceConfig(_ctx) {
+  return `import { defineDocs, defineConfig } from 'fumadocs-mdx/config';
+
+export const docs = defineDocs({
+  dir: 'content',
+});
+
+export default defineConfig();
+`;
+}
+
+// src/core/generator/tsconfig.ts
+function generateTsconfig() {
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2022",
+        lib: ["dom", "dom.iterable", "esnext"],
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        jsx: "react-jsx",
+        noEmit: true,
+        allowJs: true,
+        resolveJsonModule: true,
+        isolatedModules: true,
+        incremental: true,
+        plugins: [{ name: "next" }],
+        paths: {
+          "@/*": ["./*"]
+        }
+      },
+      include: ["**/*.ts", "**/*.tsx", "next-env.d.ts", ".next/types/**/*.ts", ".next/dev/types/**/*.ts"],
+      exclude: ["node_modules"]
+    },
+    null,
+    2
+  )}
+`;
+}
+
+// src/core/generator/index.ts
+async function generateAll(ctx) {
+  const files = [
+    {
+      path: "source.config.ts",
+      content: generateSourceConfig(ctx)
+    },
+    {
+      path: "next.config.mjs",
+      content: generateNextConfig(ctx)
+    },
+    {
+      path: "global.css",
+      content: generateGlobalCss(ctx)
+    },
+    {
+      path: "package.json",
+      content: generatePackageJson(ctx)
+    },
+    {
+      path: "tsconfig.json",
+      content: generateTsconfig()
+    },
+    {
+      path: "postcss.config.mjs",
+      content: generatePostcssConfig()
+    },
+    {
+      path: "lib/source.ts",
+      content: generateLibSource()
+    },
+    {
+      path: "lib/layout.ts",
+      content: generateLayout(ctx)
+    },
+    {
+      path: "app/layout.tsx",
+      content: generateRootLayout()
+    },
+    {
+      path: "app/provider.tsx",
+      content: generateProvider(ctx)
+    },
+    {
+      path: "app/[[...slug]]/layout.tsx",
+      content: generateDocsLayout(ctx)
+    },
+    {
+      path: "app/[[...slug]]/page.tsx",
+      content: generatePage(ctx)
+    }
+  ];
+  for (const file of files) {
+    const fullPath = join2(ctx.appDir, file.path);
+    const dir = join2(fullPath, "..");
+    await mkdir(dir, { recursive: true });
+    await writeFile(fullPath, file.content, "utf-8");
+  }
+}
+function generateRootLayout() {
+  return `import { Provider } from './provider';
+import type { ReactNode } from 'react';
+import '../global.css';
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="zh" suppressHydrationWarning>
+      <body className="flex flex-col min-h-screen">
+        <Provider>{children}</Provider>
+      </body>
+    </html>
+  );
+}
+`;
+}
+function generateDocsLayout(ctx) {
+  const { config } = ctx;
+  const githubLink = config.navbar?.github ?? "";
+  const navLinks = config.navbar?.links ?? [];
+  const footerText = config.footer?.text ?? "";
+  const linksArray = navLinks.map((l) => ({
+    text: l.label,
+    url: l.href,
+    external: true
+  }));
+  const githubLine = githubLink ? `
+    github: '${githubLink}',` : "";
+  const linksLine = linksArray.length > 0 ? `
+    links: ${JSON.stringify(linksArray)},` : "";
+  const footerLine = footerText ? `
+  footer: { children: '${footerText.replace(/'/g, "\\'")}' },` : "";
+  return `import { DocsLayout } from 'fumadocs-ui/layouts/docs';
+import { baseOptions } from '@/lib/layout';
+import { source } from '@/lib/source';
+import type { ReactNode } from 'react';
+
+const docsOptions = {
+  ...baseOptions(),
+  tree: source.getPageTree(),${githubLine}${linksLine}${footerLine}
+};
+
+export default function DocsLayoutWrapper({ children }: { children: ReactNode }) {
+  return (
+    <DocsLayout {...docsOptions}>
+      {children}
+    </DocsLayout>
+  );
+}
+`;
+}
+
+// src/utils/install-deps.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { resolve } from "path";
+async function installDeps(appDir) {
+  const nodeModules = resolve(appDir, "node_modules");
+  if (existsSync(nodeModules)) {
+    return;
+  }
+  return new Promise((resolve6, reject) => {
+    const child = spawn("pnpm", ["install", "--no-frozen-lockfile"], {
+      cwd: appDir,
+      stdio: "pipe",
+      env: { ...process.env }
+    });
+    let stderr = "";
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve6();
+      } else {
+        reject(new Error(`pnpm install failed: ${stderr}`));
+      }
+    });
+  });
+}
+
+// src/utils/logger.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m"
+};
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("zh-CN", { hour12: false });
+}
+var logger = {
+  info(msg) {
+    console.log(
+      `${COLORS.gray}[${timestamp()}]${COLORS.reset} ${COLORS.cyan}info${COLORS.reset} ${msg}`
+    );
+  },
+  success(msg) {
+    console.log(
+      `${COLORS.gray}[${timestamp()}]${COLORS.reset} ${COLORS.green}done${COLORS.reset} ${msg}`
+    );
+  },
+  warn(msg) {
+    console.warn(
+      `${COLORS.gray}[${timestamp()}]${COLORS.reset} ${COLORS.yellow}warn${COLORS.reset} ${msg}`
+    );
+  },
+  error(msg) {
+    console.error(
+      `${COLORS.gray}[${timestamp()}]${COLORS.reset} ${COLORS.red}error${COLORS.reset} ${msg}`
+    );
+  },
+  step(msg) {
+    console.log(
+      `${COLORS.gray}[${timestamp()}]${COLORS.reset} ${COLORS.bold}\u2192${COLORS.reset} ${msg}`
+    );
+  }
+};
+
+// src/utils/temp-dir.ts
+import { existsSync as existsSync2 } from "fs";
+import { lstat, mkdir as mkdir2, rm, symlink } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+var TEMP_DIR_NAME = ".openmanual";
+function getTempDir(cwd) {
+  return join3(cwd, TEMP_DIR_NAME);
+}
+function getAppDir(cwd) {
+  return join3(getTempDir(cwd), "app");
+}
+async function ensureTempDir(cwd) {
+  const tempDir = getTempDir(cwd);
+  const appDir = getAppDir(cwd);
+  await mkdir2(tempDir, { recursive: true });
+  await mkdir2(join3(appDir, "app"), { recursive: true });
+  return tempDir;
+}
+async function cleanTempDir(cwd) {
+  const tempDir = getTempDir(cwd);
+  if (existsSync2(tempDir)) {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+async function createSymlink(target, linkPath) {
+  const resolvedTarget = resolve2(target);
+  const resolvedLink = resolve2(linkPath);
+  try {
+    await lstat(resolvedLink);
+    await rm(resolvedLink, { recursive: true, force: true });
+  } catch {
+  }
+  await symlink(resolvedTarget, resolvedLink, "junction");
+}
+
+// src/cli/commands/build.ts
+var buildCommand = new Command("build").description("\u6784\u5EFA\u9759\u6001\u7AD9\u70B9").action(async () => {
+  const cwd = process.cwd();
+  try {
+    logger.step("\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6...");
+    const config = await loadConfig(cwd);
+    logger.step("\u751F\u6210\u4E34\u65F6\u5E94\u7528...");
+    const appDir = getAppDir(cwd);
+    const contentDir = resolve3(cwd, config.contentDir ?? "content");
+    await ensureTempDir(cwd);
+    const ctx = {
+      config,
+      projectDir: cwd,
+      appDir,
+      contentDir: config.contentDir ?? "content"
+    };
+    await generateAll(ctx);
+    await createSymlink(contentDir, resolve3(appDir, "content"));
+    const publicDir = resolve3(cwd, "public");
+    try {
+      const { stat } = await import("fs/promises");
+      await stat(publicDir);
+      await createSymlink(publicDir, resolve3(appDir, "public"));
+    } catch {
+    }
+    logger.step("\u5B89\u88C5\u4F9D\u8D56...");
+    await installDeps(appDir);
+    logger.step("\u6784\u5EFA\u9759\u6001\u7AD9\u70B9...");
+    const buildResult = spawn2("npx", ["next", "build"], {
+      cwd: appDir,
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    await new Promise((resolve6, reject) => {
+      buildResult.on("error", reject);
+      buildResult.on("exit", (code) => {
+        if (code === 0) {
+          resolve6();
+        } else {
+          reject(new Error(`Build failed with code ${code}`));
+        }
+      });
+    });
+    const outputDir = resolve3(cwd, config.outputDir ?? "dist");
+    await mkdir3(outputDir, { recursive: true });
+    const nextOutput = resolve3(appDir, "out");
+    try {
+      await cp(nextOutput, outputDir, { recursive: true });
+      logger.success(`\u9759\u6001\u7AD9\u70B9\u5DF2\u8F93\u51FA\u5230: ${outputDir}`);
+    } catch {
+      logger.warn('\u672A\u627E\u5230\u9759\u6001\u5BFC\u51FA\u4EA7\u7269\uFF0C\u8BF7\u68C0\u67E5 next.config.mjs \u4E2D output: "export" \u914D\u7F6E');
+    }
+    logger.step("\u6E05\u7406\u4E34\u65F6\u6587\u4EF6...");
+    await cleanTempDir(cwd);
+    logger.success("\u6784\u5EFA\u5B8C\u6210\uFF01");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/dev.ts
+import { spawn as spawn3 } from "child_process";
+import { resolve as resolve4 } from "path";
+import { Command as Command2 } from "commander";
+var devCommand = new Command2("dev").description("\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668").option("-p, --port <port>", "\u7AEF\u53E3\u53F7", "3000").action(async (options) => {
+  const cwd = process.cwd();
+  try {
+    logger.step("\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6...");
+    const config = await loadConfig(cwd);
+    logger.step("\u751F\u6210\u4E34\u65F6\u5E94\u7528...");
+    const tempDir = await ensureTempDir(cwd);
+    const appDir = getAppDir(cwd);
+    const contentDir = resolve4(cwd, config.contentDir ?? "content");
+    const ctx = {
+      config,
+      projectDir: cwd,
+      appDir,
+      contentDir: config.contentDir ?? "content"
+    };
+    await generateAll(ctx);
+    await createSymlink(contentDir, resolve4(appDir, "content"));
+    const publicDir = resolve4(cwd, "public");
+    try {
+      const { stat } = await import("fs/promises");
+      await stat(publicDir);
+      await createSymlink(publicDir, resolve4(appDir, "public"));
+    } catch {
+    }
+    logger.step("\u5B89\u88C5\u4F9D\u8D56...");
+    await installDeps(appDir);
+    logger.success(`\u5F00\u53D1\u670D\u52A1\u5668\u542F\u52A8\u4E2D...`);
+    logger.info(`\u5185\u5BB9\u76EE\u5F55: ${contentDir}`);
+    logger.info(`\u4E34\u65F6\u76EE\u5F55: ${tempDir}`);
+    logger.info(`\u7AEF\u53E3: ${options.port}`);
+    const child = spawn3("npx", ["next", "dev", "--port", options.port], {
+      cwd: appDir,
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    child.on("error", (err) => {
+      logger.error(`\u542F\u52A8\u5931\u8D25: ${err.message}`);
+      process.exit(1);
+    });
+    child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        process.exit(code);
+      }
+    });
+    const cleanup = () => {
+      child.kill();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/preview.ts
+import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+import { Command as Command3 } from "commander";
+var previewCommand = new Command3("preview").description("\u9884\u89C8\u6784\u5EFA\u4EA7\u7269").option("-p, --port <port>", "\u7AEF\u53E3\u53F7", "8080").option("-d, --dir <dir>", "\u4EA7\u7269\u76EE\u5F55").action(async (options) => {
+  const cwd = process.cwd();
+  try {
+    let outputDir = options.dir;
+    if (!outputDir) {
+      const config = await loadConfig(cwd);
+      outputDir = resolve5(cwd, config.outputDir ?? "dist");
+    }
+    if (!existsSync3(outputDir)) {
+      logger.error(`\u4EA7\u7269\u76EE\u5F55\u4E0D\u5B58\u5728: ${outputDir}`);
+      logger.info("\u8BF7\u5148\u8FD0\u884C openmanual build");
+      process.exit(1);
+    }
+    logger.info(`\u9884\u89C8\u76EE\u5F55: ${outputDir}`);
+    logger.info(`\u9884\u89C8\u5730\u5740: http://localhost:${options.port}`);
+    const child = spawn4("npx", ["serve", outputDir, "-p", options.port], {
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    child.on("error", (err) => {
+      logger.error(`\u542F\u52A8\u5931\u8D25: ${err.message}`);
+      process.exit(1);
+    });
+    const cleanup = () => {
+      child.kill();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error(message);
+    process.exit(1);
+  }
+});
+
+// src/cli/bin.ts
+var program = new Command4();
+program.name("openmanual").description("AI \u53CB\u597D\u7684\u5F00\u6E90\u6587\u6863\u7CFB\u7EDF\u6846\u67B6").version("0.1.0");
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(previewCommand);
+program.parse();
+//# sourceMappingURL=bin.js.map