@revealui/ai 0.1.0

package/dist/inference/context-assembly.js

@@ -0,0 +1,81 @@
+/**
+ * Context Assembly with Smart Trimming
+ *
+ * Blends relevance (cosine similarity) and recency (createdAt) to rank chunks,
+ * then greedily assembles them up to a token budget.
+ * Auto-compresses single chunks that exceed half the budget.
+ *
+ * AnythingLLM lesson: plain cosine-only retrieval without recency weighting
+ * produces stale, misleading context in long-running knowledge bases.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Compute a 0–1 recency score: newest chunk = 1.0, oldest = 0.1.
+ * Decays linearly based on position in time-sorted array.
+ */
+function computeRecencyScores(results) {
+    if (results.length === 0)
+        return new Map();
+    if (results.length === 1) {
+        const r = results[0];
+        return r ? new Map([[r.chunk.id, 1.0]]) : new Map();
+    }
+    const sorted = [...results].sort((a, b) => b.chunk.createdAt.getTime() - a.chunk.createdAt.getTime());
+    const map = new Map();
+    const n = sorted.length;
+    sorted.forEach((r, i) => {
+        // Linearly decay from 1.0 (newest) to 0.1 (oldest)
+        const score = 1.0 - (0.9 * i) / Math.max(n - 1, 1);
+        map.set(r.chunk.id, score);
+    });
+    return map;
+}
+/**
+ * Assemble RAG context from search results.
+ *
+ * Returns a formatted string of numbered references, trimmed to maxTokens.
+ * Returns '' if results is empty.
+ */
+export function assembleContext(results, options) {
+    if (results.length === 0)
+        return '';
+    const relevanceWeight = options.relevanceWeight ?? 0.7;
+    const recencyWeight = options.recencyWeight ?? 0.3;
+    const maxTokens = options.maxTokens;
+    const recencyScores = computeRecencyScores(results);
+    // Compute blended scores
+    const scored = results.map((r) => {
+        const recency = recencyScores.get(r.chunk.id) ?? 0.5;
+        const finalScore = r.similarity * relevanceWeight + recency * recencyWeight;
+        return { result: r, finalScore };
+    });
+    // Sort descending by blended score
+    scored.sort((a, b) => b.finalScore - a.finalScore);
+    // Greedy token-budget assembly
+    const sections = [];
+    let usedTokens = 0;
+    const halfBudget = Math.floor(maxTokens / 2);
+    for (let i = 0; i < scored.length; i++) {
+        const item = scored[i];
+        if (!item)
+            continue;
+        const { result } = item;
+        const title = result.document.title ?? result.document.sourceCollection ?? 'Unknown';
+        let content = result.chunk.content;
+        // Auto-compress: if single chunk exceeds half the budget, truncate
+        const chunkTokens = estimateTokens(content);
+        if (chunkTokens > halfBudget) {
+            const maxChars = halfBudget * 4;
+            content = `${content.slice(0, maxChars)} [content truncated]`;
+        }
+        const section = `[${i + 1}] Source: ${title}\n${content}`;
+        const sectionTokens = estimateTokens(section);
+        if (usedTokens + sectionTokens > maxTokens)
+            break;
+        sections.push(section);
+        usedTokens += sectionTokens;
+    }
+    return sections.join('\n\n---\n\n');
+}

package/dist/inference/overflow-compressor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Content Overflow Auto-Compressor
+ *
+ * Called when assembled context exceeds the token budget.
+ * Uses the LLM to summarize, preserving key facts.
+ */
+import type { LLMClient } from '../llm/client.js';
+/**
+ * Compress context string if it exceeds maxTokens.
+ * Returns the original context if it fits within budget.
+ * Prepends "[summarized from N source chunks]" to compressed output.
+ */
+export declare function compressContext(context: string, options: {
+    maxTokens: number;
+    llmClient: LLMClient;
+}): Promise<string>;
+//# sourceMappingURL=overflow-compressor.d.ts.map

package/dist/inference/overflow-compressor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overflow-compressor.d.ts","sourceRoot":"","sources":["../../src/inference/overflow-compressor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAMjD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,CAAA;CAAE,GACnD,OAAO,CAAC,MAAM,CAAC,CA4BjB"}

package/dist/inference/overflow-compressor.js

