Markdown To Pdf

/* Default PDF styling for markdown-to-pdf skill */

/* Page setup */
@page {
    size: A4;
    margin: 2cm;
}

/* Body */
body {
    font-family: Georgia, 'Times New Roman', serif;
    font-size: 12pt;
    line-height: 1.6;
    color: #333;
    max-width: none;
}

/* Headings */
h1,
h2,
h3,
h4,
h5,
h6 {
    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
    margin-top: 1.5em;
    margin-bottom: 0.5em;
    page-break-after: avoid;
}

h1 {
    font-size: 24pt;
    border-bottom: 2px solid #333;
    padding-bottom: 0.3em;
}

h2 {
    font-size: 18pt;
    border-bottom: 1px solid #ccc;
    padding-bottom: 0.2em;
}

h3 {
    font-size: 14pt;
}
h4 {
    font-size: 12pt;
}

/* Paragraphs */
p {
    margin: 0.8em 0;
    text-align: justify;
}

/* Code blocks */
pre {
    background-color: #f6f8fa;
    border: 1px solid #e1e4e8;
    border-radius: 4px;
    padding: 1em;
    overflow-x: auto;
    font-size: 10pt;
    line-height: 1.4;
    page-break-inside: avoid;
}

code {
    font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
}

/* Inline code */
p code,
li code {
    background-color: #f6f8fa;
    padding: 0.2em 0.4em;
    border-radius: 3px;
    font-size: 0.9em;
}

/* Tables */
table {
    border-collapse: collapse;
    width: 100%;
    margin: 1em 0;
    page-break-inside: avoid;
}

th,
td {
    border: 1px solid #ddd;
    padding: 8px 12px;
    text-align: left;
}

th {
    background-color: #f6f8fa;
    font-weight: bold;
}

tr:nth-child(even) {
    background-color: #fafafa;
}

/* Lists */
ul,
ol {
    margin: 0.8em 0;
    padding-left: 2em;
}

li {
    margin: 0.3em 0;
}

/* Blockquotes */
blockquote {
    border-left: 4px solid #ddd;
    margin: 1em 0;
    padding: 0.5em 1em;
    color: #666;
    background-color: #fafafa;
}

/* Links */
a {
    color: #0366d6;
    text-decoration: none;
}

a:hover {
    text-decoration: underline;
}

/* Images */
img {
    max-width: 100%;
    height: auto;
    display: block;
    margin: 1em auto;
}

/* Horizontal rule */
hr {
    border: none;
    border-top: 1px solid #ddd;
    margin: 2em 0;
}

/* Page breaks */
.page-break {
    page-break-after: always;
}

/* Print-specific */
@media print {
    body {
        font-size: 11pt;
    }

    pre {
        white-space: pre-wrap;
        word-wrap: break-word;
    }

    a {
        color: #333;
    }

    a[href^='http']::after {
        content: ' (' attr(href) ')';
        font-size: 0.8em;
        color: #666;
    }
}

{
    "name": "markdown-to-pdf",
    "version": "1.0.0",
    "description": "Convert markdown files to PDF with syntax highlighting and custom CSS",
    "main": "scripts/convert.cjs",
    "scripts": {
        "start": "node scripts/convert.cjs",
        "test": "node tests/run-tests.cjs"
    },
    "dependencies": {
        "gray-matter": "^4.0.3",
        "md-to-pdf": "^5.2.4"
    },
    "engines": {
        "node": ">=18.0.0"
    }
}

#!/usr/bin/env node

/**
 * Markdown to PDF Converter CLI
 * Converts markdown files to PDF with syntax highlighting and custom CSS
 *
 * Usage:
 *   node convert.cjs --input ./doc.md [--output ./out.pdf] [--css ./style.css]
 *
 * Options:
 *   --input, -i       Input markdown file (required)
 *   --output, -o      Output PDF path (default: input.pdf)
 *   --css, -c         Custom CSS file path
 *   --no-highlight    Disable syntax highlighting
 *   --help, -h        Show help message
 */

const path = require('path');

/**
 * Parse command line arguments
 * @param {string[]} argv - Process arguments
 * @returns {{input: string|null, output: string|null, css: string|null, noHighlight: boolean, help: boolean}}
 */
