@usejunior/docx-mcp 0.4.0 → 0.6.0

package/dist/tool_catalog.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly name: "read_file";
-    readonly description: "Read document content. Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate. Accepts session_id or file_path.";
+    readonly description: "Read document content (DOCX or Google Doc). Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate.";
     readonly input: z.ZodObject<{
         offset: z.ZodOptional<z.ZodNumber>;
         limit: z.ZodOptional<z.ZodNumber>;
@@ -12,7 +12,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
             simple: "simple";
         }>>;
         show_formatting: z.ZodOptional<z.ZodBoolean>;
-        session_id: z.ZodOptional<z.ZodString>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -21,8 +21,9 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "grep";
-    readonly description: "Search paragraphs with regex. Accepts session_id or file_path.";
+    readonly description: "Search paragraphs with regex. Use file_path for session-based search, file_paths for stateless multi-file search, or google_doc_id for Google Docs.";
     readonly input: z.ZodObject<{
+        file_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
         patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
         pattern: z.ZodOptional<z.ZodString>;
         case_sensitive: z.ZodOptional<z.ZodBoolean>;
@@ -30,7 +31,9 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         max_results: z.ZodOptional<z.ZodNumber>;
         context_chars: z.ZodOptional<z.ZodNumber>;
         dedupe_by_paragraph: z.ZodOptional<z.ZodBoolean>;
-        session_id: z.ZodOptional<z.ZodString>;
+        search_xml: z.ZodOptional<z.ZodBoolean>;
+        include_context: z.ZodOptional<z.ZodBoolean>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -39,12 +42,11 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "init_plan";
-    readonly description: "Initialize revision-bound context metadata for coordinated multi-agent planning. Accepts session_id or file_path.";
+    readonly description: "Initialize revision-bound context metadata for coordinated multi-agent planning.";
     readonly input: z.ZodObject<{
         plan_name: z.ZodOptional<z.ZodString>;
         orchestrator_id: z.ZodOptional<z.ZodString>;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: true;
@@ -64,12 +66,11 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "apply_plan";
-    readonly description: "Validate and apply a batch of edit steps (replace_text, insert_paragraph) to a session document in one call. Validates all steps first; applies only if all pass. Accepts inline steps or a plan_file_path. Compatible with merge_plans output.";
+    readonly description: "Validate and apply a batch of edit steps (replace_text, insert_paragraph) to a document in one call. Validates all steps first; applies only if all pass. Accepts inline steps or a plan_file_path. Compatible with merge_plans output.";
     readonly input: z.ZodObject<{
         steps: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>>>;
         plan_file_path: z.ZodOptional<z.ZodString>;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -77,14 +78,14 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "replace_text";
-    readonly description: "Replace text in a paragraph by _bk_* id, preserving formatting. Accepts session_id or file_path.";
+    readonly description: "Replace text in a paragraph by _bk_* id, preserving formatting. Supports DOCX and Google Docs.";
     readonly input: z.ZodObject<{
         target_paragraph_id: z.ZodString;
         old_string: z.ZodString;
         new_string: z.ZodString;
         instruction: z.ZodString;
         normalize_first: z.ZodOptional<z.ZodBoolean>;
-        session_id: z.ZodOptional<z.ZodString>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -93,7 +94,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "insert_paragraph";
-    readonly description: "Insert a paragraph before/after an anchor paragraph by _bk_* id. Accepts session_id or file_path.";
+    readonly description: "Insert a paragraph before/after an anchor paragraph by _bk_* id. Supports DOCX and Google Docs.";
     readonly input: z.ZodObject<{
         positional_anchor_node_id: z.ZodString;
         new_string: z.ZodString;
@@ -103,7 +104,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
             AFTER: "AFTER";
         }>>;
         style_source_id: z.ZodOptional<z.ZodString>;
-        session_id: z.ZodOptional<z.ZodString>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -112,7 +113,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "save";
-    readonly description: "Save clean and/or tracked changes output back to the local filesystem. Defaults to both clean and tracked outputs when no format override is provided. Accepts session_id or file_path.";
+    readonly description: "Save document. For DOCX: saves clean and/or tracked changes output. For Google Docs: checkpoint (default) returns revisionId, or snapshot exports as DOCX.";
     readonly input: z.ZodObject<{
         save_to_local_path: z.ZodString;
         clean_bookmarks: z.ZodOptional<z.ZodBoolean>;
@@ -129,7 +130,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
             atomizer: "atomizer";
         }>>;
         fail_on_rebuild_fallback: z.ZodOptional<z.ZodBoolean>;
-        session_id: z.ZodOptional<z.ZodString>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -138,7 +139,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "format_layout";
-    readonly description: "Apply deterministic OOXML layout controls (paragraph spacing, table row height, cell padding). Accepts session_id or file_path.";
+    readonly description: "Apply layout controls (paragraph spacing, table row height, cell padding). Google Docs supports paragraph spacing only.";
     readonly input: z.ZodObject<{
         strict: z.ZodOptional<z.ZodBoolean>;
         paragraph_spacing: z.ZodOptional<z.ZodObject<{
@@ -171,7 +172,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
             left_dxa: z.ZodOptional<z.ZodNumber>;
             right_dxa: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
-        session_id: z.ZodOptional<z.ZodString>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -182,8 +183,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly name: "accept_changes";
     readonly description: "Accept all tracked changes in the document body, producing a clean document with no revision markup. Returns acceptance stats.";
     readonly input: z.ZodObject<{
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -193,18 +193,17 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly name: "has_tracked_changes";
     readonly description: "Check whether the document body contains tracked-change markers (insertions, deletions, moves, and property-change records). Read-only.";
     readonly input: z.ZodObject<{
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: true;
         readonly destructiveHint: false;
     };
 }, {
-    readonly name: "get_session_status";
-    readonly description: "Get session metadata. Accepts session_id or file_path.";
+    readonly name: "get_file_status";
+    readonly description: "Get file/session metadata including edit count, normalization stats, and cache info. Supports DOCX and Google Docs.";
     readonly input: z.ZodObject<{
-        session_id: z.ZodOptional<z.ZodString>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
         file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
@@ -212,13 +211,13 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         readonly destructiveHint: false;
     };
 }, {
-    readonly name: "clear_session";
-    readonly description: "Clear one session, all sessions for a file path, or all sessions with explicit confirmation.";
+    readonly name: "close_file";
+    readonly description: "Close an open file session, or close all sessions with explicit confirmation. Supports DOCX and Google Docs.";
     readonly input: z.ZodObject<{
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
         clear_all: z.ZodOptional<z.ZodBoolean>;
         confirm: z.ZodOptional<z.ZodBoolean>;
+        google_doc_id: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -234,8 +233,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         author: z.ZodString;
         text: z.ZodString;
         initials: z.ZodOptional<z.ZodString>;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -245,8 +243,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly name: "get_comments";
     readonly description: "Get all comments from the document with IDs, authors, dates, text, and anchored paragraph IDs. Includes threaded replies. Read-only.";
     readonly input: z.ZodObject<{
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: true;
@@ -257,8 +254,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly description: "Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants.";
     readonly input: z.ZodObject<{
         comment_id: z.ZodNumber;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -266,18 +262,17 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "compare_documents";
-    readonly description: "Compare two DOCX documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or session_id/file_path to compare session edits against the original.";
+    readonly description: "Compare two DOCX documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or file_path to compare session edits against the original.";
     readonly input: z.ZodObject<{
-        original_file_path: z.ZodOptional<z.ZodString>;
-        revised_file_path: z.ZodOptional<z.ZodString>;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
         save_to_local_path: z.ZodString;
         author: z.ZodOptional<z.ZodString>;
         engine: z.ZodOptional<z.ZodEnum<{
             auto: "auto";
             atomizer: "atomizer";
         }>>;
+        file_path: z.ZodOptional<z.ZodString>;
+        original_file_path: z.ZodOptional<z.ZodString>;
+        revised_file_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: true;
@@ -287,8 +282,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly name: "get_footnotes";
     readonly description: "Get all footnotes from the document with IDs, display numbers, text, and anchored paragraph IDs. Read-only.";
     readonly input: z.ZodObject<{
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: true;
@@ -301,8 +295,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         target_paragraph_id: z.ZodString;
         after_text: z.ZodOptional<z.ZodString>;
         text: z.ZodString;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -314,8 +307,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly input: z.ZodObject<{
         note_id: z.ZodNumber;
         new_text: z.ZodString;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -326,8 +318,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly description: "Delete a footnote and its reference from the document.";
     readonly input: z.ZodObject<{
         note_id: z.ZodNumber;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -335,7 +326,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }, {
     readonly name: "clear_formatting";
-    readonly description: "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs. Accepts session_id or file_path.";
+    readonly description: "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs.";
     readonly input: z.ZodObject<{
         paragraph_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         clear_highlight: z.ZodOptional<z.ZodBoolean>;
@@ -344,8 +335,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
         clear_underline: z.ZodOptional<z.ZodBoolean>;
         clear_color: z.ZodOptional<z.ZodBoolean>;
         clear_font: z.ZodOptional<z.ZodBoolean>;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: false;
@@ -357,8 +347,7 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     readonly input: z.ZodObject<{
         offset: z.ZodOptional<z.ZodNumber>;
         limit: z.ZodOptional<z.ZodNumber>;
-        session_id: z.ZodOptional<z.ZodString>;
-        file_path: z.ZodOptional<z.ZodString>;
+        file_path: z.ZodString;
     }, z.core.$strip>;
     readonly annotations: {
         readonly readOnlyHint: true;
@@ -366,8 +355,8 @@ export declare const SAFE_DOCX_TOOL_CATALOG: readonly [{
     };
 }];
 export declare const SAFE_DOCX_MCP_TOOLS: {
-    name: "read_file" | "grep" | "init_plan" | "merge_plans" | "apply_plan" | "replace_text" | "insert_paragraph" | "save" | "format_layout" | "accept_changes" | "has_tracked_changes" | "get_session_status" | "clear_session" | "add_comment" | "get_comments" | "delete_comment" | "compare_documents" | "get_footnotes" | "add_footnote" | "update_footnote" | "delete_footnote" | "clear_formatting" | "extract_revisions";
-    description: "Read document content. Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate. Accepts session_id or file_path." | "Search paragraphs with regex. Accepts session_id or file_path." | "Initialize revision-bound context metadata for coordinated multi-agent planning. Accepts session_id or file_path." | "Deterministically merge multiple sub-agent plans and detect hard conflicts before apply." | "Validate and apply a batch of edit steps (replace_text, insert_paragraph) to a session document in one call. Validates all steps first; applies only if all pass. Accepts inline steps or a plan_file_path. Compatible with merge_plans output." | "Replace text in a paragraph by _bk_* id, preserving formatting. Accepts session_id or file_path." | "Insert a paragraph before/after an anchor paragraph by _bk_* id. Accepts session_id or file_path." | "Save clean and/or tracked changes output back to the local filesystem. Defaults to both clean and tracked outputs when no format override is provided. Accepts session_id or file_path." | "Apply deterministic OOXML layout controls (paragraph spacing, table row height, cell padding). Accepts session_id or file_path." | "Accept all tracked changes in the document body, producing a clean document with no revision markup. Returns acceptance stats." | "Check whether the document body contains tracked-change markers (insertions, deletions, moves, and property-change records). Read-only." | "Get session metadata. Accepts session_id or file_path." | "Clear one session, all sessions for a file path, or all sessions with explicit confirmation." | "Add a comment or threaded reply to a document. Provide target_paragraph_id + anchor_text for root comments, or parent_comment_id for replies." | "Get all comments from the document with IDs, authors, dates, text, and anchored paragraph IDs. Includes threaded replies. Read-only." | "Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants." | "Compare two DOCX documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or session_id/file_path to compare session edits against the original." | "Get all footnotes from the document with IDs, display numbers, text, and anchored paragraph IDs. Read-only." | "Add a footnote anchored to a paragraph. Optionally position the reference after specific text using after_text. Note: [^N] markers in read_file output are display-only and not part of the editable text used by replace_text." | "Update the text content of an existing footnote." | "Delete a footnote and its reference from the document." | "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs. Accepts session_id or file_path." | "Extract tracked changes as structured JSON with before/after text per paragraph, revision details, and comments. Supports pagination via offset and limit. Read-only - does not modify the document.";
+    name: "read_file" | "grep" | "init_plan" | "merge_plans" | "apply_plan" | "replace_text" | "insert_paragraph" | "save" | "format_layout" | "accept_changes" | "has_tracked_changes" | "get_file_status" | "close_file" | "add_comment" | "get_comments" | "delete_comment" | "compare_documents" | "get_footnotes" | "add_footnote" | "update_footnote" | "delete_footnote" | "clear_formatting" | "extract_revisions";
+    description: "Read document content (DOCX or Google Doc). Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate." | "Search paragraphs with regex. Use file_path for session-based search, file_paths for stateless multi-file search, or google_doc_id for Google Docs." | "Initialize revision-bound context metadata for coordinated multi-agent planning." | "Deterministically merge multiple sub-agent plans and detect hard conflicts before apply." | "Validate and apply a batch of edit steps (replace_text, insert_paragraph) to a document in one call. Validates all steps first; applies only if all pass. Accepts inline steps or a plan_file_path. Compatible with merge_plans output." | "Replace text in a paragraph by _bk_* id, preserving formatting. Supports DOCX and Google Docs." | "Insert a paragraph before/after an anchor paragraph by _bk_* id. Supports DOCX and Google Docs." | "Save document. For DOCX: saves clean and/or tracked changes output. For Google Docs: checkpoint (default) returns revisionId, or snapshot exports as DOCX." | "Apply layout controls (paragraph spacing, table row height, cell padding). Google Docs supports paragraph spacing only." | "Accept all tracked changes in the document body, producing a clean document with no revision markup. Returns acceptance stats." | "Check whether the document body contains tracked-change markers (insertions, deletions, moves, and property-change records). Read-only." | "Get file/session metadata including edit count, normalization stats, and cache info. Supports DOCX and Google Docs." | "Close an open file session, or close all sessions with explicit confirmation. Supports DOCX and Google Docs." | "Add a comment or threaded reply to a document. Provide target_paragraph_id + anchor_text for root comments, or parent_comment_id for replies." | "Get all comments from the document with IDs, authors, dates, text, and anchored paragraph IDs. Includes threaded replies. Read-only." | "Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants." | "Compare two DOCX documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or file_path to compare session edits against the original." | "Get all footnotes from the document with IDs, display numbers, text, and anchored paragraph IDs. Read-only." | "Add a footnote anchored to a paragraph. Optionally position the reference after specific text using after_text. Note: [^N] markers in read_file output are display-only and not part of the editable text used by replace_text." | "Update the text content of an existing footnote." | "Delete a footnote and its reference from the document." | "Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs." | "Extract tracked changes as structured JSON with before/after text per paragraph, revision details, and comments. Supports pagination via offset and limit. Read-only - does not modify the document.";
     inputSchema: Record<string, unknown>;
     annotations: {
         readonly readOnlyHint: true;

package/dist/tool_catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_catalog.d.ts","sourceRoot":"","sources":["../src/tool_catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqBxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Ta,CAAC;AAUjD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAK7B,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"tool_catalog.d.ts","sourceRoot":"","sources":["../src/tool_catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+BxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmUa,CAAC;AAUjD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAK7B,CAAC;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/tool_catalog.js

@@ -1,15 +1,22 @@
 import { z } from 'zod';
-const SESSION_OR_FILE_FIELDS = {
-    session_id: z.string().optional(),
-    file_path: z.string().optional(),
+const FILE_FIELD = {
+    file_path: z.string().describe('Path to the DOCX file.'),
+};
+const FILE_FIELD_OPTIONAL = {
+    file_path: z.string().optional().describe('Path to the DOCX file.'),
+};
+const GOOGLE_DOC_ID_FIELD = {
+    google_doc_id: z.string().optional().describe('Google Doc ID or URL (alternative to file_path). ' +
+        'Extract from URL: docs.google.com/document/d/{ID}/edit'),
 };
 const PLAN_OBJECT_SCHEMA = z.object({}).catchall(z.unknown());
 export const SAFE_DOCX_TOOL_CATALOG = [
     {
         name: 'read_file',
-        description: 'Read document content. Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate. Accepts session_id or file_path.',
+        description: 'Read document content (DOCX or Google Doc). Output is token-limited (~14k tokens) by default with pagination metadata (has_more, next_offset). Use offset/limit to paginate.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
             offset: z.number().optional().describe('1-based paragraph offset for pagination. Negative values count from end.'),
             limit: z.number().optional().describe('Max paragraphs to return. When omitted, output is token-limited to ~14k tokens with pagination.'),
             node_ids: z.array(z.string()).optional(),
@@ -23,9 +30,11 @@ export const SAFE_DOCX_TOOL_CATALOG = [
     },
     {
         name: 'grep',
-        description: 'Search paragraphs with regex. Accepts session_id or file_path.',
+        description: 'Search paragraphs with regex. Use file_path for session-based search, file_paths for stateless multi-file search, or google_doc_id for Google Docs.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
+            file_paths: z.array(z.string()).optional().describe('Multiple file paths for stateless multi-file search. No session created.'),
             patterns: z.array(z.string()).optional(),
             pattern: z.string().optional(),
             case_sensitive: z.boolean().optional(),
@@ -33,14 +42,16 @@ export const SAFE_DOCX_TOOL_CATALOG = [
             max_results: z.number().optional(),
             context_chars: z.number().optional(),
             dedupe_by_paragraph: z.boolean().optional(),
+            search_xml: z.boolean().optional().describe('When true, search raw XML (word/document.xml) instead of paragraph text.'),
+            include_context: z.boolean().optional().describe('When false, skip document view context (list labels, headers) for faster results. Default: true.'),
         }),
         annotations: { readOnlyHint: true, destructiveHint: false },
     },
     {
         name: 'init_plan',
-        description: 'Initialize revision-bound context metadata for coordinated multi-agent planning. Accepts session_id or file_path.',
+        description: 'Initialize revision-bound context metadata for coordinated multi-agent planning.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             plan_name: z.string().optional(),
             orchestrator_id: z.string().optional(),
         }),
@@ -58,9 +69,9 @@ export const SAFE_DOCX_TOOL_CATALOG = [
     },
     {
         name: 'apply_plan',
-        description: 'Validate and apply a batch of edit steps (replace_text, insert_paragraph) to a session document in one call. Validates all steps first; applies only if all pass. Accepts inline steps or a plan_file_path. Compatible with merge_plans output.',
+        description: 'Validate and apply a batch of edit steps (replace_text, insert_paragraph) to a document in one call. Validates all steps first; applies only if all pass. Accepts inline steps or a plan_file_path. Compatible with merge_plans output.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             steps: z
                 .array(z.object({}).catchall(z.unknown()))
                 .optional()
@@ -74,9 +85,10 @@ export const SAFE_DOCX_TOOL_CATALOG = [
     },
     {
         name: 'replace_text',
-        description: 'Replace text in a paragraph by _bk_* id, preserving formatting. Accepts session_id or file_path.',
+        description: 'Replace text in a paragraph by _bk_* id, preserving formatting. Supports DOCX and Google Docs.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
             target_paragraph_id: z.string(),
             old_string: z.string(),
             new_string: z.string(),
@@ -90,9 +102,10 @@ export const SAFE_DOCX_TOOL_CATALOG = [
     },
     {
         name: 'insert_paragraph',
-        description: 'Insert a paragraph before/after an anchor paragraph by _bk_* id. Accepts session_id or file_path.',
+        description: 'Insert a paragraph before/after an anchor paragraph by _bk_* id. Supports DOCX and Google Docs.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
             positional_anchor_node_id: z.string(),
             new_string: z.string(),
             instruction: z.string(),
@@ -106,9 +119,10 @@ export const SAFE_DOCX_TOOL_CATALOG = [
     },
     {
         name: 'save',
-        description: 'Save clean and/or tracked changes output back to the local filesystem. Defaults to both clean and tracked outputs when no format override is provided. Accepts session_id or file_path.',
+        description: 'Save document. For DOCX: saves clean and/or tracked changes output. For Google Docs: checkpoint (default) returns revisionId, or snapshot exports as DOCX.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
             save_to_local_path: z.string(),
             clean_bookmarks: z.boolean().optional(),
             save_format: z.enum(['clean', 'tracked', 'both']).optional(),
@@ -125,9 +139,10 @@ export const SAFE_DOCX_TOOL_CATALOG = [
     },
     {
         name: 'format_layout',
-        description: 'Apply deterministic OOXML layout controls (paragraph spacing, table row height, cell padding). Accepts session_id or file_path.',
+        description: 'Apply layout controls (paragraph spacing, table row height, cell padding). Google Docs supports paragraph spacing only.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
             strict: z.boolean().optional(),
             paragraph_spacing: z
                 .object({
@@ -164,7 +179,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'accept_changes',
         description: 'Accept all tracked changes in the document body, producing a clean document with no revision markup. Returns acceptance stats.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
         }),
         annotations: { readOnlyHint: false, destructiveHint: true },
     },
@@ -172,24 +187,25 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'has_tracked_changes',
         description: 'Check whether the document body contains tracked-change markers (insertions, deletions, moves, and property-change records). Read-only.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
         }),
         annotations: { readOnlyHint: true, destructiveHint: false },
     },
     {
-        name: 'get_session_status',
-        description: 'Get session metadata. Accepts session_id or file_path.',
+        name: 'get_file_status',
+        description: 'Get file/session metadata including edit count, normalization stats, and cache info. Supports DOCX and Google Docs.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
         }),
         annotations: { readOnlyHint: true, destructiveHint: false },
     },
     {
-        name: 'clear_session',
-        description: 'Clear one session, all sessions for a file path, or all sessions with explicit confirmation.',
+        name: 'close_file',
+        description: 'Close an open file session, or close all sessions with explicit confirmation. Supports DOCX and Google Docs.',
         input: z.object({
-            session_id: z.string().optional(),
-            file_path: z.string().optional(),
+            ...FILE_FIELD_OPTIONAL,
+            ...GOOGLE_DOC_ID_FIELD,
             clear_all: z.boolean().optional(),
             confirm: z.boolean().optional(),
         }),
@@ -199,7 +215,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'add_comment',
         description: 'Add a comment or threaded reply to a document. Provide target_paragraph_id + anchor_text for root comments, or parent_comment_id for replies.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             target_paragraph_id: z.string().optional().describe('Paragraph ID to anchor the comment to (for root comments).'),
             anchor_text: z.string().optional().describe('Text within the paragraph to anchor the comment to. If omitted, anchors to entire paragraph.'),
             parent_comment_id: z.number().optional().describe('Parent comment ID for threaded replies.'),
@@ -213,7 +229,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'get_comments',
         description: 'Get all comments from the document with IDs, authors, dates, text, and anchored paragraph IDs. Includes threaded replies. Read-only.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
         }),
         annotations: { readOnlyHint: true, destructiveHint: false },
     },
@@ -221,19 +237,18 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'delete_comment',
         description: 'Delete a comment and all its threaded replies from the document. Cascade-deletes all descendants.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             comment_id: z.number().describe('Comment ID to delete.'),
         }),
         annotations: { readOnlyHint: false, destructiveHint: true },
     },
     {
         name: 'compare_documents',
-        description: 'Compare two DOCX documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or session_id/file_path to compare session edits against the original.',
+        description: 'Compare two DOCX documents and produce a tracked-changes output document. Provide original_file_path + revised_file_path for standalone comparison, or file_path to compare session edits against the original.',
         input: z.object({
             original_file_path: z.string().optional().describe('Path to the original DOCX file.'),
             revised_file_path: z.string().optional().describe('Path to the revised DOCX file.'),
-            session_id: z.string().optional(),
-            file_path: z.string().optional(),
+            ...FILE_FIELD_OPTIONAL,
             save_to_local_path: z.string().describe('Path to save the tracked-changes DOCX output.'),
             author: z.string().optional().describe("Author name for track changes. Default: 'Comparison'."),
             engine: z.enum(['auto', 'atomizer']).optional().describe("Comparison engine. Default: 'auto'."),
@@ -244,7 +259,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'get_footnotes',
         description: 'Get all footnotes from the document with IDs, display numbers, text, and anchored paragraph IDs. Read-only.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
         }),
         annotations: { readOnlyHint: true, destructiveHint: false },
     },
@@ -252,7 +267,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'add_footnote',
         description: 'Add a footnote anchored to a paragraph. Optionally position the reference after specific text using after_text. Note: [^N] markers in read_file output are display-only and not part of the editable text used by replace_text.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             target_paragraph_id: z.string().describe('Paragraph ID to anchor the footnote to.'),
             after_text: z.string().optional().describe('Text after which to insert the footnote reference. If omitted, appends at end of paragraph.'),
             text: z.string().describe('Footnote body text.'),
@@ -263,7 +278,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'update_footnote',
         description: 'Update the text content of an existing footnote.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             note_id: z.number().describe('Footnote ID to update.'),
             new_text: z.string().describe('New footnote body text.'),
         }),
@@ -273,16 +288,16 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'delete_footnote',
         description: 'Delete a footnote and its reference from the document.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             note_id: z.number().describe('Footnote ID to delete.'),
         }),
         annotations: { readOnlyHint: false, destructiveHint: true },
     },
     {
         name: 'clear_formatting',
-        description: 'Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs. Accepts session_id or file_path.',
+        description: 'Clear specific run-level formatting (bold, italic, underline, highlight, color, font) from paragraphs.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             paragraph_ids: z.array(z.string()).optional().describe('Paragraph IDs to clear formatting from. If omitted, clears from all paragraphs.'),
             clear_highlight: z.boolean().optional().describe('Remove highlight formatting.'),
             clear_bold: z.boolean().optional().describe('Remove bold formatting.'),
@@ -297,7 +312,7 @@ export const SAFE_DOCX_TOOL_CATALOG = [
         name: 'extract_revisions',
         description: 'Extract tracked changes as structured JSON with before/after text per paragraph, revision details, and comments. Supports pagination via offset and limit. Read-only - does not modify the document.',
         input: z.object({
-            ...SESSION_OR_FILE_FIELDS,
+            ...FILE_FIELD,
             offset: z.number().optional().describe('0-based offset for pagination. Default: 0.'),
             limit: z.number().optional().describe('Max entries per page (1-500). Default: 50.'),
         }),