@echofiles/echo-pdf 0.4.3 → 0.6.0

package/dist/file-utils.d.ts

@@ -1,6 +1,3 @@
-import type { ReturnMode, StoredFileRecord } from "./types.js";
 export declare const fromBase64: (value: string) => Uint8Array;
 export declare const toBase64: (bytes: Uint8Array) => string;
 export declare const toDataUrl: (bytes: Uint8Array, mimeType: string) => string;
-export declare const normalizeReturnMode: (value: unknown) => ReturnMode;
-export declare const toInlineFilePayload: (file: StoredFileRecord, includeBase64: boolean) => Record<string, unknown>;

package/dist/file-utils.js

@@ -16,21 +16,3 @@ export const toBase64 = (bytes) => {
     return btoa(binary);
 };
 export const toDataUrl = (bytes, mimeType) => `data:${mimeType};base64,${toBase64(bytes)}`;
-export const normalizeReturnMode = (value) => {
-    if (value === "file_id" || value === "url" || value === "inline") {
-        return value;
-    }
-    return "inline";
-};
-export const toInlineFilePayload = (file, includeBase64) => ({
-    file: {
-        id: file.id,
-        filename: file.filename,
-        mimeType: file.mimeType,
-        sizeBytes: file.sizeBytes,
-        createdAt: file.createdAt,
-    },
-    dataUrl: file.mimeType.startsWith("image/") ? toDataUrl(file.bytes, file.mimeType) : undefined,
-    base64: includeBase64 ? toBase64(file.bytes) : undefined,
-    text: file.mimeType.startsWith("text/") ? new TextDecoder().decode(file.bytes) : undefined,
-});

package/dist/local/document.d.ts

@@ -0,0 +1,10 @@
+import type { LocalDocumentMetadata, LocalDocumentRequest, LocalDocumentStructure, LocalPageContent, LocalPageContentRequest, LocalPageRenderArtifact, LocalPageRenderRequest, StoredDocumentRecord } from "./types.js";
+export declare const indexDocumentInternal: (request: LocalDocumentRequest) => Promise<{
+    record: StoredDocumentRecord;
+    reused: boolean;
+}>;
+export declare const ensureRenderArtifact: (request: LocalPageRenderRequest) => Promise<LocalPageRenderArtifact>;
+export declare const get_document: (request: LocalDocumentRequest) => Promise<LocalDocumentMetadata>;
+export declare const get_document_structure: (request: LocalDocumentRequest) => Promise<LocalDocumentStructure>;
+export declare const get_page_content: (request: LocalPageContentRequest) => Promise<LocalPageContent>;
+export declare const get_page_render: (request: LocalPageRenderRequest) => Promise<LocalPageRenderArtifact>;

package/dist/local/document.js

