open-agents-ai 0.31.0 → 0.31.2

package/dist/index.js

@@ -7719,13 +7719,13 @@ var init_ocr_image_advanced = __esm({
     OcrImageAdvancedTool = class {
       workingDir;
       name = "ocr_image_advanced";
-      description = "Advanced OCR for images using multi-variant preprocessing and multi-PSM Tesseract pipeline. Generates 5 image preprocessing variants (adaptive threshold, OTSU, fixed threshold, sharpen+OTSU, denoise+OTSU) and runs Tesseract with 3 page segmentation modes on each, picking the best result by confidence score. Much more accurate than basic OCR for photos, scans, and documents with uneven lighting. Supports region extraction (header/body/footer) for structured documents like invoices.";
+      description = "Advanced OCR for images using multi-variant preprocessing and multi-PSM Tesseract pipeline. Generates 8 image preprocessing variants (2 adaptive windows, OTSU, 2 fixed thresholds, Laplacian sharpen, unsharp mask sharpen, denoise) and runs Tesseract with 3 PSM modes on each (up to 24 passes), picking the best by combined confidence + line-count score. Much more accurate than basic OCR for photos, scans, invoices, and documents with uneven lighting. Supports region extraction (header/body/footer), batch directory processing, and multi-format output (TXT + CSV + PDF).";
       parameters = {
         type: "object",
         properties: {
           image: {
             type: "string",
-            description: "Path to the image file (JPEG, PNG, TIFF, BMP, WebP)"
+            description: "Path to image file or directory (for batch mode). Supports JPEG, PNG, TIFF, BMP, WebP."
           },
           language: {
             type: "string",
@@ -7743,6 +7743,14 @@ var init_ocr_image_advanced = __esm({
             type: "number",
             description: "Use a single PSM mode instead of testing all 3. Options: 4 (single block), 6 (default), 11 (sparse)"
           },
+          output_dir: {
+            type: "string",
+            description: "Write TXT + CSV + PDF outputs to this directory (in addition to returning text)"
+          },
+          batch: {
+            type: "boolean",
+            description: "Process all images in the directory specified by 'image'. Writes results + summary to output_dir."
+          },
           debug: {
             type: "boolean",
             description: "Save preprocessed variants to a debug directory (default: false)"
@@ -7761,6 +7769,8 @@ var init_ocr_image_advanced = __esm({
         const region = args["region"];
         const psm = args["psm"];
         const debug = args["debug"] === true;
+        const outputDir = args["output_dir"];
+        const batch = args["batch"] === true;
         if (!rawPath) {
           return { success: false, output: "", error: "image path is required", durationMs: 0 };
         }
@@ -7768,10 +7778,18 @@ var init_ocr_image_advanced = __esm({
         if (!existsSync15(fullPath)) {
           return { success: false, output: "", error: `File not found: ${rawPath}`, durationMs: performance.now() - start };
         }
-        const stat5 = statSync8(fullPath);
-        if (stat5.size > 50 * 1024 * 1024) {
-          return { success: false, output: "", error: `Image too large: ${(stat5.size / 1024 / 1024).toFixed(0)}MB (max 50MB)`, durationMs: performance.now() - start };
+        if (!batch) {
+          const stat5 = statSync8(fullPath);
+          if (stat5.isDirectory()) {
+            return this.executeBatchOrSingle(fullPath, language, doRegions, region, psm, debug, outputDir, true, start);
+          }
+          if (stat5.size > 50 * 1024 * 1024) {
+            return { success: false, output: "", error: `Image too large: ${(stat5.size / 1024 / 1024).toFixed(0)}MB (max 50MB)`, durationMs: performance.now() - start };
+          }
         }
+        return this.executeBatchOrSingle(fullPath, language, doRegions, region, psm, debug, outputDir, batch, start);
+      }
+      executeBatchOrSingle(fullPath, language, doRegions, region, psm, debug, outputDir, batch, start) {
         const tesCheck = ensureCommand("tesseract");
         if (!tesCheck.available) {
           return {
@@ -7784,11 +7802,19 @@ var init_ocr_image_advanced = __esm({
         const python = findPython();
         const script = findOcrScript();
         if (python && script) {
-          return this.runPythonPipeline(python, script, fullPath, language, doRegions, region, psm, debug, start);
+          return this.runPythonPipeline(python, script, fullPath, language, doRegions, region, psm, debug, outputDir, batch, start);
+        }
+        if (batch) {
+          return {
+            success: false,
+            output: "",
+            error: "Batch mode requires the Python OCR pipeline (pytesseract, opencv-python-headless, Pillow, numpy). Install them in ~/.open-agents/venv.",
+            durationMs: performance.now() - start
+          };
         }
         return this.runBasicTesseract(fullPath, language, region, psm, start);
       }
-      runPythonPipeline(python, script, imagePath, language, regions, region, psm, debug, start) {
+      runPythonPipeline(python, script, imagePath, language, regions, region, psm, debug, outputDir, batch, start) {
         const cmdParts = [
           JSON.stringify(python),
           JSON.stringify(script),
@@ -7804,6 +7830,10 @@ var init_ocr_image_advanced = __esm({
           cmdParts.push("--region", region);
         if (psm)
           cmdParts.push("--psm", String(psm));
+        if (batch)
+          cmdParts.push("--batch");
+        if (outputDir)
+          cmdParts.push("--output-dir", JSON.stringify(resolve18(this.workingDir, outputDir)));
         let debugDir;
         if (debug) {
           debugDir = join18(tmpdir5(), `oa-ocr-debug-${Date.now()}`);
@@ -7826,10 +7856,34 @@ var init_ocr_image_advanced = __esm({
               durationMs: performance.now() - start
             };
           }
+          if (result.batch && result.results) {
+            const parts2 = [];
+            parts2.push(`Batch OCR: processed ${result.images_processed} images`);
+            parts2.push(`Output directory: ${result.output_dir}`);
+            parts2.push(`Summary: ${result.summary}`);
+            parts2.push("");
+            for (const [imgName, imgResult] of Object.entries(result.results)) {
+              if (imgResult.error) {
+                parts2.push(`  ${imgName}: ERROR \u2014 ${imgResult.error}`);
+              } else {
+                parts2.push(`  ${imgName}: ${imgResult.lines} lines, ${imgResult.chars} chars, ${imgResult.confidence}% confidence (${imgResult.variant})`);
+              }
+            }
+            return {
+              success: true,
+              output: parts2.join("\n"),
+              durationMs: performance.now() - start
+            };
+          }
           const parts = [];
           parts.push(`OCR extracted from ${basename7(imagePath)} (${result.image_size})`);
-          parts.push(`Best variant: ${result.variant} (confidence: ${result.confidence}%, ${result.chars} chars)`);
+          parts.push(`Best variant: ${result.variant} (confidence: ${result.confidence}%, ${result.chars} chars, ${result.lines} lines, score: ${result.score})`);
           parts.push(`Variants tested: ${result.variants_tested}`);
+          if (result.output_files) {
+            const files = result.output_files;
+            const saved = [files.txt, files.csv, files.pdf].filter(Boolean);
+            parts.push(`Output files: ${saved.join(", ")}`);
+          }
           parts.push("");
           parts.push("--- Extracted Text ---");
           parts.push(result.text);
@@ -7845,12 +7899,12 @@ var init_ocr_image_advanced = __esm({
             }
           }
           if (result.all_variants) {
-            const sorted = Object.entries(result.all_variants).filter(([_, v]) => v.chars > 0).sort((a, b) => b[1].confidence - a[1].confidence).slice(0, 5);
+            const sorted = Object.entries(result.all_variants).filter(([_, v]) => v.chars > 0).sort((a, b) => b[1].score - a[1].score).slice(0, 5);
             if (sorted.length > 1) {
               parts.push("");
               parts.push("--- Top Variants ---");
               for (const [key, v] of sorted) {
-                parts.push(`  ${key}: ${v.confidence}% confidence, ${v.chars} chars`);
+                parts.push(`  ${key}: ${v.confidence}% confidence, ${v.chars} chars, ${v.lines} lines (score: ${v.score})`);
               }
             }
           }
@@ -11608,7 +11662,9 @@ ${tail}`;
           return sum;
         }, 0);
         const estimatedTokens = totalChars / 4;
-        if (estimatedTokens < this.options.compactionThreshold) {
+        const ctxWinThreshold = this.options.contextWindowSize > 0 ? Math.floor(this.options.contextWindowSize * 0.75) : Infinity;
+        const effectiveThreshold = Math.min(this.options.compactionThreshold, ctxWinThreshold);
+        if (estimatedTokens < effectiveThreshold) {
           return messages;
         }
         const ctxWin = this.options.contextWindowSize;
@@ -20294,6 +20350,35 @@ var init_status_bar = __esm({
       setInputStateProvider(provider) {
         this.inputStateProvider = provider;
       }
+      /** Sorted list of slash command/skill completions (e.g. ["/help", "/model", ...]) */
+      _completions = [];
+      /**
+       * Set the list of available slash commands and skills for ghost-text autocomplete.
+       * Should include the leading "/" (e.g. "/help", "/model", "/ralph").
+       */
+      setCompletions(completions) {
+        this._completions = completions.slice().sort();
+      }
+      /**
+       * Find the best completion match for current input.
+       * Returns the suffix to show as ghost text, or empty string if no match.
+       * Only shows ghost when cursor is at end of input.
+       */
+      getGhostText(inputLine, cursorPos) {
+        if (!inputLine.startsWith("/") || inputLine.length < 2)
+          return "";
+        if (cursorPos !== void 0 && cursorPos < inputLine.length)
+          return "";
+        if (inputLine.includes(" "))
+          return "";
+        const lower = inputLine.toLowerCase();
+        for (const cmd of this._completions) {
+          if (cmd.toLowerCase().startsWith(lower) && cmd.length > inputLine.length) {
+            return cmd.slice(inputLine.length);
+          }
+        }
+        return "";
+      }
       /** Set recording indicator state (blinking red ●) */
       setRecording(active) {
         this._recording = active;
@@ -20625,9 +20710,11 @@ var init_status_bar = __esm({
         const inputState = this.inputStateProvider?.();
         const fullLine = inputState?.line ?? "";
         const cursorPos = inputState?.cursor ?? 0;
+        const ghost = this.getGhostText(fullLine, cursorPos);
         if (fullLine.length <= availWidth) {
+          const displayLine = ghost ? fullLine + `\x1B[2m\x1B[38;5;240m${ghost}\x1B[0m` : fullLine;
           return {
-            lines: [fullLine],
+            lines: [displayLine],
             cursorRow: 0,
             cursorCol: this.promptWidth + cursorPos + 1
           };
@@ -21454,14 +21541,58 @@ async function startInteractive(config, repoPath) {
   const idlePrompt = `${c2.bold(c2.white("\u276F "))}`;
   const activePrompt = `${c2.bold(c2.white("+ "))}`;
   const pausedPrompt = `${c2.bold(c2.yellow("| "))}`;
+  const BUILTIN_COMMANDS = [
+    "/help",
+    "/quit",
+    "/exit",
+    "/clear",
+    "/verbose",
+    "/config",
+    "/cost",
+    "/evaluate",
+    "/eval",
+    "/task-type",
+    "/stats",
+    "/metrics",
+    "/dashboard",
+    "/model",
+    "/models",
+    "/endpoint",
+    "/update",
+    "/upgrade",
+    "/voice",
+    "/stream",
+    "/dream",
+    "/listen",
+    "/bruteforce",
+    "/brute",
+    "/emojis",
+    "/colors",
+    "/tools",
+    "/skills",
+    "/pause",
+    "/stop",
+    "/resume"
+  ];
+  const discoveredSkillNames = discoverSkills(repoRoot).map((s) => `/${s.name}`);
+  const allCompletions = [.../* @__PURE__ */ new Set([...BUILTIN_COMMANDS, ...discoveredSkillNames])].sort();
+  function completer(line) {
+    if (!line.startsWith("/"))
+      return [[], line];
+    const lower = line.toLowerCase();
+    const hits = allCompletions.filter((c3) => c3.toLowerCase().startsWith(lower));
+    return [hits, line];
+  }
   const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: idlePrompt,
     terminal: true,
-    historySize: 100
+    historySize: 100,
+    completer
   });
   statusBar.setPromptText(idlePrompt, 2);
+  statusBar.setCompletions(allCompletions);
   if (statusBar.isActive) {
     rl.output = new Writable({ write: (_c, _e, cb) => cb() });
     statusBar.setInputStateProvider(() => ({

package/dist/scripts/ocr-advanced.py

@@ -2,33 +2,42 @@
 """
 ocr-advanced.py — Multi-variant, multi-PSM OCR pipeline for open-agents.
 
-Implements the full preprocessing + OCR + cross-reference pipeline:
+Implements a full preprocessing + OCR + cross-reference pipeline:
   1. Load image → grayscale → 2x upscale
-  2. Generate 5 preprocessing variants (adaptive, OTSU, fixed, sharpen, denoise)
-  3. Run Tesseract with PSM 4, 6, 11 on each variant
-  4. Pick best result by character count and confidence
-  5. Optionally extract regions and cross-reference
+  2. Generate 7 preprocessing variants (two adaptive windows, OTSU, two fixed
+     thresholds, two sharpen kernels, denoise)
+  3. Run Tesseract with PSM 4, 6, 11 on each variant (up to 21 passes)
+  4. Score results using combined heuristic (confidence * coverage + line bonus)
+  5. Optionally extract regions (header/body/footer) with cross-reference
+  6. Output as JSON, text, CSV, or write all formats to an output directory
 
 Usage:
-  python3 ocr-advanced.py <image_path> [--language eng] [--output json|text|csv]
-                                        [--regions] [--debug-dir <path>]
-                                        [--psm <mode>] [--region <x,y,w,h>]
+  python3 ocr-advanced.py <image_or_dir> [options]
+
+Single image:
+  python3 ocr-advanced.py photo.jpg --output json
+  python3 ocr-advanced.py scan.png --output-dir ./ocr_out --regions
+
+Batch directory:
+  python3 ocr-advanced.py ./images/ --output-dir ./ocr_out --batch
 
 Output (JSON to stdout):
   {
     "text": "best extracted text",
     "confidence": 85.2,
     "variant": "otsu_psm6",
-    "all_variants": { "otsu_psm6": { "text": "...", "chars": 1234, "confidence": 85 }, ... },
-    "regions": { "header": "...", "body": "...", "footer": "..." },  // if --regions
-    "debug_dir": "/path/to/debug"  // if --debug-dir
+    "lines": 42,
+    "all_variants": { ... },
+    "regions": { ... }
   }
 """
 
 import sys
 import os
 import json
+import csv
 import argparse
+from pathlib import Path
 
 def check_deps():
     """Check that required Python packages are available."""
@@ -52,8 +61,9 @@ def check_deps():
 
     if missing:
         print(json.dumps({
-            "error": f"Missing Python packages: {', '.join(missing)}. Install with: pip install {' '.join(missing)}",
-            "missing": missing
+            "error": f"Missing Python packages: {', '.join(missing)}. "
+                     f"Install with: pip install {' '.join(missing)}",
+            "missing": missing,
         }))
         sys.exit(1)
 
@@ -64,6 +74,8 @@ import numpy as np
 import pytesseract
 from PIL import Image
 
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".tiff", ".tif", ".bmp", ".webp"}
+
 
 # ---------------------------------------------------------------------------
 # Image preprocessing variants
@@ -82,47 +94,72 @@ def upscale_2x(gray):
     return cv2.resize(gray, (w * 2, h * 2), interpolation=cv2.INTER_CUBIC)
 
 
-def variant_adaptive(gray):
-    """Adaptive Gaussian threshold — handles uneven lighting."""
+def variant_adaptive_wide(gray):
+    """Adaptive Gaussian threshold — wide window (31px), handles gradual lighting."""
     return cv2.adaptiveThreshold(
         gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
         cv2.THRESH_BINARY, 31, 10
     )
 
 
+def variant_adaptive_fine(gray):
+    """Adaptive Gaussian threshold — fine window (11px), catches small text detail."""
+    return cv2.adaptiveThreshold(
+        gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY, 11, 2
+    )
+
+
 def variant_otsu(gray):
     """OTSU threshold — optimal global threshold for bimodal images."""
     _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
     return binary
 
 
-def variant_fixed(gray, threshold=140):
-    """Fixed threshold — simple cutoff for dark text on light paper."""
-    _, binary = cv2.threshold(gray, threshold, 255, cv2.THRESH_BINARY)
+def variant_fixed_140(gray):
+    """Fixed threshold 140 — standard cutoff for dark text on light paper."""
+    _, binary = cv2.threshold(gray, 140, 255, cv2.THRESH_BINARY)
+    return binary
+
+
+def variant_fixed_150(gray):
+    """Fixed threshold 150 — slightly brighter cutoff for lighter scans."""
+    _, binary = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY)
     return binary
 
 
-def variant_sharpen_otsu(gray):
-    """Sharpen + OTSU — enhances character edges before thresholding."""
+def variant_sharpen_laplacian_otsu(gray):
+    """Laplacian sharpen + OTSU — aggressive edge enhancement."""
     kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
     sharpened = cv2.filter2D(gray, -1, kernel)
     _, binary = cv2.threshold(sharpened, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
     return binary
 
 
+def variant_sharpen_unsharp_otsu(gray):
+    """Unsharp mask sharpen + OTSU — gentler enhancement, better for photos."""
+    kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
+    sharpened = cv2.filter2D(gray, -1, kernel)
+    _, binary = cv2.threshold(sharpened, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    return binary
+
+
 def variant_denoise_otsu(gray):
-    """Denoise + OTSU — removes JPEG artifacts before thresholding."""
+    """Denoise + OTSU — removes JPEG artifacts and photo noise."""
     denoised = cv2.fastNlMeansDenoising(gray, h=10, templateWindowSize=7, searchWindowSize=21)
     _, binary = cv2.threshold(denoised, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
     return binary
 
 
 ALL_VARIANTS = {
-    "adaptive": variant_adaptive,
-    "otsu": variant_otsu,
-    "fixed": variant_fixed,
-    "sharpen": variant_sharpen_otsu,
-    "denoise": variant_denoise_otsu,
+    "adaptive_wide":   variant_adaptive_wide,
+    "adaptive_fine":   variant_adaptive_fine,
+    "otsu":            variant_otsu,
+    "fixed_140":       variant_fixed_140,
+    "fixed_150":       variant_fixed_150,
+    "sharpen_lap":     variant_sharpen_laplacian_otsu,
+    "sharpen_unsharp": variant_sharpen_unsharp_otsu,
+    "denoise":         variant_denoise_otsu,
 }
 
 PSM_MODES = {
@@ -137,24 +174,42 @@ PSM_MODES = {
 # ---------------------------------------------------------------------------
 
 def run_tesseract(binary_img, language="eng", psm=6):
-    """Run Tesseract on a preprocessed binary image. Returns (text, confidence)."""
+    """Run Tesseract on a preprocessed binary image.
+    Returns (text, confidence, line_count)."""
     pil_img = Image.fromarray(binary_img)
     config = f"--psm {psm}"
 
     try:
         text = pytesseract.image_to_string(pil_img, lang=language, config=config).strip()
-    except Exception as e:
-        return "", 0.0
+    except Exception:
+        return "", 0.0, 0
+
+    line_count = len([l for l in text.split("\n") if l.strip()])
 
     # Get confidence via image_to_data
     try:
-        data = pytesseract.image_to_data(pil_img, lang=language, config=config, output_type=pytesseract.Output.DICT)
+        data = pytesseract.image_to_data(
+            pil_img, lang=language, config=config,
+            output_type=pytesseract.Output.DICT,
+        )
         confs = [int(c) for c in data["conf"] if int(c) >= 0]
         avg_conf = sum(confs) / len(confs) if confs else 0.0
     except Exception:
         avg_conf = 0.0
 
-    return text, avg_conf
+    return text, avg_conf, line_count
+
+
+def compute_score(text, confidence, line_count):
+    """Combined scoring heuristic:
+      - confidence * sqrt(char_count)  — rewards quality and coverage
+      - + line_count * 10              — bonus for structured output (more lines = better parse)
+    The agent discovered that line-count is a strong proxy for successful parsing
+    on structured documents like invoices and forms."""
+    char_count = len(text)
+    if char_count == 0:
+        return 0
+    return confidence * (char_count ** 0.5) + line_count * 10
 
 
 def extract_region(gray, y_start_pct, y_end_pct, x_start_pct=0, x_end_pct=100):
@@ -172,12 +227,77 @@ def extract_pixel_region(gray, x, y, w, h):
     return gray[y:y+h, x:x+w]
 
 
+# ---------------------------------------------------------------------------
+# Output writers
+# ---------------------------------------------------------------------------
+
+def write_txt(text, output_path):
+    """Write plain text output."""
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(text)
+
+
+def write_csv(text, output_path):
+    """Write CSV with line numbers."""
+    lines = [l for l in text.split("\n") if l.strip()]
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.writer(f)
+        writer.writerow(["Line_Number", "Extracted_Text"])
+        for i, line in enumerate(lines, 1):
+            writer.writerow([i, line])
+
+
+def write_pdf(text, output_path):
+    """Write searchable PDF using reportlab (if available)."""
+    try:
+        from reportlab.lib.pagesizes import letter
+        from reportlab.pdfgen import canvas as pdf_canvas
+        from reportlab.lib.units import inch
+    except ImportError:
+        return False
+
+    lines = [l for l in text.split("\n") if l.strip()]
+    c = pdf_canvas.Canvas(output_path, pagesize=letter)
+    width, height = letter
+    y = height - 1 * inch
+
+    for line in lines:
+        if y < 1 * inch:
+            c.showPage()
+            y = height - 1 * inch
+        c.drawString(1 * inch, y, line)
+        y -= 14
+
+    c.save()
+    return True
+
+
+def write_all_outputs(text, base_name, output_dir):
+    """Write TXT + CSV + PDF to output directory."""
+    os.makedirs(output_dir, exist_ok=True)
+
+    txt_path = os.path.join(output_dir, f"{base_name}.txt")
+    write_txt(text, txt_path)
+
+    csv_path = os.path.join(output_dir, f"{base_name}.csv")
+    write_csv(text, csv_path)
+
+    pdf_path = os.path.join(output_dir, f"{base_name}.pdf")
+    pdf_ok = write_pdf(text, pdf_path)
+
+    return {
+        "txt": txt_path,
+        "csv": csv_path,
+        "pdf": pdf_path if pdf_ok else None,
+    }
+
+
 # ---------------------------------------------------------------------------
 # Main pipeline
 # ---------------------------------------------------------------------------
 
 def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
-                 single_psm=None, pixel_region=None):
+                 single_psm=None, pixel_region=None, output_dir=None):
     """Run the full multi-variant, multi-PSM OCR pipeline."""
 
     # Load image
@@ -208,7 +328,7 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
     for vname, vfunc in ALL_VARIANTS.items():
         try:
             binary = vfunc(gray_2x)
-        except Exception as e:
+        except Exception:
             continue
 
         # Save debug images
@@ -218,16 +338,18 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
 
         for psm in psm_modes:
             key = f"{vname}_psm{psm}"
-            text, confidence = run_tesseract(binary, language, psm)
+            text, confidence, line_count = run_tesseract(binary, language, psm)
             char_count = len(text)
+            score = compute_score(text, confidence, line_count)
+
             all_results[key] = {
                 "text": text,
                 "chars": char_count,
+                "lines": line_count,
                 "confidence": round(confidence, 1),
+                "score": round(score, 1),
             }
 
-            # Score: confidence * sqrt(char_count) — rewards both quality and coverage
-            score = confidence * (char_count ** 0.5) if char_count > 0 else 0
             if score > best_score:
                 best_score = score
                 best_key = key
@@ -235,11 +357,14 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
     if not best_key:
         return {"error": "All OCR variants failed to produce output"}
 
+    best = all_results[best_key]
     result = {
-        "text": all_results[best_key]["text"],
-        "confidence": all_results[best_key]["confidence"],
+        "text": best["text"],
+        "confidence": best["confidence"],
         "variant": best_key,
-        "chars": all_results[best_key]["chars"],
+        "chars": best["chars"],
+        "lines": best["lines"],
+        "score": best["score"],
         "image_size": f"{w_orig}x{h_orig}",
         "variants_tested": len(all_results),
         "all_variants": all_results,
@@ -260,11 +385,13 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
             if debug_dir:
                 cv2.imwrite(os.path.join(debug_dir, f"region_{rname}.png"), region_gray)
 
-            # Use best 2 variants on each region
+            # Test all variants on each region for best accuracy
             region_best = ""
             region_best_score = -1
 
-            for vname in ["otsu", "denoise"]:
+            for vname in ["otsu", "denoise", "adaptive_fine", "sharpen_unsharp"]:
+                if vname not in ALL_VARIANTS:
+                    continue
                 try:
                     binary = ALL_VARIANTS[vname](region_gray)
                 except Exception:
@@ -273,8 +400,8 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
                 if debug_dir:
                     cv2.imwrite(os.path.join(debug_dir, f"region_{rname}_{vname}.png"), binary)
 
-                text, conf = run_tesseract(binary, language, 6)
-                score = conf * (len(text) ** 0.5) if text else 0
+                text, conf, lc = run_tesseract(binary, language, 6)
+                score = compute_score(text, conf, lc)
                 if score > region_best_score:
                     region_best_score = score
                     region_best = text
@@ -286,21 +413,127 @@ def run_pipeline(image_path, language="eng", do_regions=False, debug_dir=None,
     if debug_dir:
         result["debug_dir"] = debug_dir
 
+    # Write output files if output_dir specified
+    if output_dir:
+        base_name = Path(image_path).stem
+        files = write_all_outputs(best["text"], base_name, output_dir)
+        result["output_files"] = files
+
     return result
 
 
+def run_batch(images_dir, language="eng", do_regions=False, debug_dir=None,
+              output_dir=None):
+    """Process all images in a directory."""
+    images_dir = os.path.abspath(images_dir)
+    if not os.path.isdir(images_dir):
+        return {"error": f"Not a directory: {images_dir}"}
+
+    out_dir = output_dir or os.path.join(images_dir, "ocr_out")
+    os.makedirs(out_dir, exist_ok=True)
+
+    batch_results = {}
+    image_files = sorted(
+        f for f in os.listdir(images_dir)
+        if Path(f).suffix.lower() in IMAGE_EXTENSIONS
+    )
+
+    if not image_files:
+        return {"error": f"No image files found in {images_dir}"}
+
+    for img_file in image_files:
+        img_path = os.path.join(images_dir, img_file)
+        img_debug = os.path.join(debug_dir, Path(img_file).stem) if debug_dir else None
+        result = run_pipeline(
+            img_path,
+            language=language,
+            do_regions=do_regions,
+            debug_dir=img_debug,
+            output_dir=out_dir,
+        )
+        # Compact per-image result (omit all_variants for batch summary)
+        batch_results[img_file] = {
+            "text": result.get("text", ""),
+            "confidence": result.get("confidence", 0),
+            "variant": result.get("variant", ""),
+            "chars": result.get("chars", 0),
+            "lines": result.get("lines", 0),
+            "output_files": result.get("output_files"),
+            "error": result.get("error"),
+        }
+
+    # Write summary
+    summary_path = os.path.join(out_dir, "OCR_PROCESSING_SUMMARY.md")
+    with open(summary_path, "w", encoding="utf-8") as f:
+        f.write("# OCR Processing Summary Report\n\n")
+        f.write(f"**Source:** `{images_dir}`\n\n")
+        f.write("## Processed Documents\n\n")
+        f.write("| Document | Lines | Chars | Confidence | Variant |\n")
+        f.write("|----------|-------|-------|------------|----------|\n")
+        for img, data in batch_results.items():
+            if data.get("error"):
+                f.write(f"| {img} | ERROR | - | - | {data['error']} |\n")
+            else:
+                f.write(
+                    f"| {img} | {data['lines']} | {data['chars']} "
+                    f"| {data['confidence']}% | {data['variant']} |\n"
+                )
+
+    return {
+        "batch": True,
+        "images_processed": len(batch_results),
+        "output_dir": out_dir,
+        "summary": summary_path,
+        "results": batch_results,
+    }
+
+
 def main():
-    parser = argparse.ArgumentParser(description="Advanced multi-variant OCR pipeline")
-    parser.add_argument("image", help="Path to image file")
-    parser.add_argument("--language", "-l", default="eng", help="OCR language (default: eng)")
-    parser.add_argument("--regions", action="store_true", help="Also OCR header/body/footer regions")
-    parser.add_argument("--debug-dir", help="Save preprocessed images to this directory")
-    parser.add_argument("--psm", type=int, choices=[4, 6, 11], help="Use single PSM mode instead of all 3")
-    parser.add_argument("--region", help="Crop region before OCR: x,y,w,h in pixels")
-    parser.add_argument("--output", choices=["json", "text"], default="json", help="Output format")
+    parser = argparse.ArgumentParser(
+        description="Advanced multi-variant OCR pipeline for open-agents"
+    )
+    parser.add_argument(
+        "image",
+        help="Path to image file, or directory for --batch mode",
+    )
+    parser.add_argument("--language", "-l", default="eng",
+                        help="OCR language (default: eng)")
+    parser.add_argument("--regions", action="store_true",
+                        help="Also OCR header/body/footer regions")
+    parser.add_argument("--debug-dir",
+                        help="Save preprocessed images to this directory")
+    parser.add_argument("--psm", type=int, choices=[4, 6, 11],
+                        help="Use single PSM mode instead of all 3")
+    parser.add_argument("--region",
+                        help="Crop region before OCR: x,y,w,h in pixels")
+    parser.add_argument("--output", choices=["json", "text"], default="json",
+                        help="Stdout output format (default: json)")
+    parser.add_argument("--output-dir",
+                        help="Write TXT + CSV + PDF outputs to this directory")
+    parser.add_argument("--batch", action="store_true",
+                        help="Process all images in a directory")
 
     args = parser.parse_args()
 
+    # Batch mode
+    if args.batch or os.path.isdir(args.image):
+        result = run_batch(
+            args.image,
+            language=args.language,
+            do_regions=args.regions,
+            debug_dir=args.debug_dir,
+            output_dir=args.output_dir,
+        )
+        if args.output == "text":
+            if "error" in result:
+                print(f"ERROR: {result['error']}", file=sys.stderr)
+                sys.exit(1)
+            print(f"Processed {result['images_processed']} images → {result['output_dir']}")
+        else:
+            print(json.dumps(result, indent=2))
+        sys.exit(0)
+
+    # Single image mode
     if not os.path.isfile(args.image):
         print(json.dumps({"error": f"File not found: {args.image}"}))
         sys.exit(1)
@@ -322,6 +555,7 @@ def main():
         debug_dir=args.debug_dir,
         single_psm=args.psm,
         pixel_region=pixel_region,
+        output_dir=args.output_dir,
     )
 
     if args.output == "text":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.31.0",
+  "version": "0.31.2",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",