ai-prompt-guide-mcp 1.0.0

package/dist/tools/schemas/move-document-schemas.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Schema definitions for move_document tool
+ * Provides document relocation functionality within the filesystem
+ */
+export interface MoveDocumentInputSchema {
+    type: 'object';
+    properties: {
+        from: {
+            type: 'string';
+            description: string;
+        };
+        to: {
+            type: 'string';
+            description: string;
+        };
+    };
+    required: ['from', 'to'];
+    additionalProperties: false;
+}
+/**
+ * Returns the schema for move_document tool
+ * Validates source and destination paths
+ */
+export declare function getMoveDocumentSchema(): MoveDocumentInputSchema;
+//# sourceMappingURL=move-document-schemas.d.ts.map

package/dist/tools/schemas/move-document-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-document-schemas.d.ts","sourceRoot":"","sources":["../../../src/tools/schemas/move-document-schemas.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE;QACV,IAAI,EAAE;YACJ,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;QACF,EAAE,EAAE;YACF,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACzB,oBAAoB,EAAE,KAAK,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,uBAAuB,CAgB/D"}

package/dist/tools/schemas/move-document-schemas.js

@@ -0,0 +1,26 @@
+/**
+ * Schema definitions for move_document tool
+ * Provides document relocation functionality within the filesystem
+ */
+/**
+ * Returns the schema for move_document tool
+ * Validates source and destination paths
+ */
+export function getMoveDocumentSchema() {
+    return {
+        type: 'object',
+        properties: {
+            from: {
+                type: 'string',
+                description: 'Source document path (e.g., "/docs/api/auth.md")',
+            },
+            to: {
+                type: 'string',
+                description: 'Destination document path (e.g., "/docs/api/security/auth.md")',
+            },
+        },
+        required: ['from', 'to'],
+        additionalProperties: false,
+    };
+}
+//# sourceMappingURL=move-document-schemas.js.map

package/dist/tools/schemas/move-document-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-document-schemas.js","sourceRoot":"","sources":["../../../src/tools/schemas/move-document-schemas.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAkBH;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,kDAAkD;aAChE;YACD,EAAE,EAAE;gBACF,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,gEAAgE;aAC9E;SACF;QACD,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC;QACxB,oBAAoB,EAAE,KAAK;KAC5B,CAAC;AACJ,CAAC"}

package/dist/tools/schemas/move-schemas.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Schema definitions for the move tool
+ *
+ * Moves sections or tasks between documents or within the same document.
+ * Creates in new location BEFORE deleting from old location to prevent data loss.
+ */
+export interface MoveInputSchema {
+    type: 'object';
+    properties: {
+        from: {
+            type: 'string';
+            description: string;
+        };
+        to: {
+            type: 'string';
+            description: string;
+        };
+        reference: {
+            type: 'string';
+            description: string;
+        };
+        position: {
+            type: 'string';
+            enum: ['before', 'after', 'child'];
+            description: string;
+        };
+    };
+    required: ['from', 'to', 'reference', 'position'];
+    additionalProperties: false;
+}
+/**
+ * Get the JSON schema for the move tool
+ */
+export declare function getMoveSchema(): MoveInputSchema;
+/**
+ * Position type for move operations
+ */
+export type MovePosition = 'before' | 'after' | 'child';
+/**
+ * Type guard for position validation
+ */
+export declare function isValidMovePosition(value: unknown): value is MovePosition;
+//# sourceMappingURL=move-schemas.d.ts.map

package/dist/tools/schemas/move-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-schemas.d.ts","sourceRoot":"","sources":["../../../src/tools/schemas/move-schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE;QACV,IAAI,EAAE;YACJ,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;QACF,EAAE,EAAE;YACF,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;QACF,SAAS,EAAE;YACT,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;QACF,QAAQ,EAAE;YACR,IAAI,EAAE,QAAQ,CAAC;YACf,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YACnC,WAAW,EAAE,MAAM,CAAC;SACrB,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;IAClD,oBAAoB,EAAE,KAAK,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,eAAe,CA6B/C;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAExD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAKzE"}

package/dist/tools/schemas/move-schemas.js

