@bevel-software/platform-core-backend 0.11.2 → 0.12.0

package/dist/modules/workspace/file-readers/extraction-cache.d.ts

@@ -0,0 +1,61 @@
+import type { ExtractedDoc } from './doc-extract.types.js';
+/**
+ * Git BLOB sha of `bytes` — sha1 over `"blob <len>\0" + bytes`, exactly what
+ * `git hash-object` computes. Chosen as the cache key because the workspace is
+ * a git clone: for a clean tracked file this equals the sha `git ls-files -s`
+ * would report, WITHOUT spawning git — and because it is computed from the
+ * bytes actually read, it stays correct (it just stops matching the index)
+ * when the file is untracked or dirty. One code path, no fallback branch.
+ */
+export declare function gitBlobSha(bytes: Buffer): string;
+/**
+ * On-disk cache of document extractions. The KEY is the caller's business —
+ * `DocExtractService` passes git blob sha + extension (content hash, so a
+ * re-upload of identical bytes, or the same document on another branch or
+ * path, hits the same entry; extension, so identical bytes under another
+ * FORMAT never return the wrong extractor's output). One JSON file per entry
+ * (`<key>.json` holding the `{ summary, text }`), under a dedicated root
+ * that — like the spill
+ * store's — sits BESIDE the workspaces root, never inside a workspace and
+ * never committed.
+ *
+ * Bounding: writes best-effort prune OLDEST-MTIME entries until the total
+ * size fits `maxTotalBytes` (simple LRU-ish eviction; reads don't touch
+ * mtime, so it is closer to FIFO — good enough for a cache whose entries are
+ * cheap to rebuild). The full scan is deferred until the writes since the
+ * last one could plausibly have reached the bound (see `writtenSinceScan`).
+ * Every filesystem error here is swallowed: the cache is an accelerator,
+ * never a reason for a read to fail.
+ */
+export declare class DocExtractionCache {
+    private readonly root;
+    private readonly maxTotalBytes;
+    constructor(root: string, maxTotalBytes?: number);
+    /** The cached extraction for `sha`, or undefined on miss/corrupt entry. */
+    get(sha: string): Promise<ExtractedDoc | undefined>;
+    /**
+     * Bytes written since the last full scan. The scan costs a `readdir` plus a
+     * `stat` per entry, and running it on EVERY cold extraction made a cache that
+     * is nowhere near its bound pay for the bound anyway. Writes are accumulated
+     * instead and the scan runs once they could plausibly have reached it.
+     */
+    private writtenSinceScan;
+    /** Total size the last scan found (after eviction); undefined before the first scan, so the first write scans. */
+    private totalAtLastScan;
+    /** The prune in flight, so concurrent puts share ONE scan instead of racing their own. */
+    private pruning;
+    /** Store an extraction under `sha`; prunes towards the size bound. Never throws. */
+    put(sha: string, doc: ExtractedDoc): Promise<void>;
+    /**
+     * The file backing `key`, always INSIDE the cache root.
+     *
+     * The key is built from a content hash and an extension taken from a
+     * workspace path, so a path spelling `../` — or a Windows backslash — would
+     * otherwise resolve outside the root and let a read or a write reach an
+     * arbitrary file. Only the characters a real key uses survive.
+     */
+    private entryPath;
+    /** Delete oldest-mtime entries until the total size fits the bound. */
+    private prune;
+}
+//# sourceMappingURL=extraction-cache.d.ts.map

package/dist/modules/workspace/file-readers/extraction-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-cache.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/extraction-cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAKD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa;gBADb,IAAI,EAAE,MAAM,EACZ,aAAa,GAAE,MAAgC;IAGlE,2EAA2E;IACrE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;IAgBzD;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB,CAAK;IAE7B,kHAAkH;IAClH,OAAO,CAAC,eAAe,CAAqB;IAE5C,0FAA0F;IAC1F,OAAO,CAAC,OAAO,CAA4B;IAE3C,oFAAoF;IAC9E,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBxD;;;;;;;OAOG;IACH,OAAO,CAAC,SAAS;IAKjB,uEAAuE;YACzD,KAAK;CA8BpB"}

package/dist/modules/workspace/file-readers/extraction-cache.js

