@zeke-02/docx-editor-agents 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @zeke-02/docx-editor-agents
+ *
+ * Word-like API for AI document review.
+ *
+ * @example
+ * ```ts
+ * const reviewer = await DocxReviewer.fromBuffer(buffer, 'AI Reviewer');
+ *
+ * // Read
+ * const text = reviewer.getContentAsText();
+ *
+ * // Comment on a paragraph
+ * reviewer.addComment(5, 'Liability cap seems too low.');
+ *
+ * // Replace text (creates tracked change)
+ * reviewer.replace(5, '$50k', '$500k');
+ *
+ * // Or batch from LLM JSON response
+ * reviewer.applyReview({
+ *   comments: [{ paragraphIndex: 5, text: 'Too low.' }],
+ *   proposals: [{ paragraphIndex: 5, search: '$50k', replaceWith: '$500k' }],
+ * });
+ *
+ * const output = await reviewer.toBuffer();
+ * ```
+ *
+ * @packageDocumentation
+ * @public
+ */
+import { G as GetContentOptions, C as ContentBlock, a as CommentFilter, R as ReviewComment, b as ChangeFilter, c as ReviewChange, F as FoundMatch, S as SelectionInfo, A as AddCommentByParaIdOptions, d as ReplyOptions, P as ProposeChangeOptions, e as ApplyFormattingOptions, f as SetParagraphStyleOptions, g as PageContent, h as ContentChangeEvent, i as SelectionChangeEvent } from './server-uWvnaIh-.js';
+export { j as AgentToolDefinition, k as AgentToolResult, B as BatchError, l as BatchResult, m as BatchReviewOptions, D as DocxReviewer, n as agentTools, o as createReviewerBridge, p as executeToolCall, q as getToolSchemas } from './server-uWvnaIh-.js';
+import '@zeke-02/docx-editor-core/headless';
+
+/**
+ * Error classes for @zeke-02/docx-editor-agents
+ */
+declare class TextNotFoundError extends Error {
+    constructor(search: string, paragraphIndex?: number);
+}
+declare class ChangeNotFoundError extends Error {
+    constructor(id: number);
+}
+declare class CommentNotFoundError extends Error {
+    constructor(id: number);
+}
+
+/**
+ * Formal Word JS API parity contract.
+ *
+ * This file declares what subset of Microsoft Word's Office.js JavaScript API
+ * (https://learn.microsoft.com/en-us/javascript/api/word) we mirror, **at the
+ * type level**. It is checked at compile time: `EditorBridge` must satisfy
+ * `WordCompatBridge` (verified via the static assertion at the bottom).
+ *
+ * The assertion is the source of truth. If you change the bridge surface and
+ * forget to update parity, typecheck breaks.
+ *
+ * ## What we mirror (✓)
+ *
+ * | Word JS API                         | Our equivalent                        |
+ * | ----------------------------------- | ------------------------------------- |
+ * | `Range` (stable handle)             | `paraId: string`                      |
+ * | `body.search(text)` → Ranges        | `findText(query, opts) → FoundMatch[]`|
+ * | `range.insertComment(text)`         | `addComment({paraId, text, search?})` |
+ * | `comment.reply(text)`               | `replyTo(commentId, {text})`          |
+ * | `comment.resolved = true`           | `resolveComment(commentId)`           |
+ * | `range.insertText(text, location)`  | `proposeChange({paraId, search, replaceWith})` (3 modes via empty-string semantics) |
+ * | `document.getSelection()`           | `getSelection() → SelectionInfo|null` |
+ * | `range.scrollIntoView()`            | `scrollTo(paraId)`                    |
+ * | `commentCollection.getItems()`      | `getComments(filter?)`                |
+ * | `body.paragraphs.getItems()`        | `getContent(opts?)`                   |
+ * | `document.body.text`                | `getContentAsText(opts?)`             |
+ * | `revisionCollection.getItems()`     | `getChanges(filter?)`                 |
+ * | `Document.onContentChanged.add(...)`| `onContentChange(listener)`           |
+ * | `Document.onSelectionChanged.add()` | `onSelectionChange(listener)`         |
+ * | `Range.font.bold` / `italic` / `color` / `size` / `name` | `applyFormatting({paraId, search?, marks})` |
+ * | `ParagraphFormat.style` / `applyStyle(...)` | `setParagraphStyle({paraId, styleId})` |
+ *
+ * ## Beyond Word's surface (paged-document affordances)
+ *
+ *  - `getPage(n)` / `getPages({from, to})` / `getTotalPages()` — Word's JS API
+ *    doesn't model pages as first-class addressable units. We do, because the
+ *    editor is paged. Backed by the layout-painter's page boundary state.
+ *
+ * ## Differences (intentional, documented)
+ *
+ *  - All "insertText" overloads collapse into `proposeChange` with empty-string
+ *    semantics: replaceWith="" deletes; search="" inserts at paragraph end;
+ *    both non-empty replaces. Word has separate `insertText(...,'Replace')`,
+ *    `insertText(...,'Before')`, etc.; we found three modes were enough and
+ *    serialize cleaner for LLM tool calls.
+ *  - Tracked changes are always *suggestions* in our world. Word lets the
+ *    range mutate directly; we always go through the tracked-change path so
+ *    the human keeps the final say. (This matches the agent UX.)
+ *  - Word's `Range.context.sync()` is unnecessary — every call is one PM
+ *    transaction.
+ *  - Word's `Range` is a stateful object. Ours is a plain `{paraId, search?}`
+ *    JSON value, so it survives JSON.stringify and works for tool calls / MCP.
+ *
+ * ## Out of scope (gaps we deliberately don't implement)
+ *
+ *  - Paragraph creation (`body.insertParagraph`). Out of scope for v1.
+ *  - Table mutation (insert row/col, delete cell). Read-only.
+ *  - Headers / footers / sections.
+ *  - `Range.getOoxml()` / `getHtml()`. Plain text only.
+ *  - `customXmlParts` / `contentControls`.
+ *  - Accept / reject tracked changes. Human-only by design.
+ *
+ * Future versions can grow these by extending this interface — typecheck
+ * will then enforce the new contract.
+ */
+
+/**
+ * The formal Word-JS-API parity surface. Each method maps to one or more
+ * Word API methods (named in the JSDoc above each member).
+ *
+ * If you change the EditorBridge surface, this interface must change too —
+ * the static assertion at the bottom of the file enforces it.
+ */
+interface WordCompatBridge {
+    /** Word: `document.body.text` (stringified, indexed lines). */
+    getContentAsText(options?: GetContentOptions): string;
+    /** Word: `body.paragraphs.getItems()`. */
+    getContent(options?: GetContentOptions): ContentBlock[];
+    /** Word: `commentCollection.getItems()`. */
+    getComments(filter?: CommentFilter): ReviewComment[];
+    /** Word: `revisionCollection.getItems()`. */
+    getChanges(filter?: ChangeFilter): ReviewChange[];
+    /** Word: `body.search(text)` returning Range[]. */
+    findText(query: string, options?: {
+        caseSensitive?: boolean;
+        limit?: number;
+    }): FoundMatch[];
+    /** Word: `document.getSelection()`. */
+    getSelection(): SelectionInfo | null;
+    /** Word: `range.insertComment(text)`. Anchored by paraId (Range handle). */
+    addComment(options: AddCommentByParaIdOptions): number | null;
+    /** Word: `comment.reply(text)`. */
+    replyTo(commentId: number, options: ReplyOptions): number | null;
+    /** Word: `comment.resolved = true`. */
+    resolveComment(commentId: number): void;
+    /**
+     * Word: `range.insertText(text, location)` collapsed into one verb.
+     *  - replacement: search non-empty, replaceWith non-empty
+     *  - deletion:    search non-empty, replaceWith ""
+     *  - insertion:   search "",        replaceWith non-empty (paragraph end)
+     */
+    proposeChange(options: ProposeChangeOptions): boolean;
+    /**
+     * Word: `range.font.bold = true` / `range.font.italic = true` / etc.
+     * Applied to a paragraph or to a unique phrase within it. Direct edit,
+     * not a tracked change.
+     */
+    applyFormatting(options: ApplyFormattingOptions): boolean;
+    /** Word: `paragraph.styleBuiltIn = ...` / `paragraph.style = 'Heading 1'`. */
+    setParagraphStyle(options: SetParagraphStyleOptions): boolean;
+    /**
+     * Read one rendered page (1-indexed). Word's JS API does not expose pages
+     * as first-class objects; we do because the editor is paged.
+     */
+    getPage(pageNumber: number): PageContent | null;
+    /** Read a range of rendered pages (1-indexed, inclusive). */
+    getPages(options: {
+        from: number;
+        to: number;
+    }): PageContent[];
+    /** Total number of pages currently rendered. */
+    getTotalPages(): number;
+    /** Word: `range.scrollIntoView()`. */
+    scrollTo(paraId: string): boolean;
+    /** Word: `Document.onContentChanged.add(handler)`. Returns unsubscribe. */
+    onContentChange(listener: (event: ContentChangeEvent) => void): () => void;
+    /** Word: `Document.onSelectionChanged.add(handler)`. Returns unsubscribe. */
+    onSelectionChange(listener: (event: SelectionChangeEvent) => void): () => void;
+}
+
+export { ChangeNotFoundError, CommentNotFoundError, ContentBlock, GetContentOptions, ReviewChange, ReviewComment, TextNotFoundError, type WordCompatBridge };

