@chronoter/main 0.1.0

package/dist/cli.js

@@ -0,0 +1,1708 @@
+#!/usr/bin/env node
+import ignore from 'ignore';
+import * as fs from 'fs/promises';
+import { readFile } from 'fs/promises';
+import * as path from 'path';
+import { dirname, resolve, join, relative, extname, basename } from 'path';
+import { visit } from 'unist-util-visit';
+import { compile } from '@mdx-js/mdx';
+import matter from 'gray-matter';
+import remarkGfm from 'remark-gfm';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import chalk2 from 'chalk';
+import { createServer, defineConfig } from 'vite';
+import { z } from 'zod';
+import react from '@vitejs/plugin-react';
+import mdx from '@mdx-js/rollup';
+import { realpathSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { watch } from 'chokidar';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+import { spawn } from 'child_process';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var DEFAULT_IGNORE_PATTERNS, IgnorePatterns;
+var init_ignore_patterns = __esm({
+  "src/core/routing/ignore-patterns.ts"() {
+    DEFAULT_IGNORE_PATTERNS = [
+      // 依存関係
+      "node_modules/**",
+      "bower_components/**",
+      // ビルド出力
+      "dist/**",
+      "build/**",
+      "out/**",
+      ".next/**",
+      ".nuxt/**",
+      ".output/**",
+      // バージョン管理
+      ".git/**",
+      ".svn/**",
+      ".hg/**",
+      // IDE/エディタ
+      ".vscode/**",
+      ".idea/**",
+      "*.swp",
+      "*.swo",
+      "*~",
+      // OS
+      ".DS_Store",
+      "Thumbs.db",
+      // テスト/カバレッジ
+      "coverage/**",
+      ".nyc_output/**",
+      // キャッシュ
+      ".cache/**",
+      ".temp/**",
+      ".tmp/**",
+      // ログ
+      "*.log",
+      "logs/**"
+    ];
+    IgnorePatterns = class {
+      constructor() {
+        this.ig = ignore();
+      }
+      /**
+       * 除外パターンを初期化
+       *
+       * 優先順位:
+       * 1. デフォルト除外パターン（常に適用）
+       * 2. .gitignoreの内容（baseDirのルートに存在する場合）
+       * 3. chronoter.config.jsonのignoreフィールド（存在する場合）
+       *
+       * .gitignoreの読み込み:
+       * - baseDirは通常docsDirと同じです
+       * - docsDir: "docs" の場合 → docs/.gitignoreを読み込む
+       * - docsDir: "." の場合（デフォルト） → プロジェクトルートの.gitignoreを読み込む
+       *
+       * 注意:
+       * - サブディレクトリの.gitignoreは現在サポートされていません
+       * - 必要な場合はchronoter.config.jsonのignoreフィールドで指定してください
+       *
+       * ネガティブパターン:
+       * デフォルト除外を解除したい場合は、`!` プレフィックスを使用できます。
+       * 例: `["!dist/**", "!build/**"]` でdistとbuildの除外を解除
+       *
+       * @param baseDir ベースディレクトリ（通常はdocsDir）
+       * @param customIgnore カスタム除外パターン（chronoter.config.jsonから）
+       */
+      async initialize(baseDir, customIgnore) {
+        this.ig.add(DEFAULT_IGNORE_PATTERNS);
+        try {
+          const gitignorePath = join(baseDir, ".gitignore");
+          const gitignoreContent = await readFile(gitignorePath, "utf-8");
+          this.ig.add(gitignoreContent);
+        } catch (error) {
+        }
+        if (customIgnore && customIgnore.length > 0) {
+          this.ig.add(customIgnore);
+        }
+      }
+      /**
+       * 指定されたパスが除外対象かどうかを判定
+       *
+       * @param relativePath ベースディレクトリからの相対パス
+       * @returns 除外対象の場合true
+       */
+      shouldIgnore(relativePath) {
+        return this.ig.ignores(relativePath);
+      }
+    };
+  }
+});
+
+// src/core/mdx/errors.ts
+var MDXError;
+var init_errors = __esm({
+  "src/core/mdx/errors.ts"() {
+    MDXError = class _MDXError extends Error {
+      /**
+       * MDXErrorのコンストラクタ
+       * @param message エラーメッセージ
+       * @param filePath エラーが発生したファイルのパス
+       * @param line エラーが発生した行番号（オプション）
+       */
+      constructor(message, filePath, line) {
+        super(message);
+        this.filePath = filePath;
+        this.line = line;
+        this.name = "MDXError";
+        Object.setPrototypeOf(this, _MDXError.prototype);
+      }
+      /**
+       * エラーメッセージを整形して返す
+       * ファイルパスと行番号を含む詳細なエラーメッセージを生成します
+       * @returns 整形されたエラーメッセージ
+       */
+      toString() {
+        const location = this.line !== void 0 ? `${this.filePath}:${this.line}` : this.filePath;
+        return `${this.name}: ${this.message}
+  at ${location}`;
+      }
+    };
+  }
+});
+function isRelativePath(url) {
+  if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) {
+    return false;
+  }
+  if (url.startsWith("/")) {
+    return false;
+  }
+  return true;
+}
+function convertToAbsolutePath(relativePath, baseUrl) {
+  const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const cleanedPath = relativePath.startsWith("./") ? relativePath.slice(2) : relativePath;
+  return `${normalizedBaseUrl}${cleanedPath}`;
+}
+var remarkAbsolutePath;
+var init_remark_absolute_path = __esm({
+  "src/core/mdx/remark-absolute-path.ts"() {
+    remarkAbsolutePath = (options) => {
+      const { baseUrl } = options;
+      return (tree) => {
+        visit(tree, (node) => {
+          const typedNode = node;
+          if (typedNode.type === "image") {
+            const imageNode = node;
+            if (isRelativePath(imageNode.url)) {
+              imageNode.url = convertToAbsolutePath(imageNode.url, baseUrl);
+            }
+          }
+          if (typedNode.type === "mdxJsxFlowElement" || typedNode.type === "mdxJsxTextElement") {
+            const jsxNode = node;
+            const tagName = jsxNode.name;
+            if (tagName === "img" || tagName === "video" || tagName === "source") {
+              jsxNode.attributes?.forEach((attr) => {
+                const typedAttr = attr;
+                if (typedAttr.type === "mdxJsxAttribute" && typedAttr.name === "src") {
+                  if (typeof typedAttr.value === "string" && isRelativePath(typedAttr.value)) {
+                    typedAttr.value = convertToAbsolutePath(typedAttr.value, baseUrl);
+                  }
+                }
+              });
+            }
+          }
+        });
+      };
+    };
+  }
+});
+
+// src/core/mdx/processor.ts
+var processor_exports = {};
+__export(processor_exports, {
+  MDXProcessor: () => MDXProcessor
+});
+var MDXProcessor;
+var init_processor = __esm({
+  "src/core/mdx/processor.ts"() {
+    init_errors();
+    init_remark_absolute_path();
+    MDXProcessor = class {
+      /**
+       * MarkdownまたはMDXファイルを処理する
+       *
+       * ファイルを読み込み、フロントマターを抽出し、MDXとしてコンパイルします。
+       * .mdと.mdxの両方のファイル形式に対応しています。
+       *
+       * @param filePath - 処理するMarkdownまたはMDXファイルのパス（.mdまたは.mdx）
+       * @param options - 処理オプション
+       * @param options.baseUrl - 画像パスを絶対パスに変換する際のベースURL（例: /cli/configuration）
+       * @returns 処理済みファイルの情報
+       * @throws {MDXError} ファイルの読み込みまたはコンパイルに失敗した場合
+       */
+      async process(filePath, options) {
+        try {
+          const source = await readFile(filePath, "utf-8");
+          let data;
+          let content;
+          try {
+            const result = matter(source);
+            data = result.data;
+            content = result.content;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new MDXError(`Failed to parse frontmatter: ${message}`, filePath);
+          }
+          const code = await this.compile(content, filePath, options?.baseUrl);
+          const slug = this.generateSlug(filePath);
+          const frontmatter = this.parseFrontmatter(data);
+          return {
+            code,
+            frontmatter,
+            slug
+          };
+        } catch (error) {
+          if (error instanceof MDXError) {
+            throw error;
+          }
+          const message = error instanceof Error ? error.message : String(error);
+          throw new MDXError(`Failed to process MDX file: ${message}`, filePath);
+        }
+      }
+      /**
+       * gray-matterから取得したdataをMDXFrontmatter型に変換する
+       *
+       * asを使わずに型安全にフロントマターを処理します。
+       * gray-matterのdataは{ [key: string]: any }型なので、
+       * そのまま使用しても実行時の動作は同じですが、型の明示性を高めます。
+       *
+       * フロントマターにtitleやdescriptionが存在しない場合、
+       * デフォルト値は設定せず、undefinedを返します。
+       * デフォルト値の適用は、このデータを使用する上位層（Layout、HTMLジェネレーター等）で行います。
+       *
+       * @param data - gray-matterから取得した生データ
+       * @returns MDXFrontmatter型のオブジェクト
+       * @private
+       */
+      parseFrontmatter(data) {
+        return {
+          title: typeof data.title === "string" ? data.title : void 0,
+          description: typeof data.description === "string" ? data.description : void 0,
+          ...data
+        };
+      }
+      /**
+       * MarkdownまたはMDXソースコードをコンパイルする
+       *
+       * @mdx-js/mdxを使用してMarkdown/MDXをReactコンポーネントにコンパイルします。
+       * 通常のMarkdownもMDXとして処理されるため、JSXを含めることができます。
+       *
+       * @param source - MarkdownまたはMDXソースコード
+       * @param filePath - ファイルパス（エラーメッセージ用、オプション）
+       * @param baseUrl - 画像パスを絶対パスに変換する際のベースURL（例: /cli/configuration）
+       * @returns コンパイル済みのJavaScriptコード
+       * @throws {MDXError} コンパイルに失敗した場合
+       */
+      async compile(source, filePath, baseUrl) {
+        try {
+          const remarkPlugins = [remarkGfm];
+          if (baseUrl) {
+            remarkPlugins.push([remarkAbsolutePath, { baseUrl }]);
+          }
+          const result = await compile(source, {
+            outputFormat: "function-body",
+            development: false,
+            remarkPlugins
+          });
+          return String(result);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const lineMatch = message.match(/:(\d+):/);
+          const line = lineMatch ? parseInt(lineMatch[1], 10) : void 0;
+          throw new MDXError(
+            `Failed to compile MDX: ${message}`,
+            filePath || "unknown",
+            line
+          );
+        }
+      }
+      /**
+       * ファイルパスからスラッグを生成する
+       *
+       * @param filePath - ファイルパス
+       * @returns スラッグ
+       * @private
+       */
+      generateSlug(filePath) {
+        const fileName = basename(filePath, extname(filePath));
+        return fileName;
+      }
+    };
+  }
+});
+var RouteGenerator;
+var init_router = __esm({
+  "src/core/routing/router.ts"() {
+    init_processor();
+    init_ignore_patterns();
+    RouteGenerator = class {
+      constructor() {
+        this.mdxProcessor = new MDXProcessor();
+        this.ignorePatterns = new IgnorePatterns();
+      }
+      /**
+       * docsディレクトリを再帰的にスキャンしてルートを生成
+       *
+       * .mdxと.mdの両方のファイルを検出してルートを生成します。
+       * node_modulesなどの除外パターンに一致するファイル/ディレクトリは自動的にスキップされます。
+       *
+       * @param docsDir - ドキュメントディレクトリのパス
+       * @param customIgnore - カスタム除外パターン（オプション）
+       * @returns 生成されたルートの配列
+       *
+       * @example
+       * ```typescript
+       * const generator = new RouteGenerator();
+       * const routes = await generator.generateRoutes('docs');
+       * // routes = [
+       * //   { path: '/', filePath: 'docs/index.mdx', frontmatter: {...} },
+       * //   { path: '/guide/intro', filePath: 'docs/guide/intro.md', frontmatter: {...} }
+       * // ]
+       * ```
+       */
+      async generateRoutes(docsDir, customIgnore) {
+        await this.ignorePatterns.initialize(docsDir, customIgnore);
+        const routes = [];
+        await this.scanDirectory(docsDir, docsDir, routes);
+        return this.resolveDuplicatePaths(routes);
+      }
+      /**
+       * 重複するパスを解決する
+       *
+       * 同じURLパスに対して複数のファイル（.mdと.mdx）が存在する場合、
+       * .mdxファイルを優先します。
+       *
+       * @param routes - ルート配列
+       * @returns 重複を解決したルート配列
+       */
+      resolveDuplicatePaths(routes) {
+        const pathMap = /* @__PURE__ */ new Map();
+        for (const route of routes) {
+          const existingRoute = pathMap.get(route.path);
+          if (!existingRoute) {
+            pathMap.set(route.path, route);
+          } else {
+            const currentIsMdx = route.filePath.endsWith(".mdx");
+            const existingIsMdx = existingRoute.filePath.endsWith(".mdx");
+            if (currentIsMdx && !existingIsMdx) {
+              console.warn(
+                `Duplicate path detected: ${route.path}. Prioritizing ${route.filePath} over ${existingRoute.filePath}`
+              );
+              pathMap.set(route.path, route);
+            } else if (!currentIsMdx && existingIsMdx) {
+              console.warn(
+                `Duplicate path detected: ${route.path}. Prioritizing ${existingRoute.filePath} over ${route.filePath}`
+              );
+            } else {
+              console.warn(
+                `Duplicate path detected: ${route.path}. Using ${existingRoute.filePath}, ignoring ${route.filePath}`
+              );
+            }
+          }
+        }
+        return Array.from(pathMap.values());
+      }
+      /**
+       * URLパスから対応するルートを検索
+       *
+       * @param urlPath - URLパス（例: /guide/intro）
+       * @param routes - 検索対象のルート配列
+       * @returns 対応するルート、見つからない場合はnull
+       *
+       * @example
+       * ```typescript
+       * const generator = new RouteGenerator();
+       * const routes = await generator.generateRoutes('docs');
+       * const route = generator.resolveRoute('/guide/intro', routes);
+       * // route = { path: '/guide/intro', filePath: 'docs/guide/intro.mdx', frontmatter: {...} }
+       * ```
+       */
+      resolveRoute(urlPath, routes) {
+        const normalizedPath = urlPath === "/" ? "/" : urlPath.replace(/\/$/, "");
+        return routes.find((route) => route.path === normalizedPath) || null;
+      }
+      /**
+       * ディレクトリを再帰的にスキャンしてMDX/MDファイルを検出
+       *
+       * @param currentDir - 現在のディレクトリパス
+       * @param baseDir - ベースディレクトリパス（docsDir）
+       * @param routes - ルートを追加する配列
+       */
+      async scanDirectory(currentDir, baseDir, routes) {
+        try {
+          const entries = await fs.readdir(currentDir, { withFileTypes: true });
+          for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(baseDir, fullPath);
+            if (this.ignorePatterns.shouldIgnore(relativePath)) {
+              continue;
+            }
+            if (entry.isDirectory()) {
+              await this.scanDirectory(fullPath, baseDir, routes);
+            } else if (entry.isFile() && (entry.name.endsWith(".mdx") || entry.name.endsWith(".md"))) {
+              const route = await this.createRoute(fullPath, baseDir);
+              routes.push(route);
+            }
+          }
+        } catch (error) {
+          throw new Error(
+            `Failed to scan directory ${currentDir}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      /**
+       * ファイルパスからルートを作成
+       *
+       * @param filePath - MDXまたはMDファイルのパス
+       * @param baseDir - ベースディレクトリパス
+       * @returns 生成されたルート
+       */
+      async createRoute(filePath, baseDir) {
+        const frontmatter = await this.extractFrontmatter(filePath);
+        const urlPath = this.filePathToUrlPath(filePath, baseDir);
+        return {
+          path: urlPath,
+          filePath,
+          frontmatter
+        };
+      }
+      /**
+       * ファイルパスからURLパスへ変換
+       *
+       * @param filePath - MDXまたはMDファイルのパス（例: docs/guide/intro.mdx, docs/guide/intro.md）
+       * @param baseDir - ベースディレクトリパス（例: docs）
+       * @returns URLパス（例: /guide/intro）
+       *
+       * 変換ルール:
+       * - docs/index.mdx → /
+       * - docs/index.md → /
+       * - docs/guide/index.mdx → /guide
+       * - docs/guide/index.md → /guide
+       * - docs/guide/intro.mdx → /guide/intro
+       * - docs/guide/intro.md → /guide/intro
+       */
+      filePathToUrlPath(filePath, baseDir) {
+        const relativePath = path.relative(baseDir, filePath);
+        const withoutExt = relativePath.replace(/\.(mdx|md)$/, "");
+        const normalized = withoutExt.split(path.sep).join("/");
+        if (normalized === "index") {
+          return "/";
+        }
+        if (normalized.endsWith("/index")) {
+          const dirPath = normalized.replace(/\/index$/, "");
+          return `/${dirPath}`;
+        }
+        return `/${normalized}`;
+      }
+      /**
+       * MDXまたはMDファイルからフロントマターを抽出
+       *
+       * @param filePath - MDXまたはMDファイルのパス
+       * @returns 抽出されたフロントマター
+       */
+      async extractFrontmatter(filePath) {
+        try {
+          const processed = await this.mdxProcessor.process(filePath);
+          return processed.frontmatter;
+        } catch (error) {
+          console.warn(
+            `Failed to extract frontmatter from ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+          );
+          return {};
+        }
+      }
+    };
+  }
+});
+
+// src/server/routing-middleware.ts
+var routing_middleware_exports = {};
+__export(routing_middleware_exports, {
+  createRoutingMiddleware: () => createRoutingMiddleware
+});
+var __filename$1, __dirname$1, createRoutingMiddleware, handleAllRoutesRequest, handleRouteRequest, handleMDXRequest, handle500;
+var init_routing_middleware = __esm({
+  "src/server/routing-middleware.ts"() {
+    init_router();
+    __filename$1 = fileURLToPath(import.meta.url);
+    __dirname$1 = dirname(__filename$1);
+    createRoutingMiddleware = (server, options) => {
+      const { config, cwd } = options;
+      const routeGenerator = new RouteGenerator();
+      let routes = null;
+      let routesPromise = null;
+      const getRoutes = async () => {
+        if (routes !== null) {
+          return routes;
+        }
+        if (routesPromise !== null) {
+          return routesPromise;
+        }
+        routesPromise = (async () => {
+          const docsDir = config.docsDir ? resolve(cwd, config.docsDir) : cwd;
+          const generatedRoutes = await routeGenerator.generateRoutes(
+            docsDir,
+            config.ignore
+          );
+          routes = generatedRoutes;
+          routesPromise = null;
+          return generatedRoutes;
+        })();
+        return routesPromise;
+      };
+      const clearRoutesCache = () => {
+        routes = null;
+        routesPromise = null;
+      };
+      server.watcher.on("add", (path2) => {
+        if (path2.endsWith(".mdx") || path2.endsWith(".md")) {
+          clearRoutesCache();
+        }
+      });
+      server.watcher.on("unlink", (path2) => {
+        if (path2.endsWith(".mdx") || path2.endsWith(".md")) {
+          clearRoutesCache();
+        }
+      });
+      server.watcher.on("change", (path2) => {
+        if (path2.endsWith(".mdx") || path2.endsWith(".md")) {
+          clearRoutesCache();
+        }
+      });
+      return async (req, res, next) => {
+        const url = req.url;
+        if (!url) {
+          return next();
+        }
+        const urlPath = url.split("?")[0];
+        if (urlPath === "/__chronoter_mdx__") {
+          return handleMDXRequest(req, res, cwd);
+        }
+        if (urlPath === "/__chronoter_routes__") {
+          return handleRouteRequest(req, res, getRoutes, routeGenerator);
+        }
+        if (urlPath === "/__chronoter_all_routes__") {
+          return handleAllRoutesRequest(req, res, getRoutes);
+        }
+        if (urlPath.startsWith("/@") || // Vite内部リクエスト
+        urlPath.startsWith("/node_modules") || urlPath.startsWith("/src/") || // Viteが処理するソースファイル
+        urlPath.includes(".") && !urlPath.endsWith("/") && !urlPath.startsWith("/src/")) {
+          return next();
+        }
+        try {
+          const allRoutes = await getRoutes();
+          const route = routeGenerator.resolveRoute(urlPath, allRoutes);
+          if (route) {
+            req.chronoterRoute = route;
+          }
+          const templatePath = __dirname$1.endsWith("dist") ? resolve(__dirname$1, "server/templates/index.html") : resolve(__dirname$1, "templates/index.html");
+          const html = await readFile(templatePath, "utf-8");
+          const transformedHtml = await server.transformIndexHtml(url, html);
+          res.statusCode = route ? 200 : 404;
+          res.setHeader("Content-Type", "text/html; charset=utf-8");
+          res.end(transformedHtml);
+          return;
+        } catch (error) {
+          console.error("Routing middleware error:", error);
+          return handle500(res, error);
+        }
+      };
+    };
+    handleAllRoutesRequest = async (req, res, getRoutes) => {
+      try {
+        const allRoutes = await getRoutes();
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            routes: allRoutes.map((route) => ({
+              path: route.path,
+              filePath: route.filePath,
+              frontmatter: route.frontmatter
+            }))
+          })
+        );
+      } catch (error) {
+        console.error("[All Routes API] Error:", error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            error: "Failed to fetch all routes",
+            message: errorMessage
+          })
+        );
+      }
+    };
+    handleRouteRequest = async (req, res, getRoutes, routeGenerator) => {
+      try {
+        const url = new URL(req.url || "", `http://${req.headers.host}`);
+        const urlPath = url.searchParams.get("path");
+        if (!urlPath) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: "Missing 'path' query parameter" }));
+          return;
+        }
+        const allRoutes = await getRoutes();
+        const route = routeGenerator.resolveRoute(urlPath, allRoutes);
+        if (!route) {
+          res.statusCode = 404;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: "Route not found" }));
+          return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            path: route.path,
+            filePath: route.filePath,
+            frontmatter: route.frontmatter
+          })
+        );
+      } catch (error) {
+        console.error("[Route API] Error:", error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            error: "Failed to fetch route",
+            message: errorMessage
+          })
+        );
+      }
+    };
+    handleMDXRequest = async (req, res, cwd) => {
+      try {
+        const url = new URL(req.url || "", `http://${req.headers.host}`);
+        const filePath = url.searchParams.get("path");
+        if (!filePath) {
+          res.statusCode = 400;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: "Missing 'path' query parameter" }));
+          return;
+        }
+        const absolutePath = resolve(cwd, filePath);
+        if (!absolutePath.startsWith(cwd)) {
+          res.statusCode = 403;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: "Access denied" }));
+          return;
+        }
+        const { MDXProcessor: MDXProcessor2 } = await Promise.resolve().then(() => (init_processor(), processor_exports));
+        const processor = new MDXProcessor2();
+        const processedMDX = await processor.process(absolutePath);
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            code: processedMDX.code,
+            frontmatter: processedMDX.frontmatter,
+            slug: processedMDX.slug
+          })
+        );
+      } catch (error) {
+        console.error("[MDX API] Error:", error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            error: "Failed to process MDX file",
+            message: errorMessage
+          })
+        );
+      }
+    };
+    handle500 = (res, error) => {
+      res.statusCode = 500;
+      res.setHeader("Content-Type", "text/html; charset=utf-8");
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? error.stack : "";
+      const html = `
+<!DOCTYPE html>
+<html lang="ja">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>500 - Internal Server Error</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 2rem;
+      line-height: 1.6;
+      color: #333;
+    }
+    h1 {
+      color: #e74c3c;
+      font-size: 2.5rem;
+      margin-bottom: 0.5rem;
+    }
+    .error-code {
+      font-size: 4rem;
+      font-weight: bold;
+      color: #e74c3c;
+      margin: 0;
+    }
+    .message {
+      font-size: 1.2rem;
+      color: #666;
+      margin-bottom: 2rem;
+    }
+    .error-details {
+      background: #f5f5f5;
+      padding: 1rem;
+      border-radius: 4px;
+      border-left: 4px solid #e74c3c;
+      margin: 1rem 0;
+    }
+    .error-message {
+      color: #e74c3c;
+      font-weight: bold;
+      margin-bottom: 1rem;
+    }
+    .error-stack {
+      background: #2c3e50;
+      color: #ecf0f1;
+      padding: 1rem;
+      border-radius: 4px;
+      overflow-x: auto;
+      font-family: 'Courier New', monospace;
+      font-size: 0.9rem;
+      white-space: pre-wrap;
+    }
+  </style>
+</head>
+<body>
+  <p class="error-code">500</p>
+  <h1>Internal Server Error</h1>
+  <p class="message">An error occurred while processing your request.</p>
+  
+  <div class="error-details">
+    <div class="error-message">${errorMessage}</div>
+    ${errorStack ? `<div class="error-stack">${errorStack}</div>` : ""}
+  </div>
+</body>
+</html>
+  `;
+      res.end(html);
+    };
+  }
+});
+
+// src/core/errors/config-error.ts
+var ConfigError = class _ConfigError extends Error {
+  /**
+   * ConfigErrorのコンストラクタ
+   * @param message エラーメッセージ
+   * @param details エラーの詳細情報（オプション）
+   */
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "ConfigError";
+    Object.setPrototypeOf(this, _ConfigError.prototype);
+  }
+};
+var siteConfigSchema = z.object({
+  title: z.string().min(1, "site.title is required"),
+  description: z.string().optional(),
+  baseUrl: z.string().url("site.baseUrl must be a valid URL").optional()
+});
+var navigationItemSchema = z.lazy(
+  () => z.object({
+    title: z.string().min(1, "navigation item title is required"),
+    path: z.string().optional(),
+    items: z.array(navigationItemSchema).optional()
+  })
+);
+var themeConfigSchema = z.object({
+  variant: z.enum(["blue", "slate", "violet", "green", "orange", "red", "rose", "zinc"]).optional(),
+  logo: z.string().optional()
+});
+var chronoterConfigSchema = z.object({
+  site: siteConfigSchema,
+  navigation: z.array(navigationItemSchema).optional(),
+  docsDir: z.string().min(1, "docsDir must not be empty").optional(),
+  outDir: z.string().optional(),
+  theme: themeConfigSchema.optional(),
+  ignore: z.array(z.string()).optional()
+});
+
+// src/core/config/defaults.ts
+var defaultConfig = {
+  docsDir: ".",
+  // デフォルトはルートディレクトリ
+  theme: {
+    variant: "blue"
+    // デフォルトテーマ
+  }
+};
+var mergeWithDefaults = (userConfig) => {
+  const site = userConfig.site;
+  return {
+    site,
+    docsDir: userConfig.docsDir ?? defaultConfig.docsDir,
+    navigation: userConfig.navigation,
+    theme: {
+      variant: userConfig.theme?.variant ?? defaultConfig.theme?.variant,
+      logo: userConfig.theme?.logo
+    },
+    ignore: userConfig.ignore
+  };
+};
+
+// src/core/config/loader.ts
+var ConfigLoader = class {
+  /**
+   * 指定されたディレクトリからchronoter.config.jsonを読み込む
+   *
+   * @param cwd 作業ディレクトリ（デフォルト: process.cwd()）
+   * @returns 検証済みの設定オブジェクト
+   * @throws {ConfigError} 設定ファイルが見つからない、または無効な場合
+   */
+  static async load(cwd = process.cwd()) {
+    const configPath = resolve(cwd, "chronoter.config.json");
+    try {
+      const fileContent = await readFile(configPath, "utf-8");
+      let parsedConfig;
+      try {
+        parsedConfig = JSON.parse(fileContent);
+      } catch (parseError) {
+        throw new ConfigError(
+          `Failed to parse JSON in config file: ${configPath}`,
+          parseError instanceof Error ? parseError.message : parseError
+        );
+      }
+      return this.validate(parsedConfig);
+    } catch (error) {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        throw new ConfigError(
+          `Config file not found: ${configPath}
+Please create a chronoter.config.json file.`
+        );
+      }
+      if (error instanceof ConfigError) {
+        throw error;
+      }
+      throw new ConfigError(
+        `Error occurred while loading config file: ${configPath}`,
+        error
+      );
+    }
+  }
+  /**
+   * 設定オブジェクトを検証する
+   *
+   * @param config 検証する設定オブジェクト
+   * @returns 検証済みの設定オブジェクト（デフォルト値がマージ済み）
+   * @throws {ConfigError} 設定が無効な場合
+   */
+  static validate(config) {
+    try {
+      const validatedConfig = chronoterConfigSchema.parse(config);
+      return mergeWithDefaults(validatedConfig);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        const errorMessages = error.errors.map((err) => {
+          const path2 = err.path.join(".");
+          return `  - ${path2}: ${err.message}`;
+        }).join("\n");
+        throw new ConfigError(
+          "Config validation failed:\n" + errorMessages,
+          error.errors
+        );
+      }
+      throw new ConfigError(
+        "Unexpected error occurred during config validation",
+        error
+      );
+    }
+  }
+};
+
+// src/server/vite-config.ts
+init_ignore_patterns();
+
+// src/server/plugins/config-virtual-module.ts
+var VIRTUAL_CONFIG_MODULE_ID = "virtual:chronoter-config";
+var RESOLVED_VIRTUAL_CONFIG_MODULE_ID = "\0" + VIRTUAL_CONFIG_MODULE_ID;
+var createConfigVirtualModulePlugin = (config) => {
+  return {
+    name: "chronoter-config-virtual-module",
+    /**
+     * Virtual moduleのIDを解決
+     */
+    resolveId(id) {
+      if (id === VIRTUAL_CONFIG_MODULE_ID) {
+        return RESOLVED_VIRTUAL_CONFIG_MODULE_ID;
+      }
+      return null;
+    },
+    /**
+     * Virtual moduleのコードを生成
+     */
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_CONFIG_MODULE_ID) {
+        const configCode = `
+// Auto-generated by chronoter-config-virtual-module plugin
+// This module provides access to the Chronoter configuration
+
+export const config = ${JSON.stringify(config, null, 2)};
+
+// HMR\u5BFE\u5FDC
+if (import.meta.hot) {
+  import.meta.hot.accept((newModule) => {
+    if (newModule) {
+      console.log('[chronoter] Configuration updated');
+      // \u8A2D\u5B9A\u304C\u5909\u66F4\u3055\u308C\u305F\u5834\u5408\u306F\u30DA\u30FC\u30B8\u5168\u4F53\u3092\u30EA\u30ED\u30FC\u30C9
+      window.location.reload();
+    }
+  });
+}
+`;
+        return configCode;
+      }
+      return null;
+    }
+  };
+};
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var isMediaFileRequest = (url) => {
+  const mediaExtensions = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".mp4",
+    ".webm",
+    ".ogg",
+    ".mp3",
+    ".wav"
+  ];
+  const ext = extname(url.split("?")[0]);
+  return mediaExtensions.includes(ext.toLowerCase());
+};
+var resolveMediaFilePath = (url, cwd) => {
+  const cleanUrl = url.split("?")[0];
+  const relativePath = cleanUrl.startsWith("/") ? cleanUrl.slice(1) : cleanUrl;
+  const fullPath = join(cwd, relativePath);
+  return fullPath;
+};
+var getMimeType = (filePath) => {
+  const ext = extname(filePath).toLowerCase();
+  const mimeTypes = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".ogg": "video/ogg",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+};
+var createViteConfig = (config, options = {}) => {
+  const { port = 3e3, host = "localhost", cwd = process.cwd() } = options;
+  return defineConfig({
+    // プラグイン設定
+    plugins: [
+      // MDXプラグイン（GitHub Flavored Markdownサポート）
+      mdx({
+        remarkPlugins: [remarkGfm],
+        rehypePlugins: []
+      }),
+      // React Fast Refresh対応
+      react({
+        // MDXファイルもReactコンポーネントとして扱う
+        include: /\.(jsx|tsx|mdx)$/
+      }),
+      // 設定情報をクライアントに注入するVirtual Moduleプラグイン
+      createConfigVirtualModulePlugin(config),
+      // ルーティングミドルウェアを登録するプラグイン
+      {
+        name: "chronoter-routing",
+        configureServer(server) {
+          Promise.resolve().then(() => (init_routing_middleware(), routing_middleware_exports)).then(
+            ({ createRoutingMiddleware: createRoutingMiddleware2 }) => {
+              console.log("\u{1F500} Setting up routing middleware...");
+              const routingMiddleware = createRoutingMiddleware2(server, {
+                config,
+                cwd
+              });
+              server.middlewares.use(routingMiddleware);
+            }
+          );
+        }
+      },
+      // ロゴアセット配信ミドルウェアを登録するプラグイン（メディアファイルミドルウェアより前に配置）
+      {
+        name: "chronoter-logo-assets",
+        configureServer(server) {
+          server.middlewares.use((req, res, next) => {
+            const url = req.url || "";
+            if (url.startsWith("/chronoter-assets/media/")) {
+              const fileName = url.replace("/chronoter-assets/media/", "");
+              const logoPath = resolve(
+                __dirname2,
+                "core/media/logos",
+                fileName
+              );
+              if (!existsSync(logoPath)) {
+                res.statusCode = 404;
+                res.end("Logo file not found");
+                return;
+              }
+              try {
+                const content = readFileSync(logoPath);
+                const mimeType = getMimeType(logoPath);
+                res.setHeader("Content-Type", mimeType);
+                res.setHeader("Cache-Control", "public, max-age=31536000");
+                res.end(content);
+              } catch (error) {
+                console.error("Error reading logo file:", error);
+                res.statusCode = 500;
+                res.end("Error reading logo file");
+              }
+              return;
+            }
+            if (url.startsWith("/chronoter-assets/project/")) {
+              const fileName = url.replace("/chronoter-assets/project/", "");
+              const logoPath = join(cwd, fileName);
+              if (!existsSync(logoPath)) {
+                res.statusCode = 404;
+                res.end("Custom logo file not found");
+                return;
+              }
+              try {
+                const content = readFileSync(logoPath);
+                const mimeType = getMimeType(logoPath);
+                res.setHeader("Content-Type", mimeType);
+                res.setHeader("Cache-Control", "public, max-age=31536000");
+                res.end(content);
+              } catch (error) {
+                console.error("Error reading custom logo file:", error);
+                res.statusCode = 500;
+                res.end("Error reading custom logo file");
+              }
+              return;
+            }
+            next();
+          });
+        }
+      },
+      // メディアファイル配信ミドルウェアを登録するプラグイン（ロゴアセットミドルウェアの後に配置）
+      {
+        name: "chronoter-media-files",
+        configureServer(server) {
+          server.middlewares.use((req, res, next) => {
+            if (!isMediaFileRequest(req.url || "")) {
+              return next();
+            }
+            const mediaFilePath = resolveMediaFilePath(req.url || "", cwd);
+            if (!existsSync(mediaFilePath)) {
+              res.statusCode = 404;
+              res.end("Media file not found");
+              return;
+            }
+            try {
+              const content = readFileSync(mediaFilePath);
+              const mimeType = getMimeType(mediaFilePath);
+              res.setHeader("Content-Type", mimeType);
+              res.setHeader("Cache-Control", "public, max-age=31536000");
+              res.end(content);
+            } catch (error) {
+              console.error("Error reading media file:", error);
+              res.statusCode = 500;
+              res.end("Error reading media file");
+            }
+          });
+        }
+      }
+    ],
+    // エイリアス設定
+    resolve: {
+      alias: {
+        // @/をchronoter-dev内のcoreモジュールにマップ
+        // __dirnameはビルド後: dist/server、開発時: src/server
+        "@": resolve(__dirname2, "../core")
+      }
+    },
+    // 開発サーバー設定
+    server: {
+      port,
+      host,
+      // ブラウザを自動的に開く（CLIオプションで制御）
+      open: false,
+      // CORS設定
+      cors: true,
+      // HMR設定
+      hmr: {
+        overlay: true,
+        // エラーオーバーレイを表示
+        protocol: "ws",
+        // WebSocketプロトコル
+        host,
+        // HMRのホスト
+        port,
+        // HMRのポート
+        clientPort: port
+        // クライアント側のポート
+      },
+      // ファイル監視設定
+      watch: {
+        // chronoter-coreのデフォルト除外パターン + カスタム除外パターンを使用
+        ignored: [...DEFAULT_IGNORE_PATTERNS, ...config.ignore || []]
+        // ポーリング間隔（ミリ秒）- ファイルシステムイベントが信頼できない環境用
+        // usePolling: false,
+        // interval: 100,
+      }
+    },
+    // ビルド設定（開発サーバーでは使用しないが、将来的な拡張のため定義）
+    build: {
+      // ソースマップを生成
+      sourcemap: true,
+      // チャンク分割戦略
+      rollupOptions: {
+        output: {
+          manualChunks: {
+            // Reactを別チャンクに分離
+            react: ["react", "react-dom"]
+          }
+        }
+      }
+    },
+    // 最適化設定
+    optimizeDeps: {
+      // 事前バンドルする依存関係
+      include: ["react", "react-dom"],
+      // 除外する依存関係（Node.js専用モジュール）
+      exclude: ["fsevents", "chokidar"]
+    },
+    // ルートディレクトリ（chronoter-devパッケージのルートに設定）
+    // ビルド後: __dirname = dist, resolve(__dirname, "..") = packages/chronoter-dev
+    // 開発時: __dirname = src/server, resolve(__dirname, "../..") = packages/chronoter-dev
+    // ビルド後のパスを使用（dist -> packages/chronoter-dev）
+    root: resolve(__dirname2, ".."),
+    // 公開ディレクトリ（静的アセット用）
+    publicDir: resolve(cwd, "public"),
+    // サーバー設定でベースパスを指定
+    base: "/",
+    // ログレベル
+    logLevel: "info"
+  });
+};
+
+// src/hmr/index.ts
+init_ignore_patterns();
+var HMRManager = class {
+  constructor(server, options) {
+    this.watcher = null;
+    this.configWatcher = null;
+    this.server = server;
+    this.options = options;
+  }
+  /**
+   * ファイル監視を開始する
+   */
+  start() {
+    this.startMDXWatcher();
+    this.startConfigWatcher();
+  }
+  /**
+   * MDXファイルの監視を開始
+   */
+  startMDXWatcher() {
+    const watchPath = resolve(this.options.cwd, this.options.watchDir);
+    console.log(chalk2.cyan("\u{1F440} Watching for MDX file changes..."));
+    console.log(chalk2.gray(`   Path: ${watchPath}`));
+    this.watcher = watch(["**/*.mdx", "**/*.md"], {
+      cwd: watchPath,
+      // chronoter-coreのデフォルト除外パターン + カスタム除外パターンを使用
+      ignored: [
+        ...DEFAULT_IGNORE_PATTERNS,
+        ...this.options.customIgnore || []
+      ],
+      ignoreInitial: true,
+      persistent: true
+    });
+    this.watcher.on("add", (path2) => {
+      this.handleMDXChange("added", path2);
+    });
+    this.watcher.on("change", (path2) => {
+      this.handleMDXChange("changed", path2);
+    });
+    this.watcher.on("unlink", (path2) => {
+      this.handleMDXChange("removed", path2);
+    });
+    this.watcher.on("error", (error) => {
+      console.error(chalk2.red("\u2717 File watcher error:"), error);
+    });
+  }
+  /**
+   * 設定ファイルの監視を開始
+   *
+   * chronoter.config.json は固定ファイル名
+   */
+  startConfigWatcher() {
+    const configPath = resolve(this.options.cwd, "chronoter.config.json");
+    console.log(chalk2.cyan("\u{1F440} Watching for config file changes..."));
+    console.log(chalk2.gray(`   Path: ${configPath}`));
+    this.configWatcher = watch(configPath, {
+      ignoreInitial: true,
+      persistent: true
+    });
+    this.configWatcher.on("change", () => {
+      this.handleConfigChange();
+    });
+    this.configWatcher.on("error", (error) => {
+      console.error(chalk2.red("\u2717 Config watcher error:"), error);
+    });
+  }
+  /**
+   * MDXファイルの変更を処理
+   *
+   * @param event 変更イベントの種類
+   * @param path 変更されたファイルのパス
+   */
+  handleMDXChange(event, path2) {
+    const relativePath = relative(this.options.cwd, path2);
+    const eventLabel = event === "added" ? "\u2795" : event === "changed" ? "\u{1F4DD}" : "\u{1F5D1}\uFE0F";
+    const eventColor = event === "added" ? chalk2.green : event === "changed" ? chalk2.yellow : chalk2.red;
+    console.log();
+    console.log(eventColor(`${eventLabel} MDX file ${event}: ${relativePath}`));
+    const moduleId = `/${path2}`;
+    const module = this.server.moduleGraph.getModuleById(moduleId);
+    if (module) {
+      this.server.moduleGraph.invalidateModule(module);
+      console.log(chalk2.gray(`   Module invalidated: ${moduleId}`));
+    }
+    this.server.ws.send({
+      type: "full-reload",
+      path: "*"
+    });
+    console.log(chalk2.green("\u2713 Browser reloaded"));
+  }
+  /**
+   * 設定ファイルの変更を処理
+   */
+  handleConfigChange() {
+    console.log();
+    console.log(chalk2.yellow("\u2699\uFE0F  Config file changed"));
+    this.server.ws.send({
+      type: "full-reload",
+      path: "*"
+    });
+    console.log(chalk2.green("\u2713 Configuration reloaded via HMR"));
+  }
+  /**
+   * ファイル監視を停止する
+   */
+  async stop() {
+    console.log(chalk2.yellow("\u23F9  Stopping file watchers..."));
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.configWatcher) {
+      await this.configWatcher.close();
+      this.configWatcher = null;
+    }
+    console.log(chalk2.green("\u2713 File watchers stopped"));
+  }
+};
+
+// src/server/dev-server.ts
+var startDevServer = async (options = {}) => {
+  const {
+    port = 3e3,
+    host = "localhost",
+    open = true,
+    cwd = process.cwd()
+  } = options;
+  try {
+    console.log(chalk2.cyan("\u{1F4D6} Loading configuration..."));
+    const config = await loadConfig(cwd);
+    console.log(chalk2.green("\u2713 Configuration loaded successfully"));
+    console.log(chalk2.gray(`   Site: ${config.site.title}`));
+    if (config.docsDir) {
+      console.log(chalk2.gray(`   Docs directory: ${config.docsDir}`));
+    }
+    console.log();
+    console.log(chalk2.cyan("\u2699\uFE0F  Creating Vite configuration..."));
+    const viteConfig = createViteConfig(config, { port, host, cwd });
+    console.log(chalk2.cyan("\u{1F527} Creating Vite server..."));
+    const server = await createServer(viteConfig);
+    console.log(chalk2.cyan("\u{1F680} Starting server..."));
+    await server.listen();
+    console.log(chalk2.cyan("\u{1F525} Setting up Hot Module Replacement..."));
+    const hmrManager = new HMRManager(server, {
+      watchDir: config.docsDir || ".",
+      cwd,
+      customIgnore: config.ignore
+      // カスタム除外パターンを渡す
+    });
+    hmrManager.start();
+    const serverInfo = server.httpServer?.address();
+    const actualPort = typeof serverInfo === "object" && serverInfo !== null ? serverInfo.port : port;
+    const url = `http://${host}:${actualPort}`;
+    console.log(chalk2.green.bold("\u2713 Development server is ready!"));
+    console.log();
+    console.log(
+      chalk2.cyan("  \u279C") + chalk2.bold("  Local:   ") + chalk2.cyan(url)
+    );
+    console.log();
+    console.log(chalk2.gray("  Press Ctrl+C to stop the server"));
+    console.log();
+    if (open) {
+      console.log(chalk2.cyan("\u{1F310} Opening browser..."));
+      await server.openBrowser();
+    }
+    process.on("SIGINT", async () => {
+      console.log();
+      console.log(chalk2.yellow("\u23F9  Stopping server..."));
+      await hmrManager.stop();
+      await server.close();
+      console.log(chalk2.green("\u2713 Server stopped"));
+      process.exit(0);
+    });
+  } catch (error) {
+    handleServerError(error);
+  }
+};
+var loadConfig = async (cwd) => {
+  try {
+    return await ConfigLoader.load(cwd);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      throw error;
+    }
+    throw new ConfigError(
+      "An unexpected error occurred while loading configuration",
+      error
+    );
+  }
+};
+var handleServerError = (error) => {
+  console.log();
+  if (error instanceof ConfigError) {
+    console.error(chalk2.red.bold("\u2717 Configuration Error"));
+    console.error();
+    console.error(chalk2.red(error.message));
+    if (error.details) {
+      console.error();
+      console.error(chalk2.yellow("Details:"));
+      console.error(chalk2.gray(JSON.stringify(error.details, null, 2)));
+    }
+    console.error();
+    console.error(
+      chalk2.cyan("\u{1F4A1} Tip: Make sure chronoter.config.json exists and is valid")
+    );
+  } else if (error instanceof Error) {
+    console.error(chalk2.red.bold("\u2717 Server Error"));
+    console.error();
+    console.error(chalk2.red(error.message));
+    if (error.stack) {
+      console.error();
+      console.error(chalk2.gray(error.stack));
+    }
+  } else {
+    console.error(chalk2.red.bold("\u2717 Unknown Error"));
+    console.error();
+    console.error(chalk2.red(String(error)));
+  }
+  console.error();
+  process.exit(1);
+};
+
+// src/cli/version-checker/npm-registry.ts
+var fetchLatestVersion = async (packageName, timeout = 5e3) => {
+  const registryUrl = `https://registry.npmjs.org/${packageName}`;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(registryUrl, {
+      headers: {
+        Accept: "application/json"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return {
+      latestVersion: data["dist-tags"].latest,
+      name: data.name
+    };
+  } catch {
+    return null;
+  }
+};
+var DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var getCacheDir = () => {
+  return join(homedir(), ".chronoter");
+};
+var getCacheFilePath = () => {
+  return join(getCacheDir(), "version-check-cache.json");
+};
+var ensureCacheDir = () => {
+  const cacheDir = getCacheDir();
+  if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, { recursive: true });
+  }
+};
+var isCacheValid = (cache, ttlMs) => {
+  const now = Date.now();
+  return now - cache.timestamp < ttlMs;
+};
+var getVersionCache = (packageName, ttlMs = DEFAULT_CACHE_TTL_MS) => {
+  try {
+    const cachePath = getCacheFilePath();
+    if (!existsSync(cachePath)) {
+      return null;
+    }
+    const content = readFileSync(cachePath, "utf-8");
+    const cache = JSON.parse(content);
+    if (cache.packageName === packageName && isCacheValid(cache, ttlMs)) {
+      return cache;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var setVersionCache = (packageName, latestVersion) => {
+  try {
+    ensureCacheDir();
+    const cache = {
+      packageName,
+      latestVersion,
+      timestamp: Date.now()
+    };
+    writeFileSync(getCacheFilePath(), JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+  }
+};
+var isInteractiveTerminal = () => {
+  return Boolean(process.stdin.isTTY);
+};
+var promptForUpdate = async (currentVersion, latestVersion) => {
+  console.log();
+  console.log(
+    chalk2.yellow(
+      `A new version of Chronoter is available: ${chalk2.bold(latestVersion)} (current: ${currentVersion})`
+    )
+  );
+  if (!isInteractiveTerminal()) {
+    console.log(
+      chalk2.gray("Non-interactive environment detected. Skipping update prompt.")
+    );
+    console.log(
+      chalk2.gray(`Run 'npm install -g ${process.env.npm_package_name || "chronoter"}@latest' to update manually.`)
+    );
+    console.log();
+    return false;
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve5) => {
+    rl.question(
+      "A new version of Chronoter is available. Would you like to update? (yes/no) ",
+      (answer) => {
+        rl.close();
+        const normalizedAnswer = answer.trim().toLowerCase();
+        resolve5(normalizedAnswer === "yes" || normalizedAnswer === "y");
+      }
+    );
+  });
+};
+var showUpdateStartMessage = () => {
+  console.log();
+  console.log(chalk2.cyan("Updating Chronoter..."));
+};
+var showUpdateSuccessMessage = (version) => {
+  console.log(chalk2.green(`Successfully updated to version ${version}`));
+  console.log();
+};
+var showUpdateFailedMessage = (error) => {
+  console.log(chalk2.red(`Failed to update Chronoter: ${error}`));
+  console.log(
+    chalk2.yellow("Continuing with the current version...")
+  );
+  console.log();
+};
+var showUpdateSkippedMessage = () => {
+  console.log(chalk2.gray("Update skipped. Continuing with the current version..."));
+  console.log();
+};
+var installLatestVersion = async (packageName) => {
+  return new Promise((resolve5) => {
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    const child = spawn(npmCommand, ["install", "-g", `${packageName}@latest`], {
+      stdio: "inherit"
+    });
+    child.on("error", (err) => {
+      resolve5({
+        success: false,
+        error: err.message
+      });
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve5({ success: true });
+      } else {
+        resolve5({
+          success: false,
+          error: `npm install exited with code ${code}`
+        });
+      }
+    });
+  });
+};
+
+// src/cli/version-checker/index.ts
+var compareVersions = (v1, v2) => {
+  const parts1 = v1.replace(/^v/, "").split(".").map(Number);
+  const parts2 = v2.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] ?? 0;
+    const p2 = parts2[i] ?? 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+};
+var getLatestVersion = async (packageName) => {
+  const cached = getVersionCache(packageName);
+  if (cached) {
+    return cached.latestVersion;
+  }
+  const npmInfo = await fetchLatestVersion(packageName);
+  if (npmInfo) {
+    setVersionCache(packageName, npmInfo.latestVersion);
+    return npmInfo.latestVersion;
+  }
+  return null;
+};
+var checkVersion = async (packageName, currentVersion) => {
+  const latestVersion = await getLatestVersion(packageName);
+  if (!latestVersion) {
+    return {
+      updateAvailable: false,
+      currentVersion
+    };
+  }
+  const comparison = compareVersions(currentVersion, latestVersion);
+  return {
+    updateAvailable: comparison < 0,
+    currentVersion,
+    latestVersion
+  };
+};
+var runVersionCheck = async (packageName, currentVersion) => {
+  try {
+    const result = await checkVersion(packageName, currentVersion);
+    if (!result.updateAvailable || !result.latestVersion) {
+      return;
+    }
+    const shouldUpdate = await promptForUpdate(
+      result.currentVersion,
+      result.latestVersion
+    );
+    if (shouldUpdate) {
+      showUpdateStartMessage();
+      const updateResult = await installLatestVersion(packageName);
+      if (updateResult.success) {
+        showUpdateSuccessMessage(result.latestVersion);
+      } else {
+        showUpdateFailedMessage(updateResult.error ?? "Unknown error");
+      }
+    } else {
+      showUpdateSkippedMessage();
+    }
+  } catch {
+  }
+};
+var PACKAGE_NAME = "chronoter";
+var CURRENT_VERSION = "0.1.0";
+var createCliProgram = () => {
+  const program = new Command();
+  program.name("chronoter").description("Chronoter - MDX-based documentation site generator").version(CURRENT_VERSION);
+  program.command("dev").description("Start the development server with HMR support").option("-p, --port <port>", "Server port number", "3000").option("-H, --host <host>", "Server host", "localhost").option(
+    "--no-open",
+    "Disable automatic browser opening (browser opens by default)"
+  ).option("--cwd <path>", "Working directory", process.cwd()).action(async (options) => {
+    try {
+      const port = typeof options.port === "string" ? parseInt(options.port, 10) : options.port;
+      if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(
+          chalk2.red(`Error: Invalid port number: ${options.port}`)
+        );
+        console.error(
+          chalk2.yellow("Port number must be between 1 and 65535.")
+        );
+        process.exit(1);
+      }
+      const cwd = options.cwd || process.cwd();
+      console.log(chalk2.cyan("\u{1F680} Starting Chronoter development server..."));
+      console.log(chalk2.gray(`   Port: ${port}`));
+      console.log(chalk2.gray(`   Host: ${options.host}`));
+      console.log(
+        chalk2.gray(
+          `   Open browser: ${options.open !== false ? "enabled" : "disabled"}`
+        )
+      );
+      console.log(chalk2.gray(`   Working directory: ${cwd}`));
+      console.log();
+      await startDevServer({
+        port,
+        host: options.host,
+        open: options.open,
+        cwd
+      });
+    } catch (error) {
+      console.error(chalk2.red("An error occurred:"));
+      console.error(error);
+      process.exit(1);
+    }
+  });
+  return program;
+};
+var main = async () => {
+  const args = process.argv.slice(2);
+  const isVersionOrHelp = args.some(
+    (arg) => arg === "--version" || arg === "-V" || arg === "--help" || arg === "-h"
+  );
+  if (!isVersionOrHelp) {
+    await runVersionCheck(PACKAGE_NAME, CURRENT_VERSION);
+  }
+  const program = createCliProgram();
+  await program.parseAsync(process.argv);
+};
+var isMainModule = (() => {
+  try {
+    const realArgv1 = realpathSync(process.argv[1]);
+    const currentFile = fileURLToPath(import.meta.url);
+    return currentFile === realArgv1;
+  } catch {
+    return false;
+  }
+})();
+if (isMainModule) {
+  main().catch((error) => {
+    console.error(chalk2.red("An unexpected error occurred:"));
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+export { CURRENT_VERSION, PACKAGE_NAME, createCliProgram };