@@ -0,0 +1,135 @@
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * Git BLOB sha of `bytes` — sha1 over `"blob <len>\0" + bytes`, exactly what
+ * `git hash-object` computes. Chosen as the cache key because the workspace is
+ * a git clone: for a clean tracked file this equals the sha `git ls-files -s`
+ * would report, WITHOUT spawning git — and because it is computed from the
+ * bytes actually read, it stays correct (it just stops matching the index)
+ * when the file is untracked or dirty. One code path, no fallback branch.
+ */
+export function gitBlobSha(bytes) {
+    return createHash('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+}
+/** Default size bound for the on-disk extraction cache. */
+const DEFAULT_MAX_TOTAL_BYTES = 512 * 1024 * 1024; // 512MB
+/**
+ * On-disk cache of document extractions. The KEY is the caller's business —
+ * `DocExtractService` passes git blob sha + extension (content hash, so a
+ * re-upload of identical bytes, or the same document on another branch or
+ * path, hits the same entry; extension, so identical bytes under another
+ * FORMAT never return the wrong extractor's output). One JSON file per entry
+ * (`<key>.json` holding the `{ summary, text }`), under a dedicated root
+ * that — like the spill
+ * store's — sits BESIDE the workspaces root, never inside a workspace and
+ * never committed.
+ *
+ * Bounding: writes best-effort prune OLDEST-MTIME entries until the total
+ * size fits `maxTotalBytes` (simple LRU-ish eviction; reads don't touch
+ * mtime, so it is closer to FIFO — good enough for a cache whose entries are
+ * cheap to rebuild). The full scan is deferred until the writes since the
+ * last one could plausibly have reached the bound (see `writtenSinceScan`).
+ * Every filesystem error here is swallowed: the cache is an accelerator,
+ * never a reason for a read to fail.
+ */
+export class DocExtractionCache {
+    root;
+    maxTotalBytes;
+    constructor(root, maxTotalBytes = DEFAULT_MAX_TOTAL_BYTES) {
+        this.root = root;
+        this.maxTotalBytes = maxTotalBytes;
+    }
+    /** The cached extraction for `sha`, or undefined on miss/corrupt entry. */
+    async get(sha) {
+        try {
+            const parsed = JSON.parse(await fs.readFile(this.entryPath(sha), 'utf8'));
+            if (typeof parsed === 'object' && parsed !== null &&
+                typeof parsed.summary === 'string' &&
+                typeof parsed.text === 'string') {
+                return { summary: parsed.summary, text: parsed.text };
+            }
+            return undefined;
+        }
+        catch {
+            return undefined; // miss, unreadable or corrupt — treated identically
+        }
+    }
+    /**
+     * Bytes written since the last full scan. The scan costs a `readdir` plus a
+     * `stat` per entry, and running it on EVERY cold extraction made a cache that
+     * is nowhere near its bound pay for the bound anyway. Writes are accumulated
+     * instead and the scan runs once they could plausibly have reached it.
+     */
+    writtenSinceScan = 0;
+    /** Total size the last scan found (after eviction); undefined before the first scan, so the first write scans. */
+    totalAtLastScan;
+    /** The prune in flight, so concurrent puts share ONE scan instead of racing their own. */
+    pruning;
+    /** Store an extraction under `sha`; prunes towards the size bound. Never throws. */
+    async put(sha, doc) {
+        try {
+            await fs.mkdir(this.root, { recursive: true });
+            const payload = JSON.stringify({ summary: doc.summary, text: doc.text });
+            await fs.writeFile(this.entryPath(sha), payload, 'utf8');
+            this.writtenSinceScan += Buffer.byteLength(payload);
+            if (this.totalAtLastScan === undefined ||
+                this.totalAtLastScan + this.writtenSinceScan > this.maxTotalBytes) {
+                this.pruning ??= this.prune().finally(() => {
+                    this.pruning = undefined;
+                });
+                await this.pruning;
+            }
+        }
+        catch {
+            // cache write failed — the extraction still returns; next read re-extracts
+        }
+    }
+    /**
+     * The file backing `key`, always INSIDE the cache root.
+     *
+     * The key is built from a content hash and an extension taken from a
+     * workspace path, so a path spelling `../` — or a Windows backslash — would
+     * otherwise resolve outside the root and let a read or a write reach an
+     * arbitrary file. Only the characters a real key uses survive.
+     */
+    entryPath(key) {
+        const safe = key.replace(/[^A-Za-z0-9._-]/g, '_');
+        return path.join(this.root, `${safe}.json`);
+    }
+    /** Delete oldest-mtime entries until the total size fits the bound. */
+    async prune() {
+        // Snapshot FIRST: a write counted before the scan starts is on disk when
+        // `readdir` runs, so the scan settles exactly those bytes. A put that
+        // lands DURING the scan keeps its count (resetting to zero discarded it,
+        // and a later put then trusted a total the scan never saw), so the next
+        // put still prunes instead of leaving the cache above the bound.
+        const scanned = this.writtenSinceScan;
+        const entries = [];
+        let total = 0;
+        for (const name of await fs.readdir(this.root)) {
+            try {
+                const st = await fs.stat(path.join(this.root, name));
+                if (!st.isFile())
+                    continue;
+                entries.push({ p: path.join(this.root, name), size: st.size, mtime: st.mtimeMs });
+                total += st.size;
+            }
+            catch {
+                // vanished mid-scan — ignore
+            }
+        }
+        if (total > this.maxTotalBytes) {
+            entries.sort((a, b) => a.mtime - b.mtime);
+            for (const e of entries) {
+                if (total <= this.maxTotalBytes)
+                    break;
+                await fs.rm(e.p, { force: true });
+                total -= e.size;
+            }
+        }
+        this.totalAtLastScan = total;
+        this.writtenSinceScan -= scanned;
+    }
+}
+//# sourceMappingURL=extraction-cache.js.map

package/dist/modules/workspace/file-readers/extraction-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-cache.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/extraction-cache.ts"],"names":[],"mappings":"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"}

package/dist/modules/workspace/file-readers/file-reader.d.ts

@@ -0,0 +1,76 @@
+/**
+ * What reading a file produces, before the tool layer shapes it for MCP:
+ * text (the honest `[extracted text of …]` marker is ALREADY prepended for
+ * extractions, so line numbers match between read_file and grep), an image
+ * payload (the tool layer wraps it in the `McpImageResult` sentinel), or a
+ * refusal — legacy formats, oversized images, unreadable binary, corrupt
+ * documents — whose message is returned as the file's text content.
+ */
+export type ReadResult = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'image';
+    data: string;
+    mimeType: string;
+    note: string;
+} | {
+    kind: 'refusal';
+    message: string;
+};
+/**
+ * `path` as interpolated into a ONE-LINE notice or refusal: CR/LF are shown
+ * as escapes rather than obeyed (the same rule as `extractionMarker`), so a
+ * filename cannot forge extra output lines.
+ */
+export declare function displayPath(path: string): string;
+/**
+ * Any text interpolated into a ONE-LINE notice — a path, or an extractor's
+ * own failure message, which quotes bytes from the file and can therefore
+ * carry CR/LF of the document's choosing.
+ */
+export declare const oneLine: typeof displayPath;
+/** A per-format file reader. Register implementations in `createFileReaderRegistry`. */
+export interface FileReader {
+    /** The extensions this reader owns — lowercase, with the dot. Empty for the default (fallback) reader. */
+    readonly extensions: readonly string[];
+    /** Read `bytes` (read at `path`) into what the read tools return. Must not throw for bad file content. */
+    read(bytes: Buffer, path: string): Promise<ReadResult>;
+    /**
+     * Text `grep` may search, or null when there is nothing (cheaply) searchable.
+     * Default readers: the decoded text content (TextReader; null on NUL bytes) /
+     * the CACHED extraction (DocumentReader — cold extraction is grep's call,
+     * under its per-walk budget) / absent = never greppable (ImageReader).
+     */
+    greppableText?(bytes: Buffer, path: string): Promise<string | null>;
+    /** May the agent TEXT-editing tools (write_file/write_files/edit_file) touch this file? */
+    readonly textEditable: boolean;
+    /**
+     * Format-specific copy for the write-refusal thrown when `textEditable` is
+     * false (see `assertNotDocumentEdit` in workspace.tools.ts). Absent = the
+     * generic extracted-text/round-trip explanation.
+     */
+    editRefusal?(path: string): string;
+    /**
+     * Refusal for OVERWRITING what this file ALREADY holds, or null to allow.
+     * Consulted only when `textEditable` is true: that answer covers the
+     * FORMAT, this one covers the CONTENT. The fallback reader needs it because
+     * an extensionless file may hold anything — `read_file` refuses binary
+     * content, and a write gate that did not ask would let an agent overwrite
+     * bytes it was never allowed to see.
+     */
+    editRefusalForExisting?(bytes: Buffer, path: string): string | null;
+}
+/**
+ * Extension → reader, with a default fallback (the text reader). Built once
+ * per deployment by `createFileReaderRegistry`; `readerFor` is the ONE lookup
+ * every consumer routes through.
+ */
+export declare class FileReaderRegistry {
+    private readonly fallback;
+    private readonly byExtension;
+    constructor(readers: readonly FileReader[], fallback: FileReader);
+    /** The reader owning `path`'s extension (lowercased by `fileExtension`), or the fallback. */
+    readerFor(path: string): FileReader;
+}
+//# sourceMappingURL=file-reader.d.ts.map

package/dist/modules/workspace/file-readers/file-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/file-reader.ts"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;GAIG;AACH,eAAO,MAAM,OAAO,oBAAc,CAAC;AAEnC,wFAAwF;AACxF,MAAM,WAAW,UAAU;IACzB,0GAA0G;IAC1G,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,0GAA0G;IAC1G,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACvD;;;;;OAKG;IACH,aAAa,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACpE,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,WAAW,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC;;;;;;;OAOG;IACH,sBAAsB,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACrE;AAED;;;;GAIG;AACH,qBAAa,kBAAkB;IAK3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiC;gBAG3D,OAAO,EAAE,SAAS,UAAU,EAAE,EACb,QAAQ,EAAE,UAAU;IAgBvC,6FAA6F;IAC7F,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;CAGpC"}

