markdown-to-document-cli 1.1.4 → 1.2.8

package/dist/cli.js

@@ -2,9 +2,12 @@
 /**
  * Markdown to Document CLI
  *
+ * Refactored for improved UX with streamlined Interactive Mode
+ *
  * Usage:
  *   npx markdown-to-document-cli <input.md>
  *   m2d <input.md> [options]
+ *   m2d interactive (or m2d i)
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
@@ -13,25 +16,241 @@ import inquirer from 'inquirer';
 import { MarkdownToDocument } from './index.js';
 import { TYPOGRAPHY_PRESETS, COVER_THEMES } from './utils/constants.js';
 import { Logger } from './utils/common.js';
+import { DependencyChecker } from './utils/dependencyChecker.js';
+import { PathValidator } from './utils/pathValidator.js';
 import * as path from 'path';
 import * as fs from 'fs';
+import { fileURLToPath } from 'url';
 const program = new Command();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const getCliVersion = () => {
+    try {
+        const packageJsonPath = path.resolve(__dirname, '..', 'package.json');
+        const raw = fs.readFileSync(packageJsonPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+};
+/**
+ * Analyze markdown content for Obsidian syntax and output optimization needs
+ */
+function analyzeMarkdownContent(content) {
+    const result = {
+        hasObsidianImages: false,
+        hasObsidianLinks: false,
+        hasHighlights: false,
+        hasCallouts: false,
+        hasLongCodeLines: false,
+        hasComplexTables: false,
+        hasMultipleH1: false,
+        hasFrontmatter: false,
+        imageCount: 0,
+        tableCount: 0,
+        codeBlockCount: 0,
+        wordCount: 0,
+        recommendPreprocess: false,
+        recommendedPreset: 'ebook',
+        issues: [],
+    };
+    // Check for YAML frontmatter
+    result.hasFrontmatter = /^---\n[\s\S]*?\n---/.test(content);
+    // Check for Obsidian image syntax: ![[image]]
+    const obsidianImageMatches = content.match(/!\[\[([^\]]+)\]\]/g);
+    result.hasObsidianImages = !!obsidianImageMatches;
+    if (obsidianImageMatches) {
+        result.issues.push(`Obsidian 이미지 문법 ${obsidianImageMatches.length}개 발견`);
+    }
+    // Check for Obsidian internal links: [[link]]
+    const obsidianLinkMatches = content.match(/(?<!!)\[\[([^\]]+)\]\]/g);
+    result.hasObsidianLinks = !!obsidianLinkMatches;
+    if (obsidianLinkMatches) {
+        result.issues.push(`Obsidian 내부 링크 ${obsidianLinkMatches.length}개 발견`);
+    }
+    // Check for highlights: ==text==
+    const highlightMatches = content.match(/==([^=]+)==/g);
+    result.hasHighlights = !!highlightMatches;
+    if (highlightMatches) {
+        result.issues.push(`하이라이트 문법 ${highlightMatches.length}개 발견`);
+    }
+    // Check for callouts: > [!type]
+    const calloutMatches = content.match(/>\s*\[!(\w+)\]/g);
+    result.hasCallouts = !!calloutMatches;
+    if (calloutMatches) {
+        result.issues.push(`콜아웃 ${calloutMatches.length}개 발견`);
+    }
+    // Count images (standard markdown)
+    const standardImageMatches = content.match(/!\[([^\]]*)\]\([^)]+\)/g);
+    result.imageCount = (obsidianImageMatches?.length || 0) + (standardImageMatches?.length || 0);
+    // Count tables
+    const tableMatches = content.match(/\|.*\|.*\n\|[-:| ]+\|/g);
+    result.tableCount = tableMatches?.length || 0;
+    // Check for complex tables (>5 columns or very long cells)
+    if (tableMatches) {
+        for (const table of tableMatches) {
+            const columns = (table.match(/\|/g)?.length || 0) - 1;
+            if (columns > 5) {
+                result.hasComplexTables = true;
+                result.issues.push('5열 초과 복잡한 표 발견');
+                break;
+            }
+        }
+    }
+    // Count code blocks and check for long lines
+    const codeBlockMatches = content.match(/```[\s\S]*?```/g);
+    result.codeBlockCount = codeBlockMatches?.length || 0;
+    if (codeBlockMatches) {
+        for (const block of codeBlockMatches) {
+            const lines = block.split('\n');
+            for (const line of lines) {
+                if (line.length > 100) {
+                    result.hasLongCodeLines = true;
+                    result.issues.push('100자 초과 코드 라인 발견 (PDF 잘림 위험)');
+                    break;
+                }
+            }
+            if (result.hasLongCodeLines)
+                break;
+        }
+    }
+    // Check for multiple H1
+    const h1Matches = content.match(/^#\s+[^\n]+/gm);
+    result.hasMultipleH1 = (h1Matches?.length || 0) > 1;
+    if (result.hasMultipleH1) {
+        result.issues.push(`H1 제목 ${h1Matches?.length}개 발견 (1개 권장)`);
+    }
+    // Word count (rough estimate)
+    const textOnly = content.replace(/```[\s\S]*?```/g, '').replace(/[#*`\[\]()]/g, '');
+    result.wordCount = textOnly.split(/\s+/).filter(w => w.length > 0).length;
+    // Determine if preprocessing is recommended
+    result.recommendPreprocess =
+        result.hasObsidianImages ||
+            result.hasObsidianLinks ||
+            result.hasHighlights ||
+            result.hasCallouts ||
+            result.hasLongCodeLines ||
+            result.hasComplexTables ||
+            result.hasMultipleH1;
+    // Recommend typography preset based on content analysis
+    if (result.imageCount > 10) {
+        result.recommendedPreset = 'image_heavy';
+    }
+    else if (result.tableCount > 5) {
+        result.recommendedPreset = 'table_heavy';
+    }
+    else if (result.codeBlockCount > 10) {
+        result.recommendedPreset = 'manual';
+    }
+    else if (result.wordCount > 10000) {
+        result.recommendedPreset = 'text_heavy';
+    }
+    else {
+        result.recommendedPreset = 'balanced';
+    }
+    return result;
+}
+/**
+ * Display analysis result to console
+ */
+function displayAnalysisResult(result) {
+    console.log(chalk.bold('📊 문서 분석 결과:\n'));
+    // Statistics
+    console.log(chalk.gray('  📝 단어 수:'), chalk.cyan(`약 ${result.wordCount.toLocaleString()}개`));
+    console.log(chalk.gray('  🖼️  이미지:'), chalk.cyan(`${result.imageCount}개`));
+    console.log(chalk.gray('  📊 표:'), chalk.cyan(`${result.tableCount}개`));
+    console.log(chalk.gray('  💻 코드 블록:'), chalk.cyan(`${result.codeBlockCount}개`));
+    console.log(chalk.gray('  📋 Frontmatter:'), result.hasFrontmatter ? chalk.green('있음') : chalk.yellow('없음'));
+    // Issues found
+    if (result.issues.length > 0) {
+        console.log(chalk.yellow('\n⚠️  발견된 이슈:'));
+        result.issues.forEach(issue => {
+            console.log(chalk.yellow(`  • ${issue}`));
+        });
+    }
+    else {
+        console.log(chalk.green('\n✅ 특별한 이슈 없음 - 표준 Markdown'));
+    }
+    // Recommendation
+    console.log(chalk.bold('\n💡 권장 사항:'));
+    if (result.recommendPreprocess) {
+        console.log(chalk.green('  → 문서 최적화가 필요하지만, 변환 과정에서 자동으로 적용됩니다.'));
+    }
+    else {
+        console.log(chalk.blue('  → 바로 변환해도 안정적입니다.'));
+    }
+    console.log(chalk.gray(`  → 추천 프리셋: ${result.recommendedPreset}`));
+}
+/**
+ * Get typography preset choices with recommended preset highlighted
+ */
+function getTypographyPresetChoices(analysisResult) {
+    const presetCategories = {
+        'Basic': ['novel', 'presentation', 'review', 'ebook'],
+        'Content-focused': ['text_heavy', 'table_heavy', 'image_heavy', 'balanced'],
+        'Document Type': ['report', 'manual', 'magazine'],
+    };
+    const choices = [];
+    for (const [category, presetIds] of Object.entries(presetCategories)) {
+        choices.push(new inquirer.Separator(chalk.bold(`\n── ${category} ──`)));
+        for (const presetId of presetIds) {
+            const preset = TYPOGRAPHY_PRESETS[presetId];
+            if (preset) {
+                const isRecommended = presetId === analysisResult.recommendedPreset;
+                const name = isRecommended
+                    ? chalk.green(`★ ${preset.name}`) + chalk.gray(` - ${preset.description}`) + chalk.green(' (권장)')
+                    : chalk.cyan(preset.name) + chalk.gray(` - ${preset.description}`);
+                choices.push({ name, value: presetId });
+            }
+        }
+    }
+    return choices;
+}
+/**
+ * Get cover theme choices grouped by category
+ */
+function getCoverThemeChoices() {
+    const themeCategories = {
+        'Basic': ['apple', 'modern_gradient', 'dark_tech', 'nature', 'classic_book', 'minimalist'],
+        'Professional': ['corporate', 'academic', 'magazine'],
+        'Creative': ['sunset', 'ocean', 'aurora', 'rose_gold'],
+        'Seasonal': ['spring', 'autumn', 'winter'],
+    };
+    const choices = [];
+    for (const [category, themeIds] of Object.entries(themeCategories)) {
+        choices.push(new inquirer.Separator(chalk.bold(`\n── ${category} ──`)));
+        for (const themeId of themeIds) {
+            const theme = COVER_THEMES[themeId];
+            if (theme) {
+                choices.push({
+                    name: chalk.cyan(theme.name) + chalk.gray(` - ${theme.description}`),
+                    value: themeId,
+                });
+            }
+        }
+    }
+    return choices;
+}
 // Configure CLI
 program
     .name('markdown-to-document')
     .alias('m2d')
     .description('Professional-grade EPUB/PDF conversion tool for Markdown files')
-    .version('1.0.0')
+    .version(getCliVersion())
     .argument('<input>', 'Input markdown file path')
+    .option('--title <title>', 'Book title (defaults to frontmatter title or filename)')
+    .option('--author <author>', 'Author name (defaults to frontmatter author)')
     .option('-o, --output <path>', 'Output directory')
-    .option('-f, --format <format>', 'Output format (epub, pdf, both)', 'epub')
-    .option('-t, --typography <preset>', 'Typography preset (novel, presentation, review, ebook)', 'ebook')
+    .option('-f, --format <format>', 'Output format (epub, pdf, both)', 'both')
+    .option('-t, --typography <preset>', 'Typography preset (auto, novel, presentation, review, ebook, text_heavy, table_heavy, image_heavy, balanced, report, manual, magazine)', 'auto')
     .option('-c, --cover <theme>', 'Cover theme')
     .option('--no-validate', 'Skip content validation')
     .option('--no-auto-fix', 'Disable auto-fix')
     .option('--toc-depth <number>', 'Table of contents depth', '2')
     .option('--no-toc', 'Disable table of contents')
-    .option('--pdf-engine <engine>', 'PDF engine (pdflatex, xelatex, weasyprint)', 'weasyprint')
+    .option('--pdf-engine <engine>', 'PDF engine (auto, pdflatex, xelatex, weasyprint)', 'auto')
     .option('--paper-size <size>', 'Paper size (a4, letter)', 'a4')
     .option('--font-subsetting', 'Enable font subsetting')
     .option('--css <path>', 'Custom CSS file path')
@@ -44,35 +263,29 @@ program
             Logger.setEnabled(true);
             process.env.DEBUG = 'true';
         }
-        // Resolve input path
-        const inputPath = path.resolve(input);
-        // Check if input file exists
-        if (!fs.existsSync(inputPath)) {
-            console.error(chalk.red(`❌ Error: Input file not found: ${inputPath}`));
+        // Validate and normalize input path
+        const pathValidation = PathValidator.validatePath(input);
+        if (!pathValidation.valid) {
+            PathValidator.displayValidationError(pathValidation);
             process.exit(1);
         }
-        // Check if input is markdown
-        if (!inputPath.endsWith('.md')) {
-            console.error(chalk.yellow('⚠️  Warning: Input file does not have .md extension'));
-        }
+        const inputPath = pathValidation.normalizedPath;
+        const fileContent = fs.readFileSync(inputPath, 'utf-8');
+        const analysisResult = analyzeMarkdownContent(fileContent);
+        const metadata = extractMetadata(fileContent);
+        const inferredTitle = metadata.title || path.basename(inputPath, '.md');
+        const inferredAuthor = metadata.author || '';
+        const customTitle = (options.title || inferredTitle).trim();
+        const customAuthor = (options.author || inferredAuthor).trim();
+        const typographyOption = String(options.typography || 'auto');
+        const typographyPreset = typographyOption === 'auto' ? analysisResult.recommendedPreset : typographyOption;
         console.log(chalk.cyan.bold('\n📚 Markdown to Document CLI\n'));
-        // Initialize converter
-        const spinner = ora('Initializing...').start();
-        const converter = new MarkdownToDocument(options.pandocPath);
-        const initResult = await converter.initialize();
-        if (!initResult.success) {
-            spinner.fail('Initialization failed');
-            console.error(chalk.red(`❌ ${initResult.error}`));
-            console.log(chalk.yellow('\n' + MarkdownToDocument.getInstallInstructions()));
-            process.exit(1);
-        }
-        spinner.succeed('Initialized successfully');
         // Prepare conversion options
         const conversionOptions = {
             inputPath,
             outputPath: options.output ? path.resolve(options.output) : undefined,
             format: options.format,
-            typographyPreset: options.typography,
+            typographyPreset: typographyPreset,
             coverTheme: options.cover,
             validateContent: options.validate !== false,
             autoFix: options.autoFix !== false,
@@ -82,12 +295,36 @@ program
             paperSize: options.paperSize,
             enableFontSubsetting: options.fontSubsetting,
             cssPath: options.css ? path.resolve(options.css) : undefined,
+            customTitle,
+            customAuthor: customAuthor || undefined,
         };
+        // Check dependencies proactively
+        const depChecker = new DependencyChecker();
+        const isReady = await depChecker.quickCheck(conversionOptions.format);
+        if (!isReady) {
+            await depChecker.displayDependencyReport();
+            console.log(chalk.red('\n❌ 필수 의존성을 먼저 설치해 주세요.\n'));
+            process.exit(1);
+        }
+        // Initialize converter
+        const spinner = ora('Initializing...').start();
+        const converter = new MarkdownToDocument(options.pandocPath);
+        const initResult = await converter.initialize();
+        if (!initResult.success) {
+            spinner.fail('Initialization failed');
+            console.error(chalk.red(`❌ ${initResult.error}`));
+            console.log(chalk.yellow('\n' + MarkdownToDocument.getInstallInstructions()));
+            process.exit(1);
+        }
+        spinner.succeed('Initialized successfully');
         // Show conversion info
         console.log(chalk.gray('─'.repeat(50)));
         console.log(chalk.bold('📄 Input:'), chalk.cyan(inputPath));
         console.log(chalk.bold('📤 Format:'), chalk.cyan(conversionOptions.format.toUpperCase()));
         console.log(chalk.bold('🎨 Typography:'), chalk.cyan(TYPOGRAPHY_PRESETS[conversionOptions.typographyPreset]?.name || conversionOptions.typographyPreset));
+        console.log(chalk.bold('📖 Title:'), chalk.cyan(customTitle));
+        if (customAuthor)
+            console.log(chalk.bold('✍️  Author:'), chalk.cyan(customAuthor));
         if (conversionOptions.coverTheme) {
             console.log(chalk.bold('🖼️  Cover:'), chalk.cyan(COVER_THEMES[conversionOptions.coverTheme]?.name || conversionOptions.coverTheme));
         }
@@ -154,154 +391,307 @@ program
         process.exit(1);
     }
 });
