@jiaoqsh/dsh-document 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jiaoqsh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# dsh-document
+
+A [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) plugin bundle (`@jiaoqsh/dsh-document`) that gives the model a `read_document` tool: Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV, and PDF files are converted to line-numbered Markdown the model can page through with `offset`/`limit`.
+
+Conversion runs locally: office formats through [`@firecrawl/anydoc`](https://github.com/firecrawl/anydoc) (Rust core, Node bindings) and PDFs through [`@firecrawl/pdf-inspector`](https://github.com/firecrawl/pdf-inspector) (WASM build, run in a worker thread) — no API key, no network, no external binaries; both MIT. PDFs get page selection, `<!-- Page N -->` markers, and page facts: total pages, text-based / scanned / mixed, and which pages have no extractable text. Files are read through the harness `ctx.fs` seam, so whatever filesystem provider and sandbox policy a deployment mounts applies unchanged.
+
+## Install
+
+Into an existing profile (`web`, `headless`, or your own), from npm:
+
+```sh
+dsh plugin --profile web add @jiaoqsh/dsh-document
+```
+
+The npm package ships built code, so nothing runs at install time. Releases are published from this repository's `release.yml` through npm trusted publishing and carry provenance attestations.
+
+### From GitHub instead
+
+```sh
+dsh plugin --profile web add github:jiaoqsh/dsh-document#<commit-sha>
+```
+
+A git install fetches sources, so pnpm ≥ 10 refuses to run the package's `prepare` (a `tsdown` transpile of `src/`) until you allow it: the first `add` fails and prints the exact key to copy into the profile's `pnpm-workspace.yaml` (`$DSH_HOME/profiles/<name>/pnpm-workspace.yaml`). The key names the resolved tarball, so a bare package name does not match:
+
+```yaml
+allowBuilds:
+  '@jiaoqsh/dsh-document@https://codeload.github.com/jiaoqsh/dsh-document/tar.gz/<commit-sha>': true
+```
+
+Re-run the `add`. Allowing the build means executing this package's code on your machine at install time; pin a commit so a later push cannot change what runs.
+
+`dsh plugin` prints "missing peer" warnings for the `@deepseek-ai/*` packages: expected. The dsh installation supplies them at runtime; profiles deliberately do not install peers.
+
+Verify, then boot:
+
+```sh
+dsh --profile web --dump-config   # shows a "# == @jiaoqsh/dsh-document" layer
+dsh --profile web
+```
+
+Remove with `dsh plugin --profile web remove @jiaoqsh/dsh-document`.
+
+### From a source checkout of the harness
+
+```sh
+pnpm dsh web --patch /absolute/path/to/dsh-document/overlay.yml
+```
+
+where the overlay inserts the built entry by absolute path:
+
+```yaml
+- insert:
+    - id: document-tools
+      name: '/absolute/path/to/dsh-document/lib/index.js'
+```
+
+## Configuration
+
+The bundle's layer inserts one row, `document-tools`, with schema defaults. Override it by id in your profile's `cordis.patch.yml`; a patch replaces the whole `config`, so restate every key you need:
+
+```yaml
+- id: document-tools
+  config:
+    maxInputBytes: 104857600   # 100 MiB
+    readLimit: 2000
+    maxLineLength: 2000
+    maxOutputBytes: 51200
+    pdfMaxPages: 100
+    pdfProfile: fidelity
+```
+
+| Key | Default | Meaning |
+|---|---|---|
+| `maxInputBytes` | 52428800 (50 MiB) | Inclusive byte cap on the source file. Enforced by the filesystem provider before any bytes are buffered; larger files are refused. |
+| `readLimit` | 2000 | Default and maximum number of Markdown lines returned by one call. |
+| `maxLineLength` | 2000 | Maximum characters per returned line; overflow is cut with `… [line truncated]`. |
+| `maxOutputBytes` | 51200 (50 KiB) | Maximum bytes of line text returned by one call; the window stops early and the footer says how to continue. |
+| `pdfMaxPages` | 100 | Maximum distinct pages one `pages` selection may name. |
+| `pdfProfile` | `fidelity` | PDF Markdown profile: `fidelity` keeps source structure, `compact` spends fewer tokens. |
+
+Every numeric value must be a positive integer and `pdfProfile` one of the two names; anything else fails the plugin load with a message naming the key.
+
+## The tool
+
+`read_document(file_path, offset?, limit?, pages?)`
+
+- `file_path` — resolved by the filesystem backend; relative paths resolve against the calling session's workspace.
+- `offset` — 1-based first line of the converted Markdown (default 1).
+- `limit` — lines to return (default and maximum `readLimit`).
+- `pages` — PDF only: 1-based pages to convert, as numbers and ranges like `"1-3,7"` (at most `pdfMaxPages`). Default: every page. Naming a page beyond the last one is an error that states the page count.
+
+Supported extensions: `.pdf`, `.doc`, `.docm`, `.docx`, `.ppt`, `.pps`, `.pot`, `.pptx`, `.pptm`, `.ppsx`, `.ppsm`, `.xls`, `.xlsx`, `.xlsm`, `.xlsb`, `.odt`, `.ods`, `.odp`, `.rtf`, `.epub`, `.csv`. The format comes from the extension, never from content sniffing (CSV has no signature).
+
+Canonical value (what Code Mode receives):
+
+```ts
+{ path: string, format: 'pdf' | 'docx' | ..., offset: number,
+  lines: { number: number, text: string }[], totalLines: number, truncatedByBytes: boolean,
+  pdf?: { pageCount: number, kind: 'text' | 'scanned' | 'image' | 'mixed',
+          pagesNeedingOcr: number[], pages?: number[], title?: string } }
+```
+
+Model-facing text (a PDF, pages 2 and 4 of 5):
+
+```text
+<path>/work/report.pdf</path>
+<format>pdf</format>
+<pdf>5 pages, text-based; showing pages 2, 4</pdf>
+<content>
+1: <!-- Page 2 -->
+2: 
+3: Revenue grew 12% year over year.
+
+(Showing lines 1-3 of 8. Use offset=4 to continue.)
+</content>
+```
+
+A mixed PDF adds `<warning>Pages 3, 7-8 contain no extractable text (scanned or image content); their content is missing below and would need OCR.</warning>` before `<content>`. Non-PDF formats omit the `<pdf>` line.
+
+Failures are tool errors in model terms: unsupported extension (pointing at `read` for plain text), `pages` on a non-PDF, a malformed `pages` value, not found, not a regular file, over `maxInputBytes`, encrypted, damaged or incomplete, engine resource limit, a page beyond the last page, cancellation, or no extractable text (a scanned or image-only PDF says so and that OCR is needed; this tool performs no OCR).
+
+## Model Experience
+
+### System prompt section `tool:read_document`
+
+#### What the model sees
+
+One fixed sentence, order 100 beside the shipped `tool:read` guidance:
+
+```markdown
+Use the read_document tool — not read or shell commands — to inspect PDF, Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, and CSV files. It returns the document converted to line-numbered Markdown; use offset and limit to continue reading long documents. For a PDF, pass pages (for example "1-3,7") to read only those pages; page markers like <!-- Page 4 --> show where each page starts.
+```
+
+#### Token effect
+
+Fixed: the section and the tool schema add a constant number of tokens to every request; results add up to `maxOutputBytes` per call.
+
+#### KV Cache effect
+
+Prefix-stable: the section text and schema never change between requests, so they do not invalidate a cached prompt prefix.
+
+## Known Limitations and Deferred Work
+
+- **No OCR** — pages without a text layer are reported (`pagesNeedingOcr`, the `<warning>` line) but not read; a fully scanned or image-only PDF is an error naming the cause.
+- **PDF conversion runs in a fresh worker thread per call** — cancellation terminates it, and the harness event loop stays free, at the cost of ~50 ms of WASM start-up per call. Office-format conversion (anydoc) runs on the libuv thread pool and cannot be cancelled once started; `maxInputBytes` is its bound.
+- **Layout-heavy PDFs may collapse paragraphs into long lines** (then cut by `maxLineLength`); `pdfProfile: compact` trades structure for tokens.
+- **Engines are fixed** — the `DocumentConverter` interface and `routeConverters` in `src/converter.ts` are the seam for a hosted or OCR-capable engine; none is wired today.
+- **The pdf-inspector native binary is not used** — its npm build ships no `darwin-x64` binary, so the WASM build runs everywhere for one code path.
+
+## Development
+
+```sh
+pnpm install          # also builds lib/ via prepare
+pnpm run typecheck
+pnpm test             # real Cordis Context + real registry + real local fs; no API key
+pnpm run build
+```
+
+Release: bump `version` in `package.json` on `main`, then push the matching tag (`git tag v0.2.0 && git push origin v0.2.0`). `release.yml` checks the tag against the version, runs the checks, publishes to npm via trusted publishing, and creates the GitHub release with generated notes.
+
+Fixtures under `tests/fixtures/` were generated once with macOS `textutil` and `cupsfilter` (including a five-page PDF and an image-only PDF) and are committed so the suite runs anywhere. In source mode the PDF worker is spawned as `.ts` with `--experimental-strip-types`, so it stays free of TypeScript-only runtime syntax.
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,11 @@
+# The layer this bundle contributes when a profile lists it. Config is
+# omitted so the plugin's schema defaults apply; override this row by id
+# in your profile's cordis.patch.yml to change any bound:
+#
+#   - id: document-tools
+#     name: '@jiaoqsh/dsh-document'
+#     config:
+#       maxInputBytes: 104857600
+- insert:
+    - id: document-tools
+      name: '@jiaoqsh/dsh-document'

package/lib/index.d.ts

@@ -0,0 +1,187 @@
+import "./pdf-worker-CTqxWga-.js";
+import Schema from "@deepseek-ai/schemastery";
+import { MarkdownProfile } from "@firecrawl/pdf-inspector-wasm";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/converter.d.ts
+/**
+ * Document-to-Markdown conversion behind one small interface, plus the
+ * format router the tool uses. Engines: `@firecrawl/anydoc` for every
+ * office format (local Rust napi) and `@firecrawl/pdf-inspector` (WASM in a
+ * worker thread) for PDF, where page selection and scanned-page facts matter.
+ * @module @jiaoqsh/dsh-document/converter
+ */
+/** Formats the engines convert; the value doubles as the model-visible `format` field. */
+declare const DOCUMENT_FORMATS: readonly ["doc", "docx", "odt", "pdf", "ppt", "pptx", "rtf", "epub", "xlsx", "ods", "odp", "csv"];
+/** One convertible document format. */
+type DocumentFormat = typeof DOCUMENT_FORMATS[number];
+/** File extensions (lowercase, no dot) that map to a {@link DocumentFormat}. */
+declare const DOCUMENT_EXTENSIONS: readonly ["pdf", "doc", "docm", "docx", "ppt", "pps", "pot", "pptx", "pptm", "ppsx", "ppsm", "xls", "xlsx", "xlsm", "xlsb", "odt", "ods", "odp", "rtf", "epub", "csv"];
+/**
+ * Failure classes a conversion can report. The first six mirror anydoc's
+ * `ConvertErrorCode`; `empty` means the engine returned no text; `scanned`
+ * means a PDF has no extractable text on any requested page; `aborted` means
+ * the caller's signal fired; `unknown` wraps an engine failure without a
+ * recognized code.
+ */
+type ConversionErrorCode = 'unsupported' | 'malformed' | 'encrypted' | 'resourceLimit' | 'missingPart' | 'io' | 'empty' | 'scanned' | 'pageRange' | 'aborted' | 'unknown';
+/** A conversion failure with a stable code for callers and a model-readable message. */
+declare class DocumentConversionError extends Error {
+  readonly code: ConversionErrorCode;
+  constructor(message: string, code: ConversionErrorCode);
+}
+/** PDF classification, as the model should hear it. */
+type PdfKind = 'text' | 'scanned' | 'image' | 'mixed';
+/** Facts a PDF engine reports beside the Markdown. Page numbers are 1-based. */
+interface PdfFacts {
+  /** Total pages in the document. */
+  pageCount: number;
+  /** Whether the text layer covers the document. */
+  kind: PdfKind;
+  /** Pages with no extractable text; their content is absent from the Markdown. */
+  pagesNeedingOcr: number[];
+  /** The pages that were converted, when the request selected some. */
+  pages?: number[];
+  /** Document title from metadata, when present. */
+  title?: string;
+}
+/** One conversion request. */
+interface ConvertRequest {
+  /** The whole file. */
+  bytes: Uint8Array;
+  /** The format to parse the bytes as; never sniffed (CSV has no signature). */
+  format: DocumentFormat;
+  /** 1-based pages to convert; PDF only. Absent means every page. */
+  pages?: readonly number[];
+  /** Cancels a running conversion where the engine allows it. */
+  signal: AbortSignal;
+}
+/** One conversion result. */
+interface ConvertResult {
+  /** Non-empty GitHub-Flavored Markdown. */
+  markdown: string;
+  /** Present for PDF engines. */
+  pdf?: PdfFacts;
+}
+/** One conversion engine. */
+interface DocumentConverter {
+  /** Engine identifier for diagnostics. */
+  readonly name: string;
+  /** Formats this engine converts; the router picks the first engine listing a format. */
+  readonly formats: readonly DocumentFormat[];
+  /**
+   * Convert complete document bytes to Markdown.
+   * @param request - bytes, format, optional page selection, and cancellation.
+   * @returns non-empty Markdown plus engine facts.
+   * @throws DocumentConversionError for every engine failure and for cancellation.
+   */
+  convert(request: ConvertRequest): Promise<ConvertResult>;
+}
+/**
+ * Map a file path to its document format by extension, case-insensitively.
+ * @param path - any path; only the extension is inspected.
+ * @returns the format, or `undefined` for an extension no engine handles.
+ */
+declare function formatOf(path: string): DocumentFormat | undefined;
+/**
+ * Pick the engine for a format: the first converter that lists it.
+ * @param converters - engines in priority order.
+ * @returns a lookup that throws for a format no engine lists.
+ */
+declare function routeConverters(converters: readonly DocumentConverter[]): (format: DocumentFormat) => DocumentConverter;
+/**
+ * The anydoc engine: pure local conversion on the libuv thread pool. It lists
+ * every format, so it is the last-resort engine behind any specialized one.
+ * @returns the converter.
+ */
+declare function anydocConverter(): DocumentConverter;
+//#endregion
+//#region src/pdf-inspector.d.ts
+/** Deployment choices for the PDF engine. */
+interface PdfInspectorOptions {
+  /** `fidelity` keeps source structure; `compact` spends fewer tokens. */
+  profile: MarkdownProfile;
+}
+/**
+ * Build the PDF engine.
+ * @param options - deployment choices.
+ * @returns a converter that handles only `pdf`.
+ */
+declare function pdfInspectorConverter(options: PdfInspectorOptions): DocumentConverter;
+//#endregion
+//#region src/window.d.ts
+/** One returned line. */
+interface WindowLine {
+  /** 1-based line number in the converted document. */
+  number: number;
+  /** Line text after per-line truncation. */
+  text: string;
+}
+//#endregion
+//#region src/tool.d.ts
+/** Deployment bounds after defaulting (see `Config` in index.ts). */
+interface ReadDocumentCaps {
+  /** Inclusive byte cap on the source file; larger files are refused before conversion. */
+  maxInputBytes: number;
+  /** Default and maximum number of lines returned by one call. */
+  readLimit: number;
+  /** Maximum characters returned for a single line. */
+  maxLineLength: number;
+  /** Maximum bytes of line text returned by one call. */
+  maxOutputBytes: number;
+  /** Maximum distinct PDF pages one `pages` selection may name. */
+  pdfMaxPages: number;
+}
+/** Canonical value of one successful call. */
+interface ReadDocumentOutcome {
+  path: string;
+  format: DocumentFormat;
+  offset: number;
+  lines: WindowLine[];
+  totalLines: number;
+  truncatedByBytes: boolean;
+  /** PDF facts; absent for other formats. */
+  pdf?: PdfFacts;
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "document-tools";
+declare const inject: string[];
+/** Default inclusive byte cap on a source document. */
+declare const DEFAULT_MAX_INPUT_BYTES: number;
+/** Default and maximum lines per call. */
+declare const DEFAULT_READ_LIMIT = 2000;
+/** Default per-line character cap. */
+declare const DEFAULT_MAX_LINE_LENGTH = 2000;
+/** Default byte cap on returned line text per call. */
+declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+/** Default cap on distinct pages one PDF `pages` selection may name. */
+declare const DEFAULT_PDF_MAX_PAGES = 100;
+/** PDF Markdown profiles the engine offers. */
+type PdfProfile = 'fidelity' | 'compact';
+/**
+ * Deployment-owned bounds and choices. Every field is optional on the input
+ * side because the schema fills defaults; `apply` receives the resolved record.
+ */
+interface Config {
+  /** Inclusive byte cap on the source file; larger files are refused before conversion. */
+  maxInputBytes?: number;
+  /** Default and maximum number of Markdown lines returned by one call. */
+  readLimit?: number;
+  /** Maximum characters returned for a single line; overflow is cut with a marker. */
+  maxLineLength?: number;
+  /** Maximum bytes of line text returned by one call. */
+  maxOutputBytes?: number;
+  /** Maximum distinct pages one PDF `pages` selection may name. */
+  pdfMaxPages?: number;
+  /** PDF Markdown profile: `fidelity` keeps source structure, `compact` spends fewer tokens. */
+  pdfProfile?: PdfProfile;
+}
+declare const Config: Schema<Config>;
+/**
+ * Register `read_document` over the anydoc and pdf-inspector engines.
+ * @param ctx - context carrying the tool registry, filesystem seam, and system-prompt registry.
+ * @param rawConfig - schema-validated bounds after defaulting.
+ */
+declare function apply(ctx: Context, rawConfig: Config): void;
+//#endregion
+export { Config, type ConversionErrorCode, type ConvertRequest, type ConvertResult, DEFAULT_MAX_INPUT_BYTES, DEFAULT_MAX_LINE_LENGTH, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_PDF_MAX_PAGES, DEFAULT_READ_LIMIT, DOCUMENT_EXTENSIONS, DOCUMENT_FORMATS, DocumentConversionError, type DocumentConverter, type DocumentFormat, type PdfFacts, type PdfInspectorOptions, type PdfKind, PdfProfile, type ReadDocumentCaps, type ReadDocumentOutcome, anydocConverter, apply, formatOf, inject, name, pdfInspectorConverter, routeConverters };

package/lib/index.js

@@ -0,0 +1,613 @@
+import Schema from "@deepseek-ai/schemastery";
+import { formatFromPath, toMarkdownBytes } from "@firecrawl/anydoc";
+import { Worker } from "node:worker_threads";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/converter.ts
+/**
+* Document-to-Markdown conversion behind one small interface, plus the
+* format router the tool uses. Engines: `@firecrawl/anydoc` for every
+* office format (local Rust napi) and `@firecrawl/pdf-inspector` (WASM in a
+* worker thread) for PDF, where page selection and scanned-page facts matter.
+* @module @jiaoqsh/dsh-document/converter
+*/
+/** Formats the engines convert; the value doubles as the model-visible `format` field. */
+const DOCUMENT_FORMATS = [
+	"doc",
+	"docx",
+	"odt",
+	"pdf",
+	"ppt",
+	"pptx",
+	"rtf",
+	"epub",
+	"xlsx",
+	"ods",
+	"odp",
+	"csv"
+];
+/** File extensions (lowercase, no dot) that map to a {@link DocumentFormat}. */
+const DOCUMENT_EXTENSIONS = [
+	"pdf",
+	"doc",
+	"docm",
+	"docx",
+	"ppt",
+	"pps",
+	"pot",
+	"pptx",
+	"pptm",
+	"ppsx",
+	"ppsm",
+	"xls",
+	"xlsx",
+	"xlsm",
+	"xlsb",
+	"odt",
+	"ods",
+	"odp",
+	"rtf",
+	"epub",
+	"csv"
+];
+/** A conversion failure with a stable code for callers and a model-readable message. */
+var DocumentConversionError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "DocumentConversionError";
+		this.code = code;
+	}
+};
+const FORMAT_SET = new Set(DOCUMENT_FORMATS);
+const ANYDOC_CODES = /* @__PURE__ */ new Set([
+	"unsupported",
+	"malformed",
+	"encrypted",
+	"resourceLimit",
+	"missingPart",
+	"io"
+]);
+/**
+* Map a file path to its document format by extension, case-insensitively.
+* @param path - any path; only the extension is inspected.
+* @returns the format, or `undefined` for an extension no engine handles.
+*/
+function formatOf(path) {
+	const format = formatFromPath(path);
+	return format !== null && FORMAT_SET.has(format) ? format : void 0;
+}
+/**
+* Pick the engine for a format: the first converter that lists it.
+* @param converters - engines in priority order.
+* @returns a lookup that throws for a format no engine lists.
+*/
+function routeConverters(converters) {
+	return (format) => {
+		const converter = converters.find((candidate) => candidate.formats.includes(format));
+		if (converter === void 0) throw new Error(`document-tools: no engine converts ${format}`);
+		return converter;
+	};
+}
+function anydocError(error) {
+	const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+	return new DocumentConversionError(error instanceof Error ? error.message : String(error), ANYDOC_CODES.has(code) ? code : "unknown");
+}
+/**
+* The anydoc engine: pure local conversion on the libuv thread pool. It lists
+* every format, so it is the last-resort engine behind any specialized one.
+* @returns the converter.
+*/
+function anydocConverter() {
+	return {
+		name: "anydoc",
+		formats: DOCUMENT_FORMATS,
+		async convert({ bytes, format, signal }) {
+			signal.throwIfAborted();
+			let markdown;
+			try {
+				markdown = await toMarkdownBytes(bytes, format);
+			} catch (error) {
+				throw anydocError(error);
+			}
+			if (markdown.trim().length === 0) throw new DocumentConversionError("the document contains no extractable text", "empty");
+			return { markdown };
+		}
+	};
+}
+//#endregion
+//#region src/pdf-inspector.ts
+/**
+* The pdf-inspector engine: PDF → Markdown with page selection, page markers,
+* and scanned-page facts. Each conversion runs in a fresh worker thread so a
+* large document never blocks the harness event loop, and cancellation
+* terminates the worker.
+* @module @jiaoqsh/dsh-document/pdf-inspector
+*/
+const KIND = {
+	TextBased: "text",
+	Scanned: "scanned",
+	ImageBased: "image",
+	Mixed: "mixed"
+};
+const WORKER_IS_SOURCE = import.meta.url.endsWith(".ts");
+const WORKER_URL = new URL(WORKER_IS_SOURCE ? "pdf-worker.ts" : "pdf-worker.js", import.meta.url);
+const WORKER_EXEC_ARGV = WORKER_IS_SOURCE ? [
+	...process.execArgv,
+	"--experimental-strip-types",
+	"--no-warnings"
+] : void 0;
+/** Classify an engine failure message; the engine reports plain strings, not codes. */
+function engineError(message) {
+	const text = message.replace(/^process PDF: /u, "");
+	const lower = text.toLowerCase();
+	if (lower.includes("not a pdf") || lower.includes("malformed") || lower.includes("invalid")) return new DocumentConversionError(text, "malformed");
+	if (lower.includes("encrypt") || lower.includes("password")) return new DocumentConversionError(text, "encrypted");
+	return new DocumentConversionError(text, "unknown");
+}
+/**
+* Run one conversion in a worker and settle with its reply.
+* @param request - bytes, pages, and profile for the worker.
+* @param signal - terminates the worker when it fires.
+* @returns the worker's facts and Markdown.
+*/
+function runPdfWorker(request, signal) {
+	return new Promise((resolve, reject) => {
+		const worker = new Worker(WORKER_URL, {
+			workerData: request,
+			...WORKER_EXEC_ARGV === void 0 ? {} : { execArgv: WORKER_EXEC_ARGV }
+		});
+		let settled = false;
+		const settle = (outcome) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			worker.terminate();
+			outcome();
+		};
+		const onAbort = () => settle(() => reject(new DocumentConversionError("the conversion was cancelled", "aborted")));
+		signal.addEventListener("abort", onAbort, { once: true });
+		worker.once("message", (reply) => settle(() => {
+			if (reply.ok) resolve(reply.result);
+			else reject(engineError(reply.message));
+		}));
+		worker.once("error", (error) => settle(() => reject(new DocumentConversionError(error.message, "unknown"))));
+		worker.once("exit", (code) => settle(() => reject(new DocumentConversionError(`the PDF worker exited with code ${code} before replying`, "unknown"))));
+	});
+}
+function formatPages(pages) {
+	const sorted = [...pages].sort((a, b) => a - b);
+	const parts = [];
+	for (let i = 0; i < sorted.length;) {
+		let j = i;
+		while (j + 1 < sorted.length && sorted[j + 1] === sorted[j] + 1) j += 1;
+		parts.push(j === i ? `${sorted[i]}` : `${sorted[i]}-${sorted[j]}`);
+		i = j + 1;
+	}
+	return parts.join(", ");
+}
+/**
+* Build the PDF engine.
+* @param options - deployment choices.
+* @returns a converter that handles only `pdf`.
+*/
+function pdfInspectorConverter(options) {
+	return {
+		name: "pdf-inspector",
+		formats: ["pdf"],
+		async convert({ bytes, pages, signal }) {
+			if (signal.aborted) throw new DocumentConversionError("the conversion was cancelled", "aborted");
+			const raw = await runPdfWorker({
+				bytes,
+				profile: options.profile,
+				...pages === void 0 ? {} : { pages: [...pages] }
+			}, signal);
+			if (pages !== void 0) {
+				const beyond = pages.filter((page) => page > raw.pageCount);
+				if (beyond.length > 0) throw new DocumentConversionError(`the document has ${raw.pageCount} page${raw.pageCount === 1 ? "" : "s"}; requested page${beyond.length === 1 ? "" : "s"} ${formatPages(beyond)} ${beyond.length === 1 ? "does" : "do"} not exist`, "pageRange");
+			}
+			const kind = KIND[raw.pdfType];
+			if (raw.markdown.trim().length === 0) {
+				const plural = pages === void 0 ? raw.pageCount !== 1 : pages.length !== 1;
+				const scope = pages === void 0 ? `all ${raw.pageCount} page${plural ? "s" : ""}` : `the requested page${plural ? "s" : ""} (${formatPages(pages)})`;
+				const verb = plural ? "contain" : "contains";
+				if (kind === "scanned" || kind === "image") throw new DocumentConversionError(`${scope} ${verb} no extractable text: this is ${kind === "image" ? "an image-only" : "a scanned"} PDF and needs OCR`, "scanned");
+				if (raw.pagesNeedingOcr.length > 0) throw new DocumentConversionError(`${scope} ${verb} no extractable text (pages needing OCR: ${formatPages(raw.pagesNeedingOcr)})`, "scanned");
+				throw new DocumentConversionError("the document contains no extractable text", "empty");
+			}
+			return {
+				markdown: raw.markdown,
+				pdf: {
+					pageCount: raw.pageCount,
+					kind,
+					pagesNeedingOcr: raw.pagesNeedingOcr,
+					...pages === void 0 ? {} : { pages: [...pages] },
+					...raw.title === void 0 ? {} : { title: raw.title }
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/pages.ts
+/**
+* The `pages` argument grammar: comma-separated 1-based page numbers and
+* inclusive ranges, e.g. `"1-3,7,10-12"`.
+* @module @jiaoqsh/dsh-document/pages
+*/
+const TOKEN = /^(\d+)(?:-(\d+))?$/;
+/**
+* Parse a page selection into a sorted, de-duplicated list.
+* @param spec - the model-supplied text.
+* @param maxPages - the largest number of distinct pages one call may select.
+* @returns ascending 1-based page numbers.
+* @throws Error naming the offending token, or the count when it exceeds `maxPages`.
+*/
+function parsePages(spec, maxPages) {
+	const pages = /* @__PURE__ */ new Set();
+	for (const rawToken of spec.split(",")) {
+		const token = rawToken.trim();
+		const match = TOKEN.exec(token);
+		if (match === null) throw new Error(`pages must be comma-separated page numbers or ranges like "1-3,7", got "${token}"`);
+		const first = Number(match[1]);
+		const last = match[2] === void 0 ? first : Number(match[2]);
+		if (first < 1 || last < first) throw new Error(`pages contains an invalid range "${token}"`);
+		if (last - first + 1 > maxPages || pages.size + (last - first + 1) > maxPages) throw new Error(`pages selects more than ${maxPages} pages`);
+		for (let page = first; page <= last; page += 1) pages.add(page);
+	}
+	if (pages.size === 0) throw new Error("pages must select at least one page");
+	return [...pages].sort((a, b) => a - b);
+}
+//#endregion
+//#region src/window.ts
+const TRUNCATION_MARKER = "… [line truncated]";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: false });
+/**
+* Split converted text into lines: a trailing newline does not open an empty
+* final line, and empty text has zero lines.
+* @param text - the converted document.
+* @returns lines without their terminators; CRLF is normalized.
+*/
+function splitLines(text) {
+	if (text.length === 0) return [];
+	return (text.endsWith("\n") ? text.slice(0, -1) : text).split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+/** Cut a string to at most `maxBytes` UTF-8 bytes on a character boundary. */
+function cutToBytes(text, maxBytes) {
+	const bytes = encoder.encode(text);
+	if (bytes.byteLength <= maxBytes) return text;
+	let end = maxBytes;
+	while (end > 0 && (bytes[end] & 192) === 128) end -= 1;
+	return decoder.decode(bytes.subarray(0, end));
+}
+/**
+* Select one window of lines under every bound.
+* @param text - the converted document.
+* @param request - paging and bounds; callers validate that all are positive integers.
+* @returns the window; a first line larger than `maxBytes` is cut rather than dropped so
+*   the caller always makes progress.
+*/
+function windowLines(text, request) {
+	const all = splitLines(text);
+	const lines = [];
+	let bytes = 0;
+	let truncatedByBytes = false;
+	const last = Math.min(all.length, request.offset - 1 + request.limit);
+	for (let index = request.offset - 1; index < last; index += 1) {
+		let line = all[index];
+		if (line.length > request.maxLineLength) line = `${line.slice(0, request.maxLineLength)}${TRUNCATION_MARKER}`;
+		let size = encoder.encode(line).byteLength;
+		if (bytes + size > request.maxBytes) {
+			if (lines.length > 0) {
+				truncatedByBytes = true;
+				break;
+			}
+			line = cutToBytes(line, request.maxBytes);
+			size = encoder.encode(line).byteLength;
+			truncatedByBytes = true;
+		}
+		lines.push({
+			number: index + 1,
+			text: line
+		});
+		bytes += size;
+	}
+	return {
+		lines,
+		totalLines: all.length,
+		truncatedByBytes
+	};
+}
+//#endregion
+//#region src/tool.ts
+const EXTENSION_LIST = DOCUMENT_EXTENSIONS.map((ext) => `.${ext}`).join(", ");
+const PDF_KINDS = [
+	"text",
+	"scanned",
+	"image",
+	"mixed"
+];
+function parsePositiveInteger(value, name) {
+	if (!Number.isFinite(value) || !Number.isInteger(value) || value < 1) throw new Error(`${name} must be a positive integer`);
+	return value;
+}
+/**
+* Validate the constraints the schema DSL does not express.
+* @param args - schema-validated raw arguments.
+* @param caps - the deployment line cap and PDF page cap.
+* @returns validated input with `offset` defaulted to 1 and `limit` to the cap.
+*/
+function parseReadArgs(args, caps) {
+	if (args.file_path.trim().length === 0) throw new Error("file_path must be a non-empty string");
+	const offset = args.offset === void 0 ? 1 : parsePositiveInteger(args.offset, "offset");
+	const limit = args.limit === void 0 ? caps.readLimit : parsePositiveInteger(args.limit, "limit");
+	if (limit > caps.readLimit) throw new Error(`limit must be less than or equal to ${caps.readLimit}`);
+	const pages = args.pages === void 0 ? void 0 : parsePages(args.pages, caps.pdfMaxPages);
+	return {
+		filePath: args.file_path,
+		offset,
+		limit,
+		...pages === void 0 ? {} : { pages }
+	};
+}
+const KIND_LABEL = {
+	text: "text-based",
+	scanned: "scanned",
+	image: "image-only",
+	mixed: "mixed text and scanned pages"
+};
+/**
+* Model-facing text for one outcome: an envelope naming the path and format,
+* PDF facts when present, numbered lines, and a footer that says how to
+* continue.
+* @param outcome - the canonical value.
+* @returns the rendered text.
+*/
+function formatReadOutput(outcome) {
+	const endLine = outcome.lines.at(-1)?.number ?? Math.max(0, outcome.offset - 1);
+	let footer;
+	if (outcome.truncatedByBytes) footer = `(Output capped. Showing lines ${outcome.offset}-${endLine}. Use offset=${endLine + 1} to continue.)`;
+	else if (endLine < outcome.totalLines) footer = `(Showing lines ${outcome.offset}-${endLine} of ${outcome.totalLines}. Use offset=${endLine + 1} to continue.)`;
+	else footer = `(End of document - total ${outcome.totalLines} lines)`;
+	const body = outcome.lines.length > 0 ? `${outcome.lines.map((line) => `${line.number}: ${line.text}`).join("\n")}\n\n${footer}` : footer;
+	const head = [`<path>${outcome.path}</path>`, `<format>${outcome.format}</format>`];
+	if (outcome.pdf !== void 0) {
+		const { pageCount, kind, pages, pagesNeedingOcr, title } = outcome.pdf;
+		const shown = pages === void 0 ? "all pages" : `showing page${pages.length === 1 ? "" : "s"} ${formatPages(pages)}`;
+		head.push(`<pdf>${pageCount} page${pageCount === 1 ? "" : "s"}, ${KIND_LABEL[kind]}; ${shown}${title === void 0 ? "" : `; title: ${title}`}</pdf>`);
+		if (pagesNeedingOcr.length > 0) head.push(`<warning>Page${pagesNeedingOcr.length === 1 ? "" : "s"} ${formatPages(pagesNeedingOcr)} contain${pagesNeedingOcr.length === 1 ? "s" : ""} no extractable text (scanned or image content); ${pagesNeedingOcr.length === 1 ? "its" : "their"} content is missing below and would need OCR.</warning>`);
+	}
+	return `${head.join("\n")}\n<content>\n${body}\n</content>`;
+}
+/** Model-facing message for one conversion failure. */
+function describeFailure(displayPath, error) {
+	switch (error.code) {
+		case "encrypted": return `cannot read "${displayPath}": the document is encrypted; supply a decrypted copy`;
+		case "unsupported": return `cannot read "${displayPath}": ${error.message}`;
+		case "empty": return `cannot read "${displayPath}": ${error.message}`;
+		case "scanned": return `cannot read "${displayPath}": ${error.message}, which this tool does not perform`;
+		case "pageRange": return `cannot read "${displayPath}": ${error.message}`;
+		case "malformed":
+		case "missingPart": return `cannot read "${displayPath}": the file is damaged or incomplete (${error.message})`;
+		case "resourceLimit": return `cannot read "${displayPath}": the document exceeds the converter's internal safety limits (${error.message})`;
+		case "aborted": return `cannot read "${displayPath}": ${error.message}`;
+		case "io":
+		case "unknown": return `cannot read "${displayPath}": ${error.message}`;
+	}
+}
+/**
+* Register the `read_document` tool and its system-prompt guidance.
+* @param ctx - the plugin context; registrations are effects scoped to it.
+* @param converterFor - the format router over the mounted engines.
+* @param caps - resolved deployment bounds.
+*/
+function applyReadDocumentTool(ctx, converterFor, caps) {
+	ctx.systemPrompt.section({
+		name: "tool:read_document",
+		order: 100,
+		text: `Use the read_document tool — not read or shell commands — to inspect PDF, Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, and CSV files. It returns the document converted to line-numbered Markdown; use offset and limit to continue reading long documents. For a PDF, pass pages (for example "1-3,7") to read only those pages; page markers like <!-- Page 4 --> show where each page starts.`
+	});
+	ctx.tools.register(defineTool({
+		name: "read_document",
+		description: `Read a document file as Markdown: PDF, Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, and CSV files are converted to line-numbered Markdown text. Supported: ${EXTENSION_LIST}. Returns text only and writes no files. PDFs report page count, whether pages are scanned, and accept a pages selection; scanned or image-only pages are not OCRed. For plain text or source files use read; for images use read_image.`,
+		parameters: {
+			file_path: {
+				type: "string",
+				required: true,
+				description: "Path to the document, resolved by the filesystem backend; relative paths resolve against the session workspace."
+			},
+			offset: {
+				type: "number",
+				description: "1-based first line of the converted Markdown to return. Defaults to 1."
+			},
+			limit: {
+				type: "number",
+				description: `Maximum number of lines to return. Defaults to ${caps.readLimit}.`
+			},
+			pages: {
+				type: "string",
+				description: `PDF only: 1-based pages to convert, as numbers and ranges like "1-3,7" (at most ${caps.pdfMaxPages} pages). Defaults to every page.`
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					path: {
+						type: "string",
+						required: true
+					},
+					format: {
+						type: "string",
+						enum: [...DOCUMENT_FORMATS],
+						required: true
+					},
+					offset: {
+						type: "integer",
+						required: true
+					},
+					lines: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								number: {
+									type: "integer",
+									required: true
+								},
+								text: {
+									type: "string",
+									required: true
+								}
+							}
+						}
+					},
+					totalLines: {
+						type: "integer",
+						required: true
+					},
+					truncatedByBytes: {
+						type: "boolean",
+						required: true
+					},
+					pdf: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							pageCount: {
+								type: "integer",
+								required: true
+							},
+							kind: {
+								type: "string",
+								enum: [...PDF_KINDS],
+								required: true
+							},
+							pagesNeedingOcr: {
+								type: "array",
+								required: true,
+								items: { type: "integer" }
+							},
+							pages: {
+								type: "array",
+								items: { type: "integer" }
+							},
+							title: { type: "string" }
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: formatReadOutput(value)
+			}]
+		},
+		isConcurrencySafe: () => true,
+		async execute(args, exec) {
+			const input = parseReadArgs(args, caps);
+			const format = formatOf(input.filePath);
+			if (format === void 0) throw new Error(`cannot read "${input.filePath}": unsupported extension. Supported: ${EXTENSION_LIST}. For plain text or source files use the read tool.`);
+			if (input.pages !== void 0 && format !== "pdf") throw new Error(`pages applies to PDF files only; "${input.filePath}" is ${format}`);
+			const cwd = exec.agent?.session.header.cwd;
+			const target = await ctx.fs.resolve(input.filePath, {
+				...cwd === void 0 ? {} : { cwd },
+				signal: exec.signal
+			});
+			const info = await ctx.fs.stat(target, exec.signal);
+			if (info === void 0) throw new Error(`cannot read "${target.displayPath}": not found`);
+			if (info.type !== "file") throw new Error(`cannot read "${target.displayPath}": not a regular file`);
+			const bytes = await ctx.fs.readBytes(target, exec.signal, caps.maxInputBytes);
+			let converted;
+			try {
+				converted = await converterFor(format).convert({
+					bytes,
+					format,
+					signal: exec.signal,
+					...input.pages === void 0 ? {} : { pages: input.pages }
+				});
+			} catch (error) {
+				if (error instanceof DocumentConversionError) throw new Error(describeFailure(target.displayPath, error));
+				throw error;
+			}
+			const window = windowLines(converted.markdown, {
+				offset: input.offset,
+				limit: input.limit,
+				maxLineLength: caps.maxLineLength,
+				maxBytes: caps.maxOutputBytes
+			});
+			return {
+				path: target.displayPath,
+				format,
+				offset: input.offset,
+				lines: window.lines,
+				totalLines: window.totalLines,
+				truncatedByBytes: window.truncatedByBytes,
+				...converted.pdf === void 0 ? {} : { pdf: converted.pdf }
+			};
+		},
+		presentCall(args) {
+			const { offset, limit, pages } = args;
+			const window = pages !== void 0 && pages.length > 0 ? ` (pages ${pages})` : limit !== void 0 && limit > 0 ? ` (lines ${offset ?? 1} - ${(offset ?? 1) + limit - 1})` : offset !== void 0 ? ` (from line ${offset})` : "";
+			return {
+				card: "generic",
+				title: `Read ${args.file_path} as Markdown${window}`,
+				kind: "read",
+				locations: [{ path: args.file_path }]
+			};
+		}
+	}));
+}
+//#endregion
+//#region src/index.ts
+const name = "document-tools";
+const inject = [
+	"tools",
+	"fs",
+	"systemPrompt"
+];
+/** Default inclusive byte cap on a source document. */
+const DEFAULT_MAX_INPUT_BYTES = 52428800;
+/** Default and maximum lines per call. */
+const DEFAULT_READ_LIMIT = 2e3;
+/** Default per-line character cap. */
+const DEFAULT_MAX_LINE_LENGTH = 2e3;
+/** Default byte cap on returned line text per call. */
+const DEFAULT_MAX_OUTPUT_BYTES = 51200;
+/** Default cap on distinct pages one PDF `pages` selection may name. */
+const DEFAULT_PDF_MAX_PAGES = 100;
+const Config = Schema.object({
+	maxInputBytes: Schema.number().default(DEFAULT_MAX_INPUT_BYTES),
+	readLimit: Schema.number().default(DEFAULT_READ_LIMIT),
+	maxLineLength: Schema.number().default(DEFAULT_MAX_LINE_LENGTH),
+	maxOutputBytes: Schema.number().default(DEFAULT_MAX_OUTPUT_BYTES),
+	pdfMaxPages: Schema.number().default(100),
+	pdfProfile: Schema.union(["fidelity", "compact"]).default("fidelity")
+});
+function assertPositiveInteger(name, value) {
+	if (!Number.isInteger(value) || value < 1) throw new Error(`document-tools: ${name} must be a positive integer`);
+}
+/**
+* Register `read_document` over the anydoc and pdf-inspector engines.
+* @param ctx - context carrying the tool registry, filesystem seam, and system-prompt registry.
+* @param rawConfig - schema-validated bounds after defaulting.
+*/
+function apply(ctx, rawConfig) {
+	const config = rawConfig;
+	assertPositiveInteger("maxInputBytes", config.maxInputBytes);
+	assertPositiveInteger("readLimit", config.readLimit);
+	assertPositiveInteger("maxLineLength", config.maxLineLength);
+	assertPositiveInteger("maxOutputBytes", config.maxOutputBytes);
+	assertPositiveInteger("pdfMaxPages", config.pdfMaxPages);
+	applyReadDocumentTool(ctx, routeConverters([pdfInspectorConverter({ profile: config.pdfProfile }), anydocConverter()]), {
+		maxInputBytes: config.maxInputBytes,
+		readLimit: config.readLimit,
+		maxLineLength: config.maxLineLength,
+		maxOutputBytes: config.maxOutputBytes,
+		pdfMaxPages: config.pdfMaxPages
+	});
+}
+//#endregion
+export { Config, DEFAULT_MAX_INPUT_BYTES, DEFAULT_MAX_LINE_LENGTH, DEFAULT_MAX_OUTPUT_BYTES, DEFAULT_PDF_MAX_PAGES, DEFAULT_READ_LIMIT, DOCUMENT_EXTENSIONS, DOCUMENT_FORMATS, DocumentConversionError, anydocConverter, apply, formatOf, inject, name, pdfInspectorConverter, routeConverters };