package/dist/modules/workspace/file-readers/file-reader.js

@@ -0,0 +1,55 @@
+/**
+ * The FileReader contract: ONE interface every read-path consumer goes
+ * through, with per-extension implementations picked by a single registry
+ * lookup — the same shape as the frontend's renderer registry.
+ *
+ * Adding a file format is ONE new reader entry in `createFileReaderRegistry`
+ * (file-reader.registry.ts). The three consumers — `read_file`, `grep` and the
+ * write-refusal in workspace.tools.ts — dispatch through `readerFor` and never
+ * branch on extensions themselves.
+ */
+import { fileExtension } from './doc-extract.types.js';
+/**
+ * `path` as interpolated into a ONE-LINE notice or refusal: CR/LF are shown
+ * as escapes rather than obeyed (the same rule as `extractionMarker`), so a
+ * filename cannot forge extra output lines.
+ */
+export function displayPath(path) {
+    return path.replace(/[\r\n]/g, (c) => (c === '\r' ? '\\r' : '\\n'));
+}
+/**
+ * Any text interpolated into a ONE-LINE notice — a path, or an extractor's
+ * own failure message, which quotes bytes from the file and can therefore
+ * carry CR/LF of the document's choosing.
+ */
+export const oneLine = displayPath;
+/**
+ * Extension → reader, with a default fallback (the text reader). Built once
+ * per deployment by `createFileReaderRegistry`; `readerFor` is the ONE lookup
+ * every consumer routes through.
+ */
+export class FileReaderRegistry {
+    fallback;
+    byExtension = new Map();
+    constructor(readers, fallback) {
+        this.fallback = fallback;
+        for (const reader of readers) {
+            for (const raw of reader.extensions) {
+                // Lookups arrive lowercased (`fileExtension`), so a key stored with any
+                // other casing could never match and its reader would silently fall back
+                // to the default — routing a .PDF-registered reader nowhere.
+                const ext = raw.toLowerCase();
+                // Duplicate claims fail LOUDLY: were the later registration to win
+                // silently, adding a format could disable an existing reader.
+                if (this.byExtension.has(ext))
+                    throw new Error(`two file readers claim the extension "${ext}"`);
+                this.byExtension.set(ext, reader);
+            }
+        }
+    }
+    /** The reader owning `path`'s extension (lowercased by `fileExtension`), or the fallback. */
+    readerFor(path) {
+        return this.byExtension.get(fileExtension(path)) ?? this.fallback;
+    }
+}
+//# sourceMappingURL=file-reader.js.map