package/dist/index.js

@@ -0,0 +1 @@
+'use strict';var chunkVXAJD6QK_js=require('./chunk-VXAJD6QK.js'),chunk2RGRAPLW_js=require('./chunk-2RGRAPLW.js'),chunkRI5S75JY_js=require('./chunk-RI5S75JY.js');Object.defineProperty(exports,"DocxReviewer",{enumerable:true,get:function(){return chunkVXAJD6QK_js.a}});Object.defineProperty(exports,"ChangeNotFoundError",{enumerable:true,get:function(){return chunk2RGRAPLW_js.g}});Object.defineProperty(exports,"CommentNotFoundError",{enumerable:true,get:function(){return chunk2RGRAPLW_js.h}});Object.defineProperty(exports,"TextNotFoundError",{enumerable:true,get:function(){return chunk2RGRAPLW_js.f}});Object.defineProperty(exports,"createReviewerBridge",{enumerable:true,get:function(){return chunk2RGRAPLW_js.m}});Object.defineProperty(exports,"agentTools",{enumerable:true,get:function(){return chunkRI5S75JY_js.a}});Object.defineProperty(exports,"executeToolCall",{enumerable:true,get:function(){return chunkRI5S75JY_js.b}});Object.defineProperty(exports,"getToolSchemas",{enumerable:true,get:function(){return chunkRI5S75JY_js.d}});