function parseArgs(argv) {
  const args = {
    input: null,
    output: null,
    css: null,
    noHighlight: false,
    help: false
  };

  for (let i = 2; i < argv.length; i++) {
    const arg = argv[i];
    const nextArg = argv[i + 1];

    switch (arg) {
      case '--input':
      case '-i':
        args.input = nextArg;
        i++;
        break;

      case '--output':
      case '-o':
        args.output = nextArg;
        i++;
        break;

      case '--css':
      case '-c':
        args.css = nextArg;
        i++;
        break;

      case '--no-highlight':
        args.noHighlight = true;
        break;

      case '--help':
      case '-h':
        args.help = true;
        break;

      default:
        // Handle positional argument (assume input file)
        if (!arg.startsWith('-') && !args.input) {
          args.input = arg;
        }
    }
  }

  return args;
}

/**
 * Print help message
 * @returns {void}
 */
function printHelp() {
  console.log(`
markdown-to-pdf - Convert markdown files to PDF

USAGE:
  node convert.cjs --input <file.md> [options]
  node convert.cjs <file.md> [options]

OPTIONS:
  --input, -i <path>     Input markdown file (required)
  --output, -o <path>    Output PDF path (default: same as input with .pdf)
  --css, -c <path>       Custom CSS stylesheet
  --no-highlight         Disable code syntax highlighting
  --help, -h             Show this help message

EXAMPLES:
  # Basic conversion
  node convert.cjs --input ./README.md

  # With custom output path
  node convert.cjs -i ./docs/guide.md -o ./output/guide.pdf

  # With custom CSS
  node convert.cjs -i ./report.md -c ./custom-style.css

OUTPUT:
  Returns JSON on success:
  {
    "success": true,
    "input": "/path/to/input.md",
    "output": "/path/to/output.pdf",
    "pages": 5
  }

  Returns JSON on error:
  {
    "success": false,
    "error": "Error description"
  }

EXIT CODES:
  0  Success
  1  Error (missing input, conversion failed, etc.)
`);
}

/**
 * Print result as JSON
 * @param {object} result - Result object
 * @returns {void}
 */
function printResult(result) {
  console.log(JSON.stringify(result, null, 2));
}

/**
 * Validate arguments
 * @param {{input: string|null}} args - Parsed arguments
 * @returns {{valid: boolean, error?: string}}
 */
function validateArgs(args) {
  if (!args.input) {
    return {
      valid: false,
      error: 'Input file is required. Use --input <path> or provide a positional argument.'
    };
  }

  return { valid: true };
}

/**
 * Check if dependencies are installed
 * @returns {{available: boolean, missing: string[]}}
 */
function checkDependencies() {
  const missing = [];

  try {
    require.resolve('md-to-pdf');
  } catch {
    missing.push('md-to-pdf');
  }

  try {
    require.resolve('gray-matter');
  } catch {
    missing.push('gray-matter');
  }

  return {
    available: missing.length === 0,
    missing
  };
}

/**
 * Main entry point
 * @returns {Promise<void>}
 */
async function main() {
  const args = parseArgs(process.argv);

  // Handle help flag
  if (args.help) {
    printHelp();
    process.exit(0);
  }

  // Validate arguments
  const validation = validateArgs(args);
  if (!validation.valid) {
    printResult({
      success: false,
      error: validation.error
    });
    process.exit(1);
  }

  // Check dependencies
  const deps = checkDependencies();
  if (!deps.available) {
    printResult({
      success: false,
      error: `Missing dependencies: ${deps.missing.join(', ')}. Run 'npm install' in the skill directory.`,
      hint: `cd ${path.dirname(__dirname)} && npm install`
    });
    process.exit(1);
  }

  // Import converter (lazy load after dependency check)
  const { convert } = require('./lib/converter.cjs');

  // Perform conversion
  try {
    const result = await convert({
      input: args.input,
      output: args.output,
      css: args.css,
      noHighlight: args.noHighlight
    });

    printResult(result);
    process.exit(result.success ? 0 : 1);

  } catch (error) {
    printResult({
      success: false,
      error: error.message || 'Unexpected error during conversion'
    });
    process.exit(1);
  }
}

// Run main function
main().catch(error => {
  console.error(JSON.stringify({
    success: false,
    error: `Unhandled error: ${error.message}`
  }));
  process.exit(1);
});