@@ -0,0 +1,43 @@
+/**
+ * Schema definitions for the move tool
+ *
+ * Moves sections or tasks between documents or within the same document.
+ * Creates in new location BEFORE deleting from old location to prevent data loss.
+ */
+/**
+ * Get the JSON schema for the move tool
+ */
+export function getMoveSchema() {
+    return {
+        type: 'object',
+        properties: {
+            from: {
+                type: 'string',
+                description: 'Source section/task path including document and section slug (e.g., "/docs/api/auth.md#jwt-tokens"). Must include both document path and section slug separated by #.',
+            },
+            to: {
+                type: 'string',
+                description: 'Destination document path where section/task will be moved (e.g., "/docs/api/security.md"). Can be same document as source for within-document moves.',
+            },
+            reference: {
+                type: 'string',
+                description: 'Reference section slug in destination document for positioning (e.g., "#tokens" or "tokens"). The moved content will be positioned relative to this section.',
+            },
+            position: {
+                type: 'string',
+                enum: ['before', 'after', 'child'],
+                description: 'Position relative to reference section: "before" (insert before reference), "after" (insert after reference), or "child" (append as child of reference with auto-depth calculation)',
+            },
+        },
+        required: ['from', 'to', 'reference', 'position'],
+        additionalProperties: false,
+    };
+}
+/**
+ * Type guard for position validation
+ */
+export function isValidMovePosition(value) {
+    return (typeof value === 'string' &&
+        (value === 'before' || value === 'after' || value === 'child'));
+}
+//# sourceMappingURL=move-schemas.js.map

package/dist/tools/schemas/move-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-schemas.js","sourceRoot":"","sources":["../../../src/tools/schemas/move-schemas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA2BH;;GAEG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,uKAAuK;aAC1K;YACD,EAAE,EAAE;gBACF,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,uJAAuJ;aAC1J;YACD,SAAS,EAAE;gBACT,IAAI,EAAE,QAAQ;gBACd,WAAW,EACT,8JAA8J;aACjK;YACD,QAAQ,EAAE;gBACR,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC;gBAClC,WAAW,EACT,qLAAqL;aACxL;SACF;QACD,QAAQ,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,UAAU,CAAC;QACjD,oBAAoB,EAAE,KAAK;KAC5B,CAAC;AACJ,CAAC;AAOD;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAc;IAChD,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,OAAO,CAAC,CAC/D,CAAC;AACJ,CAAC"}

package/dist/tools/schemas/search-documents-schemas.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Schema definitions for search_documents tool
+ */
+export interface SearchDocumentsInputSchema {
+    type: 'object';
+    properties: {
+        query: {
+            type: 'string';
+            description: 'Search term or regex pattern';
+        };
+        scope: {
+            type: 'string';
+            description: 'Optional namespace path like "/docs/api/" to limit search';
+        };
+        type: {
+            type: 'string';
+            enum: ['fulltext', 'regex'];
+            description: 'Search mode (default: "fulltext")';
+            default: 'fulltext';
+        };
+        verbose: {
+            type: 'boolean';
+            description: 'Show context lines around matches (default: false). When false, only match_text is included. When true, context_before and context_after are included.';
+            default: false;
+        };
+        context_lines: {
+            type: 'number';
+            description: 'Context line count when verbose=true (default: 2)';
+            minimum: 0;
+            maximum: 10;
+            default: 2;
+        };
+        max_results: {
+            type: 'number';
+            description: 'Limit total results (default: 50)';
+            minimum: 1;
+            maximum: 500;
+            default: 50;
+        };
+        max_match_length: {
+            type: 'number';
+            description: 'Maximum length for match_text field (default: 80). Longer matches will be truncated with "..."';
+            minimum: 20;
+            maximum: 500;
+            default: 80;
+        };
+    };
+    required: ['query'];
+    additionalProperties: false;
+}
+/**
+ * Schema constants for search_documents tool
+ */
+export declare const SEARCH_DOCUMENTS_CONSTANTS: {
+    readonly CONTEXT_LINES: {
+        readonly MIN: 0;
+        readonly MAX: 10;
+        readonly DEFAULT: 2;
+    };
+    readonly MAX_RESULTS: {
+        readonly MIN: 1;
+        readonly MAX: 500;
+        readonly DEFAULT: 50;
+    };
+    readonly MAX_MATCH_LENGTH: {
+        readonly MIN: 20;
+        readonly MAX: 500;
+        readonly DEFAULT: 80;
+    };
+    readonly SEARCH_TYPES: readonly ["fulltext", "regex"];
+    readonly DEFAULT_SEARCH_TYPE: "fulltext";
+};
+/**
+ * Get the input schema for search_documents tool
+ */
+export declare function getSearchDocumentsSchema(): SearchDocumentsInputSchema;
+//# sourceMappingURL=search-documents-schemas.d.ts.map

