nextblogkit 0.6.0

package/dist/cli/index.cjs

@@ -0,0 +1,1308 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  defineConfig: () => defineConfig,
+  getBlogConfig: () => getBlogConfig,
+  getConfig: () => getConfig,
+  getEnvConfig: () => getEnvConfig
+});
+function getEnvConfig() {
+  if (cachedEnv) return cachedEnv;
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    const missing = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`);
+    throw new Error(`NextBlogKit configuration error:
+${missing.join("\n")}`);
+  }
+  cachedEnv = result.data;
+  return cachedEnv;
+}
+function defineConfig(config) {
+  return config;
+}
+function getConfig(userConfig) {
+  if (cachedConfig && !userConfig) return cachedConfig;
+  const merged = {
+    ...defaultConfig,
+    ...userConfig,
+    editor: { ...defaultConfig.editor, ...userConfig?.editor },
+    seo: { ...defaultConfig.seo, ...userConfig?.seo },
+    auth: { ...defaultConfig.auth, ...userConfig?.auth },
+    features: { ...defaultConfig.features, ...userConfig?.features },
+    theme: {
+      ...defaultConfig.theme,
+      ...userConfig?.theme,
+      variables: { ...defaultConfig.theme.variables, ...userConfig?.theme?.variables }
+    },
+    hooks: { ...defaultConfig.hooks, ...userConfig?.hooks }
+  };
+  if (!userConfig) {
+    cachedConfig = merged;
+  }
+  return merged;
+}
+function getBlogConfig() {
+  const env = getEnvConfig();
+  const config = getConfig();
+  return {
+    ...config,
+    siteUrl: env.NEXTBLOGKIT_SITE_URL,
+    siteName: env.NEXTBLOGKIT_SITE_NAME,
+    metadata: {
+      title: `Blog | ${env.NEXTBLOGKIT_SITE_NAME}`,
+      description: `Latest posts from ${env.NEXTBLOGKIT_SITE_NAME}`,
+      openGraph: {
+        title: `Blog | ${env.NEXTBLOGKIT_SITE_NAME}`,
+        description: `Latest posts from ${env.NEXTBLOGKIT_SITE_NAME}`,
+        url: `${env.NEXTBLOGKIT_SITE_URL}${config.basePath}`,
+        siteName: env.NEXTBLOGKIT_SITE_NAME,
+        type: "website"
+      }
+    }
+  };
+}
+var import_zod, envSchema, cachedEnv, defaultConfig, cachedConfig;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    envSchema = import_zod.z.object({
+      NEXTBLOGKIT_MONGODB_URI: import_zod.z.string().min(1, "MongoDB URI is required"),
+      NEXTBLOGKIT_R2_ACCOUNT_ID: import_zod.z.string().min(1, "R2 Account ID is required"),
+      NEXTBLOGKIT_R2_ACCESS_KEY: import_zod.z.string().min(1, "R2 Access Key is required"),
+      NEXTBLOGKIT_R2_SECRET_KEY: import_zod.z.string().min(1, "R2 Secret Key is required"),
+      NEXTBLOGKIT_R2_BUCKET: import_zod.z.string().min(1, "R2 Bucket name is required"),
+      NEXTBLOGKIT_R2_PUBLIC_URL: import_zod.z.string().url("R2 Public URL must be a valid URL"),
+      NEXTBLOGKIT_API_KEY: import_zod.z.string().min(32, "API key must be at least 32 characters"),
+      NEXTBLOGKIT_SITE_URL: import_zod.z.string().url("Site URL must be a valid URL"),
+      NEXTBLOGKIT_SITE_NAME: import_zod.z.string().min(1, "Site name is required")
+    });
+    cachedEnv = null;
+    defaultConfig = {
+      basePath: "/blog",
+      adminPath: "/admin/blog",
+      apiPath: "/api/blog",
+      postsPerPage: 10,
+      excerptLength: 160,
+      codeHighlighter: "shiki",
+      editor: {
+        blocks: [
+          "paragraph",
+          "heading",
+          "image",
+          "codeBlock",
+          "blockquote",
+          "bulletList",
+          "orderedList",
+          "taskList",
+          "table",
+          "embed",
+          "horizontalRule",
+          "callout",
+          "tableOfContents",
+          "faq",
+          "html"
+        ],
+        maxImageSize: 10 * 1024 * 1024,
+        imageFormats: ["jpg", "jpeg", "png", "gif", "webp", "svg"],
+        autosaveInterval: 3e4
+      },
+      seo: {
+        titleTemplate: "%s | %siteName%",
+        generateRSS: true,
+        generateSitemap: true,
+        structuredData: true,
+        minContentLength: 300
+      },
+      auth: {
+        strategy: "api-key"
+      },
+      features: {
+        search: true,
+        relatedPosts: true,
+        readingProgress: true,
+        tableOfContents: true,
+        shareButtons: true,
+        darkMode: true,
+        scheduling: true,
+        revisionHistory: true,
+        imageOptimization: true
+      },
+      theme: {
+        darkMode: true,
+        variables: {
+          "--nbk-primary": "#2563eb",
+          "--nbk-primary-hover": "#1d4ed8",
+          "--nbk-text": "#1f2937",
+          "--nbk-text-muted": "#6b7280",
+          "--nbk-bg": "#ffffff",
+          "--nbk-bg-secondary": "#f9fafb",
+          "--nbk-card-bg": "#ffffff",
+          "--nbk-border": "#e5e7eb",
+          "--nbk-radius": "0.5rem",
+          "--nbk-font-heading": '"Inter", system-ui, sans-serif',
+          "--nbk-font-body": '"Inter", system-ui, sans-serif',
+          "--nbk-font-code": '"JetBrains Mono", "Fira Code", monospace'
+        }
+      },
+      hooks: {}
+    };
+    cachedConfig = null;
+  }
+});
+
+// src/lib/slug.ts
+function generateSlug(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function ensureUniqueSlug(slug, collection, excludeId) {
+  let candidate = slug;
+  let counter = 1;
+  while (true) {
+    const query = { slug: candidate };
+    if (excludeId) {
+      query._id = { $ne: excludeId };
+    }
+    const existing = await collection.findOne(query);
+    if (!existing) return candidate;
+    candidate = `${slug}-${counter}`;
+    counter++;
+  }
+}
+var init_slug = __esm({
+  "src/lib/slug.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/reading-time.ts
+function calculateReadingTime(text) {
+  const words = countWords(text);
+  return Math.max(1, Math.ceil(words / WORDS_PER_MINUTE));
+}
+function countWords(text) {
+  if (!text || !text.trim()) return 0;
+  return text.trim().split(/\s+/).length;
+}
+function extractTextFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (typeof n.text === "string") {
+      parts.push(n.text);
+    }
+    if (Array.isArray(n.content)) {
+      for (const child of n.content) {
+        walk(child);
+      }
+    }
+  }
+  for (const block of blocks) {
+    walk(block);
+  }
+  return parts.join(" ");
+}
+var WORDS_PER_MINUTE;
+var init_reading_time = __esm({
+  "src/lib/reading-time.ts"() {
+    "use strict";
+    WORDS_PER_MINUTE = 200;
+  }
+});
+
+// src/lib/db.ts
+var db_exports = {};
+__export(db_exports, {
+  createCategory: () => createCategory,
+  createMedia: () => createMedia,
+  createPost: () => createPost,
+  deleteCategory: () => deleteCategory,
+  deleteMedia: () => deleteMedia,
+  deletePost: () => deletePost,
+  ensureIndexes: () => ensureIndexes,
+  getCategoryBySlug: () => getCategoryBySlug,
+  getCollection: () => getCollection,
+  getDb: () => getDb,
+  getPostById: () => getPostById,
+  getPostBySlug: () => getPostBySlug,
+  getSettings: () => getSettings,
+  hardDeletePost: () => hardDeletePost,
+  listCategories: () => listCategories,
+  listMedia: () => listMedia,
+  listPosts: () => listPosts,
+  updateCategory: () => updateCategory,
+  updateCategoryPostCount: () => updateCategoryPostCount,
+  updatePost: () => updatePost,
+  updateSettings: () => updateSettings
+});
+async function getDb() {
+  if (db) return db;
+  const env = getEnvConfig();
+  client = new import_mongodb.MongoClient(env.NEXTBLOGKIT_MONGODB_URI);
+  await client.connect();
+  db = client.db();
+  return db;
+}
+async function getCollection(name) {
+  const database = await getDb();
+  return database.collection(name);
+}
+async function ensureIndexes() {
+  const database = await getDb();
+  const posts = database.collection("nbk_posts");
+  await posts.createIndex({ slug: 1 }, { unique: true });
+  await posts.createIndex({ status: 1, publishedAt: -1 });
+  await posts.createIndex({ categories: 1, status: 1 });
+  await posts.createIndex({ tags: 1, status: 1 });
+  await posts.createIndex({ "seo.focusKeyword": 1 });
+  await posts.createIndex({ contentText: "text", title: "text", excerpt: "text" });
+  const categories = database.collection("nbk_categories");
+  await categories.createIndex({ slug: 1 }, { unique: true });
+  await categories.createIndex({ order: 1 });
+  const media = database.collection("nbk_media");
+  await media.createIndex({ createdAt: -1 });
+  await media.createIndex({ r2Key: 1 }, { unique: true });
+}
+async function createPost(input, defaultAuthor) {
+  const col = await getCollection("nbk_posts");
+  const slug = await ensureUniqueSlug(
+    input.slug || generateSlug(input.title),
+    col
+  );
+  const contentText = input.contentText || extractTextFromBlocks(input.content || []);
+  const wordCount = countWords(contentText);
+  const readingTime = calculateReadingTime(contentText);
+  const excerpt = input.excerpt || contentText.slice(0, 160).replace(/\s+\S*$/, "") + "...";
+  const now = /* @__PURE__ */ new Date();
+  const doc = {
+    title: input.title,
+    slug,
+    excerpt,
+    content: input.content || [],
+    contentHTML: input.contentHTML || "",
+    contentText,
+    coverImage: input.coverImage,
+    categories: input.categories || [],
+    tags: input.tags || [],
+    author: input.author || defaultAuthor || { name: "Admin" },
+    seo: {
+      ogType: "article",
+      noIndex: false,
+      ...input.seo
+    },
+    status: input.status || "draft",
+    publishedAt: input.status === "published" ? now : input.publishedAt,
+    scheduledAt: input.scheduledAt,
+    readingTime,
+    wordCount,
+    version: 1,
+    revisions: [],
+    createdAt: now,
+    updatedAt: now
+  };
+  const result = await col.insertOne(doc);
+  return { _id: result.insertedId, ...doc };
+}
+async function updatePost(id, input) {
+  const col = await getCollection("nbk_posts");
+  const objectId = new import_mongodb.ObjectId(id);
+  const existing = await col.findOne({ _id: objectId });
+  if (!existing) return null;
+  const updates = { ...input, updatedAt: /* @__PURE__ */ new Date() };
+  if (input.slug && input.slug !== existing.slug) {
+    updates.slug = await ensureUniqueSlug(input.slug, col, id);
+  }
+  if (input.content) {
+    const contentText = input.contentText || extractTextFromBlocks(input.content);
+    updates.contentText = contentText;
+    updates.wordCount = countWords(contentText);
+    updates.readingTime = calculateReadingTime(contentText);
+    if (!input.excerpt) {
+      updates.excerpt = contentText.slice(0, 160).replace(/\s+\S*$/, "") + "...";
+    }
+    const revision = {
+      version: existing.version || 1,
+      title: existing.title,
+      content: existing.content,
+      contentHTML: existing.contentHTML,
+      savedAt: /* @__PURE__ */ new Date()
+    };
+    const revisions = [...existing.revisions || [], revision].slice(-10);
+    updates.revisions = revisions;
+    updates.version = (existing.version || 1) + 1;
+  }
+  if (input.status === "published" && existing.status !== "published") {
+    updates.publishedAt = /* @__PURE__ */ new Date();
+  }
+  await col.updateOne({ _id: objectId }, { $set: updates });
+  return await col.findOne({ _id: objectId });
+}
+async function deletePost(id) {
+  const col = await getCollection("nbk_posts");
+  const result = await col.updateOne(
+    { _id: new import_mongodb.ObjectId(id) },
+    { $set: { status: "archived", updatedAt: /* @__PURE__ */ new Date() } }
+  );
+  return result.modifiedCount > 0;
+}
+async function hardDeletePost(id) {
+  const col = await getCollection("nbk_posts");
+  const result = await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function getPostBySlug(slug) {
+  const col = await getCollection("nbk_posts");
+  return await col.findOne({ slug });
+}
+async function getPostById(id) {
+  const col = await getCollection("nbk_posts");
+  return await col.findOne({ _id: new import_mongodb.ObjectId(id) });
+}
+async function listPosts(query = {}) {
+  const col = await getCollection("nbk_posts");
+  const {
+    page = 1,
+    limit = 10,
+    category,
+    tag,
+    status,
+    search,
+    sortBy = "publishedAt",
+    sortOrder = "desc"
+  } = query;
+  const filter = {};
+  if (status) {
+    filter.status = status;
+  } else {
+    filter.status = { $ne: "archived" };
+  }
+  if (category) filter.categories = category;
+  if (tag) filter.tags = tag;
+  if (search) {
+    filter.$text = { $search: search };
+  }
+  const sort = {
+    [sortBy]: sortOrder === "asc" ? 1 : -1
+  };
+  const skip = (page - 1) * limit;
+  const [posts, total] = await Promise.all([
+    col.find(filter).sort(sort).skip(skip).limit(limit).toArray(),
+    col.countDocuments(filter)
+  ]);
+  return {
+    posts,
+    total
+  };
+}
+async function createCategory(input) {
+  const col = await getCollection("nbk_categories");
+  const slug = await ensureUniqueSlug(
+    input.slug || generateSlug(input.name),
+    col
+  );
+  const doc = {
+    name: input.name,
+    slug,
+    description: input.description,
+    seo: input.seo,
+    order: input.order ?? 0,
+    parentId: input.parentId ? new import_mongodb.ObjectId(input.parentId) : void 0,
+    postCount: 0
+  };
+  const result = await col.insertOne(doc);
+  return { _id: result.insertedId, ...doc };
+}
+async function updateCategory(id, input) {
+  const col = await getCollection("nbk_categories");
+  const objectId = new import_mongodb.ObjectId(id);
+  const updates = { ...input };
+  if (input.slug) {
+    updates.slug = await ensureUniqueSlug(input.slug, col, id);
+  }
+  if (input.parentId) {
+    updates.parentId = new import_mongodb.ObjectId(input.parentId);
+  }
+  await col.updateOne({ _id: objectId }, { $set: updates });
+  return await col.findOne({ _id: objectId });
+}
+async function deleteCategory(id) {
+  const col = await getCollection("nbk_categories");
+  const result = await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return result.deletedCount > 0;
+}
+async function listCategories() {
+  const col = await getCollection("nbk_categories");
+  return await col.find({}).sort({ order: 1 }).toArray();
+}
+async function getCategoryBySlug(slug) {
+  const col = await getCollection("nbk_categories");
+  return await col.findOne({ slug });
+}
+async function updateCategoryPostCount(categorySlug) {
+  const posts = await getCollection("nbk_posts");
+  const categories = await getCollection("nbk_categories");
+  const count = await posts.countDocuments({
+    categories: categorySlug,
+    status: "published"
+  });
+  await categories.updateOne({ slug: categorySlug }, { $set: { postCount: count } });
+}
+async function createMedia(data) {
+  const col = await getCollection("nbk_media");
+  const result = await col.insertOne(data);
+  return { _id: result.insertedId, ...data };
+}
+async function deleteMedia(id) {
+  const col = await getCollection("nbk_media");
+  const media = await col.findOne({ _id: new import_mongodb.ObjectId(id) });
+  if (!media) return null;
+  await col.deleteOne({ _id: new import_mongodb.ObjectId(id) });
+  return media;
+}
+async function listMedia(query = {}) {
+  const col = await getCollection("nbk_media");
+  const { page = 1, limit = 20, mimeType } = query;
+  const filter = {};
+  if (mimeType) filter.mimeType = { $regex: mimeType };
+  const skip = (page - 1) * limit;
+  const [media, total] = await Promise.all([
+    col.find(filter).sort({ createdAt: -1 }).skip(skip).limit(limit).toArray(),
+    col.countDocuments(filter)
+  ]);
+  return { media, total };
+}
+async function getSettings() {
+  const col = await getCollection("nbk_settings");
+  const settings = await col.findOne({ _id: "global" });
+  if (!settings) {
+    const defaults = {
+      _id: "global",
+      postsPerPage: 10,
+      commentSystem: "none"
+    };
+    await col.insertOne(defaults);
+    return defaults;
+  }
+  return settings;
+}
+async function updateSettings(data) {
+  const col = await getCollection("nbk_settings");
+  const { _id, ...updates } = data;
+  await col.updateOne(
+    { _id: "global" },
+    { $set: updates },
+    { upsert: true }
+  );
+  return getSettings();
+}
+var import_mongodb, client, db;
+var init_db = __esm({
+  "src/lib/db.ts"() {
+    "use strict";
+    import_mongodb = require("mongodb");
+    init_config();
+    init_slug();
+    init_reading_time();
+    client = null;
+    db = null;
+  }
+});
+
+// src/lib/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  R2StorageProvider: () => R2StorageProvider
+});
+function getS3Client() {
+  if (clientInstance) return clientInstance;
+  const env = getEnvConfig();
+  clientInstance = new import_client_s3.S3Client({
+    region: "auto",
+    endpoint: `https://${env.NEXTBLOGKIT_R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,
+    credentials: {
+      accessKeyId: env.NEXTBLOGKIT_R2_ACCESS_KEY,
+      secretAccessKey: env.NEXTBLOGKIT_R2_SECRET_KEY
+    }
+  });
+  return clientInstance;
+}
+function generateKey(filename) {
+  const now = /* @__PURE__ */ new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const uuid = (0, import_crypto.randomUUID)().split("-")[0];
+  const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "-").toLowerCase();
+  return `blog/${year}/${month}/${uuid}-${safeName}`;
+}
+var import_client_s3, import_crypto, clientInstance, R2StorageProvider;
+var init_storage = __esm({
+  "src/lib/storage.ts"() {
+    "use strict";
+    import_client_s3 = require("@aws-sdk/client-s3");
+    init_config();
+    import_crypto = require("crypto");
+    clientInstance = null;
+    R2StorageProvider = class {
+      async upload(file, filename, contentType) {
+        const env = getEnvConfig();
+        const client2 = getS3Client();
+        const key = generateKey(filename);
+        await client2.send(
+          new import_client_s3.PutObjectCommand({
+            Bucket: env.NEXTBLOGKIT_R2_BUCKET,
+            Key: key,
+            Body: file,
+            ContentType: contentType
+          })
+        );
+        return {
+          key,
+          url: `${env.NEXTBLOGKIT_R2_PUBLIC_URL}/${key}`,
+          size: file.length,
+          contentType
+        };
+      }
+      async delete(key) {
+        const env = getEnvConfig();
+        const client2 = getS3Client();
+        await client2.send(
+          new import_client_s3.DeleteObjectCommand({
+            Bucket: env.NEXTBLOGKIT_R2_BUCKET,
+            Key: key
+          })
+        );
+      }
+      async list(prefix) {
+        const env = getEnvConfig();
+        const client2 = getS3Client();
+        const response = await client2.send(
+          new import_client_s3.ListObjectsV2Command({
+            Bucket: env.NEXTBLOGKIT_R2_BUCKET,
+            Prefix: prefix || "blog/"
+          })
+        );
+        return (response.Contents || []).map((obj) => ({
+          key: obj.Key || "",
+          size: obj.Size || 0,
+          lastModified: obj.LastModified || /* @__PURE__ */ new Date()
+        }));
+      }
+    };
+  }
+});
+
+// src/cli/index.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_commander = require("commander");
+
+// src/cli/init.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+
+// src/cli/templates.ts
+function getTemplates(options) {
+  return [
+    // ---- Blog Pages ----
+    {
+      path: "blog/layout.tsx",
+      content: `import 'nextblogkit/styles/blog.css';
+
+export default function BlogLayout({ children }: { children: React.ReactNode }) {
+  return <>{children}</>;
+}
+`
+    },
+    {
+      path: "blog/page.tsx",
+      content: `import { BlogCard, BlogSearch, Pagination, CategoryList } from 'nextblogkit/components';
+import { listPosts, listCategories } from 'nextblogkit/lib';
+
+interface Props {
+  searchParams: Promise<{ page?: string; category?: string; q?: string }>;
+}
+
+export default async function Blog({ searchParams }: Props) {
+  const params = await searchParams;
+  const page = parseInt(params.page || '1', 10);
+
+  const [{ posts, total }, categories] = await Promise.all([
+    listPosts({
+      page,
+      limit: 10,
+      status: 'published',
+      category: params.category || undefined,
+      search: params.q || undefined,
+      sortBy: 'publishedAt',
+      sortOrder: 'desc',
+    }),
+    listCategories(),
+  ]);
+
+  const totalPages = Math.ceil(total / 10);
+
+  return (
+    <div className="nbk-blog-list">
+      <div className="nbk-blog-header">
+        <BlogSearch apiPath="/api/blog" />
+      </div>
+
+      <div className="nbk-blog-layout">
+        <div className="nbk-blog-main">
+          {posts.length === 0 ? (
+            <div className="nbk-empty-state">
+              <p>No posts found.</p>
+            </div>
+          ) : (
+            <div className="nbk-posts-grid">
+              {posts.map((post) => (
+                <BlogCard
+                  key={String(post._id || post.slug)}
+                  post={JSON.parse(JSON.stringify(post))}
+                  basePath="/blog"
+                />
+              ))}
+            </div>
+          )}
+
+          {totalPages > 1 && (
+            <Pagination
+              currentPage={page}
+              totalPages={totalPages}
+              basePath="/blog"
+              category={params.category}
+            />
+          )}
+        </div>
+
+        {categories.length > 0 && (
+          <aside className="nbk-blog-sidebar">
+            <CategoryList
+              categories={JSON.parse(JSON.stringify(categories))}
+              activeCategory={params.category}
+              basePath="/blog"
+            />
+          </aside>
+        )}
+      </div>
+    </div>
+  );
+}
+`
+    },
+    {
+      path: "blog/[slug]/page.tsx",
+      content: `import { AuthorCard, BreadcrumbNav, ShareButtons, ReadingProgressBar, BlogCard } from 'nextblogkit/components';
+import { getPostBySlug, listPosts, generateMetaTags } from 'nextblogkit/lib';
+import type { Metadata } from 'next';
+
+interface Props {
+  params: Promise<{ slug: string }>;
+}
+
+export async function generateMetadata({ params }: Props): Promise<Metadata> {
+  const { slug } = await params;
+  const post = await getPostBySlug(slug);
+  if (!post) return { title: 'Post Not Found' };
+  const meta = generateMetaTags(post);
+  return {
+    title: meta.title,
+    description: meta.description,
+    openGraph: meta.openGraph,
+    twitter: meta.twitter,
+    alternates: { canonical: meta.canonical },
+  };
+}
+
+export default async function BlogPost({ params }: Props) {
+  const { slug } = await params;
+  const post = await getPostBySlug(slug);
+
+  if (!post) {
+    return <div className="nbk-not-found">Post not found</div>;
+  }
+
+  let relatedPosts: any[] = [];
+  if (post.categories?.length) {
+    const { posts } = await listPosts({
+      status: 'published',
+      category: post.categories[0],
+      limit: 4,
+    });
+    relatedPosts = posts
+      .filter((p) => String(p._id) !== String(post._id))
+      .slice(0, 3);
+  }
+
+  const date = post.publishedAt
+    ? new Date(post.publishedAt).toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+      })
+    : '';
+
+  return (
+    <article className="nbk-post">
+      <ReadingProgressBar />
+
+      <BreadcrumbNav
+        items={[
+          { label: 'Home', href: '/' },
+          { label: 'Blog', href: '/blog' },
+          ...(post.categories?.[0]
+            ? [{ label: post.categories[0], href: \\\`/blog/category/\\\${post.categories[0]}\\\` }]
+            : []),
+          { label: post.title },
+        ]}
+      />
+
+      <header className="nbk-post-header">
+        {post.categories?.length > 0 && (
+          <div className="nbk-post-categories">
+            {post.categories.map((cat: string) => (
+              <a key={cat} href={\\\`/blog/category/\\\${cat}\\\`} className="nbk-post-category">
+                {cat}
+              </a>
+            ))}
+          </div>
+        )}
+        <h1 className="nbk-post-title">{post.title}</h1>
+        <div className="nbk-post-meta">
+          <span className="nbk-post-author">{post.author?.name}</span>
+          {date && (
+            <>
+              <span className="nbk-post-sep">&middot;</span>
+              <time className="nbk-post-date">{date}</time>
+            </>
+          )}
+          <span className="nbk-post-sep">&middot;</span>
+          <span className="nbk-post-reading-time">{post.readingTime} min read</span>
+        </div>
+      </header>
+
+      {post.coverImage?.url && (
+        <div className="nbk-post-cover">
+          <img src={post.coverImage.url} alt={post.coverImage.alt || post.title} />
+        </div>
+      )}
+
+      <div
+        className="nbk-post-content"
+        dangerouslySetInnerHTML={{ __html: post.contentHTML || '' }}
+      />
+
+      <ShareButtons url={\\\`/blog/\\\${slug}\\\`} title={post.title} />
+
+      {post.author && <AuthorCard author={post.author} />}
+
+      {relatedPosts.length > 0 && (
+        <section className="nbk-related">
+          <h2 className="nbk-related-title">Related Posts</h2>
+          <div className="nbk-related-grid">
+            {relatedPosts.map((p) => (
+              <BlogCard key={String(p._id)} post={JSON.parse(JSON.stringify(p))} basePath="/blog" />
+            ))}
+          </div>
+        </section>
+      )}
+    </article>
+  );
+}
+`
+    },
+    {
+      path: "blog/category/[slug]/page.tsx",
+      content: `import { BlogCard, BlogSearch, Pagination, CategoryList } from 'nextblogkit/components';
+import { listPosts, listCategories } from 'nextblogkit/lib';
+
+interface Props {
+  params: Promise<{ slug: string }>;
+  searchParams: Promise<{ page?: string }>;
+}
+
+export default async function CategoryPage({ params, searchParams }: Props) {
+  const { slug } = await params;
+  const sp = await searchParams;
+  const page = parseInt(sp.page || '1', 10);
+
+  const [{ posts, total }, categories] = await Promise.all([
+    listPosts({
+      page,
+      limit: 10,
+      status: 'published',
+      category: slug,
+      sortBy: 'publishedAt',
+      sortOrder: 'desc',
+    }),
+    listCategories(),
+  ]);
+
+  const totalPages = Math.ceil(total / 10);
+
+  return (
+    <div className="nbk-blog-list">
+      <div className="nbk-blog-header">
+        <BlogSearch apiPath="/api/blog" />
+      </div>
+
+      <div className="nbk-blog-layout">
+        <div className="nbk-blog-main">
+          {posts.length === 0 ? (
+            <div className="nbk-empty-state">
+              <p>No posts found in this category.</p>
+            </div>
+          ) : (
+            <div className="nbk-posts-grid">
+              {posts.map((post) => (
+                <BlogCard
+                  key={String(post._id || post.slug)}
+                  post={JSON.parse(JSON.stringify(post))}
+                  basePath="/blog"
+                />
+              ))}
+            </div>
+          )}
+
+          {totalPages > 1 && (
+            <Pagination
+              currentPage={page}
+              totalPages={totalPages}
+              basePath="/blog"
+              category={slug}
+            />
+          )}
+        </div>
+
+        {categories.length > 0 && (
+          <aside className="nbk-blog-sidebar">
+            <CategoryList
+              categories={JSON.parse(JSON.stringify(categories))}
+              activeCategory={slug}
+              basePath="/blog"
+            />
+          </aside>
+        )}
+      </div>
+    </div>
+  );
+}
+`
+    },
+    // ---- Admin Pages ----
+    {
+      path: "admin/blog/layout.tsx",
+      content: `import { AdminLayout } from 'nextblogkit/admin';
+import 'nextblogkit/styles/admin.css';
+
+export default function AdminBlogLayout({ children }: { children: React.ReactNode }) {
+  return <AdminLayout>{children}</AdminLayout>;
+}
+`
+    },
+    {
+      path: "admin/blog/page.tsx",
+      content: `import { Dashboard } from 'nextblogkit/admin';
+
+export default function AdminDashboard() {
+  return <Dashboard />;
+}
+`
+    },
+    {
+      path: "admin/blog/posts/page.tsx",
+      content: `import { PostList } from 'nextblogkit/admin';
+
+export default function AdminPosts() {
+  return <PostList />;
+}
+`
+    },
+    {
+      path: "admin/blog/new/page.tsx",
+      content: `import { PostEditor } from 'nextblogkit/admin';
+
+export default function NewPost() {
+  return <PostEditor />;
+}
+`
+    },
+    {
+      path: "admin/blog/[id]/edit/page.tsx",
+      content: `import { PostEditor } from 'nextblogkit/admin';
+
+interface Props {
+  params: Promise<{ id: string }>;
+}
+
+export default async function EditPost({ params }: Props) {
+  const { id } = await params;
+  return <PostEditor postId={id} />;
+}
+`
+    },
+    {
+      path: "admin/blog/media/page.tsx",
+      content: `import { MediaLibrary } from 'nextblogkit/admin';
+
+export default function AdminMedia() {
+  return <MediaLibrary />;
+}
+`
+    },
+    {
+      path: "admin/blog/categories/page.tsx",
+      content: `import { CategoryManager } from 'nextblogkit/admin';
+
+export default function AdminCategories() {
+  return <CategoryManager />;
+}
+`
+    },
+    {
+      path: "admin/blog/settings/page.tsx",
+      content: `import { SettingsPage } from 'nextblogkit/admin';
+
+export default function AdminSettings() {
+  return <SettingsPage />;
+}
+`
+    },
+    // ---- API Routes ----
+    {
+      path: "api/blog/posts/route.ts",
+      content: `export { GET, POST, PUT, DELETE } from 'nextblogkit/api/posts';
+`
+    },
+    {
+      path: "api/blog/media/route.ts",
+      content: `export { GET, POST, DELETE } from 'nextblogkit/api/media';
+`
+    },
+    {
+      path: "api/blog/categories/route.ts",
+      content: `export { GET, POST, PUT, DELETE } from 'nextblogkit/api/categories';
+`
+    },
+    {
+      path: "api/blog/settings/route.ts",
+      content: `export { GET, PUT } from 'nextblogkit/api/settings';
+`
+    },
+    {
+      path: "api/blog/sitemap.xml/route.ts",
+      content: `export { GET } from 'nextblogkit/api/sitemap';
+`
+    },
+    {
+      path: "api/blog/rss.xml/route.ts",
+      content: `export { GET } from 'nextblogkit/api/rss';
+`
+    }
+  ];
+}
+
+// src/cli/init.ts
+async function init(options) {
+  const cwd2 = process.cwd();
+  const packageJsonPath = import_path.default.join(cwd2, "package.json");
+  if (!import_fs.default.existsSync(packageJsonPath)) {
+    console.error("Error: No package.json found. Run this in a Next.js project root.");
+    process.exit(1);
+  }
+  const pkg = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+  const hasNext = pkg.dependencies?.next || pkg.devDependencies?.next;
+  if (!hasNext) {
+    console.error("Error: next is not a dependency. This must be a Next.js project.");
+    process.exit(1);
+  }
+  const appDir = import_fs.default.existsSync(import_path.default.join(cwd2, "src", "app")) ? import_path.default.join(cwd2, "src", "app") : import_path.default.join(cwd2, "app");
+  if (!import_fs.default.existsSync(appDir)) {
+    console.error("Error: No app/ directory found. NextBlogKit requires the Next.js App Router.");
+    process.exit(1);
+  }
+  console.log("");
+  console.log("  NextBlogKit \u2014 Initializing...");
+  console.log("");
+  const templates = getTemplates(options);
+  for (const template of templates) {
+    const filePath = import_path.default.join(appDir, template.path);
+    const dir = import_path.default.dirname(filePath);
+    if (!import_fs.default.existsSync(dir)) {
+      import_fs.default.mkdirSync(dir, { recursive: true });
+    }
+    if (import_fs.default.existsSync(filePath)) {
+      console.log(`  \u26A0 Skipping ${template.path} (already exists)`);
+      continue;
+    }
+    import_fs.default.writeFileSync(filePath, template.content);
+    console.log(`  \u2713 ${template.path}`);
+  }
+  const configPath = import_path.default.join(cwd2, "nextblogkit.config.ts");
+  if (!import_fs.default.existsSync(configPath)) {
+    import_fs.default.writeFileSync(
+      configPath,
+      `import { defineConfig } from 'nextblogkit';
+
+export default defineConfig({
+  basePath: '${options.blogPath}',
+  adminPath: '${options.adminPath}',
+  apiPath: '${options.apiPath}',
+  auth: {
+    strategy: 'api-key',
+  },
+});
+`
+    );
+    console.log("  \u2713 nextblogkit.config.ts");
+  }
+  const envExamplePath = import_path.default.join(cwd2, ".env.local.example");
+  if (!import_fs.default.existsSync(envExamplePath)) {
+    import_fs.default.writeFileSync(
+      envExamplePath,
+      `# NextBlogKit Configuration
+# Copy this to .env.local and fill in your values
+
+# MongoDB Connection
+NEXTBLOGKIT_MONGODB_URI=mongodb+srv://user:pass@cluster.mongodb.net/mydb
+
+# Cloudflare R2 Storage
+NEXTBLOGKIT_R2_ACCOUNT_ID=your-account-id
+NEXTBLOGKIT_R2_ACCESS_KEY=your-access-key
+NEXTBLOGKIT_R2_SECRET_KEY=your-secret-key
+NEXTBLOGKIT_R2_BUCKET=blog-media
+NEXTBLOGKIT_R2_PUBLIC_URL=https://media.yourdomain.com
+
+# Authentication
+NEXTBLOGKIT_API_KEY=your-secure-api-key-must-be-at-least-32-characters-long
+
+# Site Info
+NEXTBLOGKIT_SITE_URL=https://yourdomain.com
+NEXTBLOGKIT_SITE_NAME="Your Site Name"
+`
+    );
+    console.log("  \u2713 .env.local.example");
+  }
+  console.log("");
+  console.log("  Done! Next steps:");
+  console.log("");
+  console.log("  1. Copy .env.local.example to .env.local and fill in your values");
+  console.log("  2. Run: npm run dev");
+  console.log(`  3. Visit: http://localhost:3000${options.adminPath}`);
+  console.log("");
+}
+
+// src/cli/seed.ts
+async function seed() {
+  console.log("");
+  console.log("  NextBlogKit \u2014 Seeding example content...");
+  console.log("");
+  try {
+    const { getDb: getDb2, ensureIndexes: ensureIndexes2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const { createPost: createPost2, createCategory: createCategory2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    await ensureIndexes2();
+    console.log("  \u2713 Database indexes created");
+    const categories = [
+      { name: "Technology", slug: "technology", description: "Tech tutorials and updates", order: 0 },
+      { name: "Design", slug: "design", description: "UI/UX and design tips", order: 1 },
+      { name: "Tutorials", slug: "tutorials", description: "Step-by-step guides", order: 2 }
+    ];
+    for (const cat of categories) {
+      try {
+        await createCategory2(cat);
+        console.log(`  \u2713 Category: ${cat.name}`);
+      } catch (err) {
+        if (err.code === 11e3) {
+          console.log(`  \u26A0 Category "${cat.name}" already exists`);
+        } else {
+          throw err;
+        }
+      }
+    }
+    try {
+      await createPost2({
+        title: "Welcome to NextBlogKit",
+        slug: "welcome-to-nextblogkit",
+        excerpt: "Your new blog is ready! This is an example post to get you started with NextBlogKit.",
+        content: [
+          {
+            type: "heading",
+            attrs: { level: 2 },
+            content: [{ type: "text", text: "Getting Started" }]
+          },
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Congratulations! Your NextBlogKit blog is up and running. This example post shows you what\u2019s possible." }
+            ]
+          },
+          {
+            type: "heading",
+            attrs: { level: 2 },
+            content: [{ type: "text", text: "Features" }]
+          },
+          {
+            type: "bulletList",
+            content: [
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Block editor with slash commands" }] }] },
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Full SEO optimization out of the box" }] }] },
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Media library with R2 storage" }] }] },
+              { type: "listItem", content: [{ type: "paragraph", content: [{ type: "text", text: "Dynamic sitemap and RSS feed" }] }] }
+            ]
+          },
+          {
+            type: "callout",
+            attrs: { type: "tip" },
+            content: [
+              { type: "paragraph", content: [{ type: "text", text: "Head to the admin panel to start creating your own posts!" }] }
+            ]
+          }
+        ],
+        contentHTML: "<h2>Getting Started</h2><p>Congratulations! Your NextBlogKit blog is up and running.</p><h2>Features</h2><ul><li>Block editor with slash commands</li><li>Full SEO optimization out of the box</li><li>Media library with R2 storage</li><li>Dynamic sitemap and RSS feed</li></ul>",
+        status: "published",
+        categories: ["technology"],
+        tags: ["nextjs", "blog", "getting-started"]
+      });
+      console.log('  \u2713 Example post: "Welcome to NextBlogKit"');
+    } catch (err) {
+      if (err.code === 11e3) {
+        console.log("  \u26A0 Example post already exists");
+      } else {
+        throw err;
+      }
+    }
+    console.log("");
+    console.log("  Seeding complete!");
+    console.log("");
+    process.exit(0);
+  } catch (error) {
+    console.error("  \u2717 Seeding failed:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/health.ts
+async function health() {
+  console.log("");
+  console.log("  NextBlogKit \u2014 Health Check");
+  console.log("");
+  let allPassed = true;
+  try {
+    const { getDb: getDb2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    const db2 = await getDb2();
+    await db2.command({ ping: 1 });
+    console.log("  \u2713 MongoDB: Connected");
+  } catch (err) {
+    console.log(`  \u2717 MongoDB: ${err.message}`);
+    allPassed = false;
+  }
+  try {
+    const { R2StorageProvider: R2StorageProvider2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+    const storage = new R2StorageProvider2();
+    await storage.list("blog/");
+    console.log("  \u2713 Cloudflare R2: Connected");
+  } catch (err) {
+    console.log(`  \u2717 Cloudflare R2: ${err.message}`);
+    allPassed = false;
+  }
+  try {
+    const { getEnvConfig: getEnvConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    getEnvConfig2();
+    console.log("  \u2713 Environment: All variables set");
+  } catch (err) {
+    console.log(`  \u2717 Environment: ${err.message}`);
+    allPassed = false;
+  }
+  console.log("");
+  if (allPassed) {
+    console.log("  All checks passed!");
+  } else {
+    console.log("  Some checks failed. Please review your configuration.");
+  }
+  console.log("");
+  process.exit(allPassed ? 0 : 1);
+}
+
+// src/cli/migrate.ts
+async function migrateCommand() {
+  console.log("");
+  console.log("  NextBlogKit \u2014 Database Migration");
+  console.log("");
+  try {
+    const { ensureIndexes: ensureIndexes2 } = await Promise.resolve().then(() => (init_db(), db_exports));
+    console.log("  Creating/updating indexes...");
+    await ensureIndexes2();
+    console.log("  \u2713 All indexes created");
+    console.log("");
+    console.log("  Migration complete!");
+    console.log("");
+    process.exit(0);
+  } catch (error) {
+    console.error("  \u2717 Migration failed:", error);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+function loadEnvFile(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return;
+  const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+var cwd = process.cwd();
+loadEnvFile((0, import_node_path.resolve)(cwd, ".env.local"));
+loadEnvFile((0, import_node_path.resolve)(cwd, ".env"));
+var program = new import_commander.Command();
+program.name("nextblogkit").description("NextBlogKit \u2014 Blog engine for Next.js").version("0.1.0");
+program.command("init").description("Initialize NextBlogKit in your Next.js project").option("--blog-path <path>", "Blog base path", "/blog").option("--admin-path <path>", "Admin panel path", "/admin/blog").option("--api-path <path>", "API base path", "/api/blog").option("--no-example", "Skip creating example post").action(init);
+program.command("seed").description("Seed example blog content").action(seed);
+program.command("health").description("Check database and storage connectivity").action(health);
+program.command("migrate").description("Run database migrations").action(migrateCommand);
+program.parse();