package/dist/modules/workspace/file-readers/file-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/file-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAevD;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AACtE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,WAAW,CAAC;AAkCnC;;;;GAIG;AACH,MAAM,OAAO,kBAAkB;IAKV;IAJF,WAAW,GAAG,IAAI,GAAG,EAAsB,CAAC;IAE7D,YACE,OAA8B,EACb,QAAoB;QAApB,aAAQ,GAAR,QAAQ,CAAY;QAErC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;gBACpC,wEAAwE;gBACxE,yEAAyE;gBACzE,6DAA6D;gBAC7D,MAAM,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;gBAC9B,mEAAmE;gBACnE,8DAA8D;gBAC9D,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC;oBAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,GAAG,GAAG,CAAC,CAAC;gBAChG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;IACH,CAAC;IAED,6FAA6F;IAC7F,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC;IACpE,CAAC;CACF"}

package/dist/modules/workspace/file-readers/file-reader.registry.d.ts

@@ -0,0 +1,13 @@
+import type { DocExtractService } from './doc-extract.service.js';
+import { FileReaderRegistry } from './file-reader.js';
+/**
+ * THE registry of file readers — the one place that says which reader owns
+ * which extension. Adding a format is one entry here (plus its reader/extract
+ * function); read_file, grep and the write-refusal all follow automatically.
+ *
+ * `docExtract` is the shared content-hash extraction cache the document
+ * readers wrap their pure extract functions with (see DocumentReader).
+ * Everything not claimed below falls back to the TextReader.
+ */
+export declare function createFileReaderRegistry(docExtract: DocExtractService): FileReaderRegistry;
+//# sourceMappingURL=file-reader.registry.d.ts.map