package/dist/tools/schemas/search-documents-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-documents-schemas.d.ts","sourceRoot":"","sources":["../../../src/tools/schemas/search-documents-schemas.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE;QACV,KAAK,EAAE;YACL,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,8BAA8B,CAAC;SAC7C,CAAC;QACF,KAAK,EAAE;YACL,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,2DAA2D,CAAC;SAC1E,CAAC;QACF,IAAI,EAAE;YACJ,IAAI,EAAE,QAAQ,CAAC;YACf,IAAI,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;YAC5B,WAAW,EAAE,mCAAmC,CAAC;YACjD,OAAO,EAAE,UAAU,CAAC;SACrB,CAAC;QACF,OAAO,EAAE;YACP,IAAI,EAAE,SAAS,CAAC;YAChB,WAAW,EAAE,wJAAwJ,CAAC;YACtK,OAAO,EAAE,KAAK,CAAC;SAChB,CAAC;QACF,aAAa,EAAE;YACb,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,mDAAmD,CAAC;YACjE,OAAO,EAAE,CAAC,CAAC;YACX,OAAO,EAAE,EAAE,CAAC;YACZ,OAAO,EAAE,CAAC,CAAC;SACZ,CAAC;QACF,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,mCAAmC,CAAC;YACjD,OAAO,EAAE,CAAC,CAAC;YACX,OAAO,EAAE,GAAG,CAAC;YACb,OAAO,EAAE,EAAE,CAAC;SACb,CAAC;QACF,gBAAgB,EAAE;YAChB,IAAI,EAAE,QAAQ,CAAC;YACf,WAAW,EAAE,gGAAgG,CAAC;YAC9G,OAAO,EAAE,EAAE,CAAC;YACZ,OAAO,EAAE,GAAG,CAAC;YACb,OAAO,EAAE,EAAE,CAAC;SACb,CAAC;KACH,CAAC;IACF,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;IACpB,oBAAoB,EAAE,KAAK,CAAC;CAC7B;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;CAkB7B,CAAC;AAEX;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,0BAA0B,CAgDrE"}

package/dist/tools/schemas/search-documents-schemas.js