/**
 * Chrome/Chromium executable finder
 * Detects system-installed Chrome to avoid downloading bundled Chromium
 */

const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

/**
 * Known Chrome installation paths by platform
 * @type {Record<string, string[]>}
 */
const CHROME_PATHS = {
  win32: [
    path.join(process.env.PROGRAMFILES || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
    path.join(process.env['PROGRAMFILES(X86)'] || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
    path.join(process.env.LOCALAPPDATA || '', 'Google', 'Chrome', 'Application', 'chrome.exe'),
    // Edge (Chromium-based)
    path.join(process.env.PROGRAMFILES || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
    path.join(process.env['PROGRAMFILES(X86)'] || '', 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
  ],
  darwin: [
    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
    '/Applications/Chromium.app/Contents/MacOS/Chromium',
    path.join(process.env.HOME || '', 'Applications', 'Google Chrome.app', 'Contents', 'MacOS', 'Google Chrome'),
  ],
  linux: [
    '/usr/bin/google-chrome',
    '/usr/bin/google-chrome-stable',
    '/usr/bin/chromium',
    '/usr/bin/chromium-browser',
    '/snap/bin/chromium',
    '/snap/bin/google-chrome',
  ]
};

/**
 * Find Chrome executable on the system
 * @returns {string|null} Path to Chrome executable or null if not found
 */
function findChrome() {
  const platform = process.platform;
  const paths = CHROME_PATHS[platform] || [];

  for (const chromePath of paths) {
    if (chromePath && fs.existsSync(chromePath)) {
      return chromePath;
    }
  }

  // Fallback: try 'which' command on Unix-like systems
  if (platform !== 'win32') {
    try {
      const result = execSync('which google-chrome || which chromium || which chromium-browser 2>/dev/null', {
        encoding: 'utf8',
        stdio: ['pipe', 'pipe', 'ignore']
      }).trim();
      if (result && fs.existsSync(result)) {
        return result;
      }
    } catch {
      // Command failed, no Chrome found
    }
  }

  return null;
}

/**
 * Get Puppeteer launch arguments for the current platform
 * @returns {string[]} Array of Chrome launch arguments
 */
function getPuppeteerArgs() {
  const args = [
    '--disable-gpu',
    '--disable-dev-shm-usage', // Helps in Docker/CI environments
  ];

  // Windows and some Linux environments need --no-sandbox
  if (process.platform === 'win32') {
    args.push('--no-sandbox', '--disable-setuid-sandbox');
  }

  // Check if running in a sandbox-restricted environment
  if (process.env.CI || process.env.DOCKER) {
    args.push('--no-sandbox', '--disable-setuid-sandbox');
  }

  return args;
}

/**
 * Get Chrome configuration for md-to-pdf
 * @returns {{executablePath: string|undefined, args: string[], systemChrome: boolean}}
 */
function getChromeConfig() {
  const executablePath = findChrome();
  const args = getPuppeteerArgs();

  return {
    executablePath: executablePath || undefined,
    args,
    systemChrome: !!executablePath
  };
}

module.exports = {
  findChrome,
  getPuppeteerArgs,
  getChromeConfig,
  CHROME_PATHS
};

/**
 * Configuration and CSS file loader
 * Handles custom CSS injection and config file parsing
 */

const fs = require('fs');
const path = require('path');

// Path to default CSS
const DEFAULT_CSS_PATH = path.join(__dirname, '..', '..', 'assets', 'default-style.css');

/**
 * Load CSS from file path
 * @param {string|null} cssPath - Path to CSS file (null for default)
 * @returns {string} CSS content
 */
function loadCSS(cssPath) {
  const targetPath = cssPath || DEFAULT_CSS_PATH;

  if (!fs.existsSync(targetPath)) {
    if (cssPath) {
      throw new Error(`CSS file not found: ${cssPath}`);
    }
    // Return minimal fallback if default CSS missing
    return `
      body { font-family: Georgia, serif; font-size: 12pt; line-height: 1.6; }
      pre { background: #f5f5f5; padding: 1em; overflow-x: auto; }
      code { font-family: monospace; }
    `;
  }

  return fs.readFileSync(targetPath, 'utf8');
}

/**
 * Load markdown file and extract frontmatter
 * @param {string} filePath - Path to markdown file
 * @returns {{content: string, frontmatter: object}}
 */
function loadMarkdown(filePath) {
  if (!fs.existsSync(filePath)) {
    throw new Error(`Markdown file not found: ${filePath}`);
  }

  const content = fs.readFileSync(filePath, 'utf8');

  // Lazy load gray-matter only when needed
  let matter;
  try {
    matter = require('gray-matter');
  } catch {
    // gray-matter not installed, return raw content
    return { content, frontmatter: {} };
  }

  const parsed = matter(content);
  return {
    content: parsed.content,
    frontmatter: parsed.data || {}
  };
}

/**
 * Get CSS file path (resolves custom or default)
 * @param {string|null} cssPath - Custom CSS path or null for default
 * @returns {string} Resolved CSS file path
 */
function getCSSPath(cssPath) {
  if (cssPath) {
    const resolved = path.resolve(cssPath);
    if (!fs.existsSync(resolved)) {
      throw new Error(`CSS file not found: ${cssPath}`);
    }
    return resolved;
  }
  return DEFAULT_CSS_PATH;
}

/**
 * Build md-to-pdf configuration object
 * @param {object} options - Configuration options
 * @param {string|null} options.cssPath - Path to custom CSS
 * @param {boolean} options.noHighlight - Disable syntax highlighting
 * @param {string} options.title - Document title
 * @returns {object} md-to-pdf config
 */
function buildConfig(options = {}) {
  // md-to-pdf expects stylesheet as file path, not content
  const stylesheetPath = getCSSPath(options.cssPath);

  const config = {
    stylesheet: stylesheetPath,
    pdf_options: {
      format: 'A4',
      margin: {
        top: '2cm',
        bottom: '2cm',
        left: '2cm',
        right: '2cm'
      },
      printBackground: true
    },
    highlight_style: options.noHighlight ? null : 'github',
    marked_options: {
      gfm: true,
      breaks: false
    }
  };

  // Add document title from frontmatter if available
  if (options.title) {
    config.document_title = options.title;
  }

  return config;
}

module.exports = {
  loadCSS,
  loadMarkdown,
  buildConfig,
  getCSSPath,
  DEFAULT_CSS_PATH
};

/**
 * Core markdown-to-PDF converter
 * Wraps md-to-pdf with Chrome detection and cross-platform handling
 */

const fs = require('fs');
const path = require('path');

const { getChromeConfig } = require('./chrome-finder.cjs');
const { loadMarkdown, buildConfig } = require('./config-loader.cjs');
const { resolveOutputPath, cleanupTempFiles } = require('./output-handler.cjs');

/**
 * Convert markdown file to PDF
 *
 * @param {object} options - Conversion options
 * @param {string} options.input - Input markdown file path
 * @param {string|null} options.output - Output PDF path (optional)
 * @param {string|null} options.css - Custom CSS file path (optional)
 * @param {boolean} options.noHighlight - Disable syntax highlighting
 * @returns {Promise<{success: boolean, input: string, output: string, pages?: number, systemChrome?: boolean, error?: string}>}
 */
async function convert(options) {
  const { input, output, css, noHighlight = false } = options;

  // Validate input
  if (!input) {
    return { success: false, error: 'Input file path is required' };
  }

  const absoluteInput = path.resolve(input);
  if (!fs.existsSync(absoluteInput)) {
    return { success: false, error: `Input file not found: ${absoluteInput}` };
  }

  try {
    // Clean up old temp files (async cleanup)
    cleanupTempFiles();

    // Load markdown and extract frontmatter
    const { content, frontmatter } = loadMarkdown(absoluteInput);

    // Build configuration
    const config = buildConfig({
      cssPath: css,
      noHighlight,
      title: frontmatter.title || path.basename(absoluteInput, '.md')
    });

    // Get Chrome configuration
    const chromeConfig = getChromeConfig();

    // Import md-to-pdf dynamically (lazy load)
    const { mdToPdf } = require('md-to-pdf');

    // Resolve output path
    const outputPath = resolveOutputPath(absoluteInput, output);

    // Perform conversion
    await mdToPdf(
      { content },
      {
        ...config,
        dest: outputPath,
        launch_options: {
          executablePath: chromeConfig.executablePath,
          args: chromeConfig.args,
          headless: 'new' // Use new headless mode
        },
        basedir: path.dirname(absoluteInput) // Resolve relative paths from input dir
      }
    );

    // Verify output was created
    if (!fs.existsSync(outputPath)) {
      return { success: false, error: 'PDF generation failed - no output file created' };
    }

    // Get page count (approximate from file size)
    const stats = fs.statSync(outputPath);
    const estimatedPages = Math.max(1, Math.ceil(stats.size / 50000)); // Rough estimate

    return {
      success: true,
      input: absoluteInput,
      output: outputPath,
      pages: estimatedPages,
      systemChrome: chromeConfig.systemChrome
    };

  } catch (error) {
    // Handle specific error types
    if (error.message && error.message.includes('Could not find Chromium')) {
      return {
        success: false,
        error: 'Chromium not found. Run `npm install` in the skill directory or install Chrome/Chromium system-wide.'
      };
    }

    if (error.message && error.message.includes('ENOENT')) {
      return {
        success: false,
        error: `File not found: ${error.path || input}`
      };
    }

    return {
      success: false,
      error: error.message || 'Unknown conversion error',
      stack: process.env.DEBUG ? error.stack : undefined
    };
  }
}

/**
 * Check if md-to-pdf is available
 * @returns {boolean}
 */
function isAvailable() {
  try {
    require.resolve('md-to-pdf');
    return true;
  } catch {
    return false;
  }
}

module.exports = {
  convert,
  isAvailable
};

/**
 * Output path resolution and file handling
 * Handles various output path scenarios
 */

const fs = require('fs');
const path = require('path');
const os = require('os');

/**
 * Resolve output path based on input and user preference
 *
 * Logic:
 *   Input: ./docs/readme.md, Output: null      → ./docs/readme.pdf
 *   Input: ./docs/readme.md, Output: ./out/    → ./out/readme.pdf
 *   Input: ./docs/readme.md, Output: ./my.pdf  → ./my.pdf
 *
 * @param {string} inputPath - Input markdown file path
 * @param {string|null} outputPath - User-specified output path (optional)
 * @returns {string} Resolved absolute output path
 */
function resolveOutputPath(inputPath, outputPath) {
  const absoluteInput = path.resolve(inputPath);
  const inputDir = path.dirname(absoluteInput);
  const inputBasename = path.basename(absoluteInput, path.extname(absoluteInput));

  // Default: same directory as input, .pdf extension
  if (!outputPath) {
    return path.join(inputDir, `${inputBasename}.pdf`);
  }

  const absoluteOutput = path.resolve(outputPath);

  // Check if output is a directory (existing or ends with separator)
  const isDirectory = outputPath.endsWith(path.sep) ||
                      outputPath.endsWith('/') ||
                      (fs.existsSync(absoluteOutput) && fs.statSync(absoluteOutput).isDirectory());

  if (isDirectory) {
    // Ensure directory exists
    fs.mkdirSync(absoluteOutput, { recursive: true });
    return path.join(absoluteOutput, `${inputBasename}.pdf`);
  }

  // Output is a file path - ensure parent directory exists
  const outputDir = path.dirname(absoluteOutput);
  fs.mkdirSync(outputDir, { recursive: true });

  // Ensure .pdf extension
  if (!absoluteOutput.toLowerCase().endsWith('.pdf')) {
    return `${absoluteOutput}.pdf`;
  }

  return absoluteOutput;
}

/**
 * Create a temporary file path for intermediate operations
 * @param {string} prefix - Filename prefix
 * @returns {string} Temporary file path
 */
function createTempPath(prefix = 'md-to-pdf') {
  const tempDir = path.join(os.tmpdir(), 'markdown-to-pdf');
  fs.mkdirSync(tempDir, { recursive: true });
  return path.join(tempDir, `${prefix}-${Date.now()}.pdf`);
}

/**
 * Clean up old temporary files (older than 1 hour)
 * @returns {void}
 */
function cleanupTempFiles() {
  const tempDir = path.join(os.tmpdir(), 'markdown-to-pdf');
  if (!fs.existsSync(tempDir)) return;

  const oneHourAgo = Date.now() - 60 * 60 * 1000;

  try {
    const files = fs.readdirSync(tempDir);

    for (const file of files) {
      const filePath = path.join(tempDir, file);
      try {
        const stat = fs.statSync(filePath);
        if (stat.mtimeMs < oneHourAgo) {
          fs.unlinkSync(filePath);
        }
      } catch {
        // Ignore individual file errors
      }
    }
  } catch {
    // Ignore cleanup errors
  }
}

module.exports = {
  resolveOutputPath,
  createTempPath,
  cleanupTempFiles
};

/**
 * Tests for chrome-finder.cjs
 */

const path = require('path');

describe('chrome-finder', () => {
  const { findChrome, getPuppeteerArgs, getChromeConfig, CHROME_PATHS } = require('../scripts/lib/chrome-finder.cjs');

  it('should export CHROME_PATHS for current platform', () => {
    const platform = process.platform;
    assert.ok(CHROME_PATHS[platform], `CHROME_PATHS should have entries for ${platform}`);
    assert.ok(Array.isArray(CHROME_PATHS[platform]), 'CHROME_PATHS entry should be an array');
  });

  it('should return array from getPuppeteerArgs', () => {
    const args = getPuppeteerArgs();
    assert.ok(Array.isArray(args), 'getPuppeteerArgs should return array');
    assert.ok(args.includes('--disable-gpu'), 'Should include --disable-gpu');
  });

  it('should include --no-sandbox on Windows', () => {
    if (process.platform === 'win32') {
      const args = getPuppeteerArgs();
      assert.ok(args.includes('--no-sandbox'), 'Windows should have --no-sandbox');
    } else {
      // On non-Windows, just verify the function runs
      const args = getPuppeteerArgs();
      assert.ok(Array.isArray(args), 'Should return array on any platform');
    }
  });

  it('should return object from getChromeConfig', () => {
    const config = getChromeConfig();
    assert.ok(typeof config === 'object', 'getChromeConfig should return object');
    assert.ok('args' in config, 'Config should have args property');
    assert.ok('systemChrome' in config, 'Config should have systemChrome property');
    assert.ok(typeof config.systemChrome === 'boolean', 'systemChrome should be boolean');
  });

  it('findChrome should return string or null', () => {
    const result = findChrome();
    assert.ok(result === null || typeof result === 'string', 'findChrome should return string or null');
  });

  it('should have at least 3 Chrome paths for each platform', () => {
    for (const [platform, paths] of Object.entries(CHROME_PATHS)) {
      assert.ok(paths.length >= 2, `Platform ${platform} should have at least 2 Chrome paths`);
    }
  });
});

/**
 * Tests for converter.cjs and related modules
 */

const fs = require('fs');
const path = require('path');

describe('config-loader', () => {
  const { loadCSS, loadMarkdown, buildConfig, getCSSPath, DEFAULT_CSS_PATH } = require('../scripts/lib/config-loader.cjs');
  const fixturesDir = path.join(__dirname, 'fixtures');
  const sampleMd = path.join(fixturesDir, 'sample.md');

  it('should have correct DEFAULT_CSS_PATH', () => {
    assert.ok(DEFAULT_CSS_PATH.endsWith('default-style.css'), 'DEFAULT_CSS_PATH should end with default-style.css');
  });

  it('should load default CSS', () => {
    const css = loadCSS(null);
    assert.ok(css.length > 0, 'Default CSS should not be empty');
    assert.ok(css.includes('body'), 'CSS should have body styles');
  });

  it('should throw for missing custom CSS via loadCSS', () => {
    let threw = false;
    try {
      loadCSS('/nonexistent/path/to/file.css');
    } catch (e) {
      threw = true;
      assert.ok(e.message.includes('CSS file not found'), 'Error should mention CSS file not found');
    }
    assert.ok(threw, 'Should throw for missing CSS file');
  });

  it('should return default CSS path via getCSSPath', () => {
    const cssPath = getCSSPath(null);
    assert.equal(cssPath, DEFAULT_CSS_PATH, 'Should return default CSS path');
  });

  it('should throw for missing custom CSS via getCSSPath', () => {
    let threw = false;
    try {
      getCSSPath('/nonexistent/path/to/file.css');
    } catch (e) {
      threw = true;
      assert.ok(e.message.includes('CSS file not found'), 'Error should mention CSS file not found');
    }
    assert.ok(threw, 'Should throw for missing CSS file');
  });

  it('should load markdown with frontmatter', () => {
    const { content, frontmatter } = loadMarkdown(sampleMd);
    assert.ok(content.length > 0, 'Content should not be empty');
    assert.ok(typeof frontmatter === 'object', 'Frontmatter should be object');
    // Note: frontmatter parsing requires gray-matter
  });

  it('should throw for missing markdown file', () => {
    let threw = false;
    try {
      loadMarkdown('/nonexistent/file.md');
    } catch (e) {
      threw = true;
      assert.ok(e.message.includes('Markdown file not found'), 'Error should mention file not found');
    }
    assert.ok(threw, 'Should throw for missing markdown file');
  });

  it('should build config object', () => {
    const config = buildConfig({ noHighlight: false });
    assert.ok('stylesheet' in config, 'Config should have stylesheet');
    assert.ok(config.stylesheet.endsWith('default-style.css'), 'stylesheet should be path to default CSS');
    assert.ok('pdf_options' in config, 'Config should have pdf_options');
    assert.equal(config.pdf_options.format, 'A4', 'Default format should be A4');
  });

  it('should disable highlighting when noHighlight is true', () => {
    const config = buildConfig({ noHighlight: true });
    assert.equal(config.highlight_style, null, 'highlight_style should be null when disabled');
  });

  it('should set document title', () => {
    const config = buildConfig({ title: 'My Document' });
    assert.equal(config.document_title, 'My Document', 'Should set document_title');
  });
});

describe('output-handler', () => {
  const { resolveOutputPath, createTempPath, cleanupTempFiles } = require('../scripts/lib/output-handler.cjs');
  const os = require('os');
  const fixturesDir = path.join(__dirname, 'fixtures');

  it('should resolve output path from input (no output specified)', () => {
    const result = resolveOutputPath('/path/to/doc.md', null);
    assert.ok(result.endsWith('.pdf'), 'Result should end with .pdf');
    assert.ok(result.includes('doc.pdf'), 'Result should contain doc.pdf');
  });

  it('should use explicit output path', () => {
    const result = resolveOutputPath('/path/to/doc.md', '/output/file.pdf');
    assert.ok(result.endsWith('.pdf'), 'Output should end with .pdf');
  });

  it('should handle directory output', () => {
    // Use fixtures dir which exists
    const result = resolveOutputPath('/path/to/doc.md', fixturesDir + '/');
    assert.ok(result.includes('doc.pdf'), 'Should append filename to directory');
  });

  it('should add .pdf extension if missing', () => {
    const result = resolveOutputPath('/path/to/doc.md', '/output/file');
    assert.ok(result.endsWith('.pdf'), 'Should add .pdf extension');
  });

  it('should create temp path', () => {
    const tempPath = createTempPath('test');
    assert.ok(tempPath.includes(os.tmpdir()), 'Should be in temp directory');
    assert.ok(tempPath.endsWith('.pdf'), 'Should end with .pdf');
  });

  it('should run cleanupTempFiles without error', () => {
    // Just verify it doesn't throw
    cleanupTempFiles();
    assert.ok(true, 'cleanupTempFiles should not throw');
  });
});

describe('converter', () => {
  const { isAvailable } = require('../scripts/lib/converter.cjs');

  it('should report availability', () => {
    const available = isAvailable();
    assert.ok(typeof available === 'boolean', 'isAvailable should return boolean');
  });
});

#!/usr/bin/env node

/**
 * Test runner for markdown-to-pdf skill
 */

const fs = require('fs');
const path = require('path');

// Load test framework
require('./test-framework.cjs');

const testsDir = __dirname;
const testFiles = [
  'chrome-finder.test.cjs',
  'converter.test.cjs'
];

console.log('\n' + '='.repeat(60));
console.log('markdown-to-pdf Test Suite');
console.log('='.repeat(60));

// Load test files
for (const testFile of testFiles) {
  const testPath = path.join(testsDir, testFile);
  if (fs.existsSync(testPath)) {
    try {
      require(testPath);
    } catch (error) {
      console.error(`Error loading ${testFile}: ${error.message}`);
    }
  } else {
    console.log(`Skipping ${testFile} (not found)`);
  }
}

// Run all tests
global.runAllTests();

/**
 * Simple test framework for Node.js (mocha-like)
 * Provides describe/it/before/after/assert without external dependencies
 */

global.testStats = {
  total: 0,
  passed: 0,
  failed: 0,
  suites: [],
  currentSuite: null
};

class TestSuite {
  constructor(name) {
    this.name = name;
    this.tests = [];
    this.beforeFn = null;
    this.afterFn = null;
  }

  addTest(name, fn) {
    this.tests.push({ name, fn });
  }

  setBefore(fn) {
    this.beforeFn = fn;
  }

  setAfter(fn) {
    this.afterFn = fn;
  }

  async run() {
    const results = {
      name: this.name,
      passed: 0,
      failed: 0,
      errors: []
    };

    console.log(`\n  ${this.name}`);

    for (const test of this.tests) {
      try {
        if (this.beforeFn) await this.beforeFn();
        await test.fn();
        if (this.afterFn) await this.afterFn();

        results.passed++;
        process.stdout.write('    ✓ ' + test.name + '\n');
      } catch (error) {
        results.failed++;
        results.errors.push({ test: test.name, error: error.message });
        process.stdout.write('    ✗ ' + test.name + '\n');
        console.log('      Error: ' + error.message);
      }
    }

    return results;
  }
}

global.testSuites = {};

global.describe = function(name, fn) {
  const suite = new TestSuite(name);
  global.testStats.currentSuite = suite;
  global.testSuites[name] = suite;
  fn();
};

global.it = function(name, fn) {
  if (!global.testStats.currentSuite) {
    throw new Error('it() called outside describe()');
  }
  global.testStats.currentSuite.addTest(name, fn);
};

global.before = function(fn) {
  if (global.testStats.currentSuite) {
    global.testStats.currentSuite.setBefore(fn);
  }
};

global.after = function(fn) {
  if (global.testStats.currentSuite) {
    global.testStats.currentSuite.setAfter(fn);
  }
};

// Simple assertion helper
global.assert = {
  ok: (value, msg) => {
    if (!value) throw new Error(msg || 'Assertion failed: expected truthy value');
  },
  equal: (a, b, msg) => {
    if (a !== b) throw new Error(msg || `Expected ${JSON.stringify(a)} to equal ${JSON.stringify(b)}`);
  },
  deepEqual: (a, b, msg) => {
    if (JSON.stringify(a) !== JSON.stringify(b)) {
      throw new Error(msg || `Expected ${JSON.stringify(a)} to deep equal ${JSON.stringify(b)}`);
    }
  },
  throws: async (fn, msg) => {
    try {
      await fn();
      throw new Error(msg || 'Expected function to throw');
    } catch (e) {
      if (e.message === (msg || 'Expected function to throw')) throw e;
    }
  },
  notEqual: (a, b, msg) => {
    if (a === b) throw new Error(msg || `Expected ${JSON.stringify(a)} to not equal ${JSON.stringify(b)}`);
  }
};

global.runAllTests = async function() {
  console.log('\n' + '='.repeat(60));
  console.log('Running Tests');
  console.log('='.repeat(60));

  const results = [];
  for (const suite of Object.values(global.testSuites)) {
    const result = await suite.run();
    results.push(result);
    global.testStats.passed += result.passed;
    global.testStats.failed += result.failed;
    global.testStats.total += result.passed + result.failed;
  }

  // Print summary
  console.log('\n' + '='.repeat(60));
  console.log('Results');
  console.log('='.repeat(60) + '\n');

  for (const result of results) {
    const status = result.failed > 0 ? 'FAIL' : 'PASS';
    console.log(`${status}: ${result.name} (${result.passed}/${result.passed + result.failed})`);
    if (result.errors.length > 0) {
      result.errors.forEach(err => {
        console.log(`  - ${err.test}: ${err.error}`);
      });
    }
  }

  console.log('\n' + '='.repeat(60));
  console.log(`Total: ${global.testStats.total} | Passed: ${global.testStats.passed} | Failed: ${global.testStats.failed}`);
  console.log('='.repeat(60) + '\n');

  if (global.testStats.failed > 0) process.exit(1);
};

module.exports = { TestSuite, runAllTests };