macos-vision 1.1.0 → 1.3.0

package/dist/index.js

@@ -1,21 +1,21 @@
 import { execFile } from 'child_process';
 import { promisify } from 'util';
-import { resolve, dirname, extname, join } from 'path';
+import { resolve, dirname, extname, dirname as pathDirname } from 'path';
 import { fileURLToPath } from 'url';
-import { tmpdir } from 'os';
-import { open, mkdir, readdir, rm } from 'fs/promises';
+import { open } from 'fs/promises';
 const execFileAsync = promisify(execFile);
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const BIN_PATH = resolve(__dirname, '../bin/vision-helper');
+const PDF_BIN_PATH = resolve(__dirname, '../bin/pdf-helper');
 const BINARY_TIMEOUT_MS = 30_000;
-const SIPS_TIMEOUT_MS = 60_000;
+const PDF_RASTERIZE_TIMEOUT_MS = 120_000;
 async function run(flag, imagePath) {
     const { stdout } = await execFileAsync(BIN_PATH, [flag, resolve(imagePath)], {
         timeout: BINARY_TIMEOUT_MS,
     });
     return stdout;
 }
-// ─── PDF helpers ─────────────────────────────────────────────────────────────
+// ─── PDF helpers ─────────────────────────────────────────────────────
 /**
  * Returns true if the file at `filePath` is a PDF.
  * Uses extension as a fast path; falls back to magic bytes (`%PDF`) for
@@ -36,58 +36,50 @@ async function isPdf(filePath) {
     }
 }
 /**
- * Rasterizes a PDF to PNG files in `outDir` using macOS `sips`.
- * Returns sorted list of absolute PNG paths (order = page order).
+ * Rasterizes a PDF to 300 DPI PNG files using the native `pdf-helper` binary
+ * (PDFKit-based). Files are saved persistently to `~/.cache/macos-vision/`
+ * so they can be reused by downstream tools — **caller is responsible for cleanup**.
  *
- * sips names single-page output `{basename}.png` and multi-page output
- * `{basename}-1.png`, `{basename}-2.png`, etc. The numeric sort handles both.
+ * @param pdfPath - Absolute or relative path to the PDF file.
+ * @returns An object with `pages` (sorted array of `{page, path}`) and `cacheDir`.
  */