@@ -0,0 +1,133 @@
+/// <reference path="../node/compat.d.ts" />
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { extractLocalPdfPageText, getLocalPdfPageCount, renderLocalPdfPageToPng } from "../node/pdfium-local.js";
+import { buildArtifactPaths, buildRenderArtifactPaths, createPageTitle, createPreview, ensurePageNumber, fileExists, isReusableRecord, loadStoredDocument, matchesSourceSnapshot, pageLabel, readJson, readSourceBytes, resolveConfig, resolveRenderScale, resolveWorkspaceDir, toDocumentId, toPublicArtifactPaths, writeJson, } from "./shared.js";
+export const indexDocumentInternal = async (request) => {
+    const config = resolveConfig(request.config);
+    const sourcePath = path.resolve(process.cwd(), request.pdfPath);
+    const workspaceDir = resolveWorkspaceDir(request.workspaceDir);
+    const documentId = toDocumentId(sourcePath);
+    const artifactPaths = buildArtifactPaths(workspaceDir, documentId);
+    const sourceStats = await stat(sourcePath);
+    const stored = await loadStoredDocument(artifactPaths);
+    const sourceMeta = {
+        sizeBytes: sourceStats.size,
+        mtimeMs: sourceStats.mtimeMs,
+    };
+    if (!request.forceRefresh && stored && await isReusableRecord(stored, sourceMeta, artifactPaths)) {
+        return { record: stored, reused: true };
+    }
+    await mkdir(artifactPaths.pagesDir, { recursive: true });
+    const bytes = await readSourceBytes(sourcePath);
+    const pageCount = await getLocalPdfPageCount(config, bytes);
+    const pageNodes = [];
+    for (let pageNumber = 1; pageNumber <= pageCount; pageNumber += 1) {
+        const text = await extractLocalPdfPageText(config, bytes, pageNumber - 1);
+        const preview = createPreview(text);
+        const title = createPageTitle(pageNumber, text);
+        const artifactPath = path.join(artifactPaths.pagesDir, `${pageLabel(pageNumber)}.json`);
+        const pageArtifact = {
+            documentId,
+            pageNumber,
+            title,
+            preview,
+            text,
+            chars: text.length,
+            artifactPath,
+        };
+        await writeJson(artifactPath, pageArtifact);
+        pageNodes.push({
+            id: `page-${pageNumber}`,
+            type: "page",
+            title,
+            pageNumber,
+            preview,
+            artifactPath,
+        });
+    }
+    const structure = {
+        documentId,
+        generatedAt: new Date().toISOString(),
+        root: {
+            id: documentId,
+            type: "document",
+            title: path.basename(sourcePath),
+            children: pageNodes,
+        },
+    };
+    await writeJson(artifactPaths.structureJsonPath, structure);
+    const documentRecord = {
+        documentId,
+        sourcePath,
+        filename: path.basename(sourcePath),
+        sizeBytes: sourceMeta.sizeBytes,
+        mtimeMs: sourceMeta.mtimeMs,
+        pageCount,
+        indexedAt: structure.generatedAt,
+        artifactPaths,
+    };
+    await writeJson(artifactPaths.documentJsonPath, {
+        ...documentRecord,
+        artifactPaths: toPublicArtifactPaths(documentRecord.artifactPaths),
+    });
+    return { record: documentRecord, reused: false };
+};
+const toMetadata = (record, cacheStatus) => ({
+    ...record,
+    artifactPaths: toPublicArtifactPaths(record.artifactPaths),
+    cacheStatus,
+});
+export const ensureRenderArtifact = async (request) => {
+    const config = resolveConfig(request.config);
+    const { record } = await indexDocumentInternal(request);
+    ensurePageNumber(record.pageCount, request.pageNumber);
+    const renderScale = resolveRenderScale(config, request.renderScale);
+    const renderPaths = buildRenderArtifactPaths(record.artifactPaths, request.pageNumber, renderScale);
+    if (!request.forceRefresh && await fileExists(renderPaths.artifactPath) && await fileExists(renderPaths.imagePath)) {
+        const cached = await readJson(renderPaths.artifactPath);
+        if (matchesSourceSnapshot(cached, record)) {
+            return {
+                ...cached,
+                cacheStatus: "reused",
+            };
+        }
+    }
+    const bytes = await readSourceBytes(record.sourcePath);
+    const rendered = await renderLocalPdfPageToPng(config, bytes, request.pageNumber - 1, renderScale);
+    await mkdir(path.dirname(renderPaths.imagePath), { recursive: true });
+    await writeFile(renderPaths.imagePath, rendered.png);
+    const artifact = {
+        documentId: record.documentId,
+        pageNumber: request.pageNumber,
+        renderScale,
+        sourceSizeBytes: record.sizeBytes,
+        sourceMtimeMs: record.mtimeMs,
+        width: rendered.width,
+        height: rendered.height,
+        mimeType: "image/png",
+        imagePath: renderPaths.imagePath,
+        artifactPath: renderPaths.artifactPath,
+        generatedAt: new Date().toISOString(),
+    };
+    await writeJson(renderPaths.artifactPath, artifact);
+    return {
+        ...artifact,
+        cacheStatus: "fresh",
+    };
+};
+export const get_document = async (request) => {
+    const { record, reused } = await indexDocumentInternal(request);
+    return toMetadata(record, reused ? "reused" : "fresh");
+};
+export const get_document_structure = async (request) => {
+    const { record } = await indexDocumentInternal(request);
+    return readJson(record.artifactPaths.structureJsonPath);
+};
+export const get_page_content = async (request) => {
+    const { record } = await indexDocumentInternal(request);
+    ensurePageNumber(record.pageCount, request.pageNumber);
+    const pagePath = path.join(record.artifactPaths.pagesDir, `${pageLabel(request.pageNumber)}.json`);
+    return readJson(pagePath);
+};
+export const get_page_render = async (request) => ensureRenderArtifact(request);

package/dist/local/index.d.ts