package/lib/pdf-worker-CTqxWga-.d.ts

@@ -0,0 +1,28 @@
+import { MarkdownProfile } from "@firecrawl/pdf-inspector-wasm";
+//#region src/pdf-worker.d.ts
+/** What the parent posts as `workerData`. */
+interface PdfWorkerRequest {
+  bytes: Uint8Array;
+  /** 1-based pages to convert; absent means all. */
+  pages?: number[];
+  profile: MarkdownProfile;
+}
+/** The engine facts the parent needs; everything else stays in the worker. */
+interface PdfWorkerResult {
+  markdown: string;
+  pdfType: 'TextBased' | 'Scanned' | 'ImageBased' | 'Mixed';
+  pageCount: number;
+  /** 1-based. */
+  pagesNeedingOcr: number[];
+  title?: string;
+}
+/** Worker → parent message. */
+type PdfWorkerReply = {
+  ok: true;
+  result: PdfWorkerResult;
+} | {
+  ok: false;
+  message: string;
+};
+//#endregion
+export { PdfWorkerRequest as n, PdfWorkerResult as r, PdfWorkerReply as t };

package/lib/pdf-worker.d.ts

@@ -0,0 +1,2 @@
+import { n as PdfWorkerRequest, r as PdfWorkerResult, t as PdfWorkerReply } from "./pdf-worker-CTqxWga-.js";
+export { PdfWorkerReply, PdfWorkerRequest, PdfWorkerResult };