package/dist/index.mjs

@@ -0,0 +1 @@
+export{a as DocxReviewer}from'./chunk-UNUH3LRU.mjs';export{g as ChangeNotFoundError,h as CommentNotFoundError,f as TextNotFoundError,m as createReviewerBridge}from'./chunk-AU3KR5IN.mjs';export{a as agentTools,b as executeToolCall,d as getToolSchemas}from'./chunk-24MVJKCP.mjs';

package/dist/mcp.d.mts

@@ -0,0 +1,200 @@
+/**
+ * @zeke-02/docx-editor-agents/mcp
+ *
+ * Model Context Protocol (MCP) server for the docx editor agent bridge.
+ *
+ * Two transports, same core:
+ *   - `stdio`: classic MCP transport. Use `runStdioServer(bridge)` from a
+ *     Node subprocess that Claude Desktop, Cursor, or any MCP-aware client
+ *     will spawn. Newline-delimited JSON-RPC.
+ *   - `direct`: call `new McpServer(bridge).handle(message)` if you have
+ *     your own transport (WebSocket, `postMessage`, HTTP long-poll, etc.).
+ *
+ * The server is transport-agnostic and zero-dep. The stdio module reaches
+ * for `process.stdin` / `process.stdout` only when you call
+ * `runStdioServer` without explicit streams.
+ *
+ * @packageDocumentation
+ * @public
+ */
+import { E as EditorBridge } from './server-uWvnaIh-.mjs';
+import '@zeke-02/docx-editor-core/headless';
+
+/**
+ * MCP wire protocol (subset) — JSON-RPC 2.0 framing + the message types we
+ * actually implement. Zero dependencies. Pure functions; everything is unit-
+ * testable without a transport.
+ *
+ * This is NOT a full MCP SDK. We implement only what the server needs:
+ *   - initialize / initialized
+ *   - tools/list
+ *   - tools/call
+ *   - notifications/cancelled (no-op, accepted)
+ *
+ * Spec reference: https://spec.modelcontextprotocol.io
+ */
+type JsonRpcId = string | number | null;
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcSuccess {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    result: unknown;
+}
+interface JsonRpcError {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+type JsonRpcResponse = JsonRpcSuccess | JsonRpcError;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+/** Standard JSON-RPC error codes. We only ever emit JSON-RPC errors for
+ * protocol-level problems; tool execution failures use MCP's `isError`
+ * envelope inside a successful response, per spec. */
+declare const ErrorCode: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+};
+interface McpInitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: Record<string, unknown>;
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+interface McpToolsListResult {
+    tools: McpToolDescriptor[];
+}
+interface McpToolsCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface McpContent {
+    type: 'text';
+    text: string;
+}
+interface McpToolsCallResult {
+    content: McpContent[];
+    isError?: boolean;
+}
+declare function isJsonRpcRequest(m: unknown): m is JsonRpcRequest;
+declare function isJsonRpcNotification(m: unknown): m is JsonRpcNotification;
+declare function makeSuccess(id: JsonRpcId, result: unknown): JsonRpcSuccess;
+declare function makeError(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcError;
+interface ParseResult {
+    /** Parsed messages. */
+    messages: JsonRpcMessage[];
+    /** Lines that failed to parse — caller should send a ParseError per line if it had a discernible id. */
+    parseErrors: string[];
+    /** Remaining buffer (no trailing newline yet). */
+    rest: string;
+}
+/**
+ * Parse newline-delimited JSON-RPC frames out of a buffer. Returns parsed
+ * messages plus any leftover bytes. Tolerates blank lines.
+ */
+declare function parseFrames(buffer: string): ParseResult;
+/** Encode a JSON-RPC message as a single newline-terminated frame. */
+declare function encodeFrame(message: JsonRpcMessage): string;
+
+/**
+ * MCP server core. Transport-agnostic — accepts a JsonRpcRequest, returns
+ * either a JsonRpcResponse or `null` (for notifications, which never reply).
+ *
+ * Wraps an EditorBridge: tools/list returns the bridge's tool schemas in MCP
+ * shape; tools/call dispatches via executeToolCall and converts the
+ * AgentToolResult into MCP CallToolResult content.
+ */
+
+interface McpServerOptions {
+    /** Server name reported in `initialize` response. Default: `@zeke-02/docx-editor-agents`. */
+    name?: string;
+    /** Server version. Default: `0.0.0` (override at build time). */
+    version?: string;
+    /** MCP protocol version we claim to speak. Default: `2025-06-18`. */
+    protocolVersion?: string;
+}
+declare class McpServer {
+    private readonly bridge;
+    private readonly opts;
+    constructor(bridge: EditorBridge, options?: McpServerOptions);
+    /**
+     * Handle one inbound message. Returns the response to send back, or `null`
+     * for notifications and other no-reply messages. Never throws.
+     */
+    handle(message: JsonRpcMessage): JsonRpcResponse | null;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+}
+
+/**
+ * Stdio transport for the MCP server. Reads newline-delimited JSON-RPC from
+ * an input stream, dispatches via McpServer, writes responses to an output
+ * stream. Pure stream handling — no Node-only assumptions beyond "Readable
+ * has .on('data') and Writable has .write".
+ *
+ * For real Node usage:
+ *   import { runStdioServer } from '@zeke-02/docx-editor-agents/mcp';
+ *   runStdioServer(bridge);
+ *
+ * For tests, pass any EventEmitter-shaped Readable + a function-shaped
+ * Writable; see __tests__/mcp/stdio.test.ts.
+ */
+
+/** Minimal duck-typed input stream — anything with `on('data', cb)` works. */
+interface InputStream {
+    on(event: 'data', listener: (chunk: Buffer | string) => void): unknown;
+    on(event: 'end', listener: () => void): unknown;
+    on(event: 'error', listener: (err: Error) => void): unknown;
+}
+/** Minimal duck-typed output stream — anything with a `write(string) => bool` works. */
+interface OutputStream {
+    write(chunk: string): boolean | void;
+}
+interface StdioServerOptions extends McpServerOptions {
+    input?: InputStream;
+    output?: OutputStream;
+    /** Called with diagnostic strings (e.g. parse errors). Default: stderr. */
+    log?: (msg: string) => void;
+}
+interface StdioServerHandle {
+    /** Underlying server (for tests / introspection). */
+    server: McpServer;
+    /** Manually feed a raw chunk (used by tests; the live transport calls this internally). */
+    feed: (chunk: string | Buffer) => void;
+    /** Stop accepting input and reject further writes. Idempotent. */
+    close: () => void;
+}
+/**
+ * Wire an EditorBridge to a JSON-RPC stdio loop. Returns immediately; reading
+ * happens via the stream listeners. Designed to be testable: pass in fake
+ * streams, call `feed(...)` directly, then assert on what was written.
+ */
+declare function runStdioServer(bridge: EditorBridge, options?: StdioServerOptions): StdioServerHandle;
+
+export { ErrorCode, type JsonRpcError, type JsonRpcId, type JsonRpcMessage, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcSuccess, type McpContent, type McpInitializeResult, McpServer, type McpServerOptions, type McpToolDescriptor, type McpToolsCallParams, type McpToolsCallResult, type McpToolsListResult, type StdioServerHandle, type StdioServerOptions, encodeFrame, isJsonRpcNotification, isJsonRpcRequest, makeError, makeSuccess, parseFrames, runStdioServer };

package/dist/mcp.d.ts

@@ -0,0 +1,200 @@
+/**
+ * @zeke-02/docx-editor-agents/mcp
+ *
+ * Model Context Protocol (MCP) server for the docx editor agent bridge.
+ *
+ * Two transports, same core:
+ *   - `stdio`: classic MCP transport. Use `runStdioServer(bridge)` from a
+ *     Node subprocess that Claude Desktop, Cursor, or any MCP-aware client
+ *     will spawn. Newline-delimited JSON-RPC.
+ *   - `direct`: call `new McpServer(bridge).handle(message)` if you have
+ *     your own transport (WebSocket, `postMessage`, HTTP long-poll, etc.).
+ *
+ * The server is transport-agnostic and zero-dep. The stdio module reaches
+ * for `process.stdin` / `process.stdout` only when you call
+ * `runStdioServer` without explicit streams.
+ *
+ * @packageDocumentation
+ * @public
+ */
+import { E as EditorBridge } from './server-uWvnaIh-.js';
+import '@zeke-02/docx-editor-core/headless';
+
+/**
+ * MCP wire protocol (subset) — JSON-RPC 2.0 framing + the message types we
+ * actually implement. Zero dependencies. Pure functions; everything is unit-
+ * testable without a transport.
+ *
+ * This is NOT a full MCP SDK. We implement only what the server needs:
+ *   - initialize / initialized
+ *   - tools/list
+ *   - tools/call
+ *   - notifications/cancelled (no-op, accepted)
+ *
+ * Spec reference: https://spec.modelcontextprotocol.io
+ */
+type JsonRpcId = string | number | null;
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcSuccess {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    result: unknown;
+}
+interface JsonRpcError {
+    jsonrpc: '2.0';
+    id: JsonRpcId;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+type JsonRpcResponse = JsonRpcSuccess | JsonRpcError;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
+/** Standard JSON-RPC error codes. We only ever emit JSON-RPC errors for
+ * protocol-level problems; tool execution failures use MCP's `isError`
+ * envelope inside a successful response, per spec. */
+declare const ErrorCode: {
+    readonly ParseError: -32700;
+    readonly InvalidRequest: -32600;
+    readonly MethodNotFound: -32601;
+    readonly InvalidParams: -32602;
+    readonly InternalError: -32603;
+};
+interface McpInitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: Record<string, unknown>;
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+interface McpToolsListResult {
+    tools: McpToolDescriptor[];
+}
+interface McpToolsCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface McpContent {
+    type: 'text';
+    text: string;
+}
+interface McpToolsCallResult {
+    content: McpContent[];
+    isError?: boolean;
+}
+declare function isJsonRpcRequest(m: unknown): m is JsonRpcRequest;
+declare function isJsonRpcNotification(m: unknown): m is JsonRpcNotification;
+declare function makeSuccess(id: JsonRpcId, result: unknown): JsonRpcSuccess;
+declare function makeError(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcError;
+interface ParseResult {
+    /** Parsed messages. */
+    messages: JsonRpcMessage[];
+    /** Lines that failed to parse — caller should send a ParseError per line if it had a discernible id. */
+    parseErrors: string[];
+    /** Remaining buffer (no trailing newline yet). */
+    rest: string;
+}
+/**
+ * Parse newline-delimited JSON-RPC frames out of a buffer. Returns parsed
+ * messages plus any leftover bytes. Tolerates blank lines.
+ */
+declare function parseFrames(buffer: string): ParseResult;
+/** Encode a JSON-RPC message as a single newline-terminated frame. */
+declare function encodeFrame(message: JsonRpcMessage): string;
+
+/**
+ * MCP server core. Transport-agnostic — accepts a JsonRpcRequest, returns
+ * either a JsonRpcResponse or `null` (for notifications, which never reply).
+ *
+ * Wraps an EditorBridge: tools/list returns the bridge's tool schemas in MCP
+ * shape; tools/call dispatches via executeToolCall and converts the
+ * AgentToolResult into MCP CallToolResult content.
+ */
+
+interface McpServerOptions {
+    /** Server name reported in `initialize` response. Default: `@zeke-02/docx-editor-agents`. */
+    name?: string;
+    /** Server version. Default: `0.0.0` (override at build time). */
+    version?: string;
+    /** MCP protocol version we claim to speak. Default: `2025-06-18`. */
+    protocolVersion?: string;
+}
+declare class McpServer {
+    private readonly bridge;
+    private readonly opts;
+    constructor(bridge: EditorBridge, options?: McpServerOptions);
+    /**
+     * Handle one inbound message. Returns the response to send back, or `null`
+     * for notifications and other no-reply messages. Never throws.
+     */
+    handle(message: JsonRpcMessage): JsonRpcResponse | null;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+}
+
+/**
+ * Stdio transport for the MCP server. Reads newline-delimited JSON-RPC from
+ * an input stream, dispatches via McpServer, writes responses to an output
+ * stream. Pure stream handling — no Node-only assumptions beyond "Readable
+ * has .on('data') and Writable has .write".
+ *
+ * For real Node usage:
+ *   import { runStdioServer } from '@zeke-02/docx-editor-agents/mcp';
+ *   runStdioServer(bridge);
+ *
+ * For tests, pass any EventEmitter-shaped Readable + a function-shaped
+ * Writable; see __tests__/mcp/stdio.test.ts.
+ */
+
+/** Minimal duck-typed input stream — anything with `on('data', cb)` works. */
+interface InputStream {
+    on(event: 'data', listener: (chunk: Buffer | string) => void): unknown;
+    on(event: 'end', listener: () => void): unknown;
+    on(event: 'error', listener: (err: Error) => void): unknown;
+}
+/** Minimal duck-typed output stream — anything with a `write(string) => bool` works. */
+interface OutputStream {
+    write(chunk: string): boolean | void;
+}
+interface StdioServerOptions extends McpServerOptions {
+    input?: InputStream;
+    output?: OutputStream;
+    /** Called with diagnostic strings (e.g. parse errors). Default: stderr. */
+    log?: (msg: string) => void;
+}
+interface StdioServerHandle {
+    /** Underlying server (for tests / introspection). */
+    server: McpServer;
+    /** Manually feed a raw chunk (used by tests; the live transport calls this internally). */
+    feed: (chunk: string | Buffer) => void;
+    /** Stop accepting input and reject further writes. Idempotent. */
+    close: () => void;
+}
+/**
+ * Wire an EditorBridge to a JSON-RPC stdio loop. Returns immediately; reading
+ * happens via the stream listeners. Designed to be testable: pass in fake
+ * streams, call `feed(...)` directly, then assert on what was written.
+ */
+declare function runStdioServer(bridge: EditorBridge, options?: StdioServerOptions): StdioServerHandle;
+
+export { ErrorCode, type JsonRpcError, type JsonRpcId, type JsonRpcMessage, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcSuccess, type McpContent, type McpInitializeResult, McpServer, type McpServerOptions, type McpToolDescriptor, type McpToolsCallParams, type McpToolsCallResult, type McpToolsListResult, type StdioServerHandle, type StdioServerOptions, encodeFrame, isJsonRpcNotification, isJsonRpcRequest, makeError, makeSuccess, parseFrames, runStdioServer };

package/dist/mcp.js

@@ -0,0 +1,4 @@
+'use strict';var chunkRI5S75JY_js=require('./chunk-RI5S75JY.js'),string_decoder=require('string_decoder');var i={ParseError:-32700,InvalidRequest:-32600,MethodNotFound:-32601,InvalidParams:-32602,InternalError:-32603};function v(t){return typeof t=="object"&&t!==null&&t.jsonrpc==="2.0"&&typeof t.method=="string"&&"id"in t}function I(t){return typeof t=="object"&&t!==null&&t.jsonrpc==="2.0"&&typeof t.method=="string"&&!("id"in t)}function u(t,r){return {jsonrpc:"2.0",id:t,result:r}}function p(t,r,e,o){return {jsonrpc:"2.0",id:t,error:o===void 0?{code:r,message:e}:{code:r,message:e,data:o}}}function y(t){let r=[],e=[],o=t.split(`
+`),n=o.pop()??"";for(let c of o){let a=c.trim();if(a)try{r.push(JSON.parse(a));}catch{e.push(a);}}return {messages:r,parseErrors:e,rest:n}}function d(t){return JSON.stringify(t)+`
+`}var T="2025-06-18",f=class{constructor(r,e={}){this.bridge=r,this.opts={name:e.name??"@zeke-02/docx-editor-agents",version:e.version??"0.0.0",protocolVersion:e.protocolVersion??T};}handle(r){if(!v(r))return null;let e=r;try{switch(e.method){case "initialize":return u(e.id,this.handleInitialize());case "tools/list":return u(e.id,this.handleToolsList());case "tools/call":return this.handleToolsCall(e);case "ping":return u(e.id,{});default:return p(e.id,i.MethodNotFound,`Method not found: ${e.method}`)}}catch(o){return p(e.id,i.InternalError,o instanceof Error?o.message:String(o))}}handleInitialize(){return {protocolVersion:this.opts.protocolVersion,capabilities:{tools:{}},serverInfo:{name:this.opts.name,version:this.opts.version}}}handleToolsList(){return {tools:chunkRI5S75JY_js.a.map(r=>({name:r.name,description:r.description,inputSchema:r.inputSchema}))}}handleToolsCall(r){let e=r.params;if(!e||typeof e.name!="string")return p(r.id,i.InvalidParams,'tools/call requires a "name" string');let o=e.arguments??{},n=chunkRI5S75JY_js.b(e.name,o,this.bridge),c=n.success?{content:[{type:"text",text:typeof n.data=="string"?n.data:JSON.stringify(n.data,null,2)}]}:{isError:true,content:[{type:"text",text:n.error??"Unknown tool error"}]};return u(r.id,c)}};var x=1024*1024;function b(t,r={}){let e=new f(t,r),o=r.input??(typeof process<"u"&&process.stdin?process.stdin:null),n=r.output??(typeof process<"u"&&process.stdout?process.stdout:null),c=r.log??(s=>{typeof process<"u"&&process.stderr&&process.stderr.write(s+`
+`);});if(!o||!n)throw new Error("runStdioServer: no input/output stream available. Pass options.input and options.output, or run inside a Node process with stdin/stdout.");let a=n,h=new string_decoder.StringDecoder("utf8"),l="",R=false;function w(s){let g=e.handle(s);g!==null&&a.write(d(g));}function J(s){if(R)return;if(l+=typeof s=="string"?s:h.write(s),l.length>x){l="",c(`MCP buffer overflow (>${x} bytes without newline) \u2014 dropped`),a.write(d(p(null,i.ParseError,"Frame too large")));return}let{messages:g,parseErrors:E,rest:k}=y(l);l=k;for(let m of g)w(m);for(let m of E)c(`MCP parse error: ${m}`),a.write(d(p(null,i.ParseError,"Parse error",m)));}return o.on("data",J),o.on("end",()=>{R=true;}),o.on("error",s=>{c(`MCP input error: ${s.message}`),R=true;}),{server:e,feed:J,close(){R=true;}}}exports.ErrorCode=i;exports.McpServer=f;exports.encodeFrame=d;exports.isJsonRpcNotification=I;exports.isJsonRpcRequest=v;exports.makeError=p;exports.makeSuccess=u;exports.parseFrames=y;exports.runStdioServer=b;

package/dist/mcp.mjs

@@ -0,0 +1,4 @@
+import {a,b as b$1}from'./chunk-24MVJKCP.mjs';import {StringDecoder}from'string_decoder';var i={ParseError:-32700,InvalidRequest:-32600,MethodNotFound:-32601,InvalidParams:-32602,InternalError:-32603};function v(t){return typeof t=="object"&&t!==null&&t.jsonrpc==="2.0"&&typeof t.method=="string"&&"id"in t}function I(t){return typeof t=="object"&&t!==null&&t.jsonrpc==="2.0"&&typeof t.method=="string"&&!("id"in t)}function u(t,r){return {jsonrpc:"2.0",id:t,result:r}}function p(t,r,e,o){return {jsonrpc:"2.0",id:t,error:o===void 0?{code:r,message:e}:{code:r,message:e,data:o}}}function y(t){let r=[],e=[],o=t.split(`
+`),n=o.pop()??"";for(let c of o){let a=c.trim();if(a)try{r.push(JSON.parse(a));}catch{e.push(a);}}return {messages:r,parseErrors:e,rest:n}}function d(t){return JSON.stringify(t)+`
+`}var T="2025-06-18",f=class{constructor(r,e={}){this.bridge=r,this.opts={name:e.name??"@zeke-02/docx-editor-agents",version:e.version??"0.0.0",protocolVersion:e.protocolVersion??T};}handle(r){if(!v(r))return null;let e=r;try{switch(e.method){case "initialize":return u(e.id,this.handleInitialize());case "tools/list":return u(e.id,this.handleToolsList());case "tools/call":return this.handleToolsCall(e);case "ping":return u(e.id,{});default:return p(e.id,i.MethodNotFound,`Method not found: ${e.method}`)}}catch(o){return p(e.id,i.InternalError,o instanceof Error?o.message:String(o))}}handleInitialize(){return {protocolVersion:this.opts.protocolVersion,capabilities:{tools:{}},serverInfo:{name:this.opts.name,version:this.opts.version}}}handleToolsList(){return {tools:a.map(r=>({name:r.name,description:r.description,inputSchema:r.inputSchema}))}}handleToolsCall(r){let e=r.params;if(!e||typeof e.name!="string")return p(r.id,i.InvalidParams,'tools/call requires a "name" string');let o=e.arguments??{},n=b$1(e.name,o,this.bridge),c=n.success?{content:[{type:"text",text:typeof n.data=="string"?n.data:JSON.stringify(n.data,null,2)}]}:{isError:true,content:[{type:"text",text:n.error??"Unknown tool error"}]};return u(r.id,c)}};var x=1024*1024;function b(t,r={}){let e=new f(t,r),o=r.input??(typeof process<"u"&&process.stdin?process.stdin:null),n=r.output??(typeof process<"u"&&process.stdout?process.stdout:null),c=r.log??(s=>{typeof process<"u"&&process.stderr&&process.stderr.write(s+`
+`);});if(!o||!n)throw new Error("runStdioServer: no input/output stream available. Pass options.input and options.output, or run inside a Node process with stdin/stdout.");let a=n,h=new StringDecoder("utf8"),l="",R=false;function w(s){let g=e.handle(s);g!==null&&a.write(d(g));}function J(s){if(R)return;if(l+=typeof s=="string"?s:h.write(s),l.length>x){l="",c(`MCP buffer overflow (>${x} bytes without newline) \u2014 dropped`),a.write(d(p(null,i.ParseError,"Frame too large")));return}let{messages:g,parseErrors:E,rest:k}=y(l);l=k;for(let m of g)w(m);for(let m of E)c(`MCP parse error: ${m}`),a.write(d(p(null,i.ParseError,"Parse error",m)));}return o.on("data",J),o.on("end",()=>{R=true;}),o.on("error",s=>{c(`MCP input error: ${s.message}`),R=true;}),{server:e,feed:J,close(){R=true;}}}export{i as ErrorCode,f as McpServer,d as encodeFrame,I as isJsonRpcNotification,v as isJsonRpcRequest,p as makeError,u as makeSuccess,y as parseFrames,b as runStdioServer};