-// Interactive mode
+/**
+ * Extract metadata from frontmatter
+ */
+function extractMetadata(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch)
+        return {};
+    const frontmatter = frontmatterMatch[1];
+    const titleMatch = frontmatter.match(/^title:\s*["']?(.+?)["']?\s*$/m);
+    const authorMatch = frontmatter.match(/^author:\s*["']?(.+?)["']?\s*$/m);
+    return {
+        title: titleMatch?.[1]?.trim(),
+        author: authorMatch?.[1]?.trim(),
+    };
+}
+/**
+ * Get simplified preset choices (top 6 most useful)
+ */
+function getSimplifiedPresetChoices(recommendedPreset) {
+    const topPresets = ['ebook', 'novel', 'report', 'presentation', 'table_heavy', 'image_heavy'];
+    return topPresets.map(presetId => {
+        const preset = TYPOGRAPHY_PRESETS[presetId];
+        if (!preset)
+            return null;
+        const isRecommended = presetId === recommendedPreset;
+        const name = isRecommended
+            ? chalk.green(`★ ${preset.name}`) + chalk.gray(` - ${preset.description}`)
+            : chalk.cyan(preset.name) + chalk.gray(` - ${preset.description}`);
+        return { name, value: presetId };
+    }).filter(Boolean);
+}
+/**
+ * Get simplified cover theme choices (top 6)
+ */
+function getSimplifiedThemeChoices() {
+    const topThemes = ['apple', 'modern_gradient', 'academic', 'corporate', 'minimalist', 'classic_book'];
+    return topThemes.map(themeId => {
+        const theme = COVER_THEMES[themeId];
+        if (!theme)
+            return null;
+        return {
+            name: chalk.cyan(theme.name) + chalk.gray(` - ${theme.description}`),
+            value: themeId,
+        };
+    }).filter(Boolean);
+}
+// Interactive mode - Refactored for better UX
 program
     .command('interactive')
     .alias('i')
-    .description('Interactive mode with guided prompts')
+    .description('Interactive mode with streamlined workflow')
     .action(async () => {
-    console.log(chalk.cyan.bold('\n' + '─'.repeat(60)));
-    console.log(chalk.cyan.bold('  Markdown to Document - Interactive Mode'));
-    console.log(chalk.cyan.bold('─'.repeat(60) + '\n'));
-    const answers = await inquirer.prompt([
+    console.log(chalk.cyan.bold('\n' + '═'.repeat(60)));
+    console.log(chalk.cyan.bold('  📚 Markdown to Document - Interactive Mode'));
+    console.log(chalk.cyan.bold('═'.repeat(60) + '\n'));
+    // ============ STEP 1: 파일 선택 ============
+    console.log(chalk.gray('  Step 1/3: 파일 선택\n'));
+    const fileAnswer = await inquirer.prompt([
         {
             type: 'input',
             name: 'inputPath',
-            message: chalk.yellow('📄 Input markdown file path:'),
+            message: chalk.yellow('📄 마크다운 파일 경로:'),
             validate: (input) => {
-                // 자동으로 따옴표 제거
-                const cleanedInput = input.trim().replace(/^['"]|['"]$/g, '');
-                const resolvedPath = path.resolve(cleanedInput);
-                if (!fs.existsSync(resolvedPath)) {
-                    return chalk.red('✗ File not found. Please enter a valid path.');
+                const validation = PathValidator.validatePath(input);
+                if (!validation.valid) {
+                    // Return first error and suggestion
+                    let errorMsg = validation.error || '잘못된 경로입니다.';
+                    if (validation.suggestions && validation.suggestions.length > 0) {
+                        errorMsg += '\n' + chalk.gray('   💡 ' + validation.suggestions[0]);
+                    }
+                    return errorMsg;
                 }
                 return true;
             },
-            transformer: (input) => {
-                // 입력값 표시 시에도 따옴표 제거
-                return input.trim().replace(/^['"]|['"]$/g, '');
-            },
+            transformer: (input) => PathValidator.normalizePath(input),
         },
+    ]);
+    const pathValidation = PathValidator.validatePath(fileAnswer.inputPath);
+    if (!pathValidation.valid || !pathValidation.normalizedPath) {
+        PathValidator.displayValidationError(pathValidation);
+        process.exit(1);
+    }
+    const resolvedInputPath = pathValidation.normalizedPath;
+    const fileContent = fs.readFileSync(resolvedInputPath, 'utf-8');
+    // 문서 분석 (자동)
+    const analysisResult = analyzeMarkdownContent(fileContent);
+    const metadata = extractMetadata(fileContent);
+    // 제목/저자: 반드시 사용자 입력을 받으며, 입력값을 항상 변환에 반영
+    const metaAnswers = await inquirer.prompt([
         {
             type: 'input',
             name: 'customTitle',
-            message: chalk.yellow('📖 Book title (leave empty to use auto-detected):'),
-            default: '',
+            message: chalk.yellow('📖 책 제목 (Enter=자동):'),
+            default: metadata.title || path.basename(resolvedInputPath, '.md'),
+            validate: () => true,
+            transformer: (input) => input,
         },
         {
             type: 'input',
             name: 'customAuthor',
-            message: chalk.yellow('✍️  Author name (leave empty to use auto-detected):'),
-            default: '',
-        },
-        {
-            type: 'list',
-            name: 'format',
-            message: chalk.yellow('📤 Output format:'),
-            choices: [
-                { name: chalk.magenta('📚 Both EPUB and PDF'), value: 'both' },
-                { name: chalk.blue('📄 PDF only'), value: 'pdf' },
-                { name: chalk.green('📖 EPUB only'), value: 'epub' },
-            ],
-            default: 'both',
-        },
-        {
-            type: 'list',
-            name: 'typographyPreset',
-            message: chalk.yellow('🎨 Typography preset:'),
-            choices: Object.values(TYPOGRAPHY_PRESETS).map(preset => ({
-                name: `${chalk.cyan(preset.name)} - ${chalk.gray(preset.description)}`,
-                value: preset.id,
-            })),
-            default: 'ebook',
+            message: chalk.yellow('✍️  저자 (Enter=자동):'),
+            default: metadata.author || '',
+            validate: () => true,
+            transformer: (input) => input,
         },
+    ]);
+    // ============ STEP 2: 모드 선택 및 설정 ============
+    console.log(chalk.gray('\n' + '─'.repeat(60)));
+    console.log(chalk.gray('  Step 2/3: 변환 설정\n'));
+    // 분석 결과 요약 (간략하게)
+    console.log(chalk.bold('📊 문서 분석:'));
+    const statsLine = [
+        `${analysisResult.wordCount.toLocaleString()}단어`,
+        `이미지 ${analysisResult.imageCount}개`,
+        `표 ${analysisResult.tableCount}개`,
+    ].join(' | ');
+    console.log(chalk.gray(`   ${statsLine}`));
+    if (analysisResult.issues.length > 0) {
+        console.log(chalk.yellow(`   ⚠️  ${analysisResult.issues.length}개 이슈 감지 → 자동 최적화 적용됨`));
+    }
+    else {
+        console.log(chalk.green('   ✅ 표준 Markdown - 바로 변환 가능'));
+    }
+    if (metadata.title) {
+        console.log(chalk.gray(`   📖 제목: ${metadata.title}`));
+    }
+    console.log();
+    // 모드 선택
+    const modeAnswer = await inquirer.prompt([
         {
             type: 'list',
-            name: 'coverTheme',
-            message: chalk.yellow('🖼️  Cover theme (optional):'),
+            name: 'mode',
+            message: chalk.yellow('🚀 변환 모드 선택:'),
             choices: [
-                { name: chalk.gray('None'), value: null },
-                ...Object.values(COVER_THEMES).map(theme => ({
-                    name: `${chalk.cyan(theme.name)} - ${chalk.gray(theme.description)}`,
-                    value: theme.id,
-                })),
+                {
+                    name: chalk.green('⚡ 빠른 변환') + chalk.gray(' - 스마트 기본값으로 바로 변환 (권장)'),
+                    value: 'quick',
+                },
+                {
+                    name: chalk.blue('⚙️  상세 설정') + chalk.gray(' - 모든 옵션을 직접 선택'),
+                    value: 'custom',
+                },
             ],
-            default: null,
-        },
-        {
-            type: 'confirm',
-            name: 'validateContent',
-            message: chalk.yellow('🔍 Enable content validation?'),
-            default: true,
-        },
-        {
-            type: 'confirm',
-            name: 'autoFix',
-            message: chalk.yellow('🔧 Enable auto-fix for detected issues?'),
-            default: true,
-        },
-        {
-            type: 'input',
-            name: 'outputPath',
-            message: chalk.yellow('📁 Output directory (leave empty for same as input):'),
-            default: '',
+            default: 'quick',
         },
     ]);
+    const mode = modeAnswer.mode;
+    // 변환 설정 수집
+    let format = 'both';
+    let typographyPreset = analysisResult.recommendedPreset;
+    let coverTheme = 'apple';
+    const inferredTitle = metadata.title || path.basename(resolvedInputPath, '.md');
+    const inferredAuthor = metadata.author || '';
+    let customTitle = metaAnswers.customTitle.trim() || inferredTitle;
+    let customAuthor = metaAnswers.customAuthor.trim() || inferredAuthor;
+    let outputPath = '';
+    if (mode === 'quick') {
+        // 빠른 모드: 출력 형식만 선택
+        const quickAnswers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'format',
+                message: chalk.yellow('📤 출력 형식:'),
+                choices: [
+                    { name: chalk.magenta('📚 EPUB + PDF'), value: 'both' },
+                    { name: chalk.green('📖 EPUB만'), value: 'epub' },
+                    { name: chalk.blue('📄 PDF만'), value: 'pdf' },
+                ],
+                default: 'both',
+            },
+        ]);
+        format = quickAnswers.format;
+        // 스마트 기본값 적용
+        console.log(chalk.gray('\n   📋 적용될 설정:'));
+        console.log(chalk.gray(`      프리셋: ${TYPOGRAPHY_PRESETS[typographyPreset]?.name || typographyPreset}`));
+        console.log(chalk.gray(`      표지: ${COVER_THEMES[coverTheme]?.name || coverTheme}`));
+        if (analysisResult.recommendPreprocess) {
+            console.log(chalk.gray('      Obsidian 최적화: 자동 적용'));
+        }
+    }
+    else if (mode === 'custom') {
+        // 상세 모드: 모든 옵션 선택
+        const customAnswers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'format',
+                message: chalk.yellow('📤 출력 형식:'),
+                choices: [
+                    { name: chalk.magenta('📚 EPUB + PDF'), value: 'both' },
+                    { name: chalk.green('📖 EPUB만'), value: 'epub' },
+                    { name: chalk.blue('📄 PDF만'), value: 'pdf' },
+                ],
+                default: 'both',
+            },
+            {
+                type: 'list',
+                name: 'typographyPreset',
+                message: chalk.yellow('🎨 타이포그래피 프리셋:'),
+                choices: [
+                    ...getSimplifiedPresetChoices(analysisResult.recommendedPreset),
+                    new inquirer.Separator(),
+                    { name: chalk.gray('더 많은 프리셋 보기...'), value: '_more' },
+                ],
+                default: analysisResult.recommendedPreset,
+            },
+            {
+                type: 'list',
+                name: 'coverTheme',
+                message: chalk.yellow('🖼️  표지 테마:'),
+                choices: [
+                    ...getSimplifiedThemeChoices(),
+                    new inquirer.Separator(),
+                    { name: chalk.gray('더 많은 테마 보기...'), value: '_more' },
+                ],
+                default: 'apple',
+            },
+        ]);
+        format = customAnswers.format;
+        typographyPreset = customAnswers.typographyPreset;
+        coverTheme = customAnswers.coverTheme;
+        // "더 보기" 선택 시 전체 목록 표시
+        if (typographyPreset === '_more') {
+            const morePresetAnswer = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'typographyPreset',
+                    message: chalk.yellow('🎨 타이포그래피 프리셋 (전체):'),
+                    choices: getTypographyPresetChoices(analysisResult),
+                    default: analysisResult.recommendedPreset,
+                },
+            ]);
+            typographyPreset = morePresetAnswer.typographyPreset;
+        }
+        if (coverTheme === '_more') {
+            const moreThemeAnswer = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'coverTheme',
+                    message: chalk.yellow('🖼️  표지 테마 (전체):'),
+                    choices: getCoverThemeChoices(),
+                    default: 'apple',
+                },
+            ]);
+            coverTheme = moreThemeAnswer.coverTheme;
+        }
+    }
+    // ============ STEP 3: 변환 실행 ============
+    console.log(chalk.gray('\n' + '─'.repeat(60)));
+    console.log(chalk.gray('  Step 3/3: 변환 실행\n'));
     try {
-        console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
-        const spinner = ora({
-            text: chalk.cyan('⚙️  Initializing...'),
-            spinner: 'dots',
-        }).start();
+        // Check dependencies proactively
+        const depChecker = new DependencyChecker();
+        const isReady = await depChecker.quickCheck(format);
+        if (!isReady) {
+            await depChecker.displayDependencyReport();
+            console.log(chalk.red('\n❌ 필수 의존성을 먼저 설치해 주세요.\n'));
+            process.exit(1);
+        }
+        const spinner = ora(chalk.cyan('⚙️  초기화 중...')).start();
         const converter = new MarkdownToDocument();
         const initResult = await converter.initialize();
         if (!initResult.success) {
-            spinner.fail(chalk.red('❌ Initialization failed'));
-            console.error(chalk.red(`❌ ${initResult.error}`));
+            spinner.fail(chalk.red('초기화 실패'));
+            console.error(chalk.red(`\n❌ ${initResult.error}`));
             console.log(chalk.yellow('\n' + MarkdownToDocument.getInstallInstructions()));
             process.exit(1);
         }
-        spinner.succeed(chalk.green('✅ Initialized successfully'));
-        // 따옴표 제거 후 경로 해결
-        const cleanedInputPath = answers.inputPath.trim().replace(/^['"]|['"]$/g, '');
+        // 변환 실행
+        spinner.text = chalk.cyan('🔄 문서 변환 중...');
         const conversionOptions = {
-            inputPath: path.resolve(cleanedInputPath),
-            outputPath: answers.outputPath ? path.resolve(answers.outputPath) : undefined,
-            format: answers.format,
-            typographyPreset: answers.typographyPreset,
-            coverTheme: answers.coverTheme,
-            validateContent: answers.validateContent,
-            autoFix: answers.autoFix,
+            inputPath: resolvedInputPath,
+            outputPath: outputPath ? path.resolve(outputPath) : undefined,
+            format: format,
+            typographyPreset: typographyPreset,
+            coverTheme: coverTheme,
+            validateContent: true,
+            autoFix: true,
             tocDepth: 2,
             includeToc: true,
-            customTitle: answers.customTitle || undefined,
-            customAuthor: answers.customAuthor || undefined,
+            customTitle: customTitle || undefined,
+            customAuthor: customAuthor || undefined,
         };
-        const convertSpinner = ora({
-            text: chalk.cyan('🔄 Converting document...'),
-            spinner: 'dots',
-        }).start();
         const result = await converter.convert(conversionOptions);
         if (result.success) {
-            convertSpinner.succeed(chalk.green('✅ Conversion completed!'));
-            console.log(chalk.gray('\n' + '─'.repeat(60)));
-            console.log(chalk.green.bold('\n📦 Output Files:\n'));
+            spinner.succeed(chalk.green('변환 완료!'));
+            console.log(chalk.green.bold('\n📦 생성된 파일:\n'));
             if (result.epubPath) {
-                console.log(chalk.green(`  📖 EPUB:  ${result.epubPath}`));
+                console.log(chalk.green(`   📖 ${result.epubPath}`));
             }
             if (result.pdfPath) {
-                console.log(chalk.blue(`  📄 PDF:   ${result.pdfPath}`));
+                console.log(chalk.blue(`   📄 ${result.pdfPath}`));
             }
-            console.log(chalk.gray('\n' + '─'.repeat(60)));
-            console.log(chalk.green.bold('\n🎉 Conversion successful!\n'));
+            console.log(chalk.gray('\n' + '═'.repeat(60)));
+            console.log(chalk.green.bold('🎉 변환이 완료되었습니다!\n'));
         }
         else {
-            convertSpinner.fail(chalk.red('❌ Conversion failed'));
-            console.log(chalk.red('\n❌ Errors:'));
+            spinner.fail(chalk.red('변환 실패'));
+            console.log(chalk.red('\n❌ 오류:'));
             result.errors.forEach(error => {
-                console.log(chalk.red(`  • ${error}`));
+                console.log(chalk.red(`   • ${error}`));
             });
-            console.log(chalk.red('\n❌ Conversion failed!\n'));
             process.exit(1);
         }
     }
@@ -347,16 +737,15 @@ program
     .command('check')
     .description('Check if required dependencies are installed')
     .action(async () => {
-    console.log(chalk.cyan.bold('\n🔍 Checking Dependencies...\n'));
-    const converter = new MarkdownToDocument();
-    const result = await converter.initialize();
-    if (result.success) {
-        console.log(chalk.green('✅ All dependencies are installed!\n'));
+    const depChecker = new DependencyChecker();
+    const isReady = await depChecker.displayDependencyReport();
+    if (isReady) {
+        console.log(chalk.green('🚀 준비 완료! 지금 바로 문서 변환을 시작할 수 있습니다.\n'));
+        console.log(chalk.cyan('사용 예시:'));
+        console.log(chalk.gray('  m2d document.md'));
+        console.log(chalk.gray('  m2d interactive\n'));
     }
     else {
-        console.log(chalk.red('❌ Dependency check failed\n'));
-        console.log(chalk.yellow(result.error || 'Unknown error'));
-        console.log(chalk.yellow('\n' + MarkdownToDocument.getInstallInstructions()));
         process.exit(1);
     }
 });