package/dist/modules/workspace/file-readers/file-reader.registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.registry.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/file-reader.registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAYlE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAItD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,iBAAiB,GAAG,kBAAkB,CAmB1F"}

package/dist/modules/workspace/file-readers/file-reader.registry.js

@@ -0,0 +1,41 @@
+import { DocumentReader } from './document-reader.js';
+import { EmailReader } from './email-reader.js';
+import { extractDocx } from './extract-docx.js';
+import { extractEml } from './extract-eml.js';
+import { extractMsg } from './extract-msg.js';
+import { extractOdp } from './extract-odp.js';
+import { extractOds } from './extract-ods.js';
+import { extractOdt } from './extract-odt.js';
+import { extractPdf } from './extract-pdf.js';
+import { extractPptx } from './extract-pptx.js';
+import { extractXlsx } from './extract-xlsx.js';
+import { FileReaderRegistry } from './file-reader.js';
+import { ImageReader } from './image-reader.js';
+import { LegacyOfficeReader, TextReader } from './text-reader.js';
+/**
+ * THE registry of file readers — the one place that says which reader owns
+ * which extension. Adding a format is one entry here (plus its reader/extract
+ * function); read_file, grep and the write-refusal all follow automatically.
+ *
+ * `docExtract` is the shared content-hash extraction cache the document
+ * readers wrap their pure extract functions with (see DocumentReader).
+ * Everything not claimed below falls back to the TextReader.
+ */
+export function createFileReaderRegistry(docExtract) {
+    return new FileReaderRegistry([
+        new DocumentReader('.docx', extractDocx, docExtract),
+        new DocumentReader('.pptx', extractPptx, docExtract),
+        new DocumentReader('.xlsx', extractXlsx, docExtract),
+        new DocumentReader('.pdf', extractPdf, docExtract),
+        new DocumentReader('.odt', extractOdt, docExtract),
+        new DocumentReader('.odp', extractOdp, docExtract),
+        new DocumentReader('.ods', extractOds, docExtract),
+        // Email files ride the same document machinery (cached extraction,
+        // greppable, not text-editable) with an email-honest write refusal.
+        new EmailReader('.eml', extractEml, docExtract),
+        new EmailReader('.msg', extractMsg, docExtract),
+        new ImageReader(),
+        new LegacyOfficeReader(),
+    ], new TextReader());
+}
+//# sourceMappingURL=file-reader.registry.js.map

