cogmem 3.6.2

package/dist/assets/FileAssetStore.js

@@ -0,0 +1,152 @@
+import { randomUUID } from 'crypto';
+export class FileAssetStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS file_assets (
+        asset_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        file_path TEXT NOT NULL,
+        original_name TEXT,
+        mime_type TEXT,
+        extension TEXT,
+        size_bytes INTEGER NOT NULL,
+        content_hash TEXT NOT NULL,
+        mtime_ms INTEGER NOT NULL,
+        ingest_status TEXT NOT NULL,
+        parse_status TEXT NOT NULL,
+        privacy_level TEXT NOT NULL DEFAULT 'local',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        last_indexed_at INTEGER,
+        metadata_json TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_file_assets_project ON file_assets(project_id);
+      CREATE INDEX IF NOT EXISTS idx_file_assets_path ON file_assets(file_path);
+      CREATE INDEX IF NOT EXISTS idx_file_assets_hash ON file_assets(content_hash);
+    `);
+    }
+    upsert(input) {
+        const existing = this.findByPath(input.filePath, input.projectId);
+        const now = Date.now();
+        const record = {
+            assetId: existing?.assetId || input.assetId || `asset-${randomUUID()}`,
+            projectId: input.projectId,
+            filePath: input.filePath,
+            originalName: input.originalName,
+            mimeType: input.mimeType,
+            extension: input.extension,
+            sizeBytes: input.sizeBytes,
+            contentHash: input.contentHash,
+            mtimeMs: input.mtimeMs,
+            ingestStatus: input.ingestStatus || 'tracked',
+            parseStatus: input.parseStatus || 'not_started',
+            privacyLevel: input.privacyLevel || existing?.privacyLevel || 'local',
+            createdAt: existing?.createdAt || now,
+            updatedAt: now,
+            lastIndexedAt: input.lastIndexedAt ?? existing?.lastIndexedAt,
+            metadata: input.metadata ?? existing?.metadata
+        };
+        this.db.prepare(`
+      INSERT INTO file_assets (
+        asset_id, project_id, file_path, original_name, mime_type, extension,
+        size_bytes, content_hash, mtime_ms, ingest_status, parse_status,
+        privacy_level, created_at, updated_at, last_indexed_at, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(asset_id) DO UPDATE SET
+        project_id = excluded.project_id,
+        file_path = excluded.file_path,
+        original_name = excluded.original_name,
+        mime_type = excluded.mime_type,
+        extension = excluded.extension,
+        size_bytes = excluded.size_bytes,
+        content_hash = excluded.content_hash,
+        mtime_ms = excluded.mtime_ms,
+        ingest_status = excluded.ingest_status,
+        parse_status = excluded.parse_status,
+        privacy_level = excluded.privacy_level,
+        updated_at = excluded.updated_at,
+        last_indexed_at = excluded.last_indexed_at,
+        metadata_json = excluded.metadata_json
+    `).run(record.assetId, record.projectId || null, record.filePath, record.originalName || null, record.mimeType || null, record.extension || null, record.sizeBytes, record.contentHash, record.mtimeMs, record.ingestStatus, record.parseStatus, record.privacyLevel, record.createdAt, record.updatedAt, record.lastIndexedAt || null, record.metadata ? JSON.stringify(record.metadata) : null);
+        return record;
+    }
+    markIndexed(assetId, parseStatus = 'text_extracted') {
+        this.db.prepare(`
+      UPDATE file_assets
+      SET ingest_status = 'indexed',
+          parse_status = ?,
+          last_indexed_at = ?,
+          updated_at = ?
+      WHERE asset_id = ?
+    `).run(parseStatus, Date.now(), Date.now(), assetId);
+        return this.getById(assetId);
+    }
+    getById(assetId) {
+        const row = this.db.prepare(`SELECT * FROM file_assets WHERE asset_id = ?`).get(assetId);
+        return row ? this.mapRow(row) : null;
+    }
+    findByPath(filePath, projectId) {
+        const row = projectId
+            ? this.db.prepare(`
+          SELECT * FROM file_assets
+          WHERE file_path = ? AND project_id = ?
+          ORDER BY updated_at DESC LIMIT 1
+        `).get(filePath, projectId)
+            : this.db.prepare(`
+          SELECT * FROM file_assets
+          WHERE file_path = ? AND project_id IS NULL
+          ORDER BY updated_at DESC LIMIT 1
+        `).get(filePath);
+        return row ? this.mapRow(row) : null;
+    }
+    listByQuery(input) {
+        const params = [];
+        let sql = `SELECT * FROM file_assets WHERE 1=1`;
+        if (input.projectId) {
+            sql += ` AND project_id = ?`;
+            params.push(input.projectId);
+        }
+        if (input.extension) {
+            sql += ` AND extension = ?`;
+            params.push(input.extension.toLowerCase());
+        }
+        if (input.mimeType) {
+            sql += ` AND mime_type = ?`;
+            params.push(input.mimeType);
+        }
+        if (input.query?.trim()) {
+            sql += ` AND (file_path LIKE ? OR original_name LIKE ?)`;
+            const like = `%${input.query.trim()}%`;
+            params.push(like, like);
+        }
+        sql += ` ORDER BY updated_at DESC LIMIT ?`;
+        params.push(input.limit ?? 20);
+        return this.db.prepare(sql).all(...params).map((row) => this.mapRow(row));
+    }
+    mapRow(row) {
+        return {
+            assetId: row.asset_id,
+            projectId: row.project_id || undefined,
+            filePath: row.file_path,
+            originalName: row.original_name || undefined,
+            mimeType: row.mime_type || undefined,
+            extension: row.extension || undefined,
+            sizeBytes: row.size_bytes,
+            contentHash: row.content_hash,
+            mtimeMs: row.mtime_ms,
+            ingestStatus: row.ingest_status,
+            parseStatus: row.parse_status,
+            privacyLevel: row.privacy_level,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastIndexedAt: row.last_indexed_at || undefined,
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined
+        };
+    }
+}

package/dist/assets/FileBlockStore.d.ts

@@ -0,0 +1,12 @@
+import Database from 'bun:sqlite';
+import type { FileBlockRecord, LoadedFileBlock } from './types.js';
+export declare class FileBlockStore {
+    private readonly db;
+    constructor(db: Database);
+    initSchema(): void;
+    replaceBlocks(assetId: string, blocks: LoadedFileBlock[]): FileBlockRecord[];
+    listByAsset(assetId: string): FileBlockRecord[];
+    listRange(assetId: string, startIndex: number, endIndex: number): FileBlockRecord[];
+    private mapRow;
+}
+//# sourceMappingURL=FileBlockStore.d.ts.map

package/dist/assets/FileBlockStore.js

@@ -0,0 +1,110 @@
+import { randomUUID } from 'crypto';
+export class FileBlockStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS file_blocks (
+        block_id TEXT PRIMARY KEY,
+        asset_id TEXT NOT NULL,
+        block_index INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        text TEXT NOT NULL,
+        page INTEGER,
+        sheet_name TEXT,
+        row_start INTEGER,
+        row_end INTEGER,
+        column_start INTEGER,
+        column_end INTEGER,
+        line_start INTEGER,
+        line_end INTEGER,
+        start_ms INTEGER,
+        end_ms INTEGER,
+        selector TEXT,
+        symbol_name TEXT,
+        metadata_json TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_file_blocks_asset ON file_blocks(asset_id, block_index);
+      CREATE INDEX IF NOT EXISTS idx_file_blocks_page ON file_blocks(asset_id, page);
+      CREATE INDEX IF NOT EXISTS idx_file_blocks_sheet ON file_blocks(asset_id, sheet_name, row_start);
+    `);
+    }
+    replaceBlocks(assetId, blocks) {
+        this.db.prepare(`DELETE FROM file_blocks WHERE asset_id = ?`).run(assetId);
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO file_blocks (
+        block_id, asset_id, block_index, kind, text, page, sheet_name, row_start,
+        row_end, column_start, column_end, line_start, line_end, start_ms, end_ms,
+        selector, symbol_name, metadata_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        return blocks.map((block, index) => {
+            const record = {
+                blockId: `block-${randomUUID()}`,
+                assetId,
+                blockIndex: index,
+                kind: block.kind,
+                text: block.text,
+                page: block.page,
+                sheetName: block.sheetName,
+                rowStart: block.rowStart,
+                rowEnd: block.rowEnd,
+                columnStart: block.columnStart,
+                columnEnd: block.columnEnd,
+                lineStart: block.lineStart,
+                lineEnd: block.lineEnd,
+                startMs: block.startMs,
+                endMs: block.endMs,
+                selector: block.selector,
+                symbolName: block.symbolName,
+                metadata: block.metadata,
+                createdAt: now
+            };
+            stmt.run(record.blockId, record.assetId, record.blockIndex, record.kind, record.text, record.page || null, record.sheetName || null, record.rowStart || null, record.rowEnd || null, record.columnStart || null, record.columnEnd || null, record.lineStart || null, record.lineEnd || null, record.startMs || null, record.endMs || null, record.selector || null, record.symbolName || null, record.metadata ? JSON.stringify(record.metadata) : null, record.createdAt);
+            return record;
+        });
+    }
+    listByAsset(assetId) {
+        return this.db.prepare(`
+      SELECT * FROM file_blocks
+      WHERE asset_id = ?
+      ORDER BY block_index ASC
+    `).all(assetId).map((row) => this.mapRow(row));
+    }
+    listRange(assetId, startIndex, endIndex) {
+        return this.db.prepare(`
+      SELECT * FROM file_blocks
+      WHERE asset_id = ? AND block_index BETWEEN ? AND ?
+      ORDER BY block_index ASC
+    `).all(assetId, startIndex, endIndex).map((row) => this.mapRow(row));
+    }
+    mapRow(row) {
+        return {
+            blockId: row.block_id,
+            assetId: row.asset_id,
+            blockIndex: row.block_index,
+            kind: row.kind,
+            text: row.text,
+            page: row.page || undefined,
+            sheetName: row.sheet_name || undefined,
+            rowStart: row.row_start || undefined,
+            rowEnd: row.row_end || undefined,
+            columnStart: row.column_start || undefined,
+            columnEnd: row.column_end || undefined,
+            lineStart: row.line_start || undefined,
+            lineEnd: row.line_end || undefined,
+            startMs: row.start_ms || undefined,
+            endMs: row.end_ms || undefined,
+            selector: row.selector || undefined,
+            symbolName: row.symbol_name || undefined,
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined,
+            createdAt: row.created_at
+        };
+    }
+}

