nconv-cli 1.0.0 → 1.0.2

package/src/commands/pdf.ts

@@ -0,0 +1,150 @@
+import { ConverterOptions, createConfig } from '../config.js';
+import { NotionMarkdownExporter } from '../core/exporter.js';
+import { generateSafeFilename, extractTitleFromUrl } from '../utils/file.js';
+import * as logger from '../utils/logger.js';
+import path from 'path';
+import { promises as fs } from 'fs';
+import os from 'os';
+
+/**
+ * pdf 명령어 핸들러
+ * Notion → Markdown → PDF 플로우로 깔끔한 PDF 생성
+ */
+export async function pdfCommand(notionUrl: string, options: ConverterOptions) {
+  const tempDir = path.join(os.tmpdir(), `nconv-cli-${Date.now()}`);
+
+  try {
+    // 설정 생성
+    const config = createConfig(options);
+
+    if (config.verbose) {
+      logger.info('Configuration loaded successfully');
+      console.log(`  Output directory: ${config.output}\n`);
+    }
+
+    // 1. Notion에서 Markdown 가져오기
+    const spinner = logger.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);
+      spinner.succeed(`Notion page fetched (${result.imageFiles.length} images)`);
+    } catch (error) {
+      spinner.fail('Failed to fetch Notion page');
+      throw error;
+    }
+
+    // 2. 파일명/폴더명 생성
+    let baseFilename: string;
+    if (config.filename) {
+      baseFilename = config.filename.replace(/\.pdf$/, '');
+    } else {
+      const title = extractTitleFromUrl(notionUrl);
+      baseFilename = generateSafeFilename(title, '');
+    }
+
+    // 3. 제목별 폴더 생성 (output/제목/)
+    const pageDir = path.join(config.output, baseFilename);
+    await fs.mkdir(pageDir, { recursive: true });
+
+    // 4. 이미지 폴더 생성 및 이미지 파일 이동
+    const imageOutputDir = path.join(pageDir, config.imageDir);
+    await fs.mkdir(imageOutputDir, { recursive: true });
+
+    if (config.verbose && result.imageFiles.length > 0) {
+      console.log(`Processing image files...\n`);
+    }
+
+    let processedMarkdown = result.markdown;
+    for (const imageFile of result.imageFiles) {
+      try {
+        const originalFileName = path.basename(imageFile.filename);
+        const safeFileName = originalFileName.replace(/\s+/g, '-');
+
+        // 이미지 파일 복사
+        const targetPath = path.join(imageOutputDir, safeFileName);
+        await fs.copyFile(imageFile.sourcePath, targetPath);
+
+        if (config.verbose) {
+          console.log(`✓ ${safeFileName}`);
+        }
+
+        // PDF용: 이미지를 base64로 변환
+        const imageBuffer = await fs.readFile(targetPath);
+        const base64 = imageBuffer.toString('base64');
+
+        // 파일 확장자에서 MIME 타입 결정
+        const ext = path.extname(safeFileName).slice(1).toLowerCase();
+        const mimeType = ext === 'jpg' ? 'jpeg' : ext;
+        const dataUrl = `data:image/${mimeType};base64,${base64}`;
+
+        // Markdown 내 경로를 처리
+        const originalPath = imageFile.filename;
+        const relativePath = `./${config.imageDir}/${safeFileName}`;
+
+        const pathParts = originalPath.split('/');
+        const encodedPath = pathParts.map(part => encodeURIComponent(part)).join('/');
+
+        const escapeRegex = (str: string) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+        // PDF용 Markdown: base64 data URL 사용
+        processedMarkdown = processedMarkdown
+          .replace(new RegExp(`\\(${escapeRegex(originalPath)}\\)`, 'g'), `(${dataUrl})`)
+          .replace(new RegExp(`\\(${escapeRegex(encodedPath)}\\)`, 'g'), `(${dataUrl})`);
+
+      } catch (error) {
+        if (config.verbose) {
+          const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+          console.error(`✗ ${imageFile.filename}: ${errorMsg}`);
+        }
+      }
+    }
+
+    // 5. Markdown → PDF 변환
+    const pdfSpinner = logger.spinner('Converting Markdown to PDF...');
+
+    const filename = `${baseFilename}.pdf`;
+    const pdfPath = path.join(pageDir, filename);
+
+    try {
+      await exporter.exportMarkdownToPDF(processedMarkdown, pdfPath, {
+        format: 'A4',
+      });
+      pdfSpinner.succeed('PDF generated successfully');
+    } catch (error) {
+      pdfSpinner.fail('Failed to generate PDF');
+      throw error;
+    }
+
+    // 6. 결과 출력
+    console.log('');
+    logger.success('PDF export complete!');
+    console.log('');
+    console.log(`📁 Folder: ${path.relative(process.cwd(), pageDir)}`);
+    console.log(`📄 PDF: ${filename}`);
+    if (result.imageFiles.length > 0) {
+      console.log(`🖼️  Images: ${config.imageDir}/ (${result.imageFiles.length} files)`);
+    }
+    console.log('');
+
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error('An unknown error occurred.');
+    }
+    process.exit(1);
+  } finally {
+    // 임시 디렉토리 정리
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+      // 무시
+    }
+  }
+}