@@ -0,0 +1,40 @@
+/**
+ * Content Overflow Auto-Compressor
+ *
+ * Called when assembled context exceeds the token budget.
+ * Uses the LLM to summarize, preserving key facts.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Compress context string if it exceeds maxTokens.
+ * Returns the original context if it fits within budget.
+ * Prepends "[summarized from N source chunks]" to compressed output.
+ */
+export async function compressContext(context, options) {
+    if (estimateTokens(context) <= options.maxTokens) {
+        return context;
+    }
+    // Count source chunks (numbered references like "[1] Source:")
+    const chunkCount = (context.match(/^\[\d+\] Source:/gm) ?? []).length;
+    try {
+        const response = await options.llmClient.chat([
+            {
+                role: 'system',
+                content: 'Summarize the following context, preserving key facts, names, dates, and specific details. Be concise but complete.',
+            },
+            {
+                role: 'user',
+                content: context,
+            },
+        ]);
+        const prefix = `[summarized from ${chunkCount} source chunks]\n\n`;
+        return prefix + response.content;
+    }
+    catch {
+        // On LLM failure, hard-truncate
+        const maxChars = options.maxTokens * 4;
+        return `${context.slice(0, maxChars)} [context truncated due to size]`;
+    }
+}

package/dist/inference/runRag.d.ts

@@ -0,0 +1,35 @@
+/**
+ * RAG Query — Retrieval-Augmented Generation
+ *
+ * Generates an embedding for the query, searches the rag_chunks table via
+ * pgvector cosine distance, assembles ranked context with recency weighting,
+ * and optionally compresses it if it exceeds the token budget.
+ */
+import type { Database } from '@revealui/db/client';
+import type { LLMClient } from '../llm/client.js';
+export interface RAGOptions {
+    workspaceId: string;
+    db: Database;
+    /** Maximum search results to retrieve (default 5) */
+    limit?: number;
+    /** Minimum cosine similarity threshold 0–1 (default 0.6) */
+    threshold?: number;
+    /** Custom embedding function — defaults to generateEmbedding() */
+    embeddingFn?: (text: string) => Promise<number[]>;
+    /** search mode: 'speed' (vector-only) | 'accuracy' (BM25 hybrid + optional rerank) */
+    mode?: 'speed' | 'accuracy';
+    /** LLMClient for accuracy-mode reranking and overflow compression */
+    llmClient?: LLMClient;
+    /** Maximum tokens for assembled context (default 2000) */
+    maxContextTokens?: number;
+    /** Filter to a specific CMS collection */
+    sourceCollection?: string;
+}
+/**
+ * Run RAG retrieval for a query.
+ *
+ * Returns a formatted context string ready to prepend to an LLM prompt.
+ * Returns '' if no relevant documents exist for the workspace.
+ */
+export declare function runRAG(query: string, options?: RAGOptions): Promise<string>;
+//# sourceMappingURL=runRag.d.ts.map

package/dist/inference/runRag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runRag.d.ts","sourceRoot":"","sources":["../../src/inference/runRag.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAGnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAIjD,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,EAAE,EAAE,QAAQ,CAAA;IACZ,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,kEAAkE;IAClE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAA;IACjD,sFAAsF;IACtF,IAAI,CAAC,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,qEAAqE;IACrE,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,0CAA0C;IAC1C,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;GAKG;AACH,wBAAsB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAyCjF"}

package/dist/inference/runRag.js

@@ -0,0 +1,53 @@
+/**
+ * RAG Query — Retrieval-Augmented Generation
+ *
+ * Generates an embedding for the query, searches the rag_chunks table via
+ * pgvector cosine distance, assembles ranked context with recency weighting,
+ * and optionally compresses it if it exceeds the token budget.
+ */
+import { generateEmbedding } from '../embeddings/index.js';
+import { hybridSearch } from '../ingestion/hybrid-search.js';
+import { assembleContext } from './context-assembly.js';
+import { compressContext } from './overflow-compressor.js';
+/**
+ * Run RAG retrieval for a query.
+ *
+ * Returns a formatted context string ready to prepend to an LLM prompt.
+ * Returns '' if no relevant documents exist for the workspace.
+ */
+export async function runRAG(query, options) {
+    if (!(query?.trim() && options))
+        return '';
+    const embeddingFn = options.embeddingFn ??
+        (async (text) => {
+            const emb = await generateEmbedding(text);
+            return emb.vector;
+        });
+    const maxContextTokens = options.maxContextTokens ?? 2000;
+    // Retrieve relevant chunks
+    const results = await hybridSearch(query, options.db, embeddingFn, {
+        workspaceId: options.workspaceId,
+        limit: options.limit ?? 5,
+        threshold: options.threshold ?? 0.6,
+        mode: options.mode ?? 'speed',
+        sourceCollection: options.sourceCollection,
+        llmClient: options.llmClient,
+        rerank: options.mode === 'accuracy' && options.llmClient !== undefined,
+    });
+    if (results.length === 0)
+        return '';
+    // Assemble context with recency + relevance blending
+    const context = assembleContext(results, {
+        maxTokens: maxContextTokens,
+        relevanceWeight: 0.7,
+        recencyWeight: 0.3,
+    });
+    // Auto-compress if over budget and LLMClient available
+    if (options.llmClient) {
+        return compressContext(context, {
+            maxTokens: maxContextTokens,
+            llmClient: options.llmClient,
+        });
+    }
+    return context;
+}

