@arcships/light-ocr-runtime 0.1.0 → 0.1.3

package/package.json

@@ -28,12 +28,12 @@
   "module": "./src/index.mjs",
   "name": "@arcships/light-ocr-runtime",
   "optionalDependencies": {
-    "@arcships/light-ocr-darwin-arm64": "0.4.0",
-    "@arcships/light-ocr-darwin-x64": "0.4.0",
-    "@arcships/light-ocr-linux-arm64-gnu": "0.4.0",
-    "@arcships/light-ocr-linux-x64-gnu": "0.4.0",
-    "@arcships/light-ocr-win32-arm64": "0.4.0",
-    "@arcships/light-ocr-win32-x64": "0.4.0"
+    "@arcships/light-ocr-darwin-arm64": "0.5.3",
+    "@arcships/light-ocr-darwin-x64": "0.5.3",
+    "@arcships/light-ocr-linux-arm64-gnu": "0.5.3",
+    "@arcships/light-ocr-linux-x64-gnu": "0.5.3",
+    "@arcships/light-ocr-win32-arm64": "0.5.3",
+    "@arcships/light-ocr-win32-x64": "0.5.3"
   },
   "publishConfig": {
     "access": "public",
@@ -45,5 +45,5 @@
   },
   "type": "commonjs",
   "types": "./src/index.d.ts",
-  "version": "0.1.0"
+  "version": "0.1.3"
 }

package/src/cli.cjs

@@ -12,12 +12,14 @@
 // stdout = machine results only; stderr = logs/warnings/usage (cli-design.md §5).
 // Exit codes are a stable surface (cli-design.md §10, D106).
 
+const crypto = require('node:crypto');
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
 
 const { parseExifOrientation } = require('./exif.cjs');
 