package/dist/assets/FileChunkStore.d.ts

@@ -0,0 +1,23 @@
+import Database from 'bun:sqlite';
+import type { ChunkDraft, FileChunkEvidence, FileChunkRecord, FileEvidence } from './types.js';
+export interface InsertChunkInput extends ChunkDraft {
+    chunkId: string;
+    assetId: string;
+    neuronId: string;
+    chunkIndex: number;
+    textHash: string;
+}
+export declare class FileChunkStore {
+    private readonly db;
+    constructor(db: Database);
+    initSchema(): void;
+    replaceChunks(assetId: string, chunks: InsertChunkInput[]): FileChunkRecord[];
+    listByAsset(assetId: string): FileChunkRecord[];
+    listContext(assetId: string, chunkIndex: number, radius?: number): FileChunkEvidence[];
+    listEvidenceByNeuronIds(neuronIds: string[]): FileChunkEvidence[];
+    groupEvidenceByAsset(evidence: FileChunkEvidence[]): FileEvidence[];
+    private insertSequentialEdges;
+    private mapRow;
+    private mapEvidenceRow;
+}
+//# sourceMappingURL=FileChunkStore.d.ts.map

package/dist/assets/FileChunkStore.js

@@ -0,0 +1,179 @@
+export class FileChunkStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS file_chunks (
+        chunk_id TEXT PRIMARY KEY,
+        asset_id TEXT NOT NULL,
+        neuron_id TEXT NOT NULL,
+        chunk_index INTEGER NOT NULL,
+        block_start_index INTEGER NOT NULL,
+        block_end_index INTEGER NOT NULL,
+        kind TEXT NOT NULL,
+        token_estimate INTEGER,
+        text_hash TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        metadata_json TEXT
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_file_chunks_neuron ON file_chunks(neuron_id);
+      CREATE INDEX IF NOT EXISTS idx_file_chunks_asset ON file_chunks(asset_id, chunk_index);
+
+      CREATE TABLE IF NOT EXISTS file_chunk_edges (
+        source_chunk_id TEXT NOT NULL,
+        target_chunk_id TEXT NOT NULL,
+        edge_type TEXT NOT NULL,
+        weight REAL NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY (source_chunk_id, target_chunk_id, edge_type)
+      );
+    `);
+    }
+    replaceChunks(assetId, chunks) {
+        this.db.prepare(`DELETE FROM file_chunk_edges WHERE source_chunk_id IN (SELECT chunk_id FROM file_chunks WHERE asset_id = ?)`).run(assetId);
+        this.db.prepare(`DELETE FROM file_chunk_edges WHERE target_chunk_id IN (SELECT chunk_id FROM file_chunks WHERE asset_id = ?)`).run(assetId);
+        this.db.prepare(`DELETE FROM file_chunks WHERE asset_id = ?`).run(assetId);
+        const now = Date.now();
+        const stmt = this.db.prepare(`
+      INSERT INTO file_chunks (
+        chunk_id, asset_id, neuron_id, chunk_index, block_start_index, block_end_index,
+        kind, token_estimate, text_hash, created_at, metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const records = chunks.map((chunk) => {
+            const record = {
+                chunkId: chunk.chunkId,
+                assetId,
+                neuronId: chunk.neuronId,
+                chunkIndex: chunk.chunkIndex,
+                blockStartIndex: chunk.blockStartIndex,
+                blockEndIndex: chunk.blockEndIndex,
+                kind: chunk.kind,
+                tokenEstimate: chunk.tokenEstimate,
+                textHash: chunk.textHash,
+                createdAt: now,
+                metadata: chunk.metadata
+            };
+            stmt.run(record.chunkId, record.assetId, record.neuronId, record.chunkIndex, record.blockStartIndex, record.blockEndIndex, record.kind, record.tokenEstimate || null, record.textHash, record.createdAt, record.metadata ? JSON.stringify(record.metadata) : null);
+            return record;
+        });
+        this.insertSequentialEdges(records);
+        return records;
+    }
+    listByAsset(assetId) {
+        return this.db.prepare(`
+      SELECT * FROM file_chunks
+      WHERE asset_id = ?
+      ORDER BY chunk_index ASC
+    `).all(assetId).map((row) => this.mapRow(row));
+    }
+    listContext(assetId, chunkIndex, radius = 1) {
+        const start = Math.max(0, chunkIndex - Math.max(0, radius));
+        const end = chunkIndex + Math.max(0, radius);
+        return this.db.prepare(`
+      SELECT fc.*, fa.file_path, fa.original_name, fa.mime_type, n.content,
+        fb.page, fb.sheet_name, fb.row_start, fb.row_end, fb.line_start, fb.line_end,
+        fb.start_ms, fb.end_ms
+      FROM file_chunks fc
+      JOIN file_assets fa ON fa.asset_id = fc.asset_id
+      JOIN neurons n ON n.id = fc.neuron_id
+      LEFT JOIN file_blocks fb ON fb.asset_id = fc.asset_id AND fb.block_index = fc.block_start_index
+      WHERE fc.asset_id = ? AND fc.chunk_index BETWEEN ? AND ?
+      ORDER BY fc.chunk_index ASC
+    `).all(assetId, start, end).map((row) => this.mapEvidenceRow(row));
+    }
+    listEvidenceByNeuronIds(neuronIds) {
+        if (neuronIds.length === 0)
+            return [];
+        const placeholders = neuronIds.map(() => '?').join(', ');
+        return this.db.prepare(`
+      SELECT fc.*, fa.file_path, fa.original_name, fa.mime_type, n.content,
+        fb.page, fb.sheet_name, fb.row_start, fb.row_end, fb.line_start, fb.line_end,
+        fb.start_ms, fb.end_ms
+      FROM file_chunks fc
+      JOIN file_assets fa ON fa.asset_id = fc.asset_id
+      JOIN neurons n ON n.id = fc.neuron_id
+      LEFT JOIN file_blocks fb ON fb.asset_id = fc.asset_id AND fb.block_index = fc.block_start_index
+      WHERE fc.neuron_id IN (${placeholders})
+      ORDER BY fc.asset_id ASC, fc.chunk_index ASC
+    `).all(...neuronIds).map((row) => this.mapEvidenceRow(row));
+    }
+    groupEvidenceByAsset(evidence) {
+        const grouped = new Map();
+        for (const item of evidence) {
+            const existing = grouped.get(item.assetId) || {
+                assetId: item.assetId,
+                filePath: item.filePath,
+                originalName: item.originalName,
+                mimeType: item.mimeType,
+                matchedChunks: []
+            };
+            existing.matchedChunks.push({
+                neuronId: item.neuronId,
+                chunkIndex: item.chunkIndex,
+                text: item.text,
+                kind: item.kind,
+                page: item.page,
+                sheetName: item.sheetName,
+                rowStart: item.rowStart,
+                rowEnd: item.rowEnd,
+                lineStart: item.lineStart,
+                lineEnd: item.lineEnd,
+                startMs: item.startMs,
+                endMs: item.endMs
+            });
+            grouped.set(item.assetId, existing);
+        }
+        return Array.from(grouped.values());
+    }
+    insertSequentialEdges(chunks) {
+        if (chunks.length < 2)
+            return;
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO file_chunk_edges (
+        source_chunk_id, target_chunk_id, edge_type, weight, created_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `);
+        const now = Date.now();
+        for (let i = 0; i < chunks.length - 1; i += 1) {
+            stmt.run(chunks[i].chunkId, chunks[i + 1].chunkId, 'next_chunk', 1, now);
+            stmt.run(chunks[i + 1].chunkId, chunks[i].chunkId, 'previous_chunk', 1, now);
+        }
+    }
+    mapRow(row) {
+        return {
+            chunkId: row.chunk_id,
+            assetId: row.asset_id,
+            neuronId: row.neuron_id,
+            chunkIndex: row.chunk_index,
+            blockStartIndex: row.block_start_index,
+            blockEndIndex: row.block_end_index,
+            kind: row.kind,
+            tokenEstimate: row.token_estimate || undefined,
+            textHash: row.text_hash,
+            createdAt: row.created_at,
+            metadata: row.metadata_json ? JSON.parse(row.metadata_json) : undefined
+        };
+    }
+    mapEvidenceRow(row) {
+        return {
+            ...this.mapRow(row),
+            text: row.content,
+            filePath: row.file_path,
+            originalName: row.original_name || undefined,
+            mimeType: row.mime_type || undefined,
+            page: row.page || undefined,
+            sheetName: row.sheet_name || undefined,
+            rowStart: row.row_start || undefined,
+            rowEnd: row.row_end || undefined,
+            lineStart: row.line_start || undefined,
+            lineEnd: row.line_end || undefined,
+            startMs: row.start_ms || undefined,
+            endMs: row.end_ms || undefined
+        };
+    }
+}

package/dist/assets/FileChunker.d.ts

@@ -0,0 +1,10 @@
+import type { ChunkDraft, LoadedFileBlock } from './types.js';
+export declare class FileChunker {
+    private readonly targetTokenEstimate;
+    constructor(targetTokenEstimate?: number);
+    chunk(blocks: LoadedFileBlock[]): ChunkDraft[];
+    hashText(text: string): string;
+    private estimateTokens;
+    private mergeMetadata;
+}
+//# sourceMappingURL=FileChunker.d.ts.map

package/dist/assets/FileChunker.js

@@ -0,0 +1,69 @@
+import { createHash } from 'crypto';
+export class FileChunker {
+    targetTokenEstimate;
+    constructor(targetTokenEstimate = 420) {
+        this.targetTokenEstimate = targetTokenEstimate;
+    }
+    chunk(blocks) {
+        const chunks = [];
+        let current = [];
+        let currentStart = 0;
+        let tokens = 0;
+        const flush = (endIndex) => {
+            if (current.length === 0)
+                return;
+            const kind = current.some((block) => block.kind === 'table')
+                ? 'table'
+                : current.some((block) => block.kind === 'code')
+                    ? 'code'
+                    : current[0].kind;
+            chunks.push({
+                text: current.map((block) => block.text).join('\n\n'),
+                kind,
+                blockStartIndex: currentStart,
+                blockEndIndex: endIndex,
+                tokenEstimate: tokens,
+                metadata: this.mergeMetadata(current)
+            });
+            current = [];
+            tokens = 0;
+        };
+        blocks.forEach((block, index) => {
+            const blockTokens = this.estimateTokens(block.text);
+            const forceOwnChunk = block.kind === 'table' || block.kind === 'code';
+            if (forceOwnChunk && current.length > 0)
+                flush(index - 1);
+            if (current.length === 0)
+                currentStart = index;
+            current.push(block);
+            tokens += blockTokens;
+            if (forceOwnChunk || tokens >= this.targetTokenEstimate)
+                flush(index);
+        });
+        flush(blocks.length - 1);
+        return chunks.filter((chunk) => chunk.text.trim());
+    }
+    hashText(text) {
+        return createHash('sha256').update(text).digest('hex');
+    }
+    estimateTokens(text) {
+        const cjk = (text.match(/[\u3400-\u9fff]/g) || []).length;
+        const words = (text.match(/[A-Za-z0-9_\-.]+/g) || []).length;
+        return Math.max(1, cjk + words);
+    }
+    mergeMetadata(blocks) {
+        const first = blocks[0];
+        const last = blocks[blocks.length - 1];
+        return {
+            page: first.page,
+            sheetName: first.sheetName,
+            rowStart: first.rowStart,
+            rowEnd: last.rowEnd,
+            lineStart: first.lineStart,
+            lineEnd: last.lineEnd,
+            startMs: first.startMs,
+            endMs: last.endMs,
+            symbolName: first.symbolName
+        };
+    }
+}

package/dist/assets/FileLoaderRegistry.d.ts

@@ -0,0 +1,8 @@
+import type { FileLoadProbe, FileLoader } from './types.js';
+export declare class FileLoaderRegistry {
+    private readonly loaders;
+    constructor(loaders?: FileLoader[]);
+    resolve(input: FileLoadProbe): FileLoader | null;
+    list(): FileLoader[];
+}
+//# sourceMappingURL=FileLoaderRegistry.d.ts.map

package/dist/assets/FileLoaderRegistry.js

@@ -0,0 +1,21 @@
+import { CodeTextLoader, CsvLoader, DocxLoader, HtmlLoader, PdfLoader, PlainTextLoader, XlsxLoader } from './FileLoaders.js';
+export class FileLoaderRegistry {
+    loaders;
+    constructor(loaders) {
+        this.loaders = loaders || [
+            new CsvLoader(),
+            new HtmlLoader(),
+            new PdfLoader(),
+            new DocxLoader(),
+            new XlsxLoader(),
+            new CodeTextLoader(),
+            new PlainTextLoader()
+        ];
+    }
+    resolve(input) {
+        return this.loaders.find((loader) => loader.canLoad(input)) || null;
+    }
+    list() {
+        return [...this.loaders];
+    }
+}

package/dist/assets/FileLoaders.d.ts

@@ -0,0 +1,37 @@
+import type { FileLoadInput, FileLoadProbe, FileLoader, LoadedFile } from './types.js';
+export declare class PlainTextLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export declare class HtmlLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export declare class CsvLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export declare class CodeTextLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export declare class DocxLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export declare class XlsxLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+export declare class PdfLoader implements FileLoader {
+    id: string;
+    canLoad(input: FileLoadProbe): boolean;
+    load(input: FileLoadInput): Promise<LoadedFile>;
+}
+//# sourceMappingURL=FileLoaders.d.ts.map