@@ -1,135 +1,3 @@
-import type { EchoPdfConfig } from "../pdf-types.js";
-import type { Env } from "../types.js";
-export interface LocalDocumentArtifactPaths {
-    readonly workspaceDir: string;
-    readonly documentDir: string;
-    readonly documentJsonPath: string;
-    readonly structureJsonPath: string;
-    readonly semanticStructureJsonPath: string;
-    readonly pagesDir: string;
-    readonly rendersDir: string;
-    readonly ocrDir: string;
-}
-export interface LocalDocumentMetadata {
-    readonly documentId: string;
-    readonly sourcePath: string;
-    readonly filename: string;
-    readonly sizeBytes: number;
-    readonly mtimeMs: number;
-    readonly pageCount: number;
-    readonly indexedAt: string;
-    readonly cacheStatus: "fresh" | "reused";
-    readonly artifactPaths: LocalDocumentArtifactPaths;
-}
-export interface LocalDocumentStructureNode {
-    readonly id: string;
-    readonly type: "document" | "page";
-    readonly title: string;
-    readonly pageNumber?: number;
-    readonly preview?: string;
-    readonly artifactPath?: string;
-    readonly children?: ReadonlyArray<LocalDocumentStructureNode>;
-}
-export interface LocalDocumentStructure {
-    readonly documentId: string;
-    readonly generatedAt: string;
-    readonly root: LocalDocumentStructureNode;
-}
-export interface LocalSemanticStructureNode {
-    readonly id: string;
-    readonly type: "document" | "section";
-    readonly title: string;
-    readonly level?: number;
-    readonly pageNumber?: number;
-    readonly pageArtifactPath?: string;
-    readonly excerpt?: string;
-    readonly children?: ReadonlyArray<LocalSemanticStructureNode>;
-}
-export interface LocalSemanticDocumentStructure {
-    readonly documentId: string;
-    readonly generatedAt: string;
-    readonly detector: "agent-structured-v1" | "heading-heuristic-v1";
-    readonly strategyKey: string;
-    readonly sourceSizeBytes: number;
-    readonly sourceMtimeMs: number;
-    readonly pageIndexArtifactPath: string;
-    readonly artifactPath: string;
-    readonly root: LocalSemanticStructureNode;
-    readonly cacheStatus: "fresh" | "reused";
-}
-export interface LocalPageContent {
-    readonly documentId: string;
-    readonly pageNumber: number;
-    readonly title: string;
-    readonly preview: string;
-    readonly text: string;
-    readonly chars: number;
-    readonly artifactPath: string;
-}
-export interface LocalPageRenderArtifact {
-    readonly documentId: string;
-    readonly pageNumber: number;
-    readonly renderScale: number;
-    readonly sourceSizeBytes: number;
-    readonly sourceMtimeMs: number;
-    readonly width: number;
-    readonly height: number;
-    readonly mimeType: "image/png";
-    readonly imagePath: string;
-    readonly artifactPath: string;
-    readonly generatedAt: string;
-    readonly cacheStatus: "fresh" | "reused";
-}
-export interface LocalPageOcrArtifact {
-    readonly documentId: string;
-    readonly pageNumber: number;
-    readonly renderScale: number;
-    readonly sourceSizeBytes: number;
-    readonly sourceMtimeMs: number;
-    readonly provider: string;
-    readonly model: string;
-    readonly prompt: string;
-    readonly text: string;
-    readonly chars: number;
-    readonly imagePath: string;
-    readonly renderArtifactPath: string;
-    readonly artifactPath: string;
-    readonly generatedAt: string;
-    readonly cacheStatus: "fresh" | "reused";
-}
-export interface LocalDocumentRequest {
-    readonly pdfPath: string;
-    readonly workspaceDir?: string;
-    readonly forceRefresh?: boolean;
-    readonly config?: EchoPdfConfig;
-}
-export interface LocalPageContentRequest extends LocalDocumentRequest {
-    readonly pageNumber: number;
-}
-export interface LocalSemanticDocumentRequest extends LocalDocumentRequest {
-    readonly provider?: string;
-    readonly model?: string;
-    readonly semanticExtraction?: {
-        readonly pageSelection?: "all";
-        readonly chunkMaxChars?: number;
-        readonly chunkOverlapChars?: number;
-    };
-    readonly env?: Env;
-    readonly providerApiKeys?: Record<string, string>;
-}
-export interface LocalPageRenderRequest extends LocalPageContentRequest {
-    readonly renderScale?: number;
-}
-export interface LocalPageOcrRequest extends LocalPageRenderRequest {
-    readonly provider?: string;
-    readonly model?: string;
-    readonly prompt?: string;
-    readonly env?: Env;
-    readonly providerApiKeys?: Record<string, string>;
-}
-export declare const get_document: (request: LocalDocumentRequest) => Promise<LocalDocumentMetadata>;
-export declare const get_document_structure: (request: LocalDocumentRequest) => Promise<LocalDocumentStructure>;
-export declare const get_semantic_document_structure: (request: LocalSemanticDocumentRequest) => Promise<LocalSemanticDocumentStructure>;
-export declare const get_page_content: (request: LocalPageContentRequest) => Promise<LocalPageContent>;
-export declare const get_page_render: (request: LocalPageRenderRequest) => Promise<LocalPageRenderArtifact>;
-export declare const get_page_ocr: (request: LocalPageOcrRequest) => Promise<LocalPageOcrArtifact>;
+export type { LocalDocumentArtifactPaths, LocalDocumentMetadata, LocalDocumentRequest, LocalDocumentStructure, LocalDocumentStructureNode, LocalPageContent, LocalPageContentRequest, LocalPageRenderArtifact, LocalPageRenderRequest, LocalSemanticDocumentRequest, LocalSemanticDocumentStructure, LocalSemanticStructureNode, } from "./types.js";
+export { get_document, get_document_structure, get_page_content, get_page_render } from "./document.js";
+export { get_semantic_document_structure } from "./semantic.js";