noblog 0.0.13 → 0.2.0-beta

package/dist/generate.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import * as path from 'path';
+import { dirname, join } from 'path';
 import * as fs from 'fs/promises';
 import fetch from 'node-fetch';
 import { markdownTable } from 'markdown-table';
 import 'dotenv/config';
 import retry from 'async-retry';
-import { Client, APIResponseError } from '@notionhq/client';
+import { Client, isNotionClientError } from '@notionhq/client';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
 
 const suffixInlineCode = "`";
 const prefixInlineCode = "`";
@@ -133,9 +136,12 @@ const client = new Client({
     auth: NOTION_API_SECRET,
 });
 const numberOfRetry = 2;
-async function GetAllPosts() {
-    const params = {
+async function ListPages() {
+    const respDatabase = (await client.databases.retrieve({
         database_id: NOBLOG_DATABASE_ID,
+    }));
+    const reqDataSources = respDatabase.data_sources.map((source) => ({
+        data_source_id: source.id,
         filter: {
             and: [
                 {
@@ -151,40 +157,41 @@ async function GetAllPosts() {
             },
         ],
         page_size: 100,
-    };
+    }));
     let results = [];
-    while (true) {
-        const res = await retry(async (bail) => {
-            try {
-                return (await client.databases.query(params));
-            }
-            catch (error) {
-                if (error instanceof APIResponseError) {
-                    if (error.status && error.status >= 400 && error.status < 500) {
+    for (const req of reqDataSources) {
+        let params = req;
+        while (true) {
+            const resp = await retry(async (bail) => {
+                try {
+                    return client.dataSources.query(params);
+                }
+                catch (error) {
+                    if (isNotionClientError(error)) {
                         bail(error);
                     }
+                    throw error;
                 }
-                throw error;
+            }, { retries: numberOfRetry });
+            results = results.concat(resp.results);
+            if (!resp.has_more) {
+                break;
             }
-        }, { retries: numberOfRetry });
-        results = results.concat(res.results);
-        if (!res.has_more) {
-            break;
+            params.start_cursor = resp.next_cursor;
         }
-        params["start_cursor"] = res.next_cursor;
     }
     return results;
 }
-async function GetPageMeta(page_id) {
+async function GetPage(page_id) {
     const result = await retry(async (bail) => {
         try {
-            return (await client.pages.retrieve({ page_id: page_id }));
+            return (await client.pages.retrieve({
+                page_id: page_id,
+            }));
         }
         catch (error) {
-            if (error instanceof APIResponseError) {
-                if (error.status && error.status >= 400 && error.status < 500) {
-                    bail(error);
-                }
+            if (isNotionClientError(error)) {
+                bail(error);
             }
             throw error;
         }
@@ -192,7 +199,7 @@ async function GetPageMeta(page_id) {
     return result;
 }
 async function GetBlockChildren(block_id, totalPage) {
-    const result = [];
+    const results = [];
     let pageCount = 0;
     let start_cursor = undefined;
     do {
@@ -200,13 +207,13 @@ async function GetBlockChildren(block_id, totalPage) {
             start_cursor: start_cursor,
             block_id: block_id,
         }));
-        result.push(...response.results);
+        results.push(...response.results);
         start_cursor = response?.next_cursor;
         pageCount += 1;
     } while (start_cursor != null &&
         (totalPage == null || pageCount < totalPage));
-    ModifyNumberedListObject(result);
-    return result;
+    ModifyNumberedListObject(results);
+    return results;
 }
 function ModifyNumberedListObject(blocks) {
     let numberedListIndex = 0;
@@ -222,14 +229,66 @@ function ModifyNumberedListObject(blocks) {
     }
 }
 
+const BLOCK_TO_DO = "to_do";
+const BLOCK_TOGGLE = "toggle";
+const BLOCK_CALLOUT = "callout";
+const BLOCK_CHILD_PAGE = "child_page";
+const BLOCK_UNSUPPORTED = "supported";
+const BLOCK_SYNCED_BLOCK = "synced_block";
+const BLOCK_NUMBERED_LIST_ITEM = "numbered_list_item";
+const BLOCK_BULLETED_LIST_ITEM = "bulleted_list_item";
+const BLOCK_IMAGE = "image";
+const BLOCK_DIVIDER = "divider";
+const BLOCK_EQUATION = "equation";
+const BLOCK_PDF = "pdf";
+const BLOCK_FILE = "file";
+const BLOCK_VIDEO = "video";
+const BLOCK_EMBED = "embed";
+const BLOCK_BOOKMARK = "bookmark";
+const BLOCK_LINK_PREVIEW = "link_preview";
+const BLOCK_LINK_TO_PAGE = "link_to_page";
+const BLOCK_CHILD_DATABASE = "child_database";
+const BLOCK_TABLE = "table";
+const BLOCK_CODE = "code";
+const BLOCK_HEADING_1 = "heading_1";
+const BLOCK_HEADING_2 = "heading_2";
+const BLOCK_HEADING_3 = "heading_3";
+const BLOCK_QUOTE = "quote";
+const BLOCK_PARAGRAPH = "paragraph";
+const LINEWRAP_NULL = "";
+const LINEWRAP_NEWLINE = "\n";
+
+async function SaveJelly(fname, dir, jelly, dry_run = false) {
+    if (jelly === undefined)
+        return `failed: ${fname} has empty jelly: `;
+    try {
+        if (dry_run) {
+            console.log(jelly.content);
+            return `success: ${fname} saved to ${dir}`;
+        }
+        await fs.mkdir(dir, { recursive: true });
+        const filePath = path.join(dir, fname);
+        await fs.writeFile(filePath, jelly.content, "utf-8");
+        return `success: ${fname} saved to ${filePath}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return `failed: ${fname} - ${error.message}`;
+        }
+        else {
+            return "failed: an unknown error occurred";
+        }
+    }
+}
 class Noblog {
     Posts = [];
     CurrPage = "";
     SavePath = "./src/pages/posts/";
     ChildPath = "nob_children/";
+    LayoutPath = "../../layouts/MarkdownPostLayout.astro";
     MdCollection = {};
     CustomTransformers = {};
-    constructor(posts, save_path, child_path) {
+    constructor(posts, save_path, child_path, layout_path) {
         this.Posts = posts;
         if (child_path != undefined) {
             this.ChildPath = child_path;
@@ -237,12 +296,14 @@ class Noblog {
         if (save_path != undefined) {
             this.SavePath = save_path;
         }
-        this.CustomTransformers["child_page"] = async (block) => {
+        if (layout_path != undefined) {
+            this.LayoutPath = layout_path;
+        }
+        this.CustomTransformers[BLOCK_CHILD_PAGE] = async (block) => {
             const page = block;
             if (!page?.id) {
                 return false;
             }
-            let sub_path;
             // if (curr_page.id in this.Post) and (page.id in this.Post) ||
             //    (curr_page.id not in this.Post) and (page.id not in this.Post)
             //    * path should be "../pageid"
@@ -250,6 +311,7 @@ class Noblog {
             //    * path should be "../save_path/pageid"
             // if (curr_page.id not in this.Post) and (page.id in this.Post)
             //    * path should be "../../pageid"
+            let sub_path;
             const parent_surface = this.Posts.filter((post) => post.id === this.CurrPage).length > 0;
             const child_surface = this.Posts.filter((post) => post.id === page.id).length > 0;
             if (parent_surface === child_surface) {
@@ -262,21 +324,22 @@ class Noblog {
                 sub_path = "..";
             }
             const full_path = path.join("../", sub_path, page.id);
-            return `＆[${page.child_page.title}](${full_path})`;
+            return `(」ﾟﾛﾟ)｣ [${page.child_page.title}](${full_path})`;
         };
     }
-    async Collect(recur = true) {
+    // Collect converts all pages in database to markdown files
+    async Collect(recursive = true) {
         const save_dir = this.SavePath;
         const sub_dir = path.join(save_dir, this.ChildPath);
         for (const page of this.Posts) {
-            await this.FromPageid(page.id, recur);
+            await this.FromPageId(page.id, recursive);
         }
         try {
-            for (const pageid of Object.keys(this.MdCollection)) {
+            for (const page_id of Object.keys(this.MdCollection)) {
                 let fpath = sub_dir;
-                if (this.Posts.find((page) => page.id === pageid))
+                if (this.Posts.find((page) => page.id === page_id))
                     fpath = save_dir;
-                await this.SaveJelly(pageid + ".md", fpath, this.MdCollection[pageid]);
+                await SaveJelly(page_id + ".md", fpath, this.MdCollection[page_id]);
             }
             console.log(`success: finish dump all files to "${save_dir}"`);
         }
@@ -289,27 +352,34 @@ class Noblog {
             }
         }
     }
+    // FromBlocks converts blocks fetched from notion api to
+    // rendered chunk (which is called jelly). Content in jelly
+    // will be collected to form the final markdown. If recursive
+    // is true, it will also fetch child pages exists in the given
+    // blocks.
     async FromBlocks(blocks, recursive) {
         const jelly = { content: "", children: [] };
         for (const block of blocks) {
             const subjelly = await this.FromBlocks(block.children, recursive);
-            if (block.type === "toggle") {
-                jelly.content += toggle(block.parent, subjelly.content);
-                jelly.children = [...jelly.children, ...subjelly.children];
-                continue;
+            let line_wrap = LINEWRAP_NULL;
+            if (block.type !== BLOCK_TO_DO &&
+                block.type !== BLOCK_BULLETED_LIST_ITEM &&
+                block.type !== BLOCK_NUMBERED_LIST_ITEM) {
+                line_wrap = LINEWRAP_NEWLINE;
             }
-            let line_wrap = "";
-            if (block.type !== "to_do" &&
-                block.type !== "bulleted_list_item" &&
-                block.type !== "numbered_list_item") {
-                line_wrap = "\n";
+            switch (block.type) {
+                case BLOCK_TOGGLE:
+                    jelly.content += toggle(block.parent, subjelly.content);
+                    jelly.children = [...jelly.children, ...subjelly.children];
+                    continue;
+                default:
+                    jelly.content +=
+                        line_wrap + `${addTabSpace(block.parent, 0)}\n` + line_wrap;
             }
-            jelly.content +=
-                line_wrap + `${addTabSpace(block.parent, 0)}\n` + line_wrap;
-            if (block.type === "child_page") {
+            if (block.type === BLOCK_CHILD_PAGE) {
                 jelly.children = [...jelly.children, block.blockId];
                 if (recursive)
-                    await this.FromPageid(block.blockId, recursive);
+                    await this.FromPageId(block.blockId, recursive);
             }
             else {
                 jelly.content += subjelly.content;
@@ -318,7 +388,11 @@ class Noblog {
         }
         return jelly;
     }
-    async FromPageid(page_id, recursive = true) {
+    // FromPageid converts a page id to rendered chunk (which is
+    // called jelly). Content in jelly will be collected to form
+    // the final markdown. If recursive is true, it will also
+    // fetch child pages exists in the given page.
+    async FromPageId(page_id, recursive = true) {
         // preserve the curr page info
         const prev_page = this.CurrPage;
         this.CurrPage = page_id;
@@ -327,7 +401,7 @@ class Noblog {
         }
         const blocks = await this.PageToMarkdown(page_id);
         const jelly = await this.FromBlocks(blocks, recursive);
-        const meta = await GetPageMeta(page_id);
+        const meta = await GetPage(page_id);
         const astro_meta = await this.AssembleAstroFrontmatter(meta);
         jelly.content = astro_meta + jelly.content;
         this.MdCollection[page_id] = jelly;
@@ -337,7 +411,7 @@ class Noblog {
     }
     async PageToMarkdown(id, totalPage) {
         if (!client) {
-            throw new Error("notion client is not provided, for more details check out https://github.com/souvikinator/notion-to-md");
+            throw new Error("notion client is not provided");
         }
         const blocks = await GetBlockChildren(id, totalPage);
         const parsedData = await this.BlocksToMarkdown(blocks);
@@ -345,68 +419,64 @@ class Noblog {
     }
     async BlocksToMarkdown(blocks, totalPage = null, mdBlocks = []) {
         if (!client) {
-            throw new Error("notion client is not provided, for more details check out https://github.com/souvikinator/notion-to-md");
+            throw new Error("notion client is not provided");
         }
-        if (!mdBlocks)
-            mdBlocks = [];
         if (!blocks)
             return mdBlocks;
-        for (let i = 0; i < blocks.length; i++) {
-            const block = blocks[i];
-            if (
+        for (const block of blocks) {
             // @ts-ignore
-            block.type === "unsupported") {
+            if (block.type === BLOCK_UNSUPPORTED) {
                 continue;
             }
-            if ("has_children" in block && block.has_children) {
-                const block_id = block.type == "synced_block" &&
-                    block.synced_block?.synced_from?.block_id
-                    ? block.synced_block.synced_from.block_id
-                    : block.id;
-                // Get children of this block.
-                const child_blocks = await GetBlockChildren(block_id, totalPage);
-                // Recursively call BlocksToMarkdown to get children of this block.
-                // check for custom transformer before parsing child
-                if (!(block.type in this.CustomTransformers) &&
-                    !this.CustomTransformers[block.type]) {
-                    const l = mdBlocks.length;
-                    if (mdBlocks !== undefined) {
-                        await this.BlocksToMarkdown(child_blocks, totalPage, mdBlocks[l - 1]?.children);
-                    }
-                }
-                // Push this block to mdBlocks.
+            if (!("has_children" in block) || !block.has_children) {
                 mdBlocks.push({
+                    // @ts-ignore
                     type: block.type,
                     blockId: block.id,
-                    parent: await this.BlockToMarkdown(block),
                     children: [],
+                    parent: await this.BlockToMarkdown(block),
                 });
                 continue;
             }
-            const tmp = await this.BlockToMarkdown(block);
+            const block_id = block.type == BLOCK_SYNCED_BLOCK &&
+                block.synced_block?.synced_from?.block_id
+                ? block.synced_block.synced_from.block_id
+                : block.id;
+            // Get children of this block.
+            const child_blocks = await GetBlockChildren(block_id, totalPage);
+            // Push this block to mdBlocks.
             mdBlocks.push({
-                // @ts-ignore
                 type: block.type,
                 blockId: block.id,
-                parent: tmp,
+                parent: await this.BlockToMarkdown(block),
                 children: [],
             });
+            if (block.type === BLOCK_CALLOUT) {
+                continue;
+            }
+            if (!(block.type in this.CustomTransformers)) {
+                continue;
+            }
+            // Recursively call BlocksToMarkdown to collect children. check for custom transformer before parsing child
+            if (mdBlocks !== undefined) {
+                await this.BlocksToMarkdown(child_blocks, totalPage, mdBlocks[mdBlocks.length - 1]?.children);
+            }
         }
         return mdBlocks;
     }
     async BlockToMarkdown(block) {
         if (typeof block !== "object" || !("type" in block))
             return "";
-        let parsedData = "";
+        let renderedData = "";
         const { type } = block;
         if (type in this.CustomTransformers && !!this.CustomTransformers[type]) {
             const transformer = this.CustomTransformers[type];
-            const customTransformerValue = transformer(block);
+            const customTransformerValue = await transformer(block);
             if (typeof customTransformerValue === "string")
                 return customTransformerValue;
         }
         switch (type) {
-            case "image":
+            case BLOCK_IMAGE:
                 const blockContent = block.image;
                 let image_title = "image";
                 const image_caption_plain = blockContent.caption
@@ -429,21 +499,21 @@ class Noblog {
                     image_title = matches ? matches[0] : image_title;
                 }
                 return await image(image_title, link$1, false);
-            case "divider":
+            case BLOCK_DIVIDER:
                 return divider();
-            case "equation":
+            case BLOCK_EQUATION:
                 return equation(block.equation.expression);
-            case "pdf":
-            case "file":
-            case "video":
+            case BLOCK_PDF:
+            case BLOCK_FILE:
+            case BLOCK_VIDEO:
                 {
                     let blockContent;
                     let title = type;
-                    if (type === "pdf")
+                    if (type === BLOCK_PDF)
                         blockContent = block.pdf;
-                    if (type === "file")
+                    if (type === BLOCK_FILE)
                         blockContent = block.file;
-                    if (type === "video")
+                    if (type === BLOCK_VIDEO)
                         blockContent = block.video;
                     const caption = blockContent?.caption
                         .map((item) => item.plain_text)
@@ -466,20 +536,20 @@ class Noblog {
                     }
                 }
                 break;
-            case "embed":
-            case "bookmark":
-            case "link_preview":
-            case "link_to_page":
+            case BLOCK_EMBED:
+            case BLOCK_BOOKMARK:
+            case BLOCK_LINK_PREVIEW:
+            case BLOCK_LINK_TO_PAGE:
                 {
                     let blockContent;
                     const title = type;
-                    if (type === "embed")
+                    if (type === BLOCK_EMBED)
                         blockContent = block.embed;
-                    if (type === "bookmark")
+                    if (type === BLOCK_BOOKMARK)
                         blockContent = block.bookmark;
-                    if (type === "link_preview")
+                    if (type === BLOCK_LINK_PREVIEW)
                         blockContent = block.link_preview;
-                    if (type === "link_to_page" &&
+                    if (type === BLOCK_LINK_TO_PAGE &&
                         block.link_to_page.type === "page_id") {
                         blockContent = {
                             url: `https://www.notion.so/${block.link_to_page.page_id}`,
@@ -489,15 +559,15 @@ class Noblog {
                         return link(title, blockContent.url);
                 }
                 break;
-            case "child_page": {
+            case BLOCK_CHILD_PAGE: {
                 const pageTitle = block.child_page.title;
                 return heading2(pageTitle);
             }
-            case "child_database": {
+            case BLOCK_CHILD_DATABASE: {
                 const pageTitle = block.child_database.title || `child_database`;
                 return heading2(pageTitle);
             }
-            case "table": {
+            case BLOCK_TABLE: {
                 const { id, has_children } = block;
                 const tableArr = [];
                 if (has_children) {
@@ -511,7 +581,7 @@ class Noblog {
                          * reuse the BlockToMarkdown function
                          */
                         const cellStringPromise = cells.map(async (cell) => await this.BlockToMarkdown({
-                            type: "paragraph",
+                            type: BLOCK_PARAGRAPH,
                             paragraph: { rich_text: cell },
                         }));
                         const cellStringArr = await Promise.all(cellStringPromise);
@@ -594,125 +664,275 @@ class Noblog {
                     // @ts-ignore
                     bucket[to - 1] = bucket[to - 1] + sanno;
                 }
-                bucket.forEach((x) => (parsedData += x));
+                bucket.forEach((x) => (renderedData += x));
             }
         }
         switch (type) {
-            case "code":
-                parsedData = codeBlock(parsedData, block[type].language);
+            case BLOCK_CODE:
+                renderedData = codeBlock(renderedData, block[type].language);
                 break;
-            case "heading_1":
-                parsedData = heading1(parsedData);
+            case BLOCK_HEADING_1:
+                renderedData = heading1(renderedData);
                 break;
-            case "heading_2":
-                parsedData = heading2(parsedData);
+            case BLOCK_HEADING_2:
+                renderedData = heading2(renderedData);
                 break;
-            case "heading_3":
-                parsedData = heading3(parsedData);
+            case BLOCK_HEADING_3:
+                renderedData = heading3(renderedData);
                 break;
-            case "quote":
-                parsedData = quote(parsedData);
+            case BLOCK_QUOTE:
+                renderedData = quote(renderedData);
                 break;
-            case "callout":
+            case BLOCK_CALLOUT:
                 const { id, has_children } = block;
                 let callout_string = "";
                 if (!has_children) {
-                    return callout(parsedData, block[type].icon);
+                    return callout(renderedData, block.callout.icon);
                 }
                 const callout_children_object = await GetBlockChildren(id, 100);
                 const callout_children = await this.BlocksToMarkdown(callout_children_object);
-                callout_string += `${parsedData}\n`;
-                callout_children.map((child) => {
-                    callout_string += `${child.parent}\n\n`;
-                });
-                parsedData = callout(callout_string.trim(), block[type].icon);
+                callout_string += `${renderedData}\n`;
+                callout_string += (await this.FromBlocks(callout_children, true))
+                    .content;
+                renderedData = callout(callout_string.trim(), block.callout.icon);
                 break;
-            case "bulleted_list_item":
-                parsedData = bullet(parsedData);
+            case BLOCK_BULLETED_LIST_ITEM:
+                renderedData = bullet(renderedData);
                 break;
-            case "numbered_list_item":
-                parsedData = bullet(parsedData, block.numbered_list_item.number);
+            case BLOCK_NUMBERED_LIST_ITEM:
+                renderedData = bullet(renderedData, block.numbered_list_item.number);
                 break;
-            case "to_do":
-                parsedData = todo(parsedData, block.to_do.checked);
+            case BLOCK_TO_DO:
+                renderedData = todo(renderedData, block.to_do.checked);
                 break;
         }
-        return parsedData;
-    }
-    async SaveJelly(fname, dir, jelly) {
-        if (jelly === undefined)
-            return `failed: ${fname} has empty jelly: `;
-        try {
-            await fs.mkdir(dir, { recursive: true });
-            const filePath = path.join(dir, fname);
-            await fs.writeFile(filePath, jelly.content, "utf-8");
-            return `success: ${fname} saved to ${filePath}`;
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                return `failed: ${fname} - ${error.message}`;
-            }
-            else {
-                return "failed: an unknown error occurred";
-            }
-        }
+        return renderedData;
     }
     async AssembleAstroFrontmatter(page) {
         let frontmatter = "";
-        // default layout
+        // Default layout
         const ischild = this.Posts.filter((post) => post.id === page.id).length > 0 ? "" : "../";
-        frontmatter +=
-            "layout: " + ischild + "../../layouts/MarkdownPostLayout.astro" + "\n";
-        // get title
-        frontmatter +=
-            "title: " +
-                JSON.stringify(page.properties.title?.title?.[0]?.plain_text ?? "") +
-                "\n";
-        // get tags
-        frontmatter +=
-            "tags: " +
-                JSON.stringify((page.properties.tags?.multi_select ?? []).map((tag) => tag.name)) +
-                "\n";
-        // get date
-        frontmatter +=
-            "pubDate: " +
-                (page.properties.date?.date?.start ??
-                    new Date().toISOString().split("T")[0]) +
-                "\n";
-        // get archived
-        frontmatter +=
-            "archived: " + (page.properties.archived ? "true" : "false") + "\n";
-        // get description
-        frontmatter +=
-            "description: " +
-                JSON.stringify(page.properties.description?.rich_text?.[0]?.plain_text ?? "") +
-                "\n";
+        frontmatter += "layout: " + ischild + this.LayoutPath + "\n";
+        Object.entries(page.properties).forEach(([key, property]) => {
+            switch (property.type) {
+                case "title": // Get title
+                    frontmatter +=
+                        "title: " +
+                            JSON.stringify(property.title
+                                ?.map((title) => title.plain_text)
+                                .reduce((a, b) => a + b)) +
+                            "\n";
+                    break;
+                case "multi_select": // Get tags
+                    frontmatter +=
+                        "tags: " +
+                            JSON.stringify(property.multi_select.map((tag) => tag.name)) +
+                            "\n";
+                    break;
+                case "date": // Get date
+                    frontmatter +=
+                        "pubDate: " +
+                            (property.date?.start ?? new Date().toISOString().split("T")[0]) +
+                            "\n";
+                    break;
+                default: // Customized properties from the template given in the Github repo
+                    switch (key) {
+                        case "archived": // Get archived
+                            if (property.type === "checkbox")
+                                frontmatter +=
+                                    "archived: " + property.checkbox
+                                        ? "true"
+                                        : "false" + "\n";
+                            break;
+                        case "description": // Get description
+                            if (property.type === "rich_text")
+                                frontmatter +=
+                                    "description: " +
+                                        JSON.stringify(property.rich_text?.[0]?.plain_text ?? "") +
+                                        "\n";
+                            break;
+                    }
+            }
+        });
         return "---\n" + frontmatter + "---\n";
     }
 }
 
+function getVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const packagePath = join(__dirname, "../../package.json");
+        const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+        return packageJson.version;
+    }
+    catch {
+        return "unknown";
+    }
+}
 function help() {
-    console.log(`\n
-Usage: noblog [SAVE_PATH] [SUB_PATH]
+    console.log(`
+noblog - Generate static blog content from Notion.so
+
+Usage: noblog [command] [options] [SAVE_PATH] [SUB_PATH]
+
+Options:
+  -v, --verbose    Print more messages for debugging
+  -h, --help       Show help message
+  --version        Show version information
+  --layout PATH    Custom layout path (default: ../../layouts/MarkdownPostLayout.astro)
+
+Commands:
+  help     Show this help message
+  version  Show version information
+  generate Generate blog content (default command)
+
+Options:
+  -v, --verbose    Print more messages for debugging
+  -h, --help       Show help message
+  --version        Show version information
+
+Arguments:
+  SAVE_PATH        Directory to save main posts (default: ./src/pages/posts/)
+  SUB_PATH         Subdirectory for nested content (default: nob_children/)
 
-Example:
-  noblog
+Layout Options:
+  --layout PATH    Custom layout path relative to save directory (default: ../../layouts/MarkdownPostLayout.astro)
+
+Examples:
+  noblog help
+  noblog version
+  noblog generate
+  noblog -v
   noblog src/pages/posts/ nob_children/
+  noblog --layout ../../layouts/BlogLayout.astro
+  noblog src/posts/ children/ --layout ../../../layouts/CustomLayout.astro -v
 
-Available <option>:
-  -v  Print more messages for debugging.\n`);
+Environment Variables:
+  NOTION_API_SECRET    Your Notion API secret
+  NOBLOG_DATABASE_ID   Your Notion database ID
+`);
+}
+function parseArgs(argv) {
+    const options = {
+        verbose: false,
+        help: false,
+        version: false,
+        savePath: "./src/pages/posts/",
+        subPath: "nob_children/",
+        layoutPath: "../../layouts/MarkdownPostLayout.astro",
+    };
+    const positionalArgs = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case "-v":
+            case "--verbose":
+                options.verbose = true;
+                break;
+            case "-h":
+            case "--help":
+            case "help":
+                options.help = true;
+                break;
+            case "--version":
+            case "version":
+                options.version = true;
+                break;
+            case "--layout":
+                if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+                    options.layoutPath = argv[++i];
+                }
+                else {
+                    console.error("Error: --layout requires a path argument");
+                    help();
+                    process.exit(1);
+                }
+                break;
+            case "generate":
+                // Explicit generate command, skip it
+                break;
+            default:
+                if (arg.startsWith("-")) {
+                    console.error(`Unknown option: ${arg}`);
+                    help();
+                    process.exit(1);
+                }
+                positionalArgs.push(arg);
+                break;
+        }
+    }
+    // Handle positional arguments
+    if (positionalArgs.length > 0) {
+        options.savePath = positionalArgs[0];
+    }
+    if (positionalArgs.length > 1) {
+        options.subPath = positionalArgs[1];
+    }
+    if (positionalArgs.length > 2) {
+        console.error("Error: Too many arguments.");
+        help();
+        process.exit(1);
+    }
+    return options;
+}
+async function generateBlog(options) {
+    try {
+        if (options.verbose) {
+            console.log("Fetching posts from Notion...");
+        }
+        const pages = await ListPages();
+        if (options.verbose) {
+            console.log(`Found ${pages.length} pages`);
+            console.log(`Save path: ${options.savePath}`);
+            console.log(`Sub path: ${options.subPath}`);
+            console.log(`Layout path: ${options.layoutPath}`);
+        }
+        const nob = new Noblog(pages, options.savePath, options.subPath, options.layoutPath);
+        await nob.Collect(true);
+        console.log(`✅ Successfully generated blog content`);
+    }
+    catch (error) {
+        console.error(`❌ Error generating blog content:`);
+        if (error instanceof Error) {
+            console.error(`   ${error.message}`);
+            if (options.verbose) {
+                console.error(error.stack);
+            }
+        }
+        else {
+            console.error(`   An unknown error occurred`);
+        }
+        process.exit(1);
+    }
 }
 async function main() {
     const argv = process.argv.slice(2);
-    if (argv.length > 2) {
-        console.error("Error: invallid arg.");
+    if (argv.length === 0) {
+        // Default behavior: generate with default options
+        await generateBlog({
+            verbose: false,
+            help: false,
+            version: false,
+            savePath: "./src/pages/posts/",
+            subPath: "nob_children/",
+            layoutPath: "../../layouts/MarkdownPostLayout.astro",
+        });
+        return;
+    }
+    const options = parseArgs(argv);
+    if (options.help) {
         help();
+        return;
     }
-    const save_dir = argv[0] ?? "./src/pages/posts/";
-    const sub_dir = argv[1] ?? "nob_children/";
-    const pages = await GetAllPosts();
-    const nob = new Noblog(pages, save_dir, sub_dir);
-    nob.Collect(true);
+    if (options.version) {
+        console.log(`noblog v${getVersion()}`);
+        return;
+    }
+    await generateBlog(options);
 }
-main();
+main().catch((error) => {
+    console.error(`❌ Unexpected error:`, error);
+    process.exit(1);
+});
 //# sourceMappingURL=generate.js.map