nconv-cli 1.0.0 → 1.0.3

package/dist/index.js

@@ -4,20 +4,108 @@
 import { Command } from "commander";
 
 // src/config.ts
-import { config as dotenvConfig } from "dotenv";
-import { resolve } from "path";
-dotenvConfig();
+import { existsSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+import os from "os";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+function success(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function error(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function info(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+function warn(message) {
+  console.log(chalk.yellow("\u26A0"), message);
+}
+function spinner(text) {
+  return ora(text).start();
+}
+
+// src/config.ts
+process.env.DOTENV_CONFIG_SILENT = "true";
+function getConfigPath() {
+  return join(os.homedir(), ".nconv", ".env");
+}
+function loadEnv() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    let loadedCount = 0;
+    content.split("\n").forEach((line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) {
+        return;
+      }
+      const equalIndex = trimmed.indexOf("=");
+      if (equalIndex === -1) {
+        return;
+      }
+      const key = trimmed.substring(0, equalIndex).trim();
+      const value = trimmed.substring(equalIndex + 1).trim();
+      if (key && value) {
+        process.env[key] = value;
+        loadedCount++;
+      }
+    });
+    if (process.env.NCONV_VERBOSE) {
+      info(`\u2713 Loaded ${loadedCount} environment variable(s) from ${configPath}`);
+    }
+  } catch (error2) {
+    error(`Failed to load configuration from: ${configPath}`);
+    if (error2 instanceof Error) {
+      error(error2.message);
+    }
+  }
+}
+function checkEnv() {
+  const configPath = getConfigPath();
+  if (!process.env.TOKEN_V2 || !process.env.FILE_TOKEN) {
+    error("Notion tokens are not set.");
+    if (!existsSync(configPath)) {
+      error("Configuration file not found.");
+      error('Please run "nconv init" to create a configuration file.');
+    } else {
+      error(`Please set TOKEN_V2 and FILE_TOKEN in: ${configPath}`);
+    }
+    process.exit(1);
+  }
+}
+function validateConfig() {
+  loadEnv();
+  const configPath = getConfigPath();
+  if (!process.env.TOKEN_V2 || !process.env.FILE_TOKEN) {
+    if (!existsSync(configPath)) {
+      return {
+        valid: false,
+        message: "Configuration file not found. Please run /init to set up your Notion tokens."
+      };
+    } else {
+      return {
+        valid: false,
+        message: `Notion tokens are not set. Please run /init or /config to set up your tokens.
+Config file: ${configPath}`
+      };
+    }
+  }
+  return { valid: true };
+}
 function getNotionConfig() {
   const tokenV2 = process.env.TOKEN_V2 || "";
   const fileToken = process.env.FILE_TOKEN || "";
-  if (!tokenV2 || !fileToken) {
-    throw new Error(
-      "Notion \uD1A0\uD070\uC774 \uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.\n.env \uD30C\uC77C\uC5D0 TOKEN_V2\uC640 FILE_TOKEN\uC744 \uC124\uC815\uD574\uC8FC\uC138\uC694.\n\uC790\uC138\uD55C \uB0B4\uC6A9\uC740 .env.example\uC744 \uCC38\uACE0\uD558\uC138\uC694."
-    );
-  }
   return { tokenV2, fileToken };
 }
 function createConfig(options) {
+  loadEnv();
+  checkEnv();
   const notionConfig = getNotionConfig();
   const outputDir = resolve(process.cwd(), options.output);
   return {
@@ -31,9 +119,12 @@ function createConfig(options) {
 import { NotionExporter } from "notion-exporter";
 import { promises as fs } from "fs";
 import path from "path";
+import { mdToPdf } from "md-to-pdf";
 var NotionMarkdownExporter = class {
-  constructor(config) {
-    this.exporter = new NotionExporter(config.tokenV2, config.fileToken);
+  constructor(config, exportType = "markdown") {
+    this.exporter = new NotionExporter(config.tokenV2, config.fileToken, {
+      exportType
+    });
   }
   /**
    * Notion URL에서 마크다운과 이미지 파일 가져오기
@@ -73,6 +164,115 @@ var NotionMarkdownExporter = class {
       throw new Error("Failed to fetch Notion page.");
     }
   }
+  /**
+   * Notion URL에서 HTML과 이미지 파일 가져오기
+   */
+  async exportHTML(notionUrl, tempDir) {
+    try {
+      await fs.mkdir(tempDir, { recursive: true });
+      await this.exporter.getMdFiles(notionUrl, tempDir);
+      const files = await fs.readdir(tempDir, { withFileTypes: true });
+      const htmlFile = files.find((f) => f.isFile() && f.name.endsWith(".html"));
+      if (!htmlFile) {
+        throw new Error("HTML file not found.");
+      }
+      const htmlPath = path.join(tempDir, htmlFile.name);
+      const html = await fs.readFile(htmlPath, "utf-8");
+      const imageFiles = files.filter((f) => f.isFile() && !f.name.endsWith(".html")).map((f) => ({
+        filename: f.name,
+        sourcePath: path.join(tempDir, f.name)
+      }));
+      const dirs = files.filter((f) => f.isDirectory());
+      for (const dir of dirs) {
+        const subFiles = await fs.readdir(path.join(tempDir, dir.name), { withFileTypes: true });
+        for (const subFile of subFiles) {
+          if (subFile.isFile() && !subFile.name.endsWith(".html")) {
+            imageFiles.push({
+              filename: path.join(dir.name, subFile.name),
+              sourcePath: path.join(tempDir, dir.name, subFile.name)
+            });
+          }
+        }
+      }
+      return { html, imageFiles };
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        throw new Error(`Failed to fetch Notion page as HTML: ${error2.message}`);
+      }
+      throw new Error("Failed to fetch Notion page as HTML.");
+    }
+  }
+  /**
+   * Markdown을 PDF로 변환 (md-to-pdf 사용)
+   * GitHub 스타일의 깔끔한 PDF 생성
+   */
+  async exportMarkdownToPDF(markdownContent, outputPath, options = {}) {
+    try {
+      const pdfOptions = {
+        content: markdownContent,
+        stylesheet: options.stylesheet || [
+          "https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/5.1.0/github-markdown.min.css"
+        ],
+        body_class: "markdown-body",
+        css: `
+          .markdown-body {
+            box-sizing: border-box;
+            min-width: 200px;
+            max-width: 980px;
+            margin: 0 auto;
+            padding: 45px;
+          }
+
+          @media (max-width: 767px) {
+            .markdown-body {
+              padding: 15px;
+            }
+          }
+
+          /* \uCF54\uB4DC \uBE14\uB85D \uC2A4\uD0C0\uC77C \uAC1C\uC120 */
+          .markdown-body pre {
+            background-color: #f6f8fa;
+            border-radius: 6px;
+            padding: 16px;
+            overflow: auto;
+          }
+
+          .markdown-body code {
+            background-color: rgba(175, 184, 193, 0.2);
+            border-radius: 6px;
+            padding: 0.2em 0.4em;
+          }
+
+          /* \uC774\uBBF8\uC9C0 \uC2A4\uD0C0\uC77C */
+          .markdown-body img {
+            max-width: 100%;
+            height: auto;
+          }
+        `,
+        pdf_options: {
+          format: options.format || "A4",
+          margin: options.margin || {
+            top: "20mm",
+            right: "20mm",
+            bottom: "20mm",
+            left: "20mm"
+          },
+          printBackground: true
+        }
+      };
+      const result = await mdToPdf(pdfOptions);
+      if (result.content) {
+        await fs.writeFile(outputPath, result.content);
+      } else {
+        throw new Error("PDF content is empty");
+      }
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        throw new Error(`Failed to convert Markdown to PDF: ${error2.message}`);
+      }
+      throw new Error("Failed to convert Markdown to PDF.");
+    }
+  }
 };
 
 // src/utils/file.ts
@@ -115,28 +315,12 @@ async function saveMarkdownFile(outputDir, filename, content) {
   return filePath;
 }
 
-// src/utils/logger.ts
-import chalk from "chalk";
-import ora from "ora";
-function success(message) {
-  console.log(chalk.green("\u2713"), message);
-}
-function error(message) {
-  console.error(chalk.red("\u2717"), message);
-}
-function info(message) {
-  console.log(chalk.blue("\u2139"), message);
-}
-function spinner(text) {
-  return ora(text).start();
-}
-
 // src/commands/md.ts
 import path3 from "path";
 import { promises as fs3 } from "fs";
-import os from "os";
+import os2 from "os";
 async function mdCommand(notionUrl, options) {
-  const tempDir = path3.join(os.tmpdir(), `nconv-cli-${Date.now()}`);
+  const tempDir = path3.join(os2.tmpdir(), `nconv-cli-${Date.now()}`);
   try {
     const config = createConfig(options);
     if (config.verbose) {
@@ -166,10 +350,6 @@ async function mdCommand(notionUrl, options) {
     }
     const pageDir = path3.join(config.output, baseFilename);
     await fs3.mkdir(pageDir, { recursive: true });
-    if (config.verbose) {
-      console.log(`\u{1F4C1} \uCD9C\uB825 \uD3F4\uB354: ${path3.relative(process.cwd(), pageDir)}
-`);
-    }
     const imageOutputDir = path3.join(pageDir, config.imageDir);
     await fs3.mkdir(imageOutputDir, { recursive: true });
     if (config.verbose && result.imageFiles.length > 0) {
@@ -225,10 +405,206 @@ async function mdCommand(notionUrl, options) {
   }
 }
 
+// src/commands/html.ts
+import path4 from "path";
+import { promises as fs4 } from "fs";
+import os3 from "os";
+async function htmlCommand(notionUrl, options) {
+  const tempDir = path4.join(os3.tmpdir(), `nconv-cli-${Date.now()}`);
+  try {
+    const config = createConfig(options);
+    if (config.verbose) {
+      info("Configuration loaded successfully");
+      console.log(`  Output directory: ${config.output}
+`);
+    }
+    const spinner2 = spinner("Fetching Notion page as HTML...");
+    const exporter = new NotionMarkdownExporter({
+      tokenV2: config.tokenV2,
+      fileToken: config.fileToken
+    }, "html");
+    let result;
+    try {
+      result = await exporter.exportHTML(notionUrl, tempDir);
+      spinner2.succeed(`Notion page fetched (${result.imageFiles.length} images)`);
+    } catch (error2) {
+      spinner2.fail("Failed to fetch Notion page");
+      throw error2;
+    }
+    let baseFilename;
+    if (config.filename) {
+      baseFilename = config.filename.replace(/\.html?$/, "");
+    } else {
+      const title = extractTitleFromUrl(notionUrl);
+      baseFilename = generateSafeFilename(title, "");
+    }
+    const pageDir = path4.join(config.output, baseFilename);
+    await fs4.mkdir(pageDir, { recursive: true });
+    const imageOutputDir = path4.join(pageDir, config.imageDir);
+    await fs4.mkdir(imageOutputDir, { recursive: true });
+    if (config.verbose && result.imageFiles.length > 0) {
+      console.log(`Processing image files...
+`);
+    }
+    let processedHtml = result.html;
+    for (const imageFile of result.imageFiles) {
+      try {
+        const originalFileName = path4.basename(imageFile.filename);
+        const safeFileName = originalFileName.replace(/\s+/g, "-");
+        const targetPath = path4.join(imageOutputDir, safeFileName);
+        await fs4.copyFile(imageFile.sourcePath, targetPath);
+        if (config.verbose) {
+          console.log(`\u2713 ${safeFileName}`);
+        }
+        const originalPath = imageFile.filename;
+        const relativePath = `./${config.imageDir}/${safeFileName}`;
+        const pathParts = originalPath.split("/");
+        const encodedPath = pathParts.map((part) => encodeURIComponent(part)).join("/");
+        const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        processedHtml = processedHtml.replace(new RegExp(`(src|href)="${escapeRegex(originalPath)}"`, "g"), `$1="${relativePath}"`).replace(new RegExp(`(src|href)="${escapeRegex(encodedPath)}"`, "g"), `$1="${relativePath}"`);
+      } catch (error2) {
+        if (config.verbose) {
+          const errorMsg = error2 instanceof Error ? error2.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
+          console.error(`\u2717 ${imageFile.filename}: ${errorMsg}`);
+        }
+      }
+    }
+    const filename = `${baseFilename}.html`;
+    const filePath = path4.join(pageDir, filename);
+    await fs4.writeFile(filePath, processedHtml, "utf-8");
+    console.log("");
+    success("Conversion complete!");
+    console.log("");
+    console.log(`\u{1F4C1} Folder: ${path4.relative(process.cwd(), pageDir)}`);
+    console.log(`\u{1F4C4} HTML: ${filename}`);
+    if (result.imageFiles.length > 0) {
+      console.log(`\u{1F5BC}\uFE0F  Images: ${config.imageDir}/ (${result.imageFiles.length} files)`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      error(error2.message);
+    } else {
+      error("An unknown error occurred.");
+    }
+    process.exit(1);
+  } finally {
+    try {
+      await fs4.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+// src/commands/pdf.ts
+import path5 from "path";
+import { promises as fs5 } from "fs";
+import os4 from "os";
+async function pdfCommand(notionUrl, options) {
+  const tempDir = path5.join(os4.tmpdir(), `nconv-cli-${Date.now()}`);
+  try {
+    const config = createConfig(options);
+    if (config.verbose) {
+      info("Configuration loaded successfully");
+      console.log(`  Output directory: ${config.output}
+`);
+    }
+    const spinner2 = spinner("Fetching Notion page as Markdown...");
+    const exporter = new NotionMarkdownExporter({
+      tokenV2: config.tokenV2,
+      fileToken: config.fileToken
+    });
+    let result;
+    try {
+      result = await exporter.exportWithImages(notionUrl, tempDir);
+      spinner2.succeed(`Notion page fetched (${result.imageFiles.length} images)`);
+    } catch (error2) {
+      spinner2.fail("Failed to fetch Notion page");
+      throw error2;
+    }
+    let baseFilename;
+    if (config.filename) {
+      baseFilename = config.filename.replace(/\.pdf$/, "");
+    } else {
+      const title = extractTitleFromUrl(notionUrl);
+      baseFilename = generateSafeFilename(title, "");
+    }
+    const pageDir = path5.join(config.output, baseFilename);
+    await fs5.mkdir(pageDir, { recursive: true });
+    const imageOutputDir = path5.join(pageDir, config.imageDir);
+    await fs5.mkdir(imageOutputDir, { recursive: true });
+    if (config.verbose && result.imageFiles.length > 0) {
+      console.log(`Processing image files...
+`);
+    }
+    let processedMarkdown = result.markdown;
+    for (const imageFile of result.imageFiles) {
+      try {
+        const originalFileName = path5.basename(imageFile.filename);
+        const safeFileName = originalFileName.replace(/\s+/g, "-");
+        const targetPath = path5.join(imageOutputDir, safeFileName);
+        await fs5.copyFile(imageFile.sourcePath, targetPath);
+        if (config.verbose) {
+          console.log(`\u2713 ${safeFileName}`);
+        }
+        const imageBuffer = await fs5.readFile(targetPath);
+        const base64 = imageBuffer.toString("base64");
+        const ext = path5.extname(safeFileName).slice(1).toLowerCase();
+        const mimeType = ext === "jpg" ? "jpeg" : ext;
+        const dataUrl = `data:image/${mimeType};base64,${base64}`;
+        const originalPath = imageFile.filename;
+        const relativePath = `./${config.imageDir}/${safeFileName}`;
+        const pathParts = originalPath.split("/");
+        const encodedPath = pathParts.map((part) => encodeURIComponent(part)).join("/");
+        const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        processedMarkdown = processedMarkdown.replace(new RegExp(`\\(${escapeRegex(originalPath)}\\)`, "g"), `(${dataUrl})`).replace(new RegExp(`\\(${escapeRegex(encodedPath)}\\)`, "g"), `(${dataUrl})`);
+      } catch (error2) {
+        if (config.verbose) {
+          const errorMsg = error2 instanceof Error ? error2.message : "Unknown error";
+          console.error(`\u2717 ${imageFile.filename}: ${errorMsg}`);
+        }
+      }
+    }
+    const pdfSpinner = spinner("Converting Markdown to PDF...");
+    const filename = `${baseFilename}.pdf`;
+    const pdfPath = path5.join(pageDir, filename);
+    try {
+      await exporter.exportMarkdownToPDF(processedMarkdown, pdfPath, {
+        format: "A4"
+      });
+      pdfSpinner.succeed("PDF generated successfully");
+    } catch (error2) {
+      pdfSpinner.fail("Failed to generate PDF");
+      throw error2;
+    }
+    console.log("");
+    success("PDF export complete!");
+    console.log("");
+    console.log(`\u{1F4C1} Folder: ${path5.relative(process.cwd(), pageDir)}`);
+    console.log(`\u{1F4C4} PDF: ${filename}`);
+    if (result.imageFiles.length > 0) {
+      console.log(`\u{1F5BC}\uFE0F  Images: ${config.imageDir}/ (${result.imageFiles.length} files)`);
+    }
+    console.log("");
+  } catch (error2) {
+    if (error2 instanceof Error) {
+      error(error2.message);
+    } else {
+      error("An unknown error occurred.");
+    }
+    process.exit(1);
+  } finally {
+    try {
+      await fs5.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
 // src/commands/debug.ts
-import * as fs4 from "fs/promises";
-import * as os2 from "os";
-import * as path4 from "path";
+import * as fs6 from "fs/promises";
+import * as os5 from "os";
+import * as path6 from "path";
 async function debugCommand(notionUrl, options) {
   let tempDir;
   try {
@@ -237,7 +613,7 @@ async function debugCommand(notionUrl, options) {
       tokenV2: config.tokenV2,
       fileToken: config.fileToken
     });
-    tempDir = path4.join(os2.tmpdir(), `notion-debug-${Date.now()}`);
+    tempDir = path6.join(os5.tmpdir(), `notion-debug-${Date.now()}`);
     console.log("Fetching Notion page...\n");
     const { markdown, imageFiles } = await exporter.exportWithImages(notionUrl, tempDir);
     console.log("=== Raw Markdown ===\n");
@@ -253,17 +629,614 @@ async function debugCommand(notionUrl, options) {
     console.error("Error:", error2);
   } finally {
     if (tempDir) {
-      await fs4.rm(tempDir, { recursive: true, force: true }).catch((err) => {
+      await fs6.rm(tempDir, { recursive: true, force: true }).catch((err) => {
         console.warn(`Error cleaning up temporary directory: ${err.message}`);
       });
     }
   }
 }
 
+// src/commands/init.ts
+import fs7 from "fs";
+import path7 from "path";
+import os6 from "os";
+var handler = async (argv) => {
+  const configDir = path7.join(os6.homedir(), ".nconv");
+  const configFile = path7.join(configDir, ".env");
+  info(`Checking for config file at: ${configFile}`);
+  if (fs7.existsSync(configFile)) {
+    warn("Configuration file already exists.");
+    warn(`If you want to re-initialize, please delete the file first: ${configFile}`);
+    return;
+  }
+  const envContent = `
+# Please provide your Notion access tokens.
+# These are required to fetch content from your Notion pages.
+# You can find these tokens in your browser's cookies when you are logged into Notion.
+TOKEN_V2=
+FILE_TOKEN=
+`.trim();
+  try {
+    info(`Creating directory at: ${configDir}`);
+    if (!fs7.existsSync(configDir)) {
+      fs7.mkdirSync(configDir, { recursive: true });
+    }
+    fs7.writeFileSync(configFile, envContent);
+    info("\u2705 Successfully created configuration file.");
+    info(`Please edit the file to set your environment variables: ${configFile}`);
+  } catch (error2) {
+    error("Failed to create configuration file.");
+    if (error2 instanceof Error) {
+      error(error2.message);
+    }
+  }
+};
+
+// src/repl/index.ts
+import prompts from "prompts";
+import chalk2 from "chalk";
+
+// src/repl/commands.ts
+import { input as input2, confirm as confirm2 } from "@inquirer/prompts";
+
+// src/repl/prompts.ts
+import { input } from "@inquirer/prompts";
+import fs8 from "fs";
+import path8 from "path";
+import os7 from "os";
+function getConfigPath2() {
+  return path8.join(os7.homedir(), ".nconv", ".env");
+}
+function getConfigDir() {
+  return path8.join(os7.homedir(), ".nconv");
+}
+function loadConfig() {
+  const configPath = getConfigPath2();
+  if (!fs8.existsSync(configPath)) {
+    return null;
+  }
+  const content = fs8.readFileSync(configPath, "utf-8");
+  const config = { TOKEN_V2: "", FILE_TOKEN: "" };
+  content.split("\n").forEach((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#") || !trimmed) return;
+    const [key, ...valueParts] = trimmed.split("=");
+    const value = valueParts.join("=").trim();
+    if (key === "TOKEN_V2") config.TOKEN_V2 = value;
+    if (key === "FILE_TOKEN") config.FILE_TOKEN = value;
+  });
+  return config;
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  const configPath = getConfigPath2();
+  const envContent = `# Notion Access Tokens
+# These tokens are required to fetch content from Notion.
+# You can find them in your browser's cookies when logged into Notion.
+
+TOKEN_V2=${config.TOKEN_V2}
+FILE_TOKEN=${config.FILE_TOKEN}
+`;
+  try {
+    if (!fs8.existsSync(configDir)) {
+      fs8.mkdirSync(configDir, { recursive: true });
+    }
+    fs8.writeFileSync(configPath, envContent);
+    info("\u2705 Configuration saved successfully.");
+  } catch (error2) {
+    error("Failed to save configuration.");
+    if (error2 instanceof Error) {
+      error(error2.message);
+    }
+    throw error2;
+  }
+}
+async function promptInitConfig() {
+  info("Please enter your Notion access tokens.");
+  info("You can find these in your browser cookies when logged into Notion.\n");
+  const TOKEN_V2 = await input({
+    message: "TOKEN_V2:",
+    required: true,
+    validate: (value) => {
+      if (!value.trim()) return "TOKEN_V2 is required";
+      return true;
+    }
+  });
+  const FILE_TOKEN = await input({
+    message: "FILE_TOKEN:",
+    required: true,
+    validate: (value) => {
+      if (!value.trim()) return "FILE_TOKEN is required";
+      return true;
+    }
+  });
+  return { TOKEN_V2, FILE_TOKEN };
+}
+async function promptEditConfig(existing) {
+  info("Current configuration:\n");
+  const TOKEN_V2 = await input({
+    message: "TOKEN_V2:",
+    default: existing.TOKEN_V2,
+    required: true
+  });
+  const FILE_TOKEN = await input({
+    message: "FILE_TOKEN:",
+    default: existing.FILE_TOKEN,
+    required: true
+  });
+  return { TOKEN_V2, FILE_TOKEN };
+}
+
+// src/repl/commands.ts
+async function handleInit() {
+  const existing = loadConfig();
+  const isFirstTime = !existing || !existing.TOKEN_V2 && !existing.FILE_TOKEN;
+  if (!isFirstTime) {
+    warn("Configuration already exists.");
+    try {
+      const overwrite = await confirm2({
+        message: "Do you want to overwrite the existing configuration?",
+        default: false
+      });
+      if (!overwrite) {
+        info("Configuration unchanged. Use /config to view or edit your settings.");
+        return;
+      }
+    } catch (error2) {
+      if (error2 instanceof Error && error2.message === "User force closed the prompt") {
+        warn("\nCancelled.");
+      }
+      return;
+    }
+  }
+  info("\n\u{1F4DD} How to find your Notion tokens\n");
+  info("1. Log in to https://notion.so in your browser");
+  info("2. Open browser developer tools (press F12)");
+  info('3. Go to the "Application" tab');
+  info('4. Find "Cookies" section and select https://www.notion.so');
+  info('5. Copy the value of "token_v2" cookie \u2192 TOKEN_V2');
+  info('6. Copy the value of "file_token" cookie \u2192 FILE_TOKEN\n');
+  try {
+    const config = await promptInitConfig();
+    saveConfig(config);
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message === "User force closed the prompt") {
+      warn("\nConfiguration cancelled.");
+    } else {
+      throw error2;
+    }
+  }
+}
+async function handleConfig() {
+  const existing = loadConfig();
+  if (!existing || !existing.TOKEN_V2 && !existing.FILE_TOKEN) {
+    warn("No configuration found.");
+    info("Run /init to create initial configuration.");
+    return;
+  }
+  info("Current configuration:");
+  info(`TOKEN_V2: ${existing.TOKEN_V2 ? "***" + existing.TOKEN_V2.slice(-8) : "(not set)"}`);
+  info(`FILE_TOKEN: ${existing.FILE_TOKEN ? "***" + existing.FILE_TOKEN.slice(-8) : "(not set)"}
+`);
+  try {
+    const edit = await input2({
+      message: "Edit configuration? (y/n)",
+      default: "n"
+    });
+    if (edit.toLowerCase() === "y" || edit.toLowerCase() === "yes") {
+      const newConfig = await promptEditConfig(existing);
+      saveConfig(newConfig);
+    }
+  } catch (error2) {
+    if (error2 instanceof Error && error2.message === "User force closed the prompt") {
+      warn("\nEdit cancelled.");
+    } else {
+      throw error2;
+    }
+  }
+}
+async function handleMd(args) {
+  let url = "";
+  const options = {
+    output: "./nconv-output",
+    imageDir: "images",
+    verbose: false
+  };
+  if (args.length === 0) {
+    try {
+      url = await input2({
+        message: "Notion URL",
+        validate: (value) => {
+          if (!value.trim()) return "URL is required";
+          if (!value.includes("notion.so") && !value.includes("notion.site")) {
+            return "Please enter a valid Notion URL";
+          }
+          return true;
+        }
+      });
+      const outputDir = await input2({
+        message: "Output directory [default: ./nconv-output]",
+        default: "./nconv-output"
+      });
+      options.output = outputDir;
+      const filename = await input2({
+        message: "Filename [leave empty for auto-generated]",
+        default: ""
+      });
+      if (filename.trim()) {
+        options.filename = filename;
+      }
+      options.verbose = await confirm2({
+        message: "Enable verbose logging?",
+        default: false
+      });
+    } catch (error2) {
+      if (error2 instanceof Error && error2.message === "User force closed the prompt") {
+        warn("\nConversion cancelled.");
+      }
+      return;
+    }
+  } else {
+    url = args[0];
+    const additionalArgs = args.slice(1);
+    for (let i = 0; i < additionalArgs.length; i++) {
+      const arg = additionalArgs[i];
+      if ((arg === "-o" || arg === "--output") && i + 1 < additionalArgs.length) {
+        options.output = additionalArgs[++i];
+      } else if ((arg === "-i" || arg === "--image-dir") && i + 1 < additionalArgs.length) {
+        options.imageDir = additionalArgs[++i];
+      } else if ((arg === "-f" || arg === "--filename") && i + 1 < additionalArgs.length) {
+        options.filename = additionalArgs[++i];
+      } else if (arg === "-v" || arg === "--verbose") {
+        options.verbose = true;
+      }
+    }
+  }
+  const configCheck = validateConfig();
+  if (!configCheck.valid) {
+    error("Cannot convert Notion page:");
+    error(configCheck.message || "Configuration is invalid.");
+    return;
+  }
+  await mdCommand(url, options);
+}
+async function handleHtml(args) {
+  let url = "";
+  const options = {
+    output: "./nconv-output",
+    imageDir: "images",
+    verbose: false
+  };
+  if (args.length === 0) {
+    try {
+      url = await input2({
+        message: "Notion URL",
+        validate: (value) => {
+          if (!value.trim()) return "URL is required";
+          if (!value.includes("notion.so") && !value.includes("notion.site")) {
+            return "Please enter a valid Notion URL";
+          }
+          return true;
+        }
+      });
+      const outputDir = await input2({
+        message: "Output directory [default: ./nconv-output]",
+        default: "./nconv-output"
+      });
+      options.output = outputDir;
+      const filename = await input2({
+        message: "Filename [leave empty for auto-generated]",
+        default: ""
+      });
+      if (filename.trim()) {
+        options.filename = filename;
+      }
+      options.verbose = await confirm2({
+        message: "Enable verbose logging?",
+        default: false
+      });
+    } catch (error2) {
+      if (error2 instanceof Error && error2.message === "User force closed the prompt") {
+        warn("\nConversion cancelled.");
+      }
+      return;
+    }
+  } else {
+    url = args[0];
+    const additionalArgs = args.slice(1);
+    for (let i = 0; i < additionalArgs.length; i++) {
+      const arg = additionalArgs[i];
+      if ((arg === "-o" || arg === "--output") && i + 1 < additionalArgs.length) {
+        options.output = additionalArgs[++i];
+      } else if ((arg === "-i" || arg === "--image-dir") && i + 1 < additionalArgs.length) {
+        options.imageDir = additionalArgs[++i];
+      } else if ((arg === "-f" || arg === "--filename") && i + 1 < additionalArgs.length) {
+        options.filename = additionalArgs[++i];
+      } else if (arg === "-v" || arg === "--verbose") {
+        options.verbose = true;
+      }
+    }
+  }
+  const configCheck = validateConfig();
+  if (!configCheck.valid) {
+    error("Cannot convert Notion page:");
+    error(configCheck.message || "Configuration is invalid.");
+    return;
+  }
+  await htmlCommand(url, options);
+}
+async function handlePdf(args) {
+  let url = "";
+  const options = {
+    output: "./nconv-output",
+    imageDir: "images",
+    verbose: false
+  };
+  if (args.length === 0) {
+    try {
+      url = await input2({
+        message: "Notion URL",
+        validate: (value) => {
+          if (!value.trim()) return "URL is required";
+          if (!value.includes("notion.so") && !value.includes("notion.site")) {
+            return "Please enter a valid Notion URL";
+          }
+          return true;
+        }
+      });
+      const outputDir = await input2({
+        message: "Output directory [default: ./nconv-output]",
+        default: "./nconv-output"
+      });
+      options.output = outputDir;
+      const filename = await input2({
+        message: "Filename [leave empty for auto-generated]",
+        default: ""
+      });
+      if (filename.trim()) {
+        options.filename = filename;
+      }
+      options.verbose = await confirm2({
+        message: "Enable verbose logging?",
+        default: false
+      });
+    } catch (error2) {
+      if (error2 instanceof Error && error2.message === "User force closed the prompt") {
+        warn("\nConversion cancelled.");
+      }
+      return;
+    }
+  } else {
+    url = args[0];
+    const additionalArgs = args.slice(1);
+    for (let i = 0; i < additionalArgs.length; i++) {
+      const arg = additionalArgs[i];
+      if ((arg === "-o" || arg === "--output") && i + 1 < additionalArgs.length) {
+        options.output = additionalArgs[++i];
+      } else if ((arg === "-f" || arg === "--filename") && i + 1 < additionalArgs.length) {
+        options.filename = additionalArgs[++i];
+      } else if (arg === "-v" || arg === "--verbose") {
+        options.verbose = true;
+      }
+    }
+  }
+  const configCheck = validateConfig();
+  if (!configCheck.valid) {
+    error("Cannot convert Notion page:");
+    error(configCheck.message || "Configuration is invalid.");
+    return;
+  }
+  await pdfCommand(url, options);
+}
+var AVAILABLE_COMMANDS = [
+  {
+    name: "init",
+    description: "Initialize configuration (set Notion tokens)",
+    examples: ["/init"]
+  },
+  {
+    name: "config",
+    description: "View and edit current configuration",
+    examples: ["/config"]
+  },
+  {
+    name: "md",
+    description: "Convert Notion page to markdown",
+    examples: [
+      "/md https://notion.so/page-id",
+      "/md https://notion.so/page-id -o ./blog",
+      "/md https://notion.so/page-id -o ./blog -f my-post -v"
+    ]
+  },
+  {
+    name: "html",
+    description: "Convert Notion page to HTML",
+    examples: [
+      "/html https://notion.so/page-id",
+      "/html https://notion.so/page-id -o ./blog",
+      "/html https://notion.so/page-id -o ./blog -f my-post -v"
+    ]
+  },
+  {
+    name: "pdf",
+    description: "Convert Notion page to PDF (renders actual page)",
+    examples: [
+      "/pdf https://notion.so/page-id",
+      "/pdf https://notion.so/page-id -o ./blog",
+      "/pdf https://notion.so/page-id -o ./blog -f my-post -v"
+    ]
+  },
+  {
+    name: "help",
+    description: "Show this help message",
+    examples: ["/help"]
+  },
+  {
+    name: "exit",
+    description: "Exit the REPL",
+    examples: ["/exit"]
+  }
+];
+function getCommandSuggestions(input3) {
+  const cleanInput = input3.toLowerCase().replace(/^\//, "");
+  return AVAILABLE_COMMANDS.filter((cmd) => cmd.name.startsWith(cleanInput)).map((cmd) => `/${cmd.name}`);
+}
+function getCommandChoices() {
+  return AVAILABLE_COMMANDS.map((cmd) => ({
+    title: `/${cmd.name}`,
+    value: `/${cmd.name}`,
+    description: cmd.description
+  }));
+}
+function findSimilarCommand(input3) {
+  const cleanInput = input3.toLowerCase();
+  for (const cmd of AVAILABLE_COMMANDS) {
+    if (cmd.name.includes(cleanInput) || cleanInput.includes(cmd.name)) {
+      return cmd.name;
+    }
+  }
+  return null;
+}
+function handleHelp() {
+  info("Available commands:\n");
+  AVAILABLE_COMMANDS.forEach((cmd) => {
+    info(`  /${cmd.name.padEnd(20)} ${cmd.description}`);
+  });
+  console.log("");
+  info("Conversion options (for /md, /html, and /pdf):");
+  info("  -o, --output <dir>      Output directory (default: ./nconv-output)");
+  info("  -i, --image-dir <dir>   Image folder name (default: images) [md/html only]");
+  info("  -f, --filename <name>   Output filename");
+  info("  -v, --verbose           Enable verbose logging\n");
+  info("Examples:");
+  AVAILABLE_COMMANDS.forEach((cmd) => {
+    cmd.examples.forEach((example) => {
+      info(`  ${example}`);
+    });
+  });
+  console.log("");
+}
+async function executeCommand(input3) {
+  const trimmed = input3.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (!trimmed.startsWith("/")) {
+    error("Commands must start with /");
+    info("Type /help for available commands");
+    info("Example: /init, /md <url>, /config\n");
+    return false;
+  }
+  const parts = trimmed.slice(1).split(/\s+/);
+  const command = parts[0].toLowerCase();
+  const args = parts.slice(1);
+  switch (command) {
+    case "init":
+      await handleInit();
+      break;
+    case "config":
+      await handleConfig();
+      break;
+    case "md":
+      await handleMd(args);
+      break;
+    case "html":
+      await handleHtml(args);
+      break;
+    case "pdf":
+      await handlePdf(args);
+      break;
+    case "help":
+    case "h":
+      handleHelp();
+      break;
+    case "exit":
+    case "quit":
+    case "q":
+      return true;
+    default:
+      error(`Unknown command: /${command}`);
+      const similar = findSimilarCommand(command);
+      if (similar) {
+        info(`Did you mean /${similar}?`);
+      }
+      info("Type /help to see all available commands\n");
+      const suggestions = getCommandSuggestions(command);
+      if (suggestions.length > 0 && suggestions.length < 5) {
+        info("Available commands:");
+        suggestions.forEach((cmd) => info(`  ${cmd}`));
+        console.log("");
+      }
+  }
+  return false;
+}
+
+// src/repl/index.ts
+function showBanner() {
+  const title = "NCONV CLI (Notion Converter CLI)";
+  const padding = 2;
+  const totalWidth = title.length + padding * 2;
+  const topBorder = "\u2554" + "\u2550".repeat(totalWidth) + "\u2557";
+  const bottomBorder = "\u255A" + "\u2550".repeat(totalWidth) + "\u255D";
+  console.log(chalk2.cyan("\n" + topBorder));
+  console.log(chalk2.cyan("\u2551") + chalk2.bold(" ".repeat(padding) + title + " ".repeat(padding)) + chalk2.cyan("\u2551"));
+  console.log(chalk2.cyan(bottomBorder + "\n"));
+  info("Welcome to nconv interactive mode!");
+  info("Type /help to see available commands");
+  info("Type /exit to quit\n");
+  console.log(chalk2.dim("Quick examples:"));
+  console.log(chalk2.dim("  /init                           - Set up Notion tokens"));
+  console.log(chalk2.dim("  /md <url>                       - Convert Notion page"));
+  console.log(chalk2.dim("  /md <url> -o ./blog -f my-post  - Convert with options\n"));
+}
+async function startRepl() {
+  showBanner();
+  let shouldExit = false;
+  while (!shouldExit) {
+    try {
+      const response = await prompts({
+        type: "autocomplete",
+        name: "command",
+        message: chalk2.cyan("nconv"),
+        choices: getCommandChoices(),
+        suggest: async (input3, choices) => {
+          const searchInput = input3.startsWith("/") ? input3 : `/${input3}`;
+          const filtered = choices.filter(
+            (choice) => choice.title.toLowerCase().startsWith(searchInput.toLowerCase())
+          );
+          if (filtered.length === 0 && input3.trim()) {
+            return Promise.resolve([{ title: input3, value: input3 }]);
+          }
+          return Promise.resolve(filtered);
+        },
+        limit: 5
+      });
+      if (response.command === void 0) {
+        console.log("\n");
+        info("Goodbye! \u{1F44B}");
+        break;
+      }
+      shouldExit = await executeCommand(response.command);
+      if (!shouldExit) {
+        console.log();
+      }
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        error(`Error: ${error2.message}`);
+        console.log();
+      }
+    }
+  }
+  info("Exiting nconv...");
+}
+
 // src/index.ts
 var program = new Command();
 program.name("nconv").description("CLI tool for converting Notion pages to blog-ready markdown").version("1.0.0");
-program.command("md <url>").description("Convert a Notion page to markdown").option("-o, --output <dir>", "Output directory", "./output").option("-i, --image-dir <dir>", "Image folder name (relative to output)", "images").option("-f, --filename <name>", "\uCD9C\uB825 \uD30C\uC77C\uBA85 (\uD655\uC7A5\uC790 \uC81C\uC678 \uB610\uB294 \uD3EC\uD568)").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
+program.command("init").description("Create a default .env configuration file").action(async () => {
+  await handler({});
+});
+program.command("md <url>").description("Convert a Notion page to markdown").option("-o, --output <dir>", "Output directory", "./nconv-output").option("-i, --image-dir <dir>", "Image folder name (relative to output)", "images").option("-f, --filename <name>", "\uCD9C\uB825 \uD30C\uC77C\uBA85 (\uD655\uC7A5\uC790 \uC81C\uC678 \uB610\uB294 \uD3EC\uD568)").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
   await mdCommand(url, {
     output: options.output,
     imageDir: options.imageDir,
@@ -271,8 +1244,25 @@ program.command("md <url>").description("Convert a Notion page to markdown").opt
     verbose: options.verbose
   });
 });
+program.command("html <url>").description("Convert a Notion page to HTML").option("-o, --output <dir>", "Output directory", "./nconv-output").option("-i, --image-dir <dir>", "Image folder name (relative to output)", "images").option("-f, --filename <name>", "Output filename (without extension or with)").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
+  await htmlCommand(url, {
+    output: options.output,
+    imageDir: options.imageDir,
+    filename: options.filename,
+    verbose: options.verbose
+  });
+});
+program.command("pdf <url>").description("Convert a Notion page to PDF (renders actual Notion page)").option("-o, --output <dir>", "Output directory", "./nconv-output").option("-f, --filename <name>", "Output filename (without extension or with)").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
+  await pdfCommand(url, {
+    output: options.output,
+    imageDir: "images",
+    // Not used for PDF, but required by interface
+    filename: options.filename,
+    verbose: options.verbose
+  });
+});
 if (process.env.NODE_ENV !== "production") {
-  program.command("debug <url>").description("Debug: Output raw markdown and image URLs").option("-o, --output <dir>", "\uCD9C\uB825 \uB514\uB809\uD1A0\uB9AC", "./output").option("-i, --image-dir <dir>", "Image folder name", "images").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
+  program.command("debug <url>").description("Debug: Output raw markdown and image URLs").option("-o, --output <dir>", "\uCD9C\uB825 \uB514\uB809\uD1A0\uB9AC", "./nconv-output").option("-i, --image-dir <dir>", "Image folder name", "images").option("-v, --verbose", "Enable verbose logging", false).action(async (url, options) => {
     await debugCommand(url, {
       output: options.output,
       imageDir: options.imageDir,
@@ -281,5 +1271,11 @@ if (process.env.NODE_ENV !== "production") {
     });
   });
 }
-program.parse();
+(async () => {
+  if (process.argv.length === 2) {
+    await startRepl();
+  } else {
+    program.parse();
+  }
+})();
 //# sourceMappingURL=index.js.map