hazo_pdf 1.7.0 → 2.0.0

package/dist/server/index.js

@@ -1,40 +1,55 @@
+// src/server/index.ts
+import { HazoInternalError } from "hazo_core/errors";
+
+// src/server/extract.ts
+import {
+  generateRequestId,
+  getCorrelationId,
+  optional_import,
+  withContext
+} from "hazo_core";
+import {
+  HazoExternalError,
+  HazoNotFoundError,
+  HazoUnavailableError,
+  HazoValidationError
+} from "hazo_core/errors";
+
 // src/utils/logger.ts
+import { createLogger } from "hazo_core";
 var console_logger = {
-  info: (message, data) => {
-    if (data) {
-      console.log(`[hazo_pdf] ${message}`, data);
-    } else {
-      console.log(`[hazo_pdf] ${message}`);
-    }
-  },
-  debug: (message, data) => {
-    if (data) {
-      console.debug(`[hazo_pdf] ${message}`, data);
-    } else {
-      console.debug(`[hazo_pdf] ${message}`);
-    }
-  },
-  warn: (message, data) => {
-    if (data) {
-      console.warn(`[hazo_pdf] ${message}`, data);
-    } else {
-      console.warn(`[hazo_pdf] ${message}`);
-    }
-  },
-  error: (message, data) => {
-    if (data) {
-      console.error(`[hazo_pdf] ${message}`, data);
-    } else {
-      console.error(`[hazo_pdf] ${message}`);
-    }
-  }
+  info: (message, data) => data ? console.log(`[hazo_pdf] ${message}`, data) : console.log(`[hazo_pdf] ${message}`),
+  debug: (message, data) => data ? console.debug(`[hazo_pdf] ${message}`, data) : console.debug(`[hazo_pdf] ${message}`),
+  warn: (message, data) => data ? console.warn(`[hazo_pdf] ${message}`, data) : console.warn(`[hazo_pdf] ${message}`),
+  error: (message, data) => data ? console.error(`[hazo_pdf] ${message}`, data) : console.error(`[hazo_pdf] ${message}`)
 };
-var current_logger = console_logger;
+function build_default_logger() {
+  try {
+    return createLogger("hazo_pdf");
+  } catch {
+    return console_logger;
+  }
+}
+var current_logger = null;
 function get_logger() {
+  if (!current_logger) {
+    current_logger = build_default_logger();
+  }
   return current_logger;
 }
 
 // src/server/extract.ts
+async function require_module(pkg) {
+  const mod = await optional_import(pkg);
+  if (!mod) {
+    throw new HazoUnavailableError({
+      code: "HAZO_PDF_OPTIONAL_DEP_MISSING",
+      pkg: "hazo_pdf",
+      message: `Required optional peer "${pkg}" is not installed`
+    });
+  }
+  return mod;
+}
 var is_initialized = false;
 var hazo_files_adapter = null;
 var llm_initialized = false;
@@ -48,12 +63,14 @@ async function ensure_initialized(sqlite_path, logger = get_logger()) {
     return;
   }
   try {
-    const { initialize_llm_api, get_current_config } = await import("hazo_llm_api/server");
-    const { SqliteAdapter } = await import("hazo_connect/server");
+    const llm_mod = await require_module("hazo_llm_api/server");
+    const connect_mod = await require_module("hazo_connect/server");
+    const { initialize_llm_api, get_current_config } = llm_mod;
+    const { SqliteAdapter } = connect_mod;
     if (!llm_initialized) {
       await initialize_llm_api({ logger });
       llm_initialized = true;
-      logger.info("hazo_llm_api initialized");
+      logger.debug("extract.llm_api.initialized");
     }
     const config = get_current_config();
     const db_path = sqlite_path || config?.sqlite_path || "prompt_library.sqlite";
@@ -61,16 +78,17 @@ async function ensure_initialized(sqlite_path, logger = get_logger()) {
       type: "sqlite",
       database_path: db_path
     });
-    const { HAZO_FILES_TABLE_SCHEMA } = await import("hazo_files");
+    const files_mod = await require_module("hazo_files");
+    const { HAZO_FILES_TABLE_SCHEMA } = files_mod;
     const adapter = hazo_files_adapter;
     await adapter.rawQuery(HAZO_FILES_TABLE_SCHEMA.sqlite.ddl);
     for (const idx of HAZO_FILES_TABLE_SCHEMA.sqlite.indexes) {
       await adapter.rawQuery(idx);
     }