package/dist/ingestion/bm25.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Pure TypeScript BM25 Implementation
+ *
+ * Built on-demand from top-N vector candidates — no persistent index.
+ * k1=1.5, b=0.75 (standard values). No external deps.
+ */
+export interface BM25Document {
+    id: string;
+    text: string;
+}
+export interface BM25Result {
+    id: string;
+    score: number;
+}
+export declare class BM25 {
+    private k1;
+    private b;
+    private docs;
+    private avgDocLength;
+    private termFreqs;
+    private docFreqs;
+    constructor(options?: {
+        k1?: number;
+        b?: number;
+    });
+    index(documents: BM25Document[]): void;
+    search(query: string, topK?: number): BM25Result[];
+}
+//# sourceMappingURL=bm25.d.ts.map

package/dist/ingestion/bm25.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bm25.d.ts","sourceRoot":"","sources":["../../src/ingestion/bm25.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoFH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;CACd;AAUD,qBAAa,IAAI;IACf,OAAO,CAAC,EAAE,CAAM;IAChB,OAAO,CAAC,CAAC,CAAO;IAChB,OAAO,CAAC,IAAI,CAA8D;IAC1E,OAAO,CAAC,YAAY,CAAI;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,QAAQ,CAAiC;gBAErC,OAAO,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAKjD,KAAK,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,IAAI;IA6BtC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,SAAK,GAAG,UAAU,EAAE;CAkC/C"}

package/dist/ingestion/bm25.js

@@ -0,0 +1,161 @@
+/**
+ * Pure TypeScript BM25 Implementation
+ *
+ * Built on-demand from top-N vector candidates — no persistent index.
+ * k1=1.5, b=0.75 (standard values). No external deps.
+ */
+const STOP_WORDS = new Set([
+    'a',
+    'an',
+    'and',
+    'are',
+    'as',
+    'at',
+    'be',
+    'been',
+    'being',
+    'but',
+    'by',
+    'do',
+    'does',
+    'doing',
+    'for',
+    'from',
+    'had',
+    'has',
+    'have',
+    'having',
+    'he',
+    'her',
+    'hers',
+    'him',
+    'his',
+    'how',
+    'i',
+    'if',
+    'in',
+    'into',
+    'is',
+    'it',
+    'its',
+    'itself',
+    'me',
+    'my',
+    'nor',
+    'not',
+    'of',
+    'on',
+    'or',
+    'our',
+    'out',
+    'own',
+    'she',
+    'so',
+    'some',
+    'than',
+    'that',
+    'the',
+    'their',
+    'them',
+    'then',
+    'there',
+    'these',
+    'they',
+    'this',
+    'those',
+    'through',
+    'to',
+    'too',
+    'up',
+    'very',
+    'was',
+    'we',
+    'were',
+    'what',
+    'when',
+    'where',
+    'which',
+    'while',
+    'who',
+    'whom',
+    'why',
+    'will',
+    'with',
+    'would',
+    'you',
+    'your',
+]);
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/\W+/)
+        .filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+// biome-ignore lint/style/useNamingConvention: BM25 is the canonical algorithm name (Best Match 25)
+export class BM25 {
+    k1 = 1.5;
+    b = 0.75;
+    docs = [];
+    avgDocLength = 0;
+    termFreqs = new Map(); // term → docId → freq
+    docFreqs = new Map(); // term → number of docs containing it
+    constructor(options) {
+        if (options?.k1 !== undefined)
+            this.k1 = options.k1;
+        if (options?.b !== undefined)
+            this.b = options.b;
+    }
+    index(documents) {
+        this.docs = [];
+        this.termFreqs = new Map();
+        this.docFreqs = new Map();
+        let totalLength = 0;
+        for (const doc of documents) {
+            const tokens = tokenize(doc.text);
+            totalLength += tokens.length;
+            this.docs.push({ id: doc.id, tokens, length: tokens.length });
+            // Count term frequencies per document
+            const tfMap = new Map();
+            for (const token of tokens) {
+                tfMap.set(token, (tfMap.get(token) ?? 0) + 1);
+            }
+            for (const [term, freq] of tfMap) {
+                if (!this.termFreqs.has(term))
+                    this.termFreqs.set(term, new Map());
+                // biome-ignore lint/style/noNonNullAssertion: set above guarantees presence
+                this.termFreqs.get(term).set(doc.id, freq);
+                this.docFreqs.set(term, (this.docFreqs.get(term) ?? 0) + 1);
+            }
+        }
+        this.avgDocLength = documents.length > 0 ? totalLength / documents.length : 1;
+    }
+    search(query, topK = 10) {
+        const queryTokens = tokenize(query);
+        const N = this.docs.length;
+        if (N === 0 || queryTokens.length === 0)
+            return [];
+        const scores = new Map();
+        for (const term of queryTokens) {
+            const df = this.docFreqs.get(term) ?? 0;
+            if (df === 0)
+                continue;
+            // IDF with smoothing
+            const idf = Math.log((N - df + 0.5) / (df + 0.5) + 1);
+            const termDocs = this.termFreqs.get(term);
+            if (!termDocs)
+                continue;
+            for (const doc of this.docs) {
+                const tf = termDocs.get(doc.id) ?? 0;
+                if (tf === 0)
+                    continue;
+                const normTf = (tf * (this.k1 + 1)) /
+                    (tf + this.k1 * (1 - this.b + this.b * (doc.length / this.avgDocLength)));
+                scores.set(doc.id, (scores.get(doc.id) ?? 0) + idf * normTf);
+            }
+        }
+        return Array.from(scores.entries())
+            .map(([id, score]) => ({ id, score }))
+            .sort((a, b) => b.score - a.score)
+            .slice(0, topK);
+    }
+}