package/src/config.ts

@@ -1,9 +1,11 @@
 import { config as dotenvConfig } from 'dotenv';
-import { existsSync } from 'fs';
-import { resolve } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import os from 'os';
+import * as logger from './utils/logger.js';
 
-// 환경 변수 로드
-dotenvConfig();
+// Disable dotenv default logging
+process.env.DOTENV_CONFIG_SILENT = 'true';
 
 export interface NotionConfig {
   tokenV2: string;
@@ -19,21 +21,108 @@ export interface ConverterOptions {
 
 export interface FullConfig extends NotionConfig, ConverterOptions {}
 
+function getConfigPath(): string {
+  return join(os.homedir(), '.nconv', '.env');
+}
+
+/**
+ * Loads environment variables from the global config file.
+ */
+function loadEnv() {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    return;
+  }
+
+  try {
+    // Manually parse .env file to avoid dotenv logging
+    const content = readFileSync(configPath, 'utf-8');
+    let loadedCount = 0;
+
+    content.split('\n').forEach((line) => {
+      const trimmed = line.trim();
+
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) {
+        return;
+      }
+
+      // Parse key=value
+      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) {
+      logger.info(`✓ Loaded ${loadedCount} environment variable(s) from ${configPath}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to load configuration from: ${configPath}`);
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+  }
+}
+
+/**
+ * Checks if the required environment variables are set.
+ * Exits the process if tokens are missing (for CLI commands).
+ */
+function checkEnv() {
+  const configPath = getConfigPath();
+  if (!process.env.TOKEN_V2 || !process.env.FILE_TOKEN) {
+    logger.error('Notion tokens are not set.');
+    if (!existsSync(configPath)) {
+      logger.error('Configuration file not found.');
+      logger.error('Please run "nconv init" to create a configuration file.');
+    } else {
+      logger.error(`Please set TOKEN_V2 and FILE_TOKEN in: ${configPath}`);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Validates if the required environment variables are set.
+ * Returns true if valid, false otherwise (for REPL mode).
+ */
+export function validateConfig(): { valid: boolean; message?: string } {
+  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.\nConfig file: ${configPath}`,
+      };
+    }
+  }
+
+  return { valid: true };
+}
+
 /**
  * Notion 인증 설정 가져오기
  */
 export function getNotionConfig(): NotionConfig {
   const tokenV2 = process.env.TOKEN_V2 || '';
   const fileToken = process.env.FILE_TOKEN || '';
-
-  if (!tokenV2 || !fileToken) {
-    throw new Error(
-      'Notion 토큰이 설정되지 않았습니다.\n' +
-      '.env 파일에 TOKEN_V2와 FILE_TOKEN을 설정해주세요.\n' +
-      '자세한 내용은 .env.example을 참고하세요.'
-    );
-  }
-
   return { tokenV2, fileToken };
 }
 
@@ -41,6 +130,9 @@ export function getNotionConfig(): NotionConfig {
  * 전체 설정 생성
  */
 export function createConfig(options: ConverterOptions): FullConfig {
+  loadEnv();
+  checkEnv();
+
   const notionConfig = getNotionConfig();
 
   // 출력 디렉토리 절대 경로로 변환

package/src/core/exporter.ts

@@ -1,6 +1,7 @@
 import { NotionExporter } from 'notion-exporter';
 import { promises as fs } from 'fs';
 import path from 'path';
+import { mdToPdf } from 'md-to-pdf';
 import type { NotionConfig } from '../config.js';
 
 export interface ExportResult {
@@ -8,14 +9,37 @@ export interface ExportResult {
   imageFiles: Array<{ filename: string; sourcePath: string }>;
 }
 
+export interface HTMLExportResult {
+  html: string;
+  imageFiles: Array<{ filename: string; sourcePath: string }>;
+}
+
+export interface PDFExportResult {
+  pdfPath: string;
+  filename: string;
+}
+
+export interface MarkdownPDFOptions {
+  format?: 'A4' | 'Letter';
+  margin?: {
+    top?: string;
+    right?: string;
+    bottom?: string;
+    left?: string;
+  };
+  stylesheet?: string | string[];
+}
+
 /**
  * Notion 페이지를 마크다운으로 내보내기
  */
 export class NotionMarkdownExporter {
   private exporter: NotionExporter;
 
-  constructor(config: NotionConfig) {
-    this.exporter = new NotionExporter(config.tokenV2, config.fileToken);
+  constructor(config: NotionConfig, exportType: 'markdown' | 'html' | 'pdf' = 'markdown') {
+    this.exporter = new NotionExporter(config.tokenV2, config.fileToken, {
+      exportType,
+    });
   }
 
   /**
@@ -72,4 +96,137 @@ export class NotionMarkdownExporter {
       throw new Error('Failed to fetch Notion page.');
     }
   }
+
+  /**
+   * Notion URL에서 HTML과 이미지 파일 가져오기
+   */
+  async exportHTML(notionUrl: string, tempDir: string): Promise<HTMLExportResult> {
+    try {
+      // 임시 디렉토리 생성
+      await fs.mkdir(tempDir, { recursive: true });
+
+      // getMdFiles로 HTML과 이미지를 함께 다운로드
+      await this.exporter.getMdFiles(notionUrl, tempDir);
+
+      // 다운로드된 파일 목록 가져오기
+      const files = await fs.readdir(tempDir, { withFileTypes: true });
+
+      // HTML 파일 찾기
+      const htmlFile = files.find(f => f.isFile() && f.name.endsWith('.html'));
+      if (!htmlFile) {
+        throw new Error('HTML file not found.');
+      }
+
+      // HTML 내용 읽기
+      const htmlPath = path.join(tempDir, htmlFile.name);
+      const html = await fs.readFile(htmlPath, 'utf-8');
+
+      // 이미지 파일 목록 (HTML이 아닌 파일들)
+      const imageFiles = files
+        .filter(f => f.isFile() && !f.name.endsWith('.html'))
+        .map(f => ({
+          filename: f.name,
+          sourcePath: path.join(tempDir, f.name),
+        }));
+
+      // 디렉토리 내 폴더도 확인 (Notion이 폴더 구조로 저장할 수 있음)
+      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 (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to fetch Notion page as HTML: ${error.message}`);
+      }
+      throw new Error('Failed to fetch Notion page as HTML.');
+    }
+  }
+
+  /**
+   * Markdown을 PDF로 변환 (md-to-pdf 사용)
+   * GitHub 스타일의 깔끔한 PDF 생성
+   */
+  async exportMarkdownToPDF(
+    markdownContent: string,
+    outputPath: string,
+    options: MarkdownPDFOptions = {}
+  ): Promise<void> {
+    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;
+            }
+          }
+
+          /* 코드 블록 스타일 개선 */
+          .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;
+          }
+
+          /* 이미지 스타일 */
+          .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 (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to convert Markdown to PDF: ${error.message}`);
+      }
+      throw new Error('Failed to convert Markdown to PDF.');
+    }
+  }
 }

package/src/index.ts

@@ -2,7 +2,11 @@
 
 import { Command } from 'commander';
 import { mdCommand } from './commands/md.js';
+import { htmlCommand } from './commands/html.js';
+import { pdfCommand } from './commands/pdf.js';
 import { debugCommand } from './commands/debug.js';
+import { handler as initHandler } from './commands/init.js';
+import { startRepl } from './repl/index.js';
 
 const program = new Command();
 
@@ -11,10 +15,17 @@ program
   .description('CLI tool for converting Notion pages to blog-ready markdown')
   .version('1.0.0');
 
+program
+  .command('init')
+  .description('Create a default .env configuration file')
+  .action(async () => {
+    await initHandler({} as any); // Handler expects argv, but doesn't use it
+  });
+
 program
   .command('md <url>')
   .description('Convert a Notion page to markdown')
-  .option('-o, --output <dir>', 'Output directory', './output')
+  .option('-o, --output <dir>', 'Output directory', './nconv-output')
   .option('-i, --image-dir <dir>', 'Image folder name (relative to output)', 'images')
   .option('-f, --filename <name>', '출력 파일명 (확장자 제외 또는 포함)')
   .option('-v, --verbose', 'Enable verbose logging', false)
@@ -27,12 +38,43 @@ program
     });
   });
 
+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: string, 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: string, options) => {
+    await pdfCommand(url, {
+      output: options.output,
+      imageDir: 'images', // Not used for PDF, but required by interface
+      filename: options.filename,
+      verbose: options.verbose,
+    });
+  });
+
 // 개발 환경에서만 debug 명령어를 활성화
 if (process.env.NODE_ENV !== 'production') {
   program
     .command('debug <url>')
     .description('Debug: Output raw markdown and image URLs')
-    .option('-o, --output <dir>', '출력 디렉토리', './output')
+    .option('-o, --output <dir>', '출력 디렉토리', './nconv-output')
     .option('-i, --image-dir <dir>', 'Image folder name', 'images')
     .option('-v, --verbose', 'Enable verbose logging', false)
     .action(async (url: string, options) => {
@@ -45,4 +87,11 @@ if (process.env.NODE_ENV !== 'production') {
     });
 }
 
-program.parse();
+// If no arguments provided, start REPL mode
+(async () => {
+  if (process.argv.length === 2) {
+    await startRepl();
+  } else {
+    program.parse();
+  }
+})();