@@ -0,0 +1,78 @@
+/**
+ * Schema definitions for search_documents tool
+ */
+/**
+ * Schema constants for search_documents tool
+ */
+export const SEARCH_DOCUMENTS_CONSTANTS = {
+    CONTEXT_LINES: {
+        MIN: 0,
+        MAX: 10,
+        DEFAULT: 2,
+    },
+    MAX_RESULTS: {
+        MIN: 1,
+        MAX: 500,
+        DEFAULT: 50,
+    },
+    MAX_MATCH_LENGTH: {
+        MIN: 20,
+        MAX: 500,
+        DEFAULT: 80,
+    },
+    SEARCH_TYPES: ['fulltext', 'regex'],
+    DEFAULT_SEARCH_TYPE: 'fulltext',
+};
+/**
+ * Get the input schema for search_documents tool
+ */
+export function getSearchDocumentsSchema() {
+    return {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search term or regex pattern',
+            },
+            scope: {
+                type: 'string',
+                description: 'Optional namespace path like "/docs/api/" to limit search',
+            },
+            type: {
+                type: 'string',
+                enum: ['fulltext', 'regex'],
+                description: 'Search mode (default: "fulltext")',
+                default: SEARCH_DOCUMENTS_CONSTANTS.DEFAULT_SEARCH_TYPE,
+            },
+            verbose: {
+                type: 'boolean',
+                description: 'Show context lines around matches (default: false). When false, only match_text is included. When true, context_before and context_after are included.',
+                default: false,
+            },
+            context_lines: {
+                type: 'number',
+                description: 'Context line count when verbose=true (default: 2)',
+                minimum: SEARCH_DOCUMENTS_CONSTANTS.CONTEXT_LINES.MIN,
+                maximum: SEARCH_DOCUMENTS_CONSTANTS.CONTEXT_LINES.MAX,
+                default: SEARCH_DOCUMENTS_CONSTANTS.CONTEXT_LINES.DEFAULT,
+            },
+            max_results: {
+                type: 'number',
+                description: 'Limit total results (default: 50)',
+                minimum: SEARCH_DOCUMENTS_CONSTANTS.MAX_RESULTS.MIN,
+                maximum: SEARCH_DOCUMENTS_CONSTANTS.MAX_RESULTS.MAX,
+                default: SEARCH_DOCUMENTS_CONSTANTS.MAX_RESULTS.DEFAULT,
+            },
+            max_match_length: {
+                type: 'number',
+                description: 'Maximum length for match_text field (default: 80). Longer matches will be truncated with "..."',
+                minimum: SEARCH_DOCUMENTS_CONSTANTS.MAX_MATCH_LENGTH.MIN,
+                maximum: SEARCH_DOCUMENTS_CONSTANTS.MAX_MATCH_LENGTH.MAX,
+                default: SEARCH_DOCUMENTS_CONSTANTS.MAX_MATCH_LENGTH.DEFAULT,
+            },
+        },
+        required: ['query'],
+        additionalProperties: false,
+    };
+}
+//# sourceMappingURL=search-documents-schemas.js.map

package/dist/tools/schemas/search-documents-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-documents-schemas.js","sourceRoot":"","sources":["../../../src/tools/schemas/search-documents-schemas.ts"],"names":[],"mappings":"AAAA;;GAEG;AAkDH;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,aAAa,EAAE;QACb,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,EAAE;QACP,OAAO,EAAE,CAAC;KACX;IACD,WAAW,EAAE;QACX,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,GAAG;QACR,OAAO,EAAE,EAAE;KACZ;IACD,gBAAgB,EAAE;QAChB,GAAG,EAAE,EAAE;QACP,GAAG,EAAE,GAAG;QACR,OAAO,EAAE,EAAE;KACZ;IACD,YAAY,EAAE,CAAC,UAAU,EAAE,OAAO,CAAU;IAC5C,mBAAmB,EAAE,UAAmB;CAChC,CAAC;AAEX;;GAEG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE;YACV,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,8BAA8B;aAC5C;YACD,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,2DAA2D;aACzE;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;gBAC3B,WAAW,EAAE,mCAAmC;gBAChD,OAAO,EAAE,0BAA0B,CAAC,mBAAmB;aACxD;YACD,OAAO,EAAE;gBACP,IAAI,EAAE,SAAS;gBACf,WAAW,EAAE,wJAAwJ;gBACrK,OAAO,EAAE,KAAK;aACf;YACD,aAAa,EAAE;gBACb,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,mDAAmD;gBAChE,OAAO,EAAE,0BAA0B,CAAC,aAAa,CAAC,GAAG;gBACrD,OAAO,EAAE,0BAA0B,CAAC,aAAa,CAAC,GAAG;gBACrD,OAAO,EAAE,0BAA0B,CAAC,aAAa,CAAC,OAAO;aAC1D;YACD,WAAW,EAAE;gBACX,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,mCAAmC;gBAChD,OAAO,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG;gBACnD,OAAO,EAAE,0BAA0B,CAAC,WAAW,CAAC,GAAG;gBACnD,OAAO,EAAE,0BAA0B,CAAC,WAAW,CAAC,OAAO;aACxD;YACD,gBAAgB,EAAE;gBAChB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,gGAAgG;gBAC7G,OAAO,EAAE,0BAA0B,CAAC,gBAAgB,CAAC,GAAG;gBACxD,OAAO,EAAE,0BAA0B,CAAC,gBAAgB,CAAC,GAAG;gBACxD,OAAO,EAAE,0BAA0B,CAAC,gBAAgB,CAAC,OAAO;aAC7D;SACF;QACD,QAAQ,EAAE,CAAC,OAAO,CAAC;QACnB,oBAAoB,EAAE,KAAK;KAC5B,CAAC;AACJ,CAAC"}