package/dist/ingestion/cms-indexer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * CMS Indexer
+ *
+ * Handles automatic re-indexing of CMS documents when they change.
+ * Wire into CMS collection afterChange hooks — no CMS API calls from here,
+ * the event payload carries the document content directly.
+ *
+ * Usage (in apps/cms/src/lib/ai/indexer.ts):
+ *   export const cmsIndexer = new CmsIndexer({ db, ingestionPipeline, enabledCollections: ['posts', 'pages'] })
+ *
+ * In each CMS collection afterChange hook:
+ *   await cmsIndexer.onDocumentChanged({ collection: 'posts', id: doc.id, operation, doc })
+ */
+import type { IngestionPipeline } from './pipeline.js';
+export interface CmsDocumentEvent {
+    collection: string;
+    id: string;
+    operation: 'create' | 'update' | 'delete';
+    doc?: Record<string, unknown>;
+    workspaceId?: string;
+}
+export interface CmsIndexerConfig {
+    ingestionPipeline: IngestionPipeline;
+    enabledCollections: string[];
+    /** Default workspaceId when not provided per-event */
+    defaultWorkspaceId?: string;
+}
+export declare class CmsIndexer {
+    private pipeline;
+    private enabledCollections;
+    private defaultWorkspaceId;
+    constructor(config: CmsIndexerConfig);
+    /**
+     * Handle a CMS document change event.
+     * Skips collections not in enabledCollections.
+     */
+    onDocumentChanged(event: CmsDocumentEvent): Promise<void>;
+}
+//# sourceMappingURL=cms-indexer.d.ts.map

package/dist/ingestion/cms-indexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cms-indexer.d.ts","sourceRoot":"","sources":["../../src/ingestion/cms-indexer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAA;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAA;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,kBAAkB,EAAE,MAAM,EAAE,CAAA;IAC5B,sDAAsD;IACtD,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAoBD,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAmB;IACnC,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,kBAAkB,CAAQ;gBAEtB,MAAM,EAAE,gBAAgB;IAMpC;;;OAGG;IACG,iBAAiB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BhE"}

package/dist/ingestion/cms-indexer.js

