@raystack/chronicle 0.1.0-canary.1f5227c

package/bin/chronicle.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli/index.js'

package/dist/cli/index.js

@@ -0,0 +1,543 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/server/vite-config.ts
+var exports_vite_config = {};
+__export(exports_vite_config, {
+  createViteConfig: () => createViteConfig
+});
+import path5 from "path";
+import react from "@vitejs/plugin-react";
+import mdx from "@mdx-js/rollup";
+import remarkDirective from "remark-directive";
+import remarkGfm from "remark-gfm";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkMdxFrontmatter from "remark-mdx-frontmatter";
+import rehypeShiki from "@shikijs/rehype";
+async function createViteConfig(options) {
+  const { root, contentDir, isDev = false } = options;
+  return {
+    root,
+    configFile: false,
+    resolve: {
+      alias: {
+        "@": path5.resolve(root, "src"),
+        "@content": contentDir
+      },
+      dedupe: ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"]
+    },
+    server: {
+      fs: {
+        allow: [root, contentDir]
+      }
+    },
+    plugins: [
+      mdx({
+        remarkPlugins: [
+          remarkFrontmatter,
+          remarkMdxFrontmatter,
+          remarkGfm,
+          remarkDirective
+        ],
+        rehypePlugins: [
+          [rehypeShiki, { themes: { light: "github-light", dark: "github-dark" } }]
+        ],
+        mdExtensions: [".md"],
+        mdxExtensions: [".mdx"]
+      }),
+      react()
+    ],
+    define: {
+      "process.env.CHRONICLE_CONTENT_DIR": JSON.stringify(contentDir),
+      "process.env.CHRONICLE_PROJECT_ROOT": JSON.stringify(root)
+    },
+    css: {
+      modules: {
+        localsConvention: "camelCase"
+      }
+    },
+    ssr: {
+      noExternal: ["@raystack/apsara"]
+    },
+    build: {
+      rolldownOptions: {
+        input: isDev ? undefined : {
+          client: path5.resolve(root, "src/server/index.html")
+        }
+      }
+    }
+  };
+}
+var init_vite_config = () => {};
+
+// src/server/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  startDevServer: () => startDevServer
+});
+import { createServer as createViteServer } from "vite";
+import { createServer } from "http";
+import fsPromises from "fs/promises";
+import { createReadStream } from "fs";
+import path6 from "path";
+import chalk3 from "chalk";
+async function startDevServer(options) {
+  const { port, root, contentDir } = options;
+  const viteConfig = await createViteConfig({ root, contentDir, isDev: true });
+  const vite = await createViteServer({
+    ...viteConfig,
+    server: { middlewareMode: true },
+    appType: "custom"
+  });
+  const templatePath = path6.resolve(root, "src/server/index.html");
+  const server = createServer(async (req, res) => {
+    const url = req.url || "/";
+    try {
+      if (url.startsWith("/@") || url.startsWith("/__vite") || url.startsWith("/node_modules/")) {
+        vite.middlewares(req, res, () => {
+          res.statusCode = 404;
+          res.end();
+        });
+        return;
+      }
+      const contentFile = path6.join(contentDir, decodeURIComponent(url.split("?")[0]));
+      if (!url.endsWith(".md") && !url.endsWith(".mdx")) {
+        try {
+          const stat = await fsPromises.stat(contentFile);
+          if (stat.isFile()) {
+            const ext = path6.extname(contentFile).toLowerCase();
+            const mimeTypes = {
+              ".png": "image/png",
+              ".jpg": "image/jpeg",
+              ".jpeg": "image/jpeg",
+              ".gif": "image/gif",
+              ".svg": "image/svg+xml",
+              ".webp": "image/webp",
+              ".ico": "image/x-icon",
+              ".pdf": "application/pdf",
+              ".json": "application/json",
+              ".yaml": "text/yaml",
+              ".yml": "text/yaml",
+              ".txt": "text/plain"
+            };
+            res.setHeader("Content-Type", mimeTypes[ext] || "application/octet-stream");
+            createReadStream(contentFile).pipe(res);
+            return;
+          }
+        } catch {}
+      }
+      if (/\.(js|ts|tsx|css|map)(\?|$)/.test(url)) {
+        vite.middlewares(req, res, () => {
+          res.statusCode = 404;
+          res.end();
+        });
+        return;
+      }
+      const { matchRoute } = await vite.ssrLoadModule(path6.resolve(root, "src/server/router.ts"));
+      const routeHandler = matchRoute(new URL(url, `http://localhost:${port}`).href);
+      if (routeHandler) {
+        const request = new Request(new URL(url, `http://localhost:${port}`));
+        const response = await routeHandler(request);
+        res.statusCode = response.status;
+        response.headers.forEach((value, key) => res.setHeader(key, value));
+        const body = await response.text();
+        res.end(body);
+        return;
+      }
+      const pathname = new URL(url, `http://localhost:${port}`).pathname;
+      const slug = pathname === "/" ? [] : pathname.slice(1).split("/").filter(Boolean);
+      const source = await vite.ssrLoadModule(path6.resolve(root, "src/lib/source.ts"));
+      const { mdxComponents } = await vite.ssrLoadModule(path6.resolve(root, "src/components/mdx/index.tsx"));
+      const { loadConfig } = await vite.ssrLoadModule(path6.resolve(root, "src/lib/config.ts"));
+      const config = loadConfig();
+      const { loadApiSpecs } = await vite.ssrLoadModule(path6.resolve(root, "src/lib/openapi.ts"));
+      const apiSpecs = config.api?.length ? loadApiSpecs(config.api) : [];
+      const [tree, sourcePage] = await Promise.all([
+        source.buildPageTree(),
+        source.getPage(slug)
+      ]);
+      let pageData = null;
+      let embeddedData = { config, tree, slug, frontmatter: null, filePath: null };
+      if (sourcePage) {
+        const component = await source.loadPageComponent(sourcePage);
+        const React = await import("react");
+        const MDXBody = component;
+        pageData = {
+          slug,
+          frontmatter: sourcePage.frontmatter,
+          content: MDXBody ? React.createElement(MDXBody, { components: mdxComponents }) : null
+        };
+        embeddedData.frontmatter = sourcePage.frontmatter;
+        embeddedData.filePath = sourcePage.filePath;
+      }
+      let template = await fsPromises.readFile(templatePath, "utf-8");
+      template = await vite.transformIndexHtml(url, template);
+      const dataScript = `<script>window.__PAGE_DATA__ = ${JSON.stringify(embeddedData)}</script>`;
+      template = template.replace("<!--head-outlet-->", `<!--head-outlet-->${dataScript}`);
+      const { render } = await vite.ssrLoadModule(path6.resolve(root, "src/server/entry-server.tsx"));
+      const html = render(url, { config, tree, page: pageData, apiSpecs });
+      const finalHtml = template.replace("<!--ssr-outlet-->", html);
+      res.setHeader("Content-Type", "text/html");
+      res.statusCode = 200;
+      res.end(finalHtml);
+    } catch (e) {
+      vite.ssrFixStacktrace(e);
+      console.error(e);
+      res.statusCode = 500;
+      res.end(e.message);
+    }
+  });
+  server.listen(port, () => {
+    console.log(chalk3.cyan(`
+  Chronicle dev server running at:`));
+    console.log(chalk3.green(`  http://localhost:${port}
+`));
+  });
+  const shutdown = () => {
+    vite.close();
+    server.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return { server, vite };
+}
+var init_dev = __esm(() => {
+  init_vite_config();
+});
+
+// src/server/prod.ts
+var exports_prod = {};
+__export(exports_prod, {
+  startProdServer: () => startProdServer
+});
+import path8 from "path";
+import chalk6 from "chalk";
+async function startProdServer(options) {
+  const { port, distDir } = options;
+  const serverEntry = path8.resolve(distDir, "server/entry-prod.js");
+  const { startServer } = await import(serverEntry);
+  console.log(chalk6.cyan("Starting production server..."));
+  return startServer({ port, distDir });
+}
+var init_prod = () => {};
+
+// src/cli/index.ts
+import { Command as Command6 } from "commander";
+
+// src/cli/commands/init.ts
+import { Command } from "commander";
+import { execSync } from "child_process";
+import fs2 from "fs";
+import path3 from "path";
+import chalk from "chalk";
+import { stringify } from "yaml";
+
+// src/cli/utils/scaffold.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/cli/utils/resolve.ts
+import path from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+// src/cli/utils/scaffold.ts
+function detectPackageManager() {
+  if (process.env.npm_config_user_agent) {
+    return process.env.npm_config_user_agent.split("/")[0];
+  }
+  const cwd = process.cwd();
+  if (fs.existsSync(path2.join(cwd, "bun.lock")) || fs.existsSync(path2.join(cwd, "bun.lockb")))
+    return "bun";
+  if (fs.existsSync(path2.join(cwd, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (fs.existsSync(path2.join(cwd, "yarn.lock")))
+    return "yarn";
+  return "npm";
+}
+function getChronicleVersion() {
+  const pkgPath = path2.join(PACKAGE_ROOT, "package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  return pkg.version;
+}
+
+// src/cli/commands/init.ts
+function createConfig() {
+  return {
+    title: "My Documentation",
+    description: "Documentation powered by Chronicle",
+    theme: { name: "default" },
+    search: { enabled: true, placeholder: "Search documentation..." }
+  };
+}
+function createPackageJson(name) {
+  return {
+    name,
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "chronicle dev",
+      build: "chronicle build",
+      start: "chronicle start"
+    },
+    dependencies: {
+      "@raystack/chronicle": `^${getChronicleVersion()}`
+    },
+    devDependencies: {
+      "@raystack/tools-config": "0.56.0",
+      "openapi-types": "^12.1.3",
+      typescript: "5.9.3",
+      "@types/react": "^19.2.10",
+      "@types/node": "^25.1.0"
+    }
+  };
+}
+var sampleMdx = `---
+title: Welcome
+description: Getting started with your documentation
+order: 1
+---
+
+# Welcome
+
+This is your documentation home page.
+`;
+var initCommand = new Command("init").description("Initialize a new Chronicle project").option("-c, --content <path>", "Content directory name", "content").action((options) => {
+  const projectDir = process.cwd();
+  const dirName = path3.basename(projectDir) || "docs";
+  const contentDir = path3.join(projectDir, options.content);
+  if (!fs2.existsSync(contentDir)) {
+    fs2.mkdirSync(contentDir, { recursive: true });
+    console.log(chalk.green("✓"), "Created", contentDir);
+  }
+  const packageJsonPath = path3.join(projectDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    fs2.writeFileSync(packageJsonPath, JSON.stringify(createPackageJson(dirName), null, 2) + `
+`);
+    console.log(chalk.green("✓"), "Created", packageJsonPath);
+  } else {
+    const existing = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+    const template = createPackageJson(dirName);
+    let updated = false;
+    if (existing.type !== "module") {
+      existing.type = "module";
+      updated = true;
+    }
+    if (!existing.scripts)
+      existing.scripts = {};
+    for (const [key, value] of Object.entries(template.scripts)) {
+      if (!existing.scripts[key]) {
+        existing.scripts[key] = value;
+        updated = true;
+      }
+    }
+    if (!existing.dependencies)
+      existing.dependencies = {};
+    for (const [key, value] of Object.entries(template.dependencies)) {
+      if (!existing.dependencies[key]) {
+        existing.dependencies[key] = value;
+        updated = true;
+      }
+    }
+    if (!existing.devDependencies)
+      existing.devDependencies = {};
+    for (const [key, value] of Object.entries(template.devDependencies)) {
+      if (!existing.devDependencies[key]) {
+        existing.devDependencies[key] = value;
+        updated = true;
+      }
+    }
+    if (updated) {
+      fs2.writeFileSync(packageJsonPath, JSON.stringify(existing, null, 2) + `
+`);
+      console.log(chalk.green("✓"), "Updated", packageJsonPath);
+    } else {
+      console.log(chalk.yellow("⚠"), packageJsonPath, "already has all required entries");
+    }
+  }
+  const configPath = path3.join(projectDir, "chronicle.yaml");
+  if (!fs2.existsSync(configPath)) {
+    fs2.writeFileSync(configPath, stringify(createConfig()));
+    console.log(chalk.green("✓"), "Created", configPath);
+  } else {
+    console.log(chalk.yellow("⚠"), configPath, "already exists");
+  }
+  const contentFiles = fs2.readdirSync(contentDir);
+  if (contentFiles.length === 0) {
+    const indexPath = path3.join(contentDir, "index.mdx");
+    fs2.writeFileSync(indexPath, sampleMdx);
+    console.log(chalk.green("✓"), "Created", indexPath);
+  }
+  const gitignorePath = path3.join(projectDir, ".gitignore");
+  const gitignoreEntries = ["node_modules", "dist"];
+  if (fs2.existsSync(gitignorePath)) {
+    const existing = fs2.readFileSync(gitignorePath, "utf-8");
+    const missing = gitignoreEntries.filter((e) => !existing.includes(e));
+    if (missing.length > 0) {
+      fs2.appendFileSync(gitignorePath, `
+${missing.join(`
+`)}
+`);
+      console.log(chalk.green("✓"), "Added", missing.join(", "), "to .gitignore");
+    }
+  } else {
+    fs2.writeFileSync(gitignorePath, `${gitignoreEntries.join(`
+`)}
+`);
+    console.log(chalk.green("✓"), "Created .gitignore");
+  }
+  const pm = detectPackageManager();
+  console.log(chalk.cyan(`
+Installing dependencies with ${pm}...`));
+  execSync(`${pm} install`, { cwd: projectDir, stdio: "inherit" });
+  const runCmd = pm === "npm" ? "npx" : pm === "bun" ? "bunx" : `${pm} dlx`;
+  console.log(chalk.green(`
+✓ Chronicle initialized!`));
+  console.log(`
+Run`, chalk.cyan(`${runCmd} chronicle dev`), "to start development server");
+});
+
+// src/cli/commands/dev.ts
+import { Command as Command2 } from "commander";
+import chalk4 from "chalk";
+
+// src/cli/utils/config.ts
+import path4 from "path";
+import { parse } from "yaml";
+import chalk2 from "chalk";
+function resolveContentDir(contentFlag) {
+  if (contentFlag)
+    return path4.resolve(contentFlag);
+  if (process.env.CHRONICLE_CONTENT_DIR)
+    return path4.resolve(process.env.CHRONICLE_CONTENT_DIR);
+  return path4.resolve("content");
+}
+
+// src/cli/commands/dev.ts
+var devCommand = new Command2("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action(async (options) => {
+  const contentDir = resolveContentDir(options.content);
+  const port = parseInt(options.port, 10);
+  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
+  process.env.CHRONICLE_CONTENT_DIR = contentDir;
+  console.log(chalk4.cyan("Starting dev server..."));
+  const { startDevServer: startDevServer2 } = await Promise.resolve().then(() => (init_dev(), exports_dev));
+  await startDevServer2({ port, root: PACKAGE_ROOT, contentDir });
+});
+
+// src/cli/commands/build.ts
+import { Command as Command3 } from "commander";
+import path7 from "path";
+import chalk5 from "chalk";
+var buildCommand = new Command3("build").description("Build for production").option("-c, --content <path>", "Content directory").option("-o, --outDir <path>", "Output directory", "dist").action(async (options) => {
+  const contentDir = resolveContentDir(options.content);
+  const outDir = path7.resolve(options.outDir);
+  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
+  process.env.CHRONICLE_CONTENT_DIR = contentDir;
+  console.log(chalk5.cyan("Building for production..."));
+  const { build } = await import("vite");
+  const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
+  const baseConfig = await createViteConfig2({ root: PACKAGE_ROOT, contentDir });
+  console.log(chalk5.gray("Building client..."));
+  await build({
+    ...baseConfig,
+    build: {
+      outDir: path7.join(outDir, "client"),
+      ssrManifest: true,
+      rolldownOptions: {
+        input: path7.resolve(PACKAGE_ROOT, "src/server/index.html")
+      }
+    }
+  });
+  console.log(chalk5.gray("Building server..."));
+  await build({
+    ...baseConfig,
+    ssr: {
+      noExternal: true
+    },
+    build: {
+      outDir: path7.join(outDir, "server"),
+      ssr: path7.resolve(PACKAGE_ROOT, "src/server/entry-prod.ts")
+    }
+  });
+  console.log(chalk5.green("Build complete →"), outDir);
+});
+
+// src/cli/commands/start.ts
+import { Command as Command4 } from "commander";
+import path9 from "path";
+import chalk7 from "chalk";
+var startCommand = new Command4("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").option("-d, --dist <path>", "Dist directory", "dist").action(async (options) => {
+  const contentDir = resolveContentDir(options.content);
+  const port = parseInt(options.port, 10);
+  const distDir = path9.resolve(options.dist);
+  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
+  process.env.CHRONICLE_CONTENT_DIR = contentDir;
+  console.log(chalk7.cyan("Starting production server..."));
+  const { startProdServer: startProdServer2 } = await Promise.resolve().then(() => (init_prod(), exports_prod));
+  await startProdServer2({ port, root: PACKAGE_ROOT, distDir });
+});
+
+// src/cli/commands/serve.ts
+import { Command as Command5 } from "commander";
+import path10 from "path";
+import chalk8 from "chalk";
+var serveCommand = new Command5("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").option("-o, --outDir <path>", "Output directory", "dist").action(async (options) => {
+  const contentDir = resolveContentDir(options.content);
+  const port = parseInt(options.port, 10);
+  const outDir = path10.resolve(options.outDir);
+  process.env.CHRONICLE_PROJECT_ROOT = process.cwd();
+  process.env.CHRONICLE_CONTENT_DIR = contentDir;
+  console.log(chalk8.cyan("Building for production..."));
+  const { build } = await import("vite");
+  const { createViteConfig: createViteConfig2 } = await Promise.resolve().then(() => (init_vite_config(), exports_vite_config));
+  const baseConfig = await createViteConfig2({ root: PACKAGE_ROOT, contentDir });
+  await build({
+    ...baseConfig,
+    build: {
+      outDir: path10.join(outDir, "client"),
+      ssrManifest: true,
+      rolldownOptions: {
+        input: path10.resolve(PACKAGE_ROOT, "src/server/index.html")
+      }
+    }
+  });
+  await build({
+    ...baseConfig,
+    ssr: {
+      noExternal: true
+    },
+    build: {
+      outDir: path10.join(outDir, "server"),
+      ssr: path10.resolve(PACKAGE_ROOT, "src/server/entry-prod.ts")
+    }
+  });
+  console.log(chalk8.cyan("Starting production server..."));
+  const { startProdServer: startProdServer2 } = await Promise.resolve().then(() => (init_prod(), exports_prod));
+  await startProdServer2({ port, root: PACKAGE_ROOT, distDir: outDir });
+});
+
+// src/cli/index.ts
+var program = new Command6;
+program.name("chronicle").description("Config-driven documentation framework").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(devCommand);
+program.addCommand(buildCommand);
+program.addCommand(startCommand);
+program.addCommand(serveCommand);
+program.parse();

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@raystack/chronicle",
+  "version": "0.1.0-canary.1f5227c",
+  "description": "Config-driven documentation framework",
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "templates",
+    "tsconfig.json"
+  ],
+  "bin": {
+    "chronicle": "./bin/chronicle.js"
+  },
+  "scripts": {
+    "build:cli": "bun build-cli.ts"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@raystack/tools-config": "0.56.0",
+    "@types/lodash": "^4.17.23",
+    "@types/mdx": "^2.0.13",
+    "@types/node": "^25.1.0",
+    "@types/react": "^19.2.10",
+    "@types/react-dom": "^19.2.3",
+    "@types/semver": "^7.7.1",
+    "semver": "^7.7.4",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/state": "^6.5.4",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.39.14",
+    "@heroicons/react": "^2.2.0",
+    "@mdx-js/rollup": "^3.1.1",
+    "@raystack/apsara": "^0.56.0",
+    "@vitejs/plugin-react": "^6.0.1",
+    "chalk": "^5.6.2",
+    "class-variance-authority": "^0.7.1",
+    "codemirror": "^6.0.2",
+    "commander": "^14.0.2",
+    "glob": "^11.0.0",
+    "gray-matter": "^4.0.3",
+    "lodash": "^4.17.23",
+    "mermaid": "^11.13.0",
+    "openapi-types": "^12.1.3",
+    "react": "^19.0.0",
+    "react-device-detect": "^2.2.3",
+    "react-dom": "^19.0.0",
+    "react-router-dom": "^7.13.1",
+    "remark-directive": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "@shikijs/rehype": "^4.0.2",
+    "remark-frontmatter": "^5.0.0",
+    "remark-mdx-frontmatter": "^5.2.0",
+    "satori": "^0.25.0",
+    "sirv": "^3.0.1",
+    "slugify": "^1.6.6",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.1.0",
+    "minisearch": "^7.2.0",
+    "vite": "^8.0.0",
+    "yaml": "^2.8.2"
+  }
+}

package/src/cli/__tests__/config.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest'
+import { resolveContentDir } from '../utils/config'
+
+describe('resolveContentDir', () => {
+  it('returns flag value when provided', () => {
+    const result = resolveContentDir('/custom/path')
+    expect(result).toBe('/custom/path')
+  })
+
+  it('returns env var when set', () => {
+    const original = process.env.CHRONICLE_CONTENT_DIR
+    process.env.CHRONICLE_CONTENT_DIR = '/env/content'
+    const result = resolveContentDir()
+    expect(result).toContain('env/content')
+    process.env.CHRONICLE_CONTENT_DIR = original
+  })
+
+  it('defaults to content directory', () => {
+    const original = process.env.CHRONICLE_CONTENT_DIR
+    delete process.env.CHRONICLE_CONTENT_DIR
+    const result = resolveContentDir()
+    expect(result).toContain('content')
+    process.env.CHRONICLE_CONTENT_DIR = original
+  })
+})

package/src/cli/__tests__/scaffold.test.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest'
+import { detectPackageManager } from '../utils/scaffold'
+
+describe('detectPackageManager', () => {
+  it('returns a string', () => {
+    const result = detectPackageManager()
+    expect(typeof result).toBe('string')
+    expect(['npm', 'bun', 'pnpm', 'yarn']).toContain(result)
+  })
+})