-    logger.debug("hazo_files table initialized", { sqlite_path: db_path });
+    logger.debug("extract.hazo_files.table_initialized", { sqlite_path: db_path });
     is_initialized = true;
   } catch (error) {
-    logger.error("Failed to initialize extraction", {
+    logger.error("extract.initialize.failed", {
       error: error instanceof Error ? error.message : String(error)
     });
     throw error;
@@ -78,21 +96,30 @@ async function ensure_initialized(sqlite_path, logger = get_logger()) {
 }
 async function load_document_as_base64(file_path, logger = get_logger()) {
   if (file_path.startsWith("http://") || file_path.startsWith("https://")) {
-    logger.debug("Loading document from URL", { url: file_path });
+    logger.debug("extract.document.load_from_url", { url: file_path });
     const response = await fetch(file_path);
     if (!response.ok) {
-      throw new Error(`Failed to fetch document: ${response.status} ${response.statusText}`);
+      throw new HazoExternalError({
+        code: "HAZO_PDF_EXTERNAL_FETCH_FAILED",
+        pkg: "hazo_pdf",
+        message: `Failed to fetch document: ${response.status} ${response.statusText}`,
+        httpStatus: 502
+      });
     }
     const buffer2 = await response.arrayBuffer();
     const base642 = Buffer.from(buffer2).toString("base64");
     const content_type = response.headers.get("content-type") || "application/pdf";
     return { base64: base642, mime_type: content_type };
   }
-  logger.debug("Loading document from filesystem", { path: file_path });
+  logger.debug("extract.document.load_from_fs", { path: file_path });
   const fs = await import("fs");
   const path = await import("path");
   if (!fs.existsSync(file_path)) {
-    throw new Error(`File not found: ${file_path}`);
+    throw new HazoNotFoundError({
+      code: "HAZO_PDF_FILE_NOT_FOUND",
+      pkg: "hazo_pdf",
+      message: `File not found: ${file_path}`
+    });
   }
   const buffer = fs.readFileSync(file_path);
   const base64 = buffer.toString("base64");
@@ -109,10 +136,16 @@ async function load_document_as_base64(file_path, logger = get_logger()) {
   return { base64, mime_type };
 }
 async function load_document_by_file_id(file_id, _storage_type, file_manager, logger = get_logger()) {
-  const { HAZO_FILES_TABLE_SCHEMA } = await import("hazo_files");
-  const { createCrudService } = await import("hazo_connect/server");
+  const files_mod = await require_module("hazo_files");
+  const connect_mod = await require_module("hazo_connect/server");
+  const { HAZO_FILES_TABLE_SCHEMA } = files_mod;
+  const { createCrudService } = connect_mod;
   if (!hazo_files_adapter) {
-    throw new Error("hazo_files adapter not initialized");
+    throw new HazoUnavailableError({
+      code: "HAZO_PDF_ADAPTER_UNINITIALIZED",
+      pkg: "hazo_pdf",
+      message: "hazo_files adapter not initialized \u2014 call ensure_initialized() first"
+    });
   }
   const crudService = createCrudService(
     hazo_files_adapter,
@@ -122,23 +155,40 @@ async function load_document_by_file_id(file_id, _storage_type, file_manager, lo
     where: { id: file_id }
   });
   if (!files || files.length === 0) {
-    throw new Error(`File record not found: ${file_id}`);
+    throw new HazoNotFoundError({
+      code: "HAZO_PDF_FILE_RECORD_NOT_FOUND",
+      pkg: "hazo_pdf",
+      message: `File record not found: ${file_id}`
+    });
   }
   const file_record = files[0];
   const file_path = file_record.file_path;
   const mime_type = file_record.file_type || "application/pdf";
-  logger.debug("Found file record", { file_id, file_path, storage_type: file_record.storage_type });
+  logger.debug("extract.file_record.found", { file_id, file_path, storage_type: file_record.storage_type });
   if (file_record.storage_type === "google_drive") {
     if (!file_manager) {
-      throw new Error("file_manager is required for Google Drive files");
+      throw new HazoValidationError({
+        code: "HAZO_PDF_FILE_MANAGER_REQUIRED",
+        pkg: "hazo_pdf",
+        message: "file_manager is required for Google Drive files"
+      });
     }
     if (!file_manager.isInitialized()) {
-      throw new Error("file_manager is not initialized");
+      throw new HazoUnavailableError({
+        code: "HAZO_PDF_FILE_MANAGER_UNINITIALIZED",
+        pkg: "hazo_pdf",
+        message: "file_manager is not initialized"
+      });
     }
-    logger.debug("Downloading from Google Drive", { file_path });
+    logger.debug("extract.google_drive.download", { file_path });
     const result = await file_manager.downloadFile(file_path);
     if (!result.success || !result.data) {
-      throw new Error(result.error || "Failed to download file from Google Drive");
+      throw new HazoExternalError({
+        code: "HAZO_PDF_EXTERNAL_DOWNLOAD_FAILED",
+        pkg: "hazo_pdf",
+        message: result.error || "Failed to download file from Google Drive",
+        httpStatus: 502
+      });
     }
     const buffer = Buffer.from(result.data);
     const base64 = buffer.toString("base64");
@@ -150,6 +200,10 @@ async function load_document_by_file_id(file_id, _storage_type, file_manager, lo
   };
 }
 async function extract_document_data(source, options) {
+  const correlationId = getCorrelationId() ?? generateRequestId();
+  return withContext({ correlationId }, () => _extract_document_data(source, options));
+}
+async function _extract_document_data(source, options) {
   const logger = options.logger || get_logger();
   const storage_type = options.storage_type || "local";
   const save_to_hazo_files = options.save_to_hazo_files !== false;
@@ -192,12 +246,13 @@ async function extract_document_data(source, options) {
       size_kb: doc_size_kb,
       prompt: `${options.prompt_area}/${options.prompt_key}`
     });
+    const llm_mod = await require_module("hazo_llm_api/server");
     const {
       hazo_llm_dynamic_data_extract,
       get_database,
       get_prompt_by_area_and_key,
       default_logger
-    } = await import("hazo_llm_api/server");
+    } = llm_mod;
     const db = get_database();
     if (!db) {
       return {
@@ -249,8 +304,10 @@ async function extract_document_data(source, options) {
     const storage_file_path = options.original_file_path || resolved_file_path;
     if (save_to_hazo_files && hazo_files_adapter) {
       try {
-        const { createFileMetadataService, HAZO_FILES_TABLE_SCHEMA } = await import("hazo_files");
-        const { createCrudService } = await import("hazo_connect/server");
+        const files_mod = await require_module("hazo_files");
+        const connect_mod = await require_module("hazo_connect/server");
+        const { createFileMetadataService, HAZO_FILES_TABLE_SCHEMA } = files_mod;
+        const { createCrudService } = connect_mod;
         const crudService = createCrudService(
           hazo_files_adapter,
           HAZO_FILES_TABLE_SCHEMA.tableName
@@ -326,7 +383,34 @@ async function extract_document_data(source, options) {
 }
 
 // src/server/snippet.ts
+import {
+  generateRequestId as generateRequestId2,
+  getCorrelationId as getCorrelationId2,
+  optional_import as optional_import2,
+  withContext as withContext2
+} from "hazo_core";
+import {
+  HazoExternalError as HazoExternalError2,
+  HazoNotFoundError as HazoNotFoundError2,
+  HazoUnavailableError as HazoUnavailableError2,
+  HazoValidationError as HazoValidationError2
+} from "hazo_core/errors";
+async function require_module2(pkg) {
+  const mod = await optional_import2(pkg);
+  if (!mod) {
+    throw new HazoUnavailableError2({
+      code: "HAZO_PDF_OPTIONAL_DEP_MISSING",
+      pkg: "hazo_pdf",
+      message: `Required optional peer "${pkg}" is not installed`
+    });
+  }
+  return mod;
+}
 async function extract_text_snippet(source, options) {
+  const correlationId = getCorrelationId2() ?? generateRequestId2();
+  return withContext2({ correlationId }, () => _extract_text_snippet(source, options));
+}
+async function _extract_text_snippet(source, options) {
   const {
     search_text,
     page_index = 0,
@@ -356,7 +440,7 @@ async function extract_text_snippet(source, options) {
       standardFontDataUrl: standard_font_data_url,
       verbosity: 0
     }).promise;
-    const { find_all_text_in_pdf } = await import("./text_search-2OZOVUIP.js");
+    const { find_all_text_in_pdf } = await import("./text_search-PVDG5Y6I.js");
     const total_pages = pdf.numPages;
     const snippets = [];
     if (match_mode === "first") {
@@ -564,20 +648,33 @@ async function load_pdf_bytes(source) {
     return source.pdf_bytes;
   }
   if (!source.file_path) {
-    throw new Error("Either file_path or pdf_bytes is required");
+    throw new HazoValidationError2({
+      code: "HAZO_PDF_VALIDATION_ERROR",
+      pkg: "hazo_pdf",
+      message: "Either file_path or pdf_bytes is required"
+    });
   }
   const file_path = source.file_path;
   if (file_path.startsWith("http://") || file_path.startsWith("https://")) {
     const response = await fetch(file_path);
     if (!response.ok) {
-      throw new Error(`Failed to fetch PDF: ${response.status} ${response.statusText}`);
+      throw new HazoExternalError2({
+        code: "HAZO_PDF_EXTERNAL_FETCH_FAILED",
+        pkg: "hazo_pdf",
+        message: `Failed to fetch PDF: ${response.status} ${response.statusText}`,
+        httpStatus: 502
+      });
     }
     const buffer2 = await response.arrayBuffer();
     return new Uint8Array(buffer2);
   }
   const fs = await import("fs");
   if (!fs.existsSync(file_path)) {
-    throw new Error(`File not found: ${file_path}`);
+    throw new HazoNotFoundError2({
+      code: "HAZO_PDF_FILE_NOT_FOUND",
+      pkg: "hazo_pdf",
+      message: `File not found: ${file_path}`
+    });
   }
   const buffer = fs.readFileSync(file_path);
   return new Uint8Array(buffer);
@@ -595,7 +692,8 @@ async function find_text_with_llm(page, viewport, search_text, _render_scale) {
     }).promise;
     const image_buffer = canvas.toBuffer("image/png");
     const image_base64 = image_buffer.toString("base64");
-    const { hazo_llm_image_text } = await import("hazo_llm_api/server");
+    const llm_mod = await require_module2("hazo_llm_api/server");
+    const { hazo_llm_image_text } = llm_mod;
     const prompt = `Find the text "${search_text}" in this document image.
 If found, return ONLY a JSON object with the approximate bounding box as percentage coordinates (0-100):
 {"found": true, "x_pct": <left edge %>, "y_pct": <top edge %>, "width_pct": <width %>, "height_pct": <height %>}
@@ -642,6 +740,15 @@ Return ONLY the JSON object, nothing else.`;
 }
 
 // src/server/split.ts
+import {
+  generateRequestId as generateRequestId3,
+  getCorrelationId as getCorrelationId3,
+  withContext as withContext3
+} from "hazo_core";
+import {
+  HazoExternalError as HazoExternalError3,
+  HazoValidationError as HazoValidationError3
+} from "hazo_core/errors";
 function sanitize_label(label) {
   return label.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60);
 }
@@ -653,7 +760,12 @@ function generate_filename(label, pages) {
 }
 function to_uint8array(data) {
   if (!data) {
-    throw new Error("No data received from downloadFile");
+    throw new HazoExternalError3({
+      code: "HAZO_PDF_EXTERNAL_DOWNLOAD_EMPTY",
+      pkg: "hazo_pdf",
+      message: "No data received from downloadFile",
+      httpStatus: 502
+    });
   }
   if (data instanceof Uint8Array) {
     return data;
@@ -664,52 +776,73 @@ function to_uint8array(data) {
   if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
   }
-  throw new Error("Unsupported data type from downloadFile");
+  throw new HazoValidationError3({
+    code: "HAZO_PDF_UNSUPPORTED_TYPE",
+    pkg: "hazo_pdf",
+    message: "Unsupported data type from downloadFile"
+  });
 }
 async function split_pdf(request, file_manager) {
+  const correlationId = getCorrelationId3() ?? generateRequestId3();
+  return withContext3({ correlationId }, () => _split_pdf(request, file_manager));
+}
+async function _split_pdf(request, file_manager) {
   const logger = get_logger();
-  logger.info("Starting PDF split", {
+  logger.info("pdf.split.start", {
     source_file_id: request.source_file_id,
     split_count: request.splits.length,
     output_folder: request.output_folder
   });
   const { PDFDocument } = await import("pdf-lib");
-  logger.debug("Downloading source PDF", { file_id: request.source_file_id });
+  logger.debug("split.source.download", { file_id: request.source_file_id });
   const download_result = await file_manager.downloadFile(request.source_file_id);
   if (!download_result.success || !download_result.data) {
-    throw new Error(
-      download_result.error || `Failed to download source file: ${request.source_file_id}`
-    );
+    throw new HazoExternalError3({
+      code: "HAZO_PDF_EXTERNAL_DOWNLOAD_FAILED",
+      pkg: "hazo_pdf",
+      message: download_result.error || `Failed to download source file: ${request.source_file_id}`,
+      httpStatus: 502
+    });
   }
   const source_bytes = to_uint8array(download_result.data);
-  logger.debug("Loading source PDF", { byte_size: source_bytes.byteLength });
+  logger.debug("split.source.load", { byte_size: source_bytes.byteLength });
   const source_pdf = await PDFDocument.load(source_bytes);
   const total_pages = source_pdf.getPageCount();
-  logger.info("Source PDF loaded", { total_pages });
+  logger.debug("split.source.loaded", { total_pages });
   const page_counts = new Array(total_pages + 1).fill(0);
   for (const split of request.splits) {
     for (const page of split.pages) {
       if (page < 1 || page > total_pages) {
-        throw new Error(
-          `Split "${split.label}" references page ${page} which is out of range (1-${total_pages})`
-        );
+        throw new HazoValidationError3({
+          code: "HAZO_PDF_SPLIT_PAGE_OUT_OF_RANGE",
+          pkg: "hazo_pdf",
+          message: `Split "${split.label}" references page ${page} which is out of range (1-${total_pages})`
+        });
       }
       page_counts[page]++;
     }
   }
   for (let p = 1; p <= total_pages; p++) {
     if (page_counts[p] === 0) {
-      throw new Error(`Page ${p} is not included in any split`);
+      throw new HazoValidationError3({
+        code: "HAZO_PDF_SPLIT_PAGE_MISSING",
+        pkg: "hazo_pdf",
+        message: `Page ${p} is not included in any split`
+      });
     }
     if (page_counts[p] > 1) {
-      throw new Error(`Page ${p} appears in multiple splits`);
+      throw new HazoValidationError3({
+        code: "HAZO_PDF_SPLIT_PAGE_DUPLICATED",
+        pkg: "hazo_pdf",
+        message: `Page ${p} appears in multiple splits`
+      });
     }
   }
-  logger.debug("Split validation passed", { total_pages, split_count: request.splits.length });
+  logger.debug("split.validation.passed", { total_pages, split_count: request.splits.length });
   const outputs = [];
   const output_folder = request.output_folder || "";
   for (const instruction of request.splits) {
-    logger.debug("Processing split", {
+    logger.debug("split.instruction.start", {
       split_id: instruction.split_id,
       label: instruction.label,
       pages: instruction.pages
@@ -724,14 +857,17 @@ async function split_pdf(request, file_manager) {
     const byte_size = pdf_bytes.byteLength;
     const file_name = instruction.output_filename || generate_filename(instruction.label, instruction.pages);
     const file_path = output_folder ? `${output_folder.replace(/\/$/, "")}/${file_name}` : file_name;
-    logger.debug("Uploading split PDF", { file_path, byte_size });
+    logger.debug("split.upload", { file_path, byte_size });
     const upload_result = await file_manager.uploadFile(new Uint8Array(pdf_bytes), file_path, {
       overwrite: true
     });
     if (!upload_result.success) {
-      throw new Error(
-        upload_result.error || `Failed to upload split "${instruction.label}" to ${file_path}`
-      );
+      throw new HazoExternalError3({
+        code: "HAZO_PDF_EXTERNAL_UPLOAD_FAILED",
+        pkg: "hazo_pdf",
+        message: upload_result.error || `Failed to upload split "${instruction.label}" to ${file_path}`,
+        httpStatus: 502
+      });
     }
     outputs.push({
       split_id: instruction.split_id,
@@ -743,7 +879,7 @@ async function split_pdf(request, file_manager) {
       page_count: instruction.pages.length,
       byte_size
     });
-    logger.info("Split uploaded", {
+    logger.debug("split.upload.done", {
       split_id: instruction.split_id,
       label: instruction.label,
       file_path,
@@ -751,7 +887,7 @@ async function split_pdf(request, file_manager) {
       byte_size
     });
   }
-  logger.info("PDF split complete", {
+  logger.info("pdf.split.complete", {
     source_file_id: request.source_file_id,
     output_count: outputs.length
   });
@@ -763,9 +899,11 @@ async function split_pdf(request, file_manager) {
 
 // src/server/index.ts
 if (typeof window !== "undefined") {
-  throw new Error(
-    "hazo_pdf/server cannot be imported in the browser. This module is server-only and requires Node.js runtime."
-  );
+  throw new HazoInternalError({
+    code: "HAZO_PDF_SERVER_ONLY",
+    pkg: "hazo_pdf",
+    message: "hazo_pdf/server cannot be imported in the browser. This module is server-only and requires Node.js runtime."
+  });
 }
 export {
   extract_document_data,