@@ -0,0 +1,74 @@
+/**
+ * CMS Indexer
+ *
+ * Handles automatic re-indexing of CMS documents when they change.
+ * Wire into CMS collection afterChange hooks — no CMS API calls from here,
+ * the event payload carries the document content directly.
+ *
+ * Usage (in apps/cms/src/lib/ai/indexer.ts):
+ *   export const cmsIndexer = new CmsIndexer({ db, ingestionPipeline, enabledCollections: ['posts', 'pages'] })
+ *
+ * In each CMS collection afterChange hook:
+ *   await cmsIndexer.onDocumentChanged({ collection: 'posts', id: doc.id, operation, doc })
+ */
+function extractText(doc) {
+    // Prefer explicit content/rawContent fields, then JSON fallback
+    if (typeof doc.content === 'string')
+        return doc.content;
+    if (typeof doc.rawContent === 'string')
+        return doc.rawContent;
+    if (typeof doc.description === 'string')
+        return doc.description;
+    if (typeof doc.body === 'string')
+        return doc.body;
+    // Strip internal metadata fields before JSON serialization
+    const { id: _id, createdAt: _c, updatedAt: _u, ...rest } = doc;
+    return JSON.stringify(rest, null, 2);
+}
+function extractTitle(doc) {
+    if (typeof doc.title === 'string')
+        return doc.title;
+    if (typeof doc.name === 'string')
+        return doc.name;
+    return undefined;
+}
+export class CmsIndexer {
+    pipeline;
+    enabledCollections;
+    defaultWorkspaceId;
+    constructor(config) {
+        this.pipeline = config.ingestionPipeline;
+        this.enabledCollections = new Set(config.enabledCollections);
+        this.defaultWorkspaceId = config.defaultWorkspaceId ?? 'default';
+    }
+    /**
+     * Handle a CMS document change event.
+     * Skips collections not in enabledCollections.
+     */
+    async onDocumentChanged(event) {
+        if (!this.enabledCollections.has(event.collection))
+            return;
+        const workspaceId = event.workspaceId ?? this.defaultWorkspaceId;
+        const sourceId = String(event.id);
+        const sourceCollection = event.collection;
+        if (event.operation === 'delete') {
+            await this.pipeline.deleteBySource(workspaceId, sourceCollection, sourceId);
+            return;
+        }
+        if (!event.doc)
+            return;
+        // For create/update: remove existing chunks, then re-ingest
+        await this.pipeline.deleteBySource(workspaceId, sourceCollection, sourceId);
+        const rawContent = extractText(event.doc);
+        const title = extractTitle(event.doc);
+        await this.pipeline.ingest({
+            workspaceId,
+            sourceType: 'cms_collection',
+            sourceCollection,
+            sourceId,
+            title,
+            mimeType: 'text/plain',
+            rawContent,
+        });
+    }
+}

package/dist/ingestion/file-parsers.d.ts

@@ -0,0 +1,51 @@
+/**
+ * File Parsers
+ *
+ * Zero external dependencies — pure Node.js + regex/string manipulation.
+ * PDF extraction uses a hand-rolled parser that reads text streams directly
+ * from the binary PDF format (BT/ET blocks, Tj/TJ operators).
+ */
+export interface ParseResult {
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+export declare class PlainTextParser {
+    parse(input: string): ParseResult;
+}
+export declare class MarkdownParser {
+    parse(input: string): ParseResult;
+}
+export declare class HtmlParser {
+    parse(input: string): ParseResult;
+}
+/**
+ * Hand-rolled PDF text extractor.
+ *
+ * Reads text content directly from the binary PDF format without any
+ * external dependencies. Works for text-based PDFs (the vast majority).
+ * Encrypted or image-only PDFs return an empty string.
+ *
+ * Supports:
+ * - BT/ET text blocks with Tj, TJ, ' and " operators
+ * - Literal string decoding (escape sequences + octal)
+ * - Page count from /Count dictionary entry
+ * - Document title from /Title dictionary entry
+ *
+ */
+export declare class PdfParser {
+    /** Parse a PDF string (for API compatibility; use parseBuffer for binary data). */
+    parse(input: string): ParseResult;
+    /** Parse a PDF from a Buffer. */
+    parseBuffer(input: Buffer): ParseResult & {
+        metadata: {
+            pageCount: number;
+            title?: string;
+        };
+    };
+}
+export declare class JsonParser {
+    parse(input: string): ParseResult;
+}
+export type Parser = PlainTextParser | MarkdownParser | HtmlParser | JsonParser | PdfParser;
+export declare function createParser(mimeType: string): Parser;
+//# sourceMappingURL=file-parsers.d.ts.map

package/dist/ingestion/file-parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-parsers.d.ts","sourceRoot":"","sources":["../../src/ingestion/file-parsers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAMD,qBAAa,eAAe;IAC1B,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW;CAGlC;AAgBD,qBAAa,cAAc;IACzB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW;CA6BlC;AAyBD,qBAAa,UAAU;IACrB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW;CAclC;AAmED;;;;;;;;;;;;;GAaG;AACH,qBAAa,SAAS;IACpB,mFAAmF;IACnF,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW;IAIjC,iCAAiC;IACjC,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG;QAAE,QAAQ,EAAE;YAAE,SAAS,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAqC9F;AAMD,qBAAa,UAAU;IACrB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW;CASlC;AAMD,MAAM,MAAM,MAAM,GAAG,eAAe,GAAG,cAAc,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;AAE3F,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBrD"}