package/dist/tools/schemas/section-schemas.d.ts

@@ -0,0 +1,361 @@
+/**
+ * Schema definitions for section tool
+ *
+ * This module defines the comprehensive input validation schema for the section
+ * MCP tool, supporting unified section operations including editing existing
+ * sections, creating new sections, and deleting sections.
+ */
+/**
+ * Input schema interface for section tool
+ *
+ * Defines the structure and validation rules for section tool parameters.
+ * Supports comprehensive section management operations with automatic
+ * hierarchical addressing and flexible content manipulation.
+ *
+ * @example Single section edit (uses operations array)
+ * ```typescript
+ * const editInput = {
+ *   document: '/docs/api/authentication.md',
+ *   operations: [{
+ *     section: 'jwt-tokens',
+ *     content: 'Updated JWT token documentation...',
+ *     operation: 'replace'
+ *   }]
+ * };
+ * ```
+ *
+ * @example Creating new section (uses operations array)
+ * ```typescript
+ * const createInput = {
+ *   document: '/docs/api/endpoints.md',
+ *   operations: [{
+ *     section: 'users',  // Reference section for placement
+ *     content: 'New OAuth section content...',
+ *     operation: 'insert_after',
+ *     title: 'OAuth Integration'
+ *   }]
+ * };
+ * ```
+ *
+ * @example Multiple operations in one call
+ * ```typescript
+ * const multiInput = {
+ *   document: '/docs/api/specs.md',
+ *   operations: [
+ *     {
+ *       section: 'overview',
+ *       content: 'Updated overview...',
+ *       operation: 'replace'
+ *     },
+ *     {
+ *       section: 'overview',
+ *       content: 'New migration guide...',
+ *       operation: 'insert_after',
+ *       title: 'Migration Guide'
+ *     },
+ *     {
+ *       section: 'deprecated',
+ *       content: '',
+ *       operation: 'remove'
+ *     }
+ *   ]
+ * };
+ * ```
+ */
+export interface SectionInputSchema {
+    /** Schema type, always 'object' for MCP tools */
+    type: 'object';
+    /** Parameter definitions with detailed validation and examples */
+    properties: {
+        /**
+         * Target document path for section operations
+         *
+         * ALWAYS required - provides default context for all operations.
+         * Individual section fields can override with full path "/other.md#slug" for multi-document operations.
+         *
+         * Must be absolute path from document root including .md extension.
+         * Document must exist before performing section operations.
+         *
+         * @example Standard document paths
+         * "/docs/specs/authentication.md"
+         * "/docs/api/endpoints/users.md"
+         * "/docs/guides/setup-guide.md"
+         *
+         * @example Namespace organization
+         * "/docs/api/specs/oauth-flows.md"
+         * "/docs/user-guides/admin-panel.md"
+         */
+        document: {
+            type: 'string';
+            description: 'Document path (e.g., "/docs/specs/search-api.md"). ALWAYS required - provides default context for all operations. Individual section fields can override with full path "/other.md#slug" for multi-document operations.';
+        };
+        /**
+         * Array of section operations to perform
+         *
+         * Each operation contains section slug, operation type, content, and optional title.
+         * Always provide as an array, even for single operations.
+         */
+        operations: {
+            type: 'array';
+            description: 'Array of section operations to perform. Always pass operations as an array, even for single edits.';
+            items: {
+                type: 'object';
+                properties: {
+                    section: {
+                        type: 'string';
+                        description: 'Section slug or full path with override support. THREE FORMATS: 1) "slug" - uses document parameter as context, 2) "#slug" - uses document parameter as context (with # prefix), 3) "/other.md#slug" - overrides document parameter for this operation. Example multi-document: document="/docs/api/auth.md" with section="/docs/api/security.md#authentication" edits security.md instead.';
+                    };
+                    operation: {
+                        type: 'string';
+                        enum: ['replace', 'append', 'prepend', 'insert_before', 'insert_after', 'append_child', 'remove'];
+                        description: 'Operation type';
+                    };
+                    content: {
+                        type: 'string';
+                        description: 'Content for the operation (empty string for remove)';
+                    };
+                    title: {
+                        type: 'string';
+                        description: 'Title for new sections (required for insert_before, insert_after, append_child)';
+                    };
+                };
+                required: ['section', 'operation', 'content'];
+            };
+        };
+    };
+    /** Required parameters - document and operations array are mandatory */
+    required: ['document', 'operations'];
+    /** Prevent additional properties for strict validation */
+    additionalProperties: false;
+}
+/**
+ * Schema constants for section tool
+ */
+export declare const SECTION_CONSTANTS: {
+    readonly OPERATIONS: {
+        readonly REPLACE: "replace";
+        readonly APPEND: "append";
+        readonly PREPEND: "prepend";
+        readonly INSERT_BEFORE: "insert_before";
+        readonly INSERT_AFTER: "insert_after";
+        readonly APPEND_CHILD: "append_child";
+        readonly REMOVE: "remove";
+    };
+    readonly EDIT_OPERATIONS: readonly ["replace", "append", "prepend"];
+    readonly CREATE_OPERATIONS: readonly ["insert_before", "insert_after", "append_child"];
+    readonly DELETE_OPERATIONS: readonly ["remove"];
+    readonly DEFAULT_OPERATION: "replace";
+};
+/**
+ * Type definitions for section operations
+ *
+ * These types provide compile-time safety and categorization for section
+ * operations, enabling proper validation and operation-specific logic.
+ */
+/**
+ * Union type of all supported section operations
+ *
+ * Provides type safety for operation parameter validation and ensures
+ * only valid operations are accepted by the section tool.
+ *
+ * @example Operation validation
+ * ```typescript
+ * function validateOperation(op: string): op is SectionOperation {
+ *   const validOps: SectionOperation[] = [
+ *     'replace', 'append', 'prepend',
+ *     'insert_before', 'insert_after', 'append_child',
+ *     'remove'
+ *   ];
+ *   return validOps.includes(op as SectionOperation);
+ * }
+ * ```
+ *
+ * @see {@link EditOperation} Edit-specific operations
+ * @see {@link CreateOperation} Creation-specific operations
+ * @see {@link DeleteOperation} Deletion-specific operations
+ */
+export type SectionOperation = 'replace' | 'append' | 'prepend' | 'insert_before' | 'insert_after' | 'append_child' | 'remove';
+/**
+ * Operations for editing existing sections
+ *
+ * These operations modify the content of existing sections without
+ * changing document structure or creating new sections.
+ *
+ * @example Edit operation usage
+ * ```typescript
+ * function performEdit(
+ *   section: Section,
+ *   content: string,
+ *   operation: EditOperation
+ * ): Section {
+ *   switch (operation) {
+ *     case 'replace':
+ *       return { ...section, content };
+ *     case 'append':
+ *       return { ...section, content: section.content + '\n\n' + content };
+ *     case 'prepend':
+ *       return { ...section, content: content + '\n\n' + section.content };
+ *   }
+ * }
+ * ```
+ */
+export type EditOperation = 'replace' | 'append' | 'prepend';
+/**
+ * Operations for creating new sections
+ *
+ * These operations create new sections in the document with automatic
+ * positioning and depth calculation based on the reference section.
+ *
+ * @example Create operation usage
+ * ```typescript
+ * function performCreate(
+ *   document: Document,
+ *   referenceSection: Section,
+ *   newContent: string,
+ *   title: string,
+ *   operation: CreateOperation
+ * ): Document {
+ *   switch (operation) {
+ *     case 'insert_before':
+ *       return insertSectionBefore(document, referenceSection, { title, content: newContent });
+ *     case 'insert_after':
+ *       return insertSectionAfter(document, referenceSection, { title, content: newContent });
+ *     case 'append_child':
+ *       const childDepth = referenceSection.depth + 1;
+ *       return appendChildSection(document, referenceSection, { title, content: newContent, depth: childDepth });
+ *   }
+ * }
+ * ```
+ */
+export type CreateOperation = 'insert_before' | 'insert_after' | 'append_child';
+/**
+ * Operations for deleting sections
+ *
+ * Currently supports only complete section removal. Future versions
+ * may include partial deletion or archiving operations.
+ *
+ * @example Delete operation usage
+ * ```typescript
+ * function performDelete(
+ *   document: Document,
+ *   targetSection: Section,
+ *   operation: DeleteOperation
+ * ): Document {
+ *   switch (operation) {
+ *     case 'remove':
+ *       // Remove section and all its subsections
+ *       return removeSectionAndChildren(document, targetSection);
+ *   }
+ * }
+ * ```
+ */
+export type DeleteOperation = 'remove';
+/**
+ * Helper functions for operation validation and categorization
+ *
+ * These type guard functions provide runtime validation and categorization
+ * of section operations, enabling operation-specific logic and validation.
+ */
+/**
+ * Type guard to check if operation is an edit operation
+ *
+ * Validates that the operation modifies existing section content without
+ * creating new sections or changing document structure.
+ *
+ * @param operation - Operation string to validate
+ * @returns True if operation is replace, append, or prepend
+ *
+ * @example Operation-specific validation
+ * ```typescript
+ * function validateEditParameters(operation: string, content: string): void {
+ *   if (isEditOperation(operation)) {
+ *     if (!content || content.trim() === '') {
+ *       throw new Error('Content is required for edit operations');
+ *     }
+ *     // Edit operations don't require title
+ *   }
+ * }
+ * ```
+ *
+ * @example Conditional logic
+ * ```typescript
+ * if (isEditOperation(operation)) {
+ *   // Handle existing section modification
+ *   return await editExistingSection(document, section, content, operation);
+ * }
+ * ```
+ */
+export declare function isEditOperation(operation: string): operation is EditOperation;
+/**
+ * Type guard to check if operation is a create operation
+ *
+ * Validates that the operation creates new sections in the document
+ * with proper positioning relative to existing sections.
+ *
+ * @param operation - Operation string to validate
+ * @returns True if operation is insert_before, insert_after, or append_child
+ *
+ * @example Create operation validation
+ * ```typescript
+ * function validateCreateParameters(
+ *   operation: string,
+ *   content: string,
+ *   title?: string
+ * ): void {
+ *   if (isCreateOperation(operation)) {
+ *     if (!content || content.trim() === '') {
+ *       throw new Error('Content is required for create operations');
+ *     }
+ *     if (!title || title.trim() === '') {
+ *       throw new Error('Title is required for create operations');
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example Depth calculation for child sections
+ * ```typescript
+ * if (isCreateOperation(operation) && operation === 'append_child') {
+ *   const parentDepth = findSectionDepth(document, referenceSection);
+ *   const newDepth = parentDepth + 1;
+ *   return createSectionWithDepth(title, content, newDepth);
+ * }
+ * ```
+ */
+export declare function isCreateOperation(operation: string): operation is CreateOperation;
+/**
+ * Type guard to check if operation is a delete operation
+ *
+ * Validates that the operation removes sections from the document,
+ * including all subsections and related content.
+ *
+ * @param operation - Operation string to validate
+ * @returns True if operation is remove
+ *
+ * @example Delete operation handling
+ * ```typescript
+ * function validateDeleteOperation(operation: string): void {
+ *   if (isDeleteOperation(operation)) {
+ *     // Delete operations don't require content or title
+ *     console.warn('Delete operation will remove section and all subsections');
+ *   }
+ * }
+ * ```
+ *
+ * @example Confirmation workflow
+ * ```typescript
+ * if (isDeleteOperation(operation)) {
+ *   const subsections = findSubsections(document, targetSection);
+ *   if (subsections.length > 0) {
+ *     console.log(`Warning: Will also delete ${subsections.length} subsections`);
+ *   }
+ *   return await deleteSection(document, targetSection);
+ * }
+ * ```
+ */
+export declare function isDeleteOperation(operation: string): operation is DeleteOperation;
+/**
+ * Get the input schema for section tool (bulk operations only)
+ */
+export declare function getSectionSchema(): SectionInputSchema;
+//# sourceMappingURL=section-schemas.d.ts.map