-const SUBCOMMANDS = new Set(['recognize', 'detect', 'info']);
+const SUBCOMMANDS = new Set(['recognize', 'detect', 'info', 'document', 'doctor']);
 const EXIT = {
   success: 0,
   usage: 64,
@@ -88,7 +90,7 @@ function parseArgs(argv) {
       const name = arg.slice(2);
       const knownBooleans = new Set([
         'stdin', 'no-exif', 'no-color', 'quiet', 'help',
-        'model-info', 'version', 'crop',
+        'model-info', 'version', 'crop', 'json',
       ]);
       if (knownBooleans.has(name)) {
         flags[name] = true;
@@ -470,6 +472,188 @@ function writeResult(envelope, format, stdout, subcommand) {
   stdout.write(JSON.stringify(envelope, null, 2) + '\n');
 }
 
+// --- doctor subcommand (system diagnostics, no user content) ---
+function safeRequireResolve(spec) {
+  try { return require.resolve(spec); } catch { return undefined; }
+}
+
+async function loadGpuInfo(config) {
+  try {
+    const engine = await config.createEngine();
+    try {
+      return { ...engine.info };
+    } finally {
+      await engine.close();
+    }
+  } catch {
+    return undefined;
+  }
+}
+
+async function runDoctor(rest, flags, stdout, stderr, config) {
+  if (rest.length > 0) {
+    throw { code: EXIT.invalid_argument, message: `doctor does not accept arguments: ${rest[0]}` };
+  }
+  for (const blocked of ['stdin', 'type', 'format', 'region', 'no-exif', 'provider', 'crop',
+    'model-info', 'version']) {
+    if (flags[blocked] !== undefined) {
+      throw { code: EXIT.invalid_argument, message: `doctor does not accept --${blocked}` };
+    }
+  }
+
+  const info = {
+    schemaVersion: 1,
+    tool: {
+      command: config.commandName,
+      version: config.packageVersion,
+      coreVersion: config.coreVersion,
+    },
+    model: { ...config.modelProfile },
+    system: {
+      node: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      release: os.release(),
+      hostHash: crypto.createHash('sha256').update(os.hostname()).digest('hex').slice(0, 16),
+      cpuModel: os.cpus()[0]?.model || 'unknown',
+      cpuCores: os.cpus().length,
+      totalMemoryGB: +(os.totalmem() / (1024 ** 3)).toFixed(1),
+    },
+    native: { status: 'unavailable' },
+    modules: {
+      runtime: safeRequireResolve('@arcships/light-ocr-runtime') !== undefined,
+      model: safeRequireResolve(config.modelProfile.model ? `@arcships/light-ocr-model-${config.modelProfile.model}` : '@arcships/light-ocr-model-ppocrv6-small') !== undefined,
+      pdfium: false,
+    },
+  };
+
+  // Native runtime details
+  if (typeof config.loadNative === 'function') {
+    try {
+      const native = config.loadNative();
+      info.native = {
+        status: 'ok',
+        availableProviders: native.runtimePolicy.availableProviders,
+        runtimeFlavor: native.runtimePolicy.runtimeFlavor,
+        runtimeVersion: native.runtimePolicy.runtimeVersion,
+        platformId: native.runtimePolicy.platformId,
+        qualificationOnly: native.runtimePolicy.qualificationOnly,
+        released: native.runtimePolicy.released,
+        descriptorPath: native.descriptorPath,
+      };
+    } catch (error) {
+      info.native = { status: 'error', message: error.message || String(error) };
+    }
+  }
+
+  // GPU/engine info (requires engine creation — slow, only when available)
+  if (flags.gpu !== true) {
+    // skip GPU probe unless explicitly requested
+  } else {
+    const gpuInfo = await loadGpuInfo(config);
+    if (gpuInfo) info.gpu = gpuInfo;
+  }
+
+  // PDF support
+  if (typeof config.hasPdfSupport === 'function') {
+    info.modules.pdfium = config.hasPdfSupport();
+  }
+
+  stdout.write(JSON.stringify(info, null, 2) + '\n');
+}
+
+// --- document subcommand (PDF and multi-page support) ---
+function parsePageRange(rangeStr) {
+  if (!rangeStr) return undefined;
+  const match = String(rangeStr).match(/^(\d+)(?:-(\d+))?$/);
+  if (!match) {
+    throw { code: EXIT.invalid_argument, message: `--pages expects N or N-M (got ${rangeStr})` };
+  }
+  return {
+    start: parseInt(match[1]),
+    end: match[2] ? parseInt(match[2]) : parseInt(match[1])
+  };
+}
+
+async function runDocument(rest, flags, stdout, stderr, config) {
+  const format = resolveFormat(flags, 'recognize');
+  const provider = resolveProvider(flags);
+  
+  if (rest.length === 0) {
+    throw { code: EXIT.usage, message: 'expected a PDF or image file path' };
+  }
+
+  // Parse document-specific flags
+  const pageRange = parsePageRange(flags.pages);
+  const dpi = flags.dpi ? parseInt(flags.dpi) : 150;
+  const maxPages = flags['max-pages'] ? parseInt(flags['max-pages']) : 100;
+  const quiet = flags.quiet === true;
+
+  // Check if recognizeDocument is available
+  if (typeof config.recognizeDocument !== 'function') {
+    throw { code: EXIT.unsupported_capability, message: 'PDF/document support not available' };
+  }
+
+  const source = rest.length === 1 ? rest[0] : rest;
+  
+  const pages = [];
+  let pageCount = 0;
+
+  try {
+    for await (const page of config.recognizeDocument(source, {
+      pageRange,
+      dpi,
+      maxPages,
+      engine: undefined // Will use default
+    })) {
+      pages.push(page);
+      pageCount++;
+      
+      // Output JSONL as we go
+      if (format === 'jsonl') {
+        stdout.write(JSON.stringify({
+          schemaVersion: SUPPORTED_SCHEMA_VERSION,
+          source: { kind: page.source.kind },
+          pageIndex: page.index,
+          status: 'ok',
+          page
+        }) + '\n');
+      }
+      
+      // Progress output
+      if (!quiet) {
+        stderr.write(`\rProcessed page ${pageCount}...`);
+      }
+    }
+    
+    if (!quiet && pageCount > 0) {
+      stderr.write('\n');
+    }
+
+    // Output final result for non-JSONL formats
+    if (format === 'json') {
+      const result = {
+        schemaVersion: SUPPORTED_SCHEMA_VERSION,
+        source: {
+          kind: Array.isArray(source) ? 'page-images' : 
+                (typeof source === 'string' && source.endsWith('.pdf') ? 'pdf' : 'image'),
+          mediaType: typeof source === 'string' && source.endsWith('.pdf') ? 'application/pdf' : 'image/*',
+          identity: { files: Array.isArray(source) ? source : [source] },
+          pageCount: pages.length
+        },
+        pages
+      };
+      stdout.write(JSON.stringify(result, null, 2) + '\n');
+    } else if (format === 'text') {
+      for (const page of pages) {
+        stdout.write(page.lines.map(l => l.text).join('\n') + '\n');
+      }
+    }
+  } catch (e) {
+    throw e;
+  }
+}
+
 // --- help ---
 function printHelp(stdout, verbose, config) {
   const command = config.commandName;
@@ -477,7 +661,9 @@ function printHelp(stdout, verbose, config) {
   stdout.write('Usage:\n');
   stdout.write(`  ${command} recognize <path|--stdin> [flags]   Recognize text in an image (default)\n`);
   stdout.write(`  ${command} detect     <path|--stdin> [flags]   Detect text regions only\n`);
+  stdout.write(`  ${command} document   <path|paths...> [flags]  Process PDF or multiple images\n`);
   stdout.write(`  ${command} info       --model-info | --version  Show engine/version info\n`);
+  stdout.write(`  ${command} doctor     [--json]                 System diagnostics\n`);
   stdout.write(`  ${command} <image> [flags]                     Implicit recognize\n\n`);
   stdout.write(`Run \`${command} <subcommand> --help\` for flags of that subcommand.\n`);
 }
@@ -518,6 +704,27 @@ function printSubcommandHelp(stdout, subcommand, config) {
     stdout.write('  --version      Print npm/core/model version triple\n');
     return;
   }
+  if (subcommand === 'document') {
+    stdout.write(`${command} document — process PDF or multiple images\n\n`);
+    stdout.write(`Usage:\n  ${command} document <file.pdf> [flags]\n  ${command} document <img1.png> <img2.jpg> [flags]\n\n`);
+    stdout.write('Flags:\n');
+    stdout.write('  --format json|jsonl|text   Output format (default: json)\n');
+    stdout.write('  --pages N-M                Page range for PDF (e.g., 1-5 or 3)\n');
+    stdout.write('  --dpi <n>                  PDF raster DPI (default: 150)\n');
+    stdout.write('  --max-pages <n>            Maximum pages to process (default: 100)\n');
+    stdout.write('  --provider auto|cpu|apple|webgpu  Execution provider (default: auto)\n');
+    stdout.write('  --quiet                    Suppress progress output\n');
+    return;
+  }
+  if (subcommand === 'doctor') {
+    stdout.write(`${command} doctor — system diagnostics for troubleshooting\n\n`);
+    stdout.write(`Usage:\n  ${command} doctor [--json]\n\n`);
+    stdout.write('Collects hardware and runtime information (no user content).\n');
+    stdout.write('Output is always JSON. Use --json for explicit intent.\n\n');
+    stdout.write('Flags:\n');
+    stdout.write('  --json   Explicit JSON output flag (default behavior)\n');
+    return;
+  }
   printHelp(stdout, false, config);
 }
 
@@ -548,6 +755,8 @@ async function main(argv, config) {
   try {
     if (subcommand === 'info') {
       await runInfo(rest, parsed.flags, stdout, stderr, config);
+    } else if (subcommand === 'doctor') {
+      await runDoctor(rest, parsed.flags, stdout, stderr, config);
     } else if (subcommand === 'recognize') {
       await runRecognize(rest, parsed.flags, stdout, stderr, config);
     } else if (subcommand === 'detect') {
@@ -563,6 +772,8 @@ async function main(argv, config) {
         };
       }
       await runDetect(rest, parsed.flags, stdout, stderr, config);
+    } else if (subcommand === 'document') {
+      await runDocument(rest, parsed.flags, stdout, stderr, config);
     } else {
       die(stderr, config.commandName, `unknown subcommand: ${subcommand}`);
       return EXIT.usage;
@@ -600,6 +811,7 @@ function createCli(config) {
     resolveSchemaVersion,
     inferMediaType,
     parseRegion,
+    runDoctor: (rest, flags, stdout, stderr) => runDoctor(rest, flags, stdout, stderr, frozenConfig),
   });
 }
 

package/src/index.cjs

@@ -174,4 +174,4 @@ async function createEngine(options) {
   }
 }
 
-module.exports = { createEngine, OcrError };
+module.exports = { createEngine, OcrError, loadNative };

package/src/metadata.cjs

@@ -1,3 +1,3 @@
 'use strict';
 
-module.exports = Object.freeze({ coreVersion: '0.4.0' });
+module.exports = Object.freeze({ coreVersion: '0.5.3' });