package/dist/modules/workspace/file-readers/file-reader.registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.registry.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/file-reader.registry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB,CAAC,UAA6B;IACpE,OAAO,IAAI,kBAAkB,CAC3B;QACE,IAAI,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC;QACpD,IAAI,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC;QACpD,IAAI,cAAc,CAAC,OAAO,EAAE,WAAW,EAAE,UAAU,CAAC;QACpD,IAAI,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;QAClD,IAAI,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;QAClD,IAAI,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;QAClD,IAAI,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;QAClD,mEAAmE;QACnE,oEAAoE;QACpE,IAAI,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;QAC/C,IAAI,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC;QAC/C,IAAI,WAAW,EAAE;QACjB,IAAI,kBAAkB,EAAE;KACzB,EACD,IAAI,UAAU,EAAE,CACjB,CAAC;AACJ,CAAC"}

package/dist/modules/workspace/file-readers/image-read.d.ts

@@ -0,0 +1,35 @@
+/** The extensions the `ImageReader` registers for — exactly the map above. */
+export declare const IMAGE_EXTENSIONS: readonly string[];
+/** Is this a file `read_file` should return as an image? */
+export declare function isImageFile(path: string): boolean;
+/** The MCP mime type for an image path — call only after `isImageFile`. */
+export declare function imageMimeType(path: string): string;
+/**
+ * Cap on the RAW bytes of an image `read_file` will return.
+ *
+ * The arithmetic: Claude-family clients reject a base64 image payload around
+ * 5 MB encoded (5 * 1024 * 1024 = 5,242,880 chars). Base64 inflates by 4/3,
+ * so the raw ceiling for that limit is 5,242,880 * 3/4 = 3,932,160 bytes. We
+ * cap at 3.5 MiB raw = 3,670,016 bytes, which encodes to
+ * ceil(3,670,016 / 3) * 4 = 4,893,356 base64 chars (~4.67 MiB) — under the
+ * reject line with headroom for the JSON envelope the sentinel travels in.
+ */
+export declare const IMAGE_MAX_RAW_BYTES: number;
+/** Width×height parsed from the container header, when the format makes that cheap. */
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+/**
+ * Best-effort dimensions straight from the header bytes: PNG (IHDR), GIF
+ * (logical screen descriptor), JPEG (SOFn scan). WebP is left dimensionless —
+ * its three sub-formats (VP8/VP8L/VP8X) each encode size differently, and the
+ * note is honest without it. Returns undefined on anything unexpected; never
+ * throws (a corrupt image must still be delivered or refused, not 500).
+ */
+export declare function imageDimensions(bytes: Buffer): ImageDimensions | undefined;
+/** The one-line note emitted as a text block beside the image, so the transcript names what it shows. */
+export declare function imageNote(path: string, mime: string, sizeBytes: number, dims: ImageDimensions | undefined): string;
+/** The honest refusal for an image over {@link IMAGE_MAX_RAW_BYTES} — returned as the file's text content. */
+export declare function oversizedImageNotice(path: string, mime: string, sizeBytes: number): string;
+//# sourceMappingURL=image-read.d.ts.map

package/dist/modules/workspace/file-readers/image-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-read.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-read.ts"],"names":[],"mappings":"AAwBA,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAAmC,CAAC;AAElF,4DAA4D;AAC5D,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,QAAoB,CAAC;AAErD,uFAAuF;AACvF,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CA2C1E;AAED,yGAAyG;AACzG,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,SAAS,GAAG,MAAM,CAGlH;AAED,8GAA8G;AAC9G,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAO1F"}

package/dist/modules/workspace/file-readers/image-read.js