-async function rasterizePdf(pdfPath, outDir) {
-    await execFileAsync('sips', ['-s', 'format', 'png', '--resampleHeight', '2000', pdfPath, '--out', outDir], { timeout: SIPS_TIMEOUT_MS });
-    const entries = await readdir(outDir);
-    const pngs = entries.filter((n) => n.toLowerCase().endsWith('.png'));
-    pngs.sort((a, b) => {
-        const numA = parseInt(a.match(/-(\d+)\.png$/i)?.[1] ?? '0', 10);
-        const numB = parseInt(b.match(/-(\d+)\.png$/i)?.[1] ?? '0', 10);
-        return numA - numB;
+export async function rasterizePdf(pdfPath) {
+    const absPath = resolve(pdfPath);
+    const { stdout } = await execFileAsync(PDF_BIN_PATH, [absPath], {
+        timeout: PDF_RASTERIZE_TIMEOUT_MS,
     });
-    return pngs.map((n) => join(outDir, n));
+    const pages = JSON.parse(stdout);
+    const cacheDir = pages.length > 0 ? pathDirname(pages[0].path) : '';
+    return { pages, cacheDir };
 }
 /**
- * Full PDF OCR pipeline: rasterize → per-page OCR → merge results.
- * Temporary PNG files are always cleaned up in the `finally` block.
+ * Internal PDF OCR pipeline: rasterize via pdf-helper → OCR each page → merge.
+ * PNG files are NOT cleaned up — they persist in ~/.cache/macos-vision/.
  */
 async function ocrPdf(pdfPath, format) {
-    const outDir = join(tmpdir(), `macos-vision-${globalThis.crypto.randomUUID()}`);
-    await mkdir(outDir, { recursive: true });
-    try {
-        const pages = await rasterizePdf(pdfPath, outDir);
-        if (format === 'blocks') {
-            const all = [];
-            for (let i = 0; i < pages.length; i++) {
-                const blocks = (await ocr(pages[i], { format: 'blocks' }));
-                all.push(...blocks.map((b) => ({ ...b, page: i })));
-            }
-            return all;
-        }
-        const texts = [];
-        for (let i = 0; i < pages.length; i++) {
-            texts.push((await ocr(pages[i])));
+    const { pages } = await rasterizePdf(pdfPath);
+    if (format === 'blocks') {
+        const all = [];
+        for (const { page, path: pagePath } of pages) {
+            const blocks = (await ocr(pagePath, { format: 'blocks' }));
+            all.push(...blocks.map((b) => ({ ...b, page })));
         }
-        return texts.join('\n\n--- Page Break ---\n\n');
+        return all;
     }
-    finally {
-        await rm(outDir, { recursive: true, force: true });
+    const texts = [];
+    for (const { path: pagePath } of pages) {
+        texts.push((await ocr(pagePath)));
     }
+    return texts.join('\n\n--- Page Break ---\n\n');
 }
 export async function ocr(imagePath, options = {}) {
     const absPath = resolve(imagePath);
     const { format = 'text' } = options;
-    // ── PDF fast-path: rasterize via sips, then OCR each page ────────────────
+    // ── PDF fast-path: rasterize via sips, then OCR each page ────────────
     if (await isPdf(absPath)) {
         return ocrPdf(absPath, format);
     }
-    // ── Existing image path (unchanged) ──────────────────────────────────────
+    // ── Existing image path (unchanged) ─────────────────────────────────
     if (format === 'blocks') {
         const { stdout } = await execFileAsync(BIN_PATH, ['--json', absPath], {
             timeout: BINARY_TIMEOUT_MS,
@@ -136,3 +128,5 @@ export async function classify(imagePath) {
     return raw;
 }
 export { inferLayout, sortBlocksByReadingOrder } from './layout.js';
+// ─── Markdown pipeline (VisionScribe) ──────────────────────────────────────────
+export { VisionScribe, OllamaUnavailableError } from './markdown/index.js';

package/dist/markdown/chunker.d.ts

@@ -0,0 +1,11 @@
+import type { ParagraphGroup } from './prompt.js';
+export declare function estimateTokens(text: string): number;
+/**
+ * Split an array of paragraphs into chunks where each chunk's estimated prompt
+ * token count stays within `chunkSizeTokens`. Paragraph boundaries are never
+ * split — chunks always break between `ParagraphGroup` objects.
+ *
+ * A paragraph whose estimated token count exceeds the budget on its own is
+ * emitted as a singleton chunk with a warning.
+ */
+export declare function chunkParagraphs(paragraphs: ParagraphGroup[], chunkSizeTokens: number): ParagraphGroup[][];

package/dist/markdown/chunker.js

@@ -0,0 +1,39 @@
+import { buildPrompt } from './prompt.js';
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Split an array of paragraphs into chunks where each chunk's estimated prompt
+ * token count stays within `chunkSizeTokens`. Paragraph boundaries are never
+ * split — chunks always break between `ParagraphGroup` objects.
+ *
+ * A paragraph whose estimated token count exceeds the budget on its own is
+ * emitted as a singleton chunk with a warning.
+ */
+export function chunkParagraphs(paragraphs, chunkSizeTokens) {
+    const result = [];
+    let currentBatch = [];
+    for (const p of paragraphs) {
+        const candidate = [...currentBatch, p];
+        const tokens = estimateTokens(buildPrompt(candidate));
+        if (currentBatch.length === 0) {
+            if (tokens > chunkSizeTokens) {
+                console.warn(`[macos-vision] Paragraph ${p.paragraphId} (page ${p.page}) ` +
+                    `exceeds chunk budget (~${tokens} est. tokens > ${chunkSizeTokens}). ` +
+                    `Processing as standalone chunk.`);
+            }
+            currentBatch = [p];
+        }
+        else if (tokens <= chunkSizeTokens) {
+            currentBatch = candidate;
+        }
+        else {
+            result.push(currentBatch);
+            currentBatch = [p];
+        }
+    }
+    if (currentBatch.length > 0) {
+        result.push(currentBatch);
+    }
+    return result;
+}

package/dist/markdown/index.d.ts

@@ -0,0 +1,61 @@
+export { OllamaUnavailableError } from './ollama.js';
+export type { ParagraphGroup } from './prompt.js';
+export interface VisionScribeOptions {
+    /**
+     * Ollama model name.
+     * @default 'mistral-nemo'
+     */
+    model?: string;
+    /**
+     * Base URL of the Ollama server.
+     * @default 'http://localhost:11434'
+     */
+    ollamaUrl?: string;
+    /**
+     * Skip the Ollama reachability check before each call.
+     * Useful in batch/eval contexts where you ping once upfront.
+     * @default false
+     */
+    skipPing?: boolean;
+    /**
+     * Maximum estimated output tokens per LLM chunk.
+     * Paragraphs are batched so that no single generate() call is expected
+     * to produce more than this many tokens. Lower values mean more (faster)
+     * chunks; higher values risk hitting the model's output token limit.
+     * @default 1800
+     */
+    chunkSizeTokens?: number;
+}
+/**
+ * Converts an image or PDF to structured Markdown using a two-stage pipeline:
+ *
+ * 1. **Apple Vision OCR** — extracts raw text blocks with bounding-box coordinates.
+ *    PDFs are automatically rasterized page-by-page.
+ * 2. **Layout inference** — groups blocks by `paragraphId` per page using spatial
+ *    heuristics (each page processed independently to avoid coordinate mixing).
+ * 3. **Chunking** — paragraphs are batched to stay within the LLM output token budget.
+ * 4. **Local LLM (Ollama)** — formats each chunk into clean Markdown without
+ *    hallucinating new content.
+ *
+ * @example
+ * ```ts
+ * const scribe = new VisionScribe({ model: 'mistral-nemo' });
+ * const markdown = await scribe.toMarkdown('invoice.png');
+ * const mdFromPdf = await scribe.toMarkdown('report.pdf');
+ * ```
+ */
+export declare class VisionScribe {
+    private readonly model;
+    private readonly ollamaUrl;
+    private readonly skipPing;
+    private readonly chunkSizeTokens;
+    constructor(options?: VisionScribeOptions);
+    /**
+     * Convert an image or PDF file to Markdown.
+     *
+     * @param imagePath Absolute or relative path to the image or PDF.
+     * @returns Markdown string. Empty string if no text was detected.
+     * @throws {OllamaUnavailableError} If the Ollama server cannot be reached.
+     */
+    toMarkdown(imagePath: string): Promise<string>;
+}

package/dist/markdown/index.js

@@ -0,0 +1,92 @@
+import { ocr, inferLayout, sortBlocksByReadingOrder } from '../index.js';
+import { ping, chat } from './ollama.js';
+import { groupByParagraph, buildUserContent, SYSTEM_PROMPT } from './prompt.js';
+import { chunkParagraphs } from './chunker.js';
+export { OllamaUnavailableError } from './ollama.js';
+/**
+ * Group raw OCR blocks by their page index.
+ * macos-vision attaches a `page` field (0-based) to blocks from PDFs.
+ * Single-image blocks have no `page` field and land in page 0.
+ *
+ * Coordinates in VisionBlock are always page-local (0–1), so blocks from
+ * different pages must NOT be passed together to inferLayout().
+ */
+function groupBlocksByPage(blocks) {
+    const pages = new Map();
+    for (const block of blocks) {
+        const page = block.page ?? 0;
+        const existing = pages.get(page) ?? [];
+        existing.push(block);
+        pages.set(page, existing);
+    }
+    return pages;
+}
+/**
+ * Converts an image or PDF to structured Markdown using a two-stage pipeline:
+ *
+ * 1. **Apple Vision OCR** — extracts raw text blocks with bounding-box coordinates.
+ *    PDFs are automatically rasterized page-by-page.
+ * 2. **Layout inference** — groups blocks by `paragraphId` per page using spatial
+ *    heuristics (each page processed independently to avoid coordinate mixing).
+ * 3. **Chunking** — paragraphs are batched to stay within the LLM output token budget.
+ * 4. **Local LLM (Ollama)** — formats each chunk into clean Markdown without
+ *    hallucinating new content.
+ *
+ * @example
+ * ```ts
+ * const scribe = new VisionScribe({ model: 'mistral-nemo' });
+ * const markdown = await scribe.toMarkdown('invoice.png');
+ * const mdFromPdf = await scribe.toMarkdown('report.pdf');
+ * ```
+ */
+export class VisionScribe {
+    model;
+    ollamaUrl;
+    skipPing;
+    chunkSizeTokens;
+    constructor(options = {}) {
+        this.model = options.model ?? 'mistral-nemo';
+        this.ollamaUrl = options.ollamaUrl ?? 'http://localhost:11434';
+        this.skipPing = options.skipPing ?? false;
+        this.chunkSizeTokens = options.chunkSizeTokens ?? 1800;
+    }
+    /**
+     * Convert an image or PDF file to Markdown.
+     *
+     * @param imagePath Absolute or relative path to the image or PDF.
+     * @returns Markdown string. Empty string if no text was detected.
+     * @throws {OllamaUnavailableError} If the Ollama server cannot be reached.
+     */
+    async toMarkdown(imagePath) {
+        // 1. Ensure Ollama is reachable before doing expensive OCR work.
+        if (!this.skipPing)
+            await ping(this.ollamaUrl);
+        // 2. Extract raw OCR blocks via Apple Vision.
+        //    For PDFs, macos-vision rasterizes each page and adds a `page` field.
+        const rawBlocks = await ocr(imagePath, { format: 'blocks' });
+        // 3. Split blocks by page — inferLayout() requires page-local coordinates.
+        const pageMap = groupBlocksByPage(rawBlocks);
+        // 4. Per page: infer layout → sort → group into paragraphs.
+        const allParagraphs = [];
+        for (const [pageIndex, pageBlocks] of [...pageMap.entries()].sort(([a], [b]) => a - b)) {
+            const layoutBlocks = inferLayout({ textBlocks: pageBlocks });
+            const sorted = sortBlocksByReadingOrder(layoutBlocks);
+            const paragraphs = groupByParagraph(sorted, pageIndex);
+            allParagraphs.push(...paragraphs);
+        }
+        if (allParagraphs.length === 0) {
+            return '';
+        }
+        // 5. Split paragraphs into chunks that fit within the output token budget.
+        const chunks = chunkParagraphs(allParagraphs, this.chunkSizeTokens);
+        // 6. Send each chunk to the LLM sequentially and join the results.
+        //    System prompt goes as role:"system", OCR text as role:"user" — this
+        //    prevents the model from treating instructions as content to summarise.
+        const parts = [];
+        for (const chunk of chunks) {
+            const part = await chat({ baseUrl: this.ollamaUrl, model: this.model }, SYSTEM_PROMPT, buildUserContent(chunk));
+            parts.push(part);
+        }
+        return parts.join('\n\n');
+    }
+}

package/dist/markdown/ollama.d.ts

@@ -0,0 +1,21 @@
+export interface OllamaOptions {
+    /** Base URL of the Ollama server. Default: `http://localhost:11434` */
+    baseUrl: string;
+    /** Model name to use for generation. Default: `mistral-nemo` */
+    model: string;
+}
+/**
+ * Verify that the Ollama server is reachable.
+ * Throws {@link OllamaUnavailableError} if the server cannot be contacted.
+ */
+export declare function ping(baseUrl: string): Promise<void>;
+/**
+ * Send a chat request to the Ollama /api/chat endpoint.
+ * Separating system and user roles significantly reduces hallucination compared
+ * to /api/generate where both are concatenated into a single completion string.
+ * Uses `stream: false` so the full response arrives in one shot.
+ */
+export declare function chat(opts: OllamaOptions, systemPrompt: string, userContent: string): Promise<string>;
+export declare class OllamaUnavailableError extends Error {
+    constructor(url: string);
+}

package/dist/markdown/ollama.js

@@ -0,0 +1,50 @@
+/**
+ * Verify that the Ollama server is reachable.
+ * Throws {@link OllamaUnavailableError} if the server cannot be contacted.
+ */
+export async function ping(baseUrl) {
+    try {
+        await fetch(`${baseUrl}/api/tags`, { signal: AbortSignal.timeout(3_000) });
+    }
+    catch {
+        throw new OllamaUnavailableError(baseUrl);
+    }
+}
+/**
+ * Send a chat request to the Ollama /api/chat endpoint.
+ * Separating system and user roles significantly reduces hallucination compared
+ * to /api/generate where both are concatenated into a single completion string.
+ * Uses `stream: false` so the full response arrives in one shot.
+ */
+export async function chat(opts, systemPrompt, userContent) {
+    const res = await fetch(`${opts.baseUrl}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            model: opts.model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: userContent },
+            ],
+            stream: false,
+            options: {
+                temperature: 0, // deterministic — no creative token selection
+                top_p: 1, // full vocabulary considered; determinism comes from temperature=0
+                num_predict: -1, // no output truncation
+            },
+        }),
+        signal: AbortSignal.timeout(600_000),
+    });
+    if (!res.ok) {
+        throw new Error(`Ollama request failed: ${res.status} ${res.statusText}`);
+    }
+    const data = (await res.json());
+    return data.message.content.trim();
+}
+export class OllamaUnavailableError extends Error {
+    constructor(url) {
+        super(`Ollama is not reachable at ${url}. ` +
+            `Make sure Ollama is running (e.g. \`ollama serve\`) and the URL is correct.`);
+        this.name = 'OllamaUnavailableError';
+    }
+}

package/dist/markdown/prompt.d.ts

@@ -0,0 +1,35 @@
+import type { LayoutBlock } from '../index.js';
+/**
+ * A single paragraph: all TextBlocks sharing the same paragraphId,
+ * in reading order (top-to-bottom, left-to-right within each line).
+ */
+export interface ParagraphGroup {
+    paragraphId: number;
+    /** Average y-coordinate of the first line — used as a spatial hint. */
+    y: number;
+    lines: string[];
+    /** Zero-based page index (always 0 for single images). */
+    page: number;
+}
+/**
+ * Group sorted layout blocks by paragraphId into ParagraphGroup objects.
+ * Non-text blocks (faces, barcodes, etc.) are ignored.
+ */
+export declare function groupByParagraph(blocks: LayoutBlock[], pageIndex?: number): ParagraphGroup[];
+/**
+ * The system prompt sent as `role: "system"` in every chat request.
+ * Kept separate from user content so the model treats it as hard constraints,
+ * not as text to be summarised or analysed.
+ */
+export declare const SYSTEM_PROMPT = "ACT AS A HIGH-FIDELITY DOCUMENT PARSER. Your only goal is to reconstruct the provided OCR data into a structured Markdown document. NEVER skip text. NEVER summarize. Content must be 100% identical to the source.\n\nDO NOT SUMMARIZE.\nTranscribe every single word from the provided OCR data.\nMaintain 1:1 content fidelity. If the source has 5 paragraphs, the output must have 5 paragraphs.\n\nSTRICT OUTPUT: Output ONLY the Markdown representation. No preamble, no \"Summary of key events\", no \"Here is the result\".\n\nFORMATTING RULES:\n- Add # / ## / ### before lines that are clearly headings or titles\n- Add - before items that are clearly list entries\n- Join lines within the same paragraph into flowing prose\n- Preserve blank lines between paragraphs\n- Do NOT wrap output in code fences";
+/**
+ * Build the user-facing content block from a list of paragraphs.
+ * This is the OCR text that the model will format — no instructions included.
+ * Sent as `role: "user"` in the chat request.
+ */
+export declare function buildUserContent(paragraphs: ParagraphGroup[]): string;
+/**
+ * Build the combined string used for token estimation in the chunker.
+ * Mirrors what will be sent to the model (system + user content).
+ */
+export declare function buildPrompt(paragraphs: ParagraphGroup[]): string;

package/dist/markdown/prompt.js

@@ -0,0 +1,82 @@
+/**
+ * Group sorted layout blocks by paragraphId into ParagraphGroup objects.
+ * Non-text blocks (faces, barcodes, etc.) are ignored.
+ */
+export function groupByParagraph(blocks, pageIndex = 0) {
+    const map = new Map();
+    for (const block of blocks) {
+        if (block.kind !== 'text')
+            continue;
+        if (!map.has(block.paragraphId)) {
+            map.set(block.paragraphId, { y: block.y, lines: new Map() });
+        }
+        const para = map.get(block.paragraphId);
+        const existing = para.lines.get(block.lineId) ?? [];
+        existing.push(block.text);
+        para.lines.set(block.lineId, existing);
+    }
+    const groups = [];
+    for (const [paragraphId, { y, lines }] of map) {
+        // Join tokens within each line, then collect lines in order
+        const lineStrings = [...lines.entries()]
+            .sort(([a], [b]) => a - b)
+            .map(([, tokens]) => tokens.join(' '));
+        groups.push({ paragraphId, y, lines: lineStrings, page: pageIndex });
+    }
+    return groups;
+}
+/**
+ * The system prompt sent as `role: "system"` in every chat request.
+ * Kept separate from user content so the model treats it as hard constraints,
+ * not as text to be summarised or analysed.
+ */
+export const SYSTEM_PROMPT = `ACT AS A HIGH-FIDELITY DOCUMENT PARSER. \
+Your only goal is to reconstruct the provided OCR data into a structured \
+Markdown document. NEVER skip text. NEVER summarize. \
+Content must be 100% identical to the source.
+
+DO NOT SUMMARIZE.
+Transcribe every single word from the provided OCR data.
+Maintain 1:1 content fidelity. If the source has 5 paragraphs, the output must have 5 paragraphs.
+
+STRICT OUTPUT: Output ONLY the Markdown representation. \
+No preamble, no "Summary of key events", no "Here is the result".
+
+FORMATTING RULES:
+- Add # / ## / ### before lines that are clearly headings or titles
+- Add - before items that are clearly list entries
+- Join lines within the same paragraph into flowing prose
+- Preserve blank lines between paragraphs
+- Do NOT wrap output in code fences`;
+/**
+ * Build the user-facing content block from a list of paragraphs.
+ * This is the OCR text that the model will format — no instructions included.
+ * Sent as `role: "user"` in the chat request.
+ */
+export function buildUserContent(paragraphs) {
+    const pageNumbers = [...new Set(paragraphs.map(p => p.page))].sort((a, b) => a - b);
+    const multiPage = pageNumbers.length > 1;
+    const blocks = [];
+    for (const pageNum of pageNumbers) {
+        if (multiPage) {
+            blocks.push(`[Page ${pageNum + 1}]`);
+        }
+        const pageParagraphs = paragraphs.filter(p => p.page === pageNum);
+        for (const { paragraphId, y, lines } of pageParagraphs) {
+            const yHint = y.toFixed(2);
+            const header = `[Paragraph ${paragraphId}, y≈${yHint}]`;
+            blocks.push(`${header}\n${lines.join('\n')}`);
+        }
+    }
+    const task = 'Convert the OCR source below into Markdown. ' +
+        'Reproduce EVERY word EXACTLY. Do not respond, explain, or ask questions.\n\n' +
+        '<ocr_source>';
+    return `${task}\n\n${blocks.join('\n\n')}\n</ocr_source>`;
+}
+/**
+ * Build the combined string used for token estimation in the chunker.
+ * Mirrors what will be sent to the model (system + user content).
+ */
+export function buildPrompt(paragraphs) {
+    return `${SYSTEM_PROMPT}\n\n${buildUserContent(paragraphs)}`;
+}

package/package.json

@@ -1,15 +1,33 @@
 {
   "name": "macos-vision",
-  "version": "1.1.0",
-  "description": "Apple Vision OCR & image analysis for Node.js — native, fast, offline, no API keys",
+  "version": "1.3.0",
+  "description": "Apple Vision OCR + image/PDF analysis for Node.js, with optional Ollama-driven Markdown pipeline — native, fast, offline",
   "author": "Adrian Wolczuk",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "macos-vision": "./dist/cli.js"
+    "macos-vision": "dist/cli.js"
   },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./markdown": {
+      "import": "./dist/markdown/index.js",
+      "types": "./dist/markdown/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "scripts/build-native.js",
+    "src/native",
+    "README.md",
+    "LICENSE"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/woladi/macos-vision.git"
@@ -25,7 +43,8 @@
     "lint": "eslint src/**/*.ts",
     "format": "prettier --write src/**/*.ts",
     "release": "release-it",
-    "release:beta": "release-it --preRelease=beta"
+    "release:beta": "release-it --preRelease=beta",
+    "eval:setup": "git clone https://github.com/opendataloader-project/opendataloader-bench eval/bench || echo 'bench already cloned'"
   },
   "keywords": [
     "ocr",
@@ -40,7 +59,13 @@
     "barcode",
     "qr-code",
     "document-detection",
-    "image-classification"
+    "image-classification",
+    "markdown",
+    "image-to-markdown",
+    "pdf-to-markdown",
+    "ollama",
+    "llm",
+    "document-pipeline"
   ],
   "lint-staged": {
     "src/**/*.ts": [

package/scripts/build-native.js

@@ -6,21 +6,36 @@ import path from 'path';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const root = path.resolve(__dirname, '..');
 const binDir = path.join(root, 'bin');
-const binPath = path.join(binDir, 'vision-helper');
-const swiftSrc = path.join(root, 'src', 'native', 'vision-helper.swift');
 
-if (existsSync(binPath)) {
+const binaries = [
+  {
+    src: path.join(root, 'src', 'native', 'vision-helper.swift'),
+    out: path.join(binDir, 'vision-helper'),
+    name: 'vision-helper',
+  },
+  {
+    src: path.join(root, 'src', 'native', 'pdf-helper.swift'),
+    out: path.join(binDir, 'pdf-helper'),
+    name: 'pdf-helper',
+  },
+];
+
+const allExist = binaries.every(({ out }) => existsSync(out));
+if (allExist) {
   process.exit(0);
 }
 
 mkdirSync(binDir, { recursive: true });
 
-try {
-  execSync(`swiftc -O "${swiftSrc}" -o "${binPath}"`, { stdio: 'inherit' });
-  console.log('✅ macos-vision: native binary compiled successfully');
-} catch {
-  console.error('❌ macos-vision: Swift compilation failed.');
-  console.error('   Make sure Xcode Command Line Tools are installed:');
-  console.error('   xcode-select --install');
-  process.exit(1);
+for (const { src, out, name } of binaries) {
+  if (existsSync(out)) continue;
+  try {
+    execSync(`swiftc -O "${src}" -o "${out}"`, { stdio: 'inherit' });
+    console.log(`✅ macos-vision: ${name} compiled successfully`);
+  } catch {
+    console.error(`❌ macos-vision: ${name} compilation failed.`);
+    console.error('   Make sure Xcode Command Line Tools are installed:');
+    console.error('   xcode-select --install');
+    process.exit(1);
+  }
 }