@raystack/chronicle 0.1.0-canary.e11f924 → 0.1.0-canary.f94fdd7

package/dist/cli/index.js

@@ -9044,8 +9044,9 @@ var {
 } = import__.default;
 
 // src/cli/commands/init.ts
-import fs from "fs";
-import path from "path";
+import { execSync as execSync2 } from "child_process";
+import fs3 from "fs";
+import path4 from "path";
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -9582,6 +9583,151 @@ var $stringify = publicApi.stringify;
 var $visit = visit.visit;
 var $visitAsync = visit.visitAsync;
 
+// src/cli/utils/config.ts
+import fs from "fs";
+import path from "path";
+function resolveConfigPath(contentDir) {
+  const cwdPath = path.join(process.cwd(), "chronicle.yaml");
+  if (fs.existsSync(cwdPath))
+    return cwdPath;
+  const contentPath = path.join(contentDir, "chronicle.yaml");
+  if (fs.existsSync(contentPath))
+    return contentPath;
+  return null;
+}
+function loadCLIConfig(contentDir) {
+  const configPath = resolveConfigPath(contentDir);
+  if (!configPath) {
+    console.log(source_default.red("Error: chronicle.yaml not found in"), process.cwd(), "or", contentDir);
+    console.log(source_default.gray(`Run 'chronicle init' to create one`));
+    process.exit(1);
+  }
+  const config = $parse(fs.readFileSync(configPath, "utf-8"));
+  return {
+    config,
+    configPath,
+    contentDir
+  };
+}
+// src/cli/utils/process.ts
+function attachLifecycleHandlers(child) {
+  child.on("close", (code) => process.exit(code ?? 0));
+  process.on("SIGINT", () => child.kill("SIGINT"));
+  process.on("SIGTERM", () => child.kill("SIGTERM"));
+}
+// src/cli/utils/scaffold.ts
+import { execSync } from "child_process";
+import { createRequire as createRequire2 } from "module";
+import fs2 from "fs";
+import path3 from "path";
+
+// src/cli/utils/resolve.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+// src/cli/utils/scaffold.ts
+var COPY_FILES = ["src", "source.config.ts", "tsconfig.json"];
+function copyRecursive(src, dest) {
+  const stat = fs2.statSync(src);
+  if (stat.isDirectory()) {
+    fs2.mkdirSync(dest, { recursive: true });
+    for (const entry of fs2.readdirSync(src)) {
+      copyRecursive(path3.join(src, entry), path3.join(dest, entry));
+    }
+  } else {
+    fs2.copyFileSync(src, dest);
+  }
+}
+function ensureRemoved(targetPath) {
+  try {
+    fs2.lstatSync(targetPath);
+    fs2.rmSync(targetPath, { recursive: true, force: true });
+  } catch {}
+}
+function detectPackageManager() {
+  if (process.env.npm_config_user_agent) {
+    return process.env.npm_config_user_agent.split("/")[0];
+  }
+  const cwd = process.cwd();
+  if (fs2.existsSync(path3.join(cwd, "bun.lock")) || fs2.existsSync(path3.join(cwd, "bun.lockb")))
+    return "bun";
+  if (fs2.existsSync(path3.join(cwd, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (fs2.existsSync(path3.join(cwd, "yarn.lock")))
+    return "yarn";
+  return "npm";
+}
+function generateNextConfig(scaffoldPath) {
+  const config = `import { createMDX } from 'fumadocs-mdx/next'
+
+const withMDX = createMDX()
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+}
+
+export default withMDX(nextConfig)
+`;
+  fs2.writeFileSync(path3.join(scaffoldPath, "next.config.mjs"), config);
+}
+function createPackageJson() {
+  return {
+    name: "chronicle-docs",
+    private: true,
+    dependencies: {
+      "@raystack/chronicle": "latest"
+    },
+    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"
+    }
+  };
+}
+function ensureDeps() {
+  const cwd = process.cwd();
+  const cwdPkgJson = path3.join(cwd, "package.json");
+  const cwdNodeModules = path3.join(cwd, "node_modules");
+  if (fs2.existsSync(cwdPkgJson) && fs2.existsSync(cwdNodeModules)) {
+    return;
+  }
+  if (!fs2.existsSync(cwdPkgJson)) {
+    fs2.writeFileSync(cwdPkgJson, JSON.stringify(createPackageJson(), null, 2) + `
+`);
+  }
+  if (!fs2.existsSync(cwdNodeModules)) {
+    const pm = detectPackageManager();
+    console.log(source_default.cyan(`Installing dependencies with ${pm}...`));
+    execSync(`${pm} install`, { cwd, stdio: "inherit" });
+  }
+}
+function resolveNextCli() {
+  const cwdRequire = createRequire2(path3.join(process.cwd(), "package.json"));
+  return cwdRequire.resolve("next/dist/bin/next");
+}
+function scaffoldDir(contentDir) {
+  const scaffoldPath = path3.join(process.cwd(), ".chronicle");
+  if (!fs2.existsSync(scaffoldPath)) {
+    fs2.mkdirSync(scaffoldPath, { recursive: true });
+  }
+  for (const name of COPY_FILES) {
+    const src = path3.join(PACKAGE_ROOT, name);
+    const dest = path3.join(scaffoldPath, name);
+    ensureRemoved(dest);
+    copyRecursive(src, dest);
+  }
+  generateNextConfig(scaffoldPath);
+  const contentLink = path3.join(scaffoldPath, "content");
+  ensureRemoved(contentLink);
+  fs2.symlinkSync(path3.resolve(contentDir), contentLink);
+  ensureDeps();
+  console.log(source_default.gray(`Scaffold: ${scaffoldPath}`));
+  return scaffoldPath;
+}
 // src/cli/commands/init.ts
 function createConfig() {
   return {
@@ -9591,6 +9737,27 @@ function createConfig() {
     search: { enabled: true, placeholder: "Search documentation..." }
   };
 }
+function createPackageJson2(name) {
+  return {
+    name,
+    private: true,
+    scripts: {
+      dev: "chronicle dev",
+      build: "chronicle build",
+      start: "chronicle start"
+    },
+    dependencies: {
+      "@raystack/chronicle": "latest"
+    },
+    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
@@ -9601,90 +9768,82 @@ order: 1
 
 This is your documentation home page.
 `;
-var initCommand = new Command("init").description("Initialize a new Chronicle project").option("-d, --dir <path>", "Content directory", ".").action((options) => {
-  const contentDir = path.resolve(options.dir);
-  if (!fs.existsSync(contentDir)) {
-    fs.mkdirSync(contentDir, { recursive: true });
+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 = path4.basename(projectDir) || "docs";
+  const contentDir = path4.join(projectDir, options.content);
+  if (!fs3.existsSync(contentDir)) {
+    fs3.mkdirSync(contentDir, { recursive: true });
     console.log(source_default.green("✓"), "Created", contentDir);
   }
-  const configPath = path.join(contentDir, "chronicle.yaml");
-  if (!fs.existsSync(configPath)) {
-    fs.writeFileSync(configPath, $stringify(createConfig()));
+  const packageJsonPath = path4.join(projectDir, "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    fs3.writeFileSync(packageJsonPath, JSON.stringify(createPackageJson2(dirName), null, 2) + `
+`);
+    console.log(source_default.green("✓"), "Created", packageJsonPath);
+  } else {
+    console.log(source_default.yellow("⚠"), packageJsonPath, "already exists");
+  }
+  const configPath = path4.join(projectDir, "chronicle.yaml");
+  if (!fs3.existsSync(configPath)) {
+    fs3.writeFileSync(configPath, $stringify(createConfig()));
     console.log(source_default.green("✓"), "Created", configPath);
   } else {
     console.log(source_default.yellow("⚠"), configPath, "already exists");
   }
-  const indexPath = path.join(contentDir, "index.mdx");
-  if (!fs.existsSync(indexPath)) {
-    fs.writeFileSync(indexPath, sampleMdx);
+  const contentFiles = fs3.readdirSync(contentDir);
+  if (contentFiles.length === 0) {
+    const indexPath = path4.join(contentDir, "index.mdx");
+    fs3.writeFileSync(indexPath, sampleMdx);
     console.log(source_default.green("✓"), "Created", indexPath);
   }
+  const gitignorePath = path4.join(projectDir, ".gitignore");
+  const chronicleEntry = ".chronicle";
+  if (fs3.existsSync(gitignorePath)) {
+    const existing = fs3.readFileSync(gitignorePath, "utf-8");
+    if (!existing.includes(chronicleEntry)) {
+      fs3.appendFileSync(gitignorePath, `
+${chronicleEntry}
+`);
+      console.log(source_default.green("✓"), "Added .chronicle to .gitignore");
+    }
+  } else {
+    fs3.writeFileSync(gitignorePath, `${chronicleEntry}
+`);
+    console.log(source_default.green("✓"), "Created .gitignore with .chronicle");
+  }
+  const pm = detectPackageManager();
+  console.log(source_default.cyan(`
+Installing dependencies with ${pm}...`));
+  execSync2(`${pm} install`, { cwd: projectDir, stdio: "inherit" });
+  loadCLIConfig(contentDir);
+  scaffoldDir(contentDir);
+  const runCmd = pm === "npm" ? "npx" : pm === "bun" ? "bunx" : `${pm} dlx`;
   console.log(source_default.green(`
 ✓ Chronicle initialized!`));
   console.log(`
-Run`, source_default.cyan("chronicle dev"), "to start development server");
+Run`, source_default.cyan(`${runCmd} chronicle dev`), "to start development server");
 });
 
 // src/cli/commands/dev.ts
 import { spawn } from "child_process";
-import path3 from "path";
-import { fileURLToPath } from "url";
-import { createRequire as createRequire2 } from "module";
-
-// src/cli/utils/config.ts
-import fs2 from "fs";
-import path2 from "path";
-function resolveContentDir(contentFlag) {
-  if (contentFlag)
-    return path2.resolve(contentFlag);
-  if (process.env.CHRONICLE_CONTENT_DIR)
-    return path2.resolve(process.env.CHRONICLE_CONTENT_DIR);
-  return process.cwd();
-}
-function resolveConfigPath(contentDir) {
-  const cwdPath = path2.join(process.cwd(), "chronicle.yaml");
-  if (fs2.existsSync(cwdPath))
-    return cwdPath;
-  const contentPath = path2.join(contentDir, "chronicle.yaml");
-  if (fs2.existsSync(contentPath))
-    return contentPath;
-  return null;
-}
-function loadCLIConfig(contentDir) {
-  const configPath = resolveConfigPath(contentDir);
-  if (!configPath) {
-    console.log(source_default.red("Error: chronicle.yaml not found in"), process.cwd(), "or", contentDir);
-    console.log(source_default.gray(`Run 'chronicle init' to create one`));
+import path5 from "path";
+import fs4 from "fs";
+var devCommand = new Command("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").action((options) => {
+  const scaffoldPath = path5.join(process.cwd(), ".chronicle");
+  if (!fs4.existsSync(scaffoldPath)) {
+    console.log(source_default.red("Error: .chronicle/ not found. Run"), source_default.cyan("chronicle init"), source_default.red("first."));
     process.exit(1);
   }
-  const config = $parse(fs2.readFileSync(configPath, "utf-8"));
-  return {
-    config,
-    configPath,
-    contentDir
-  };
-}
-// src/cli/utils/process.ts
-function attachLifecycleHandlers(child) {
-  child.on("close", (code) => process.exit(code ?? 0));
-  process.on("SIGINT", () => child.kill("SIGINT"));
-  process.on("SIGTERM", () => child.kill("SIGTERM"));
-}
-// src/cli/commands/dev.ts
-var require2 = createRequire2(import.meta.url);
-var PACKAGE_ROOT = path3.resolve(path3.dirname(fileURLToPath(import.meta.url)), "..", "..");
-var nextCli = require2.resolve("next/dist/bin/next");
-var devCommand = new Command("dev").description("Start development server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action((options) => {
-  const contentDir = resolveContentDir(options.content);
-  loadCLIConfig(contentDir);
+  const nextCli = resolveNextCli();
   console.log(source_default.cyan("Starting dev server..."));
-  console.log(source_default.gray(`Content: ${contentDir}`));
   const child = spawn(process.execPath, [nextCli, "dev", "-p", options.port], {
     stdio: "inherit",
-    cwd: PACKAGE_ROOT,
+    cwd: scaffoldPath,
     env: {
       ...process.env,
-      CHRONICLE_CONTENT_DIR: contentDir
+      CHRONICLE_PROJECT_ROOT: process.cwd(),
+      CHRONICLE_CONTENT_DIR: "./content"
     }
   });
   attachLifecycleHandlers(child);
@@ -9692,23 +9851,23 @@ var devCommand = new Command("dev").description("Start development server").opti
 
 // src/cli/commands/build.ts
 import { spawn as spawn2 } from "child_process";
-import path4 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { createRequire as createRequire3 } from "module";
-var require3 = createRequire3(import.meta.url);
-var PACKAGE_ROOT2 = path4.resolve(path4.dirname(fileURLToPath2(import.meta.url)), "..", "..");
-var nextCli2 = require3.resolve("next/dist/bin/next");
-var buildCommand = new Command("build").description("Build for production").option("-c, --content <path>", "Content directory").action((options) => {
-  const contentDir = resolveContentDir(options.content);
-  loadCLIConfig(contentDir);
+import path6 from "path";
+import fs5 from "fs";
+var buildCommand = new Command("build").description("Build for production").action(() => {
+  const scaffoldPath = path6.join(process.cwd(), ".chronicle");
+  if (!fs5.existsSync(scaffoldPath)) {
+    console.log(source_default.red("Error: .chronicle/ not found. Run"), source_default.cyan("chronicle init"), source_default.red("first."));
+    process.exit(1);
+  }
+  const nextCli = resolveNextCli();
   console.log(source_default.cyan("Building for production..."));
-  console.log(source_default.gray(`Content: ${contentDir}`));
-  const child = spawn2(process.execPath, [nextCli2, "build"], {
+  const child = spawn2(process.execPath, [nextCli, "build"], {
     stdio: "inherit",
-    cwd: PACKAGE_ROOT2,
+    cwd: scaffoldPath,
     env: {
       ...process.env,
-      CHRONICLE_CONTENT_DIR: contentDir
+      CHRONICLE_PROJECT_ROOT: process.cwd(),
+      CHRONICLE_CONTENT_DIR: "./content"
     }
   });
   attachLifecycleHandlers(child);
@@ -9716,23 +9875,23 @@ var buildCommand = new Command("build").description("Build for production").opti
 
 // src/cli/commands/start.ts
 import { spawn as spawn3 } from "child_process";
-import path5 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { createRequire as createRequire4 } from "module";
-var require4 = createRequire4(import.meta.url);
-var PACKAGE_ROOT3 = path5.resolve(path5.dirname(fileURLToPath3(import.meta.url)), "..", "..");
-var nextCli3 = require4.resolve("next/dist/bin/next");
-var startCommand = new Command("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action((options) => {
-  const contentDir = resolveContentDir(options.content);
-  loadCLIConfig(contentDir);
+import path7 from "path";
+import fs6 from "fs";
+var startCommand = new Command("start").description("Start production server").option("-p, --port <port>", "Port number", "3000").action((options) => {
+  const scaffoldPath = path7.join(process.cwd(), ".chronicle");
+  if (!fs6.existsSync(scaffoldPath)) {
+    console.log(source_default.red("Error: .chronicle/ not found. Run"), source_default.cyan("chronicle init"), source_default.red("first."));
+    process.exit(1);
+  }
+  const nextCli = resolveNextCli();
   console.log(source_default.cyan("Starting production server..."));
-  console.log(source_default.gray(`Content: ${contentDir}`));
-  const child = spawn3(process.execPath, [nextCli3, "start", "-p", options.port], {
+  const child = spawn3(process.execPath, [nextCli, "start", "-p", options.port], {
     stdio: "inherit",
-    cwd: PACKAGE_ROOT3,
+    cwd: scaffoldPath,
     env: {
       ...process.env,
-      CHRONICLE_CONTENT_DIR: contentDir
+      CHRONICLE_PROJECT_ROOT: process.cwd(),
+      CHRONICLE_CONTENT_DIR: "./content"
     }
   });
   attachLifecycleHandlers(child);
@@ -9740,24 +9899,24 @@ var startCommand = new Command("start").description("Start production server").o
 
 // src/cli/commands/serve.ts
 import { spawn as spawn4 } from "child_process";
-import path6 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { createRequire as createRequire5 } from "module";
-var require5 = createRequire5(import.meta.url);
-var PACKAGE_ROOT4 = path6.resolve(path6.dirname(fileURLToPath4(import.meta.url)), "..", "..");
-var nextCli4 = require5.resolve("next/dist/bin/next");
-var serveCommand = new Command("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").option("-c, --content <path>", "Content directory").action((options) => {
-  const contentDir = resolveContentDir(options.content);
-  loadCLIConfig(contentDir);
+import path8 from "path";
+import fs7 from "fs";
+var serveCommand = new Command("serve").description("Build and start production server").option("-p, --port <port>", "Port number", "3000").action((options) => {
+  const scaffoldPath = path8.join(process.cwd(), ".chronicle");
+  if (!fs7.existsSync(scaffoldPath)) {
+    console.log(source_default.red("Error: .chronicle/ not found. Run"), source_default.cyan("chronicle init"), source_default.red("first."));
+    process.exit(1);
+  }
+  const nextCli = resolveNextCli();
   const env2 = {
     ...process.env,
-    CHRONICLE_CONTENT_DIR: contentDir
+    CHRONICLE_PROJECT_ROOT: process.cwd(),
+    CHRONICLE_CONTENT_DIR: "./content"
   };
   console.log(source_default.cyan("Building for production..."));
-  console.log(source_default.gray(`Content: ${contentDir}`));
-  const buildChild = spawn4(process.execPath, [nextCli4, "build"], {
+  const buildChild = spawn4(process.execPath, [nextCli, "build"], {
     stdio: "inherit",
-    cwd: PACKAGE_ROOT4,
+    cwd: scaffoldPath,
     env: env2
   });
   process.once("SIGINT", () => buildChild.kill("SIGINT"));
@@ -9768,9 +9927,9 @@ var serveCommand = new Command("serve").description("Build and start production
       process.exit(code ?? 1);
     }
     console.log(source_default.cyan("Starting production server..."));
-    const startChild = spawn4(process.execPath, [nextCli4, "start", "-p", options.port], {
+    const startChild = spawn4(process.execPath, [nextCli, "start", "-p", options.port], {
       stdio: "inherit",
-      cwd: PACKAGE_ROOT4,
+      cwd: scaffoldPath,
       env: env2
     });
     attachLifecycleHandlers(startChild);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raystack/chronicle",
-  "version": "0.1.0-canary.e11f924",
+  "version": "0.1.0-canary.f94fdd7",
   "description": "Config-driven documentation framework",
   "license": "Apache-2.0",
   "type": "module",
@@ -10,7 +10,8 @@
     "src",
     "templates",
     "next.config.mjs",
-    "source.config.ts"
+    "source.config.ts",
+    "tsconfig.json"
   ],
   "bin": {
     "chronicle": "./bin/chronicle.js"
@@ -27,7 +28,6 @@
     "@types/react": "^19.2.10",
     "@types/react-dom": "^19.2.3",
     "@types/semver": "^7.7.1",
-    "openapi-types": "^12.1.3",
     "semver": "^7.7.4",
     "typescript": "5.9.3"
   },
@@ -56,6 +56,7 @@
     "slugify": "^1.6.6",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.1.0",
+    "openapi-types": "^12.1.3",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
   }

package/src/cli/commands/build.ts

@@ -1,31 +1,30 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
-import { fileURLToPath } from 'url'
-import { createRequire } from 'module'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-const require = createRequire(import.meta.url)
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')
-const nextCli = require.resolve('next/dist/bin/next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const buildCommand = new Command('build')
   .description('Build for production')
-  .option('-c, --content <path>', 'Content directory')
-  .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+  .action(() => {
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    const nextCli = resolveNextCli()
 
     console.log(chalk.cyan('Building for production...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
     const child = spawn(process.execPath, [nextCli, 'build'], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env: {
         ...process.env,
-        CHRONICLE_CONTENT_DIR: contentDir,
+        CHRONICLE_PROJECT_ROOT: process.cwd(),
+        CHRONICLE_CONTENT_DIR: './content',
       },
     })
 

package/src/cli/commands/dev.ts

@@ -1,32 +1,31 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
-import { fileURLToPath } from 'url'
-import { createRequire } from 'module'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-const require = createRequire(import.meta.url)
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')
-const nextCli = require.resolve('next/dist/bin/next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const devCommand = new Command('dev')
   .description('Start development server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('-c, --content <path>', 'Content directory')
   .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    const nextCli = resolveNextCli()
 
     console.log(chalk.cyan('Starting dev server...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
     const child = spawn(process.execPath, [nextCli, 'dev', '-p', options.port], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env: {
         ...process.env,
-        CHRONICLE_CONTENT_DIR: contentDir,
+        CHRONICLE_PROJECT_ROOT: process.cwd(),
+        CHRONICLE_CONTENT_DIR: './content',
       },
     })
 

package/src/cli/commands/init.ts

@@ -1,9 +1,12 @@
 import { Command } from 'commander'
+import { execSync } from 'child_process'
 import fs from 'fs'
 import path from 'path'
 import chalk from 'chalk'
 import { stringify } from 'yaml'
 import type { ChronicleConfig } from '@/types'
+import { loadCLIConfig, scaffoldDir, detectPackageManager } from '@/cli/utils'
+
 
 function createConfig(): ChronicleConfig {
   return {
@@ -14,6 +17,28 @@ function createConfig(): ChronicleConfig {
   }
 }
 
+function createPackageJson(name: string): Record<string, unknown> {
+  return {
+    name,
+    private: true,
+    scripts: {
+      dev: 'chronicle dev',
+      build: 'chronicle build',
+      start: 'chronicle start',
+    },
+    dependencies: {
+      '@raystack/chronicle': 'latest',
+    },
+    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',
+    },
+  }
+}
+
 const sampleMdx = `---
 title: Welcome
 description: Getting started with your documentation
@@ -27,18 +52,29 @@ This is your documentation home page.
 
 export const initCommand = new Command('init')
   .description('Initialize a new Chronicle project')
-  .option('-d, --dir <path>', 'Content directory', '.')
+  .option('-c, --content <path>', 'Content directory name', 'content')
   .action((options) => {
-    const contentDir = path.resolve(options.dir)
+    const projectDir = process.cwd()
+    const dirName = path.basename(projectDir) || 'docs'
+    const contentDir = path.join(projectDir, options.content)
 
-    // Create content directory
+    // Create content directory if it doesn't exist
     if (!fs.existsSync(contentDir)) {
       fs.mkdirSync(contentDir, { recursive: true })
       console.log(chalk.green('✓'), 'Created', contentDir)
     }
 
-    // Create chronicle.yaml
-    const configPath = path.join(contentDir, 'chronicle.yaml')
+    // Create package.json in project root
+    const packageJsonPath = path.join(projectDir, 'package.json')
+    if (!fs.existsSync(packageJsonPath)) {
+      fs.writeFileSync(packageJsonPath, JSON.stringify(createPackageJson(dirName), null, 2) + '\n')
+      console.log(chalk.green('✓'), 'Created', packageJsonPath)
+    } else {
+      console.log(chalk.yellow('⚠'), packageJsonPath, 'already exists')
+    }
+
+    // Create chronicle.yaml in project root
+    const configPath = path.join(projectDir, 'chronicle.yaml')
     if (!fs.existsSync(configPath)) {
       fs.writeFileSync(configPath, stringify(createConfig()))
       console.log(chalk.green('✓'), 'Created', configPath)
@@ -46,13 +82,38 @@ export const initCommand = new Command('init')
       console.log(chalk.yellow('⚠'), configPath, 'already exists')
     }
 
-    // Create sample index.mdx
-    const indexPath = path.join(contentDir, 'index.mdx')
-    if (!fs.existsSync(indexPath)) {
+    // Create sample index.mdx only if content dir is empty
+    const contentFiles = fs.readdirSync(contentDir)
+    if (contentFiles.length === 0) {
+      const indexPath = path.join(contentDir, 'index.mdx')
       fs.writeFileSync(indexPath, sampleMdx)
       console.log(chalk.green('✓'), 'Created', indexPath)
     }
 
+    // Add .chronicle to .gitignore
+    const gitignorePath = path.join(projectDir, '.gitignore')
+    const chronicleEntry = '.chronicle'
+    if (fs.existsSync(gitignorePath)) {
+      const existing = fs.readFileSync(gitignorePath, 'utf-8')
+      if (!existing.includes(chronicleEntry)) {
+        fs.appendFileSync(gitignorePath, `\n${chronicleEntry}\n`)
+        console.log(chalk.green('✓'), 'Added .chronicle to .gitignore')
+      }
+    } else {
+      fs.writeFileSync(gitignorePath, `${chronicleEntry}\n`)
+      console.log(chalk.green('✓'), 'Created .gitignore with .chronicle')
+    }
+
+    // Install dependencies
+    const pm = detectPackageManager()
+    console.log(chalk.cyan(`\nInstalling dependencies with ${pm}...`))
+    execSync(`${pm} install`, { cwd: projectDir, stdio: 'inherit' })
+
+    // Scaffold .chronicle/ directory
+    loadCLIConfig(contentDir)
+    scaffoldDir(contentDir)
+
+    const runCmd = pm === 'npm' ? 'npx' : pm === 'bun' ? 'bunx' : `${pm} dlx`
     console.log(chalk.green('\n✓ Chronicle initialized!'))
-    console.log('\nRun', chalk.cyan('chronicle dev'), 'to start development server')
+    console.log('\nRun', chalk.cyan(`${runCmd} chronicle dev`), 'to start development server')
   })

package/src/cli/commands/serve.ts

@@ -1,34 +1,33 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
-import { fileURLToPath } from 'url'
-import { createRequire } from 'module'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-const require = createRequire(import.meta.url)
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')
-const nextCli = require.resolve('next/dist/bin/next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const serveCommand = new Command('serve')
   .description('Build and start production server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('-c, --content <path>', 'Content directory')
   .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    const nextCli = resolveNextCli()
 
     const env = {
       ...process.env,
-      CHRONICLE_CONTENT_DIR: contentDir,
+      CHRONICLE_PROJECT_ROOT: process.cwd(),
+      CHRONICLE_CONTENT_DIR: './content',
     }
 
     console.log(chalk.cyan('Building for production...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
     const buildChild = spawn(process.execPath, [nextCli, 'build'], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env,
     })
 
@@ -45,7 +44,7 @@ export const serveCommand = new Command('serve')
 
       const startChild = spawn(process.execPath, [nextCli, 'start', '-p', options.port], {
         stdio: 'inherit',
-        cwd: PACKAGE_ROOT,
+        cwd: scaffoldPath,
         env,
       })
 

package/src/cli/commands/start.ts

@@ -1,32 +1,31 @@
 import { Command } from 'commander'
 import { spawn } from 'child_process'
 import path from 'path'
-import { fileURLToPath } from 'url'
-import { createRequire } from 'module'
+import fs from 'fs'
 import chalk from 'chalk'
-import { resolveContentDir, loadCLIConfig, attachLifecycleHandlers } from '@/cli/utils'
-
-const require = createRequire(import.meta.url)
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')
-const nextCli = require.resolve('next/dist/bin/next')
+import { attachLifecycleHandlers, resolveNextCli } from '@/cli/utils'
 
 export const startCommand = new Command('start')
   .description('Start production server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('-c, --content <path>', 'Content directory')
   .action((options) => {
-    const contentDir = resolveContentDir(options.content)
-    loadCLIConfig(contentDir)
+    const scaffoldPath = path.join(process.cwd(), '.chronicle')
+    if (!fs.existsSync(scaffoldPath)) {
+      console.log(chalk.red('Error: .chronicle/ not found. Run'), chalk.cyan('chronicle init'), chalk.red('first.'))
+      process.exit(1)
+    }
+
+    const nextCli = resolveNextCli()
 
     console.log(chalk.cyan('Starting production server...'))
-    console.log(chalk.gray(`Content: ${contentDir}`))
 
     const child = spawn(process.execPath, [nextCli, 'start', '-p', options.port], {
       stdio: 'inherit',
-      cwd: PACKAGE_ROOT,
+      cwd: scaffoldPath,
       env: {
         ...process.env,
-        CHRONICLE_CONTENT_DIR: contentDir,
+        CHRONICLE_PROJECT_ROOT: process.cwd(),
+        CHRONICLE_CONTENT_DIR: './content',
       },
     })
 

package/src/cli/utils/config.ts

@@ -13,7 +13,7 @@ export interface CLIConfig {
 export function resolveContentDir(contentFlag?: string): string {
   if (contentFlag) return path.resolve(contentFlag)
   if (process.env.CHRONICLE_CONTENT_DIR) return path.resolve(process.env.CHRONICLE_CONTENT_DIR)
-  return process.cwd()
+  return path.resolve('content')
 }
 
 function resolveConfigPath(contentDir: string): string | null {

package/src/cli/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './config'
 export * from './process'
+export * from './scaffold'

package/src/cli/utils/resolve.ts

@@ -0,0 +1,4 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+export const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..')

package/src/cli/utils/scaffold.ts

@@ -0,0 +1,131 @@
+import { execSync } from 'child_process'
+import { createRequire } from 'module'
+import fs from 'fs'
+import path from 'path'
+import chalk from 'chalk'
+import { PACKAGE_ROOT } from './resolve'
+
+const COPY_FILES = ['src', 'source.config.ts', 'tsconfig.json']
+
+function copyRecursive(src: string, dest: string) {
+  const stat = fs.statSync(src)
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true })
+    for (const entry of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, entry), path.join(dest, entry))
+    }
+  } else {
+    fs.copyFileSync(src, dest)
+  }
+}
+
+function ensureRemoved(targetPath: string) {
+  try {
+    fs.lstatSync(targetPath)
+    fs.rmSync(targetPath, { recursive: true, force: true })
+  } catch {
+    // nothing exists, proceed
+  }
+}
+
+export function detectPackageManager(): string {
+  if (process.env.npm_config_user_agent) {
+    return process.env.npm_config_user_agent.split('/')[0]
+  }
+  const cwd = process.cwd()
+  if (fs.existsSync(path.join(cwd, 'bun.lock')) || fs.existsSync(path.join(cwd, 'bun.lockb'))) return 'bun'
+  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn'
+  return 'npm'
+}
+
+function generateNextConfig(scaffoldPath: string) {
+  const config = `import { createMDX } from 'fumadocs-mdx/next'
+
+const withMDX = createMDX()
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  reactStrictMode: true,
+}
+
+export default withMDX(nextConfig)
+`
+  fs.writeFileSync(path.join(scaffoldPath, 'next.config.mjs'), config)
+}
+
+function createPackageJson(): Record<string, unknown> {
+  return {
+    name: 'chronicle-docs',
+    private: true,
+    dependencies: {
+      '@raystack/chronicle': 'latest',
+    },
+    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',
+    },
+  }
+}
+
+function ensureDeps() {
+  const cwd = process.cwd()
+  const cwdPkgJson = path.join(cwd, 'package.json')
+  const cwdNodeModules = path.join(cwd, 'node_modules')
+
+  if (fs.existsSync(cwdPkgJson) && fs.existsSync(cwdNodeModules)) {
+    // Case 1: existing project with deps installed
+    return
+  }
+
+  // Case 2: no package.json — create in cwd and install
+  if (!fs.existsSync(cwdPkgJson)) {
+    fs.writeFileSync(cwdPkgJson, JSON.stringify(createPackageJson(), null, 2) + '\n')
+  }
+
+  if (!fs.existsSync(cwdNodeModules)) {
+    const pm = detectPackageManager()
+    console.log(chalk.cyan(`Installing dependencies with ${pm}...`))
+    execSync(`${pm} install`, { cwd, stdio: 'inherit' })
+  }
+}
+
+export function resolveNextCli(): string {
+  const cwdRequire = createRequire(path.join(process.cwd(), 'package.json'))
+  return cwdRequire.resolve('next/dist/bin/next')
+}
+
+export function scaffoldDir(contentDir: string): string {
+  const scaffoldPath = path.join(process.cwd(), '.chronicle')
+
+  // Create .chronicle/ if not exists
+  if (!fs.existsSync(scaffoldPath)) {
+    fs.mkdirSync(scaffoldPath, { recursive: true })
+  }
+
+  // Copy package files
+  for (const name of COPY_FILES) {
+    const src = path.join(PACKAGE_ROOT, name)
+    const dest = path.join(scaffoldPath, name)
+    ensureRemoved(dest)
+    copyRecursive(src, dest)
+  }
+
+  // Generate next.config.mjs
+  generateNextConfig(scaffoldPath)
+
+  // Symlink content dir
+  const contentLink = path.join(scaffoldPath, 'content')
+  ensureRemoved(contentLink)
+  fs.symlinkSync(path.resolve(contentDir), contentLink)
+
+  // Ensure dependencies are available
+  ensureDeps()
+
+  console.log(chalk.gray(`Scaffold: ${scaffoldPath}`))
+
+  return scaffoldPath
+}

package/src/lib/config.ts

@@ -12,8 +12,16 @@ const defaultConfig: ChronicleConfig = {
 }
 
 function resolveConfigPath(): string | null {
+  // Check project root via env var
+  const projectRoot = process.env.CHRONICLE_PROJECT_ROOT
+  if (projectRoot) {
+    const rootPath = path.join(projectRoot, CONFIG_FILE)
+    if (fs.existsSync(rootPath)) return rootPath
+  }
+  // Check cwd
   const cwdPath = path.join(process.cwd(), CONFIG_FILE)
   if (fs.existsSync(cwdPath)) return cwdPath
+  // Check content dir
   const contentDir = process.env.CHRONICLE_CONTENT_DIR
   if (contentDir) {
     const contentPath = path.join(contentDir, CONFIG_FILE)

package/src/lib/source.ts

@@ -1,4 +1,4 @@
-import { docs } from '../../.source/server'
+import { docs } from '@/.source/server'
 import { loader } from 'fumadocs-core/source'
 import type { PageTree, PageTreeItem, Frontmatter } from '@/types'
 

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "composite": false,
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "inlineSources": false,
+    "isolatedModules": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "module": "ESNext",
+    "target": "es6",
+    "outDir": "dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "moduleResolution": "bundler",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@/.source/*": ["./.source/*"]
+    }
+  },
+  "include": ["src", ".source", "source.config.ts"],
+  "exclude": ["node_modules", "dist"]
+}