@@ -0,0 +1,108 @@
+/**
+ * `read_file` image support: which files come back as a native MCP image
+ * content block instead of text, the size cap that keeps the encoded payload
+ * under what Claude-family clients accept, and the self-describing note that
+ * rides beside the image so the transcript still says what was read.
+ *
+ * Deliberately dependency-free: dimensions are parsed straight from the
+ * container headers (PNG/GIF/JPEG) rather than through a native image library.
+ * No downscaling in this increment — `sharp` is a heavy native dependency, so
+ * an oversized image gets an honest refusal telling the caller to downscale
+ * locally or upload a smaller export.
+ */
+import { fileExtension } from './doc-extract.types.js';
+/** The image types `read_file` returns as a native MCP image content block. `.svg` is TEXT and stays on the text path. */
+const IMAGE_MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    // GIF passes through whole under the same cap; clients render the first frame.
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+/** The extensions the `ImageReader` registers for — exactly the map above. */
+export const IMAGE_EXTENSIONS = Object.keys(IMAGE_MIME_BY_EXT);
+/** Is this a file `read_file` should return as an image? */
+export function isImageFile(path) {
+    return fileExtension(path) in IMAGE_MIME_BY_EXT;
+}
+/** The MCP mime type for an image path — call only after `isImageFile`. */
+export function imageMimeType(path) {
+    return IMAGE_MIME_BY_EXT[fileExtension(path)];
+}
+/**
+ * Cap on the RAW bytes of an image `read_file` will return.
+ *
+ * The arithmetic: Claude-family clients reject a base64 image payload around
+ * 5 MB encoded (5 * 1024 * 1024 = 5,242,880 chars). Base64 inflates by 4/3,
+ * so the raw ceiling for that limit is 5,242,880 * 3/4 = 3,932,160 bytes. We
+ * cap at 3.5 MiB raw = 3,670,016 bytes, which encodes to
+ * ceil(3,670,016 / 3) * 4 = 4,893,356 base64 chars (~4.67 MiB) — under the
+ * reject line with headroom for the JSON envelope the sentinel travels in.
+ */
+export const IMAGE_MAX_RAW_BYTES = 3.5 * 1024 * 1024; // = 3,670,016
+/**
+ * Best-effort dimensions straight from the header bytes: PNG (IHDR), GIF
+ * (logical screen descriptor), JPEG (SOFn scan). WebP is left dimensionless —
+ * its three sub-formats (VP8/VP8L/VP8X) each encode size differently, and the
+ * note is honest without it. Returns undefined on anything unexpected; never
+ * throws (a corrupt image must still be delivered or refused, not 500).
+ */
+export function imageDimensions(bytes) {
+    try {
+        // PNG: 8-byte signature, then the IHDR chunk — width/height at 16/20 (BE).
+        if (bytes.length >= 24 && bytes.readUInt32BE(0) === 0x89504e47 && bytes.toString('latin1', 12, 16) === 'IHDR') {
+            return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
+        }
+        // GIF: the FULL "GIF87a"/"GIF89a" signature, then the logical screen
+        // size at 6/8 (LE) — a bare "GIF" prefix is not a GIF header.
+        if (bytes.length >= 10) {
+            const sig = bytes.toString('latin1', 0, 6);
+            if (sig === 'GIF87a' || sig === 'GIF89a') {
+                return { width: bytes.readUInt16LE(6), height: bytes.readUInt16LE(8) };
+            }
+        }
+        // JPEG: walk the marker segments to the first SOFn frame header.
+        if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+            let i = 2;
+            while (i + 9 < bytes.length) {
+                if (bytes[i] !== 0xff) {
+                    i += 1; // stray fill byte — resync
+                    continue;
+                }
+                const marker = bytes[i + 1];
+                // Standalone markers (no length field): padding, restarts, SOI/EOI.
+                if (marker === 0xff) {
+                    i += 1;
+                    continue;
+                }
+                if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd9)) {
+                    i += 2;
+                    continue;
+                }
+                // SOFn (C0–CF except the non-frame C4/C8/CC): height at +5, width at +7.
+                if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                    return { height: bytes.readUInt16BE(i + 5), width: bytes.readUInt16BE(i + 7) };
+                }
+                i += 2 + bytes.readUInt16BE(i + 2);
+            }
+        }
+    }
+    catch {
+        // Truncated/corrupt header — the note simply omits dimensions.
+    }
+    return undefined;
+}
+/** The one-line note emitted as a text block beside the image, so the transcript names what it shows. */
+export function imageNote(path, mime, sizeBytes, dims) {
+    const dimsPart = dims ? `, ${dims.width}×${dims.height} px` : '';
+    return `[image: ${path} — ${mime}, ${sizeBytes} bytes${dimsPart}]`;
+}
+/** The honest refusal for an image over {@link IMAGE_MAX_RAW_BYTES} — returned as the file's text content. */
+export function oversizedImageNotice(path, mime, sizeBytes) {
+    return (`[${path} is a ${mime} image of ${sizeBytes} bytes — too large to return over MCP. The cap is ` +
+        `${IMAGE_MAX_RAW_BYTES} bytes (3.5 MiB) of raw image data, because base64 encoding inflates it by 4/3 and ` +
+        'Claude-family clients reject images near 5 MB encoded. Downscale the image locally or upload a smaller ' +
+        'export, then read that file instead.]');
+}
+//# sourceMappingURL=image-read.js.map