package/lib/pdf-worker.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { parentPort, workerData } from "node:worker_threads";
+import { readFileSync } from "node:fs";
+import { initSync, processPdf } from "@firecrawl/pdf-inspector-wasm";
+//#region src/pdf-worker.ts
+/**
+* Worker-thread entry for PDF conversion. Runs `@firecrawl/pdf-inspector`'s
+* WASM build, whose `processPdf` is synchronous, off the main event loop;
+* the parent terminates the worker to cancel. This module is executed by
+* Node directly (never bundled into the plugin entry), so it stays free of
+* TypeScript-only runtime syntax and imports nothing from the plugin.
+* @module @jiaoqsh/dsh-document/pdf-worker
+*/
+const require = createRequire(import.meta.url);
+function run(request) {
+	initSync({ module: readFileSync(require.resolve("@firecrawl/pdf-inspector-wasm/pdf_inspector_wasm_bg.wasm")) });
+	const result = processPdf(new Uint8Array(request.bytes), {
+		profile: request.profile,
+		includePageMarkers: true,
+		includeImages: false,
+		...request.pages === void 0 ? {} : { pages: request.pages }
+	});
+	return {
+		markdown: result.markdown ?? "",
+		pdfType: result.pdfType,
+		pageCount: result.pageCount,
+		pagesNeedingOcr: result.pagesNeedingOcr,
+		...result.title === void 0 ? {} : { title: result.title }
+	};
+}
+if (parentPort !== null) {
+	let reply;
+	try {
+		reply = {
+			ok: true,
+			result: run(workerData)
+		};
+	} catch (error) {
+		reply = {
+			ok: false,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+	parentPort.postMessage(reply);
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@jiaoqsh/dsh-document",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness bundle: the read_document tool reads Word, PowerPoint, Excel, OpenDocument, RTF, EPUB, CSV, and PDF files as Markdown for the model",
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "plugin",
+    "document",
+    "pdf",
+    "docx",
+    "markdown",
+    "anydoc"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "jiaoqsh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiaoqsh/dsh-document.git"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml"
+  ],
+  "engines": {
+    "node": ">=22.19"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepare": "tsdown",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "check": "pnpm run typecheck && pnpm run test && pnpm run build"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-fs": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-system-prompt": ">=0.1.0-rc.5",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.5"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@firecrawl/anydoc": "0.1.9",
+    "@firecrawl/pdf-inspector-wasm": "1.14.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-fs": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-fs-local": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@types/node": "^22.20.0",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}