package/dist/modules/workspace/file-readers/image-read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-read.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-read.ts"],"names":[],"mappings":"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"}

package/dist/modules/workspace/file-readers/image-reader.d.ts

@@ -0,0 +1,19 @@
+import type { FileReader, ReadResult } from './file-reader.js';
+/**
+ * FileReader over the image types `read_file` returns as a native MCP image
+ * content block (`.svg` is text and stays on the text path). Within the raw
+ * cap the read yields the picture itself (base64 + mime + the self-describing
+ * note); over it, the honest downscale refusal — see image-read.ts for the
+ * cap arithmetic and header-parsing details.
+ *
+ * No `greppableText`: a picture is never text-searchable. And images stay
+ * `textEditable` — the write tools only refuse formats whose reads are lossy
+ * EXTRACTIONS (documents); an image read is the real bytes, and image writes
+ * were never gated.
+ */
+export declare class ImageReader implements FileReader {
+    readonly extensions: readonly string[];
+    readonly textEditable = true;
+    read(bytes: Buffer, path: string): Promise<ReadResult>;
+}
+//# sourceMappingURL=image-reader.d.ts.map

package/dist/modules/workspace/file-readers/image-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-reader.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAU/D;;;;;;;;;;;GAWG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAoB;IAC1D,QAAQ,CAAC,YAAY,QAAQ;IAEvB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAY7D"}

package/dist/modules/workspace/file-readers/image-reader.js

@@ -0,0 +1,30 @@
+import { IMAGE_EXTENSIONS, IMAGE_MAX_RAW_BYTES, imageDimensions, imageMimeType, imageNote, oversizedImageNotice, } from './image-read.js';
+/**
+ * FileReader over the image types `read_file` returns as a native MCP image
+ * content block (`.svg` is text and stays on the text path). Within the raw
+ * cap the read yields the picture itself (base64 + mime + the self-describing
+ * note); over it, the honest downscale refusal — see image-read.ts for the
+ * cap arithmetic and header-parsing details.
+ *
+ * No `greppableText`: a picture is never text-searchable. And images stay
+ * `textEditable` — the write tools only refuse formats whose reads are lossy
+ * EXTRACTIONS (documents); an image read is the real bytes, and image writes
+ * were never gated.
+ */
+export class ImageReader {
+    extensions = IMAGE_EXTENSIONS;
+    textEditable = true;
+    async read(bytes, path) {
+        const mime = imageMimeType(path);
+        if (bytes.length > IMAGE_MAX_RAW_BYTES) {
+            return { kind: 'refusal', message: oversizedImageNotice(path, mime, bytes.length) };
+        }
+        return {
+            kind: 'image',
+            data: bytes.toString('base64'),
+            mimeType: mime,
+            note: imageNote(path, mime, bytes.length, imageDimensions(bytes)),
+        };
+    }
+}
+//# sourceMappingURL=image-reader.js.map

package/dist/modules/workspace/file-readers/image-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-reader.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-reader.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,WAAW;IACb,UAAU,GAAsB,gBAAgB,CAAC;IACjD,YAAY,GAAG,IAAI,CAAC;IAE7B,KAAK,CAAC,IAAI,CAAC,KAAa,EAAE,IAAY;QACpC,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,CAAC,MAAM,GAAG,mBAAmB,EAAE,CAAC;YACvC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QACtF,CAAC;QACD,OAAO;YACL,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC9B,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;SAClE,CAAC;IACJ,CAAC;CACF"}