@vfarcic/dot-ai 0.115.0 → 0.117.0

package/dist/core/platform-operations.js

@@ -1,294 +0,0 @@
-"use strict";
-/**
- * Platform Operations Discovery
- *
- * Orchestrates tool-based discovery and mapping of Nu shell script operations.
- * All data fetching logic lives in tools, this module handles orchestration.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.discoverOperations = discoverOperations;
-exports.mapIntentToOperation = mapIntentToOperation;
-exports.getOperationParameters = getOperationParameters;
-exports.createSession = createSession;
-exports.loadSession = loadSession;
-exports.executeOperation = executeOperation;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const platform_utils_1 = require("./platform-utils");
-/**
- * Discover available operations from Nu shell scripts
- * Uses tool for data fetching and prompt injection for AI parsing
- */
-async function discoverOperations(aiProvider, logger) {
-    try {
-        // Import the tool execution function
-        const { executeDiscoverOperations } = await Promise.resolve().then(() => __importStar(require('../tools/platform/discover-operations.tool')));
-        // Execute tool directly to get help output
-        const toolResult = await executeDiscoverOperations({}, aiProvider, logger);
-        if (!toolResult.success || !toolResult.helpOutput) {
-            throw new Error(toolResult.error || 'Failed to get Nu script help output');
-        }
-        // Load the parsing prompt template
-        const promptPath = path.join(process.cwd(), 'prompts', 'platform-operations-parse-script-help.md');
-        const promptTemplate = fs.readFileSync(promptPath, 'utf8');
-        // Inject help output into prompt
-        const prompt = promptTemplate.replace('{helpOutput}', toolResult.helpOutput);
-        // Single AI call with injected data
-        const response = await aiProvider.sendMessage(prompt, 'platform-discover-operations');
-        // Parse operations from AI response
-        const operations = (0, platform_utils_1.extractJsonFromAIResponse)(response.content);
-        logger.info?.('Discovered operations from Nu scripts', {
-            count: operations.length
-        });
-        return operations;
-    }
-    catch (error) {
-        logger.error?.('Failed to discover operations', error);
-        throw error;
-    }
-}
-/**
- * Map user intent to a specific operation using AI
- */
-async function mapIntentToOperation(intent, operations, aiProvider, logger) {
-    try {
-        // Load AI prompt template for intent mapping
-        const promptPath = path.join(process.cwd(), 'prompts', 'map-intent-to-operation.md');
-        const promptTemplate = fs.readFileSync(promptPath, 'utf8');
-        // Replace template variables
-        const prompt = promptTemplate
-            .replace('{intent}', intent)
-            .replace('{operations}', JSON.stringify(operations, null, 2));
-        // Send to AI provider for AI-powered intent matching
-        const response = await aiProvider.sendMessage(prompt, 'platform-map-intent');
-        // Extract JSON from AI response with robust parsing
-        const mapping = (0, platform_utils_1.extractJsonFromAIResponse)(response.content);
-        // Validate that AI returned required fields
-        if (mapping.matched && mapping.operation) {
-            if (!mapping.operation.command || !Array.isArray(mapping.operation.command)) {
-                throw new Error(`AI did not return valid command array. Response: ${JSON.stringify(mapping)}`);
-            }
-        }
-        logger.info?.('Mapped user intent to operation', {
-            intent,
-            matched: mapping.matched,
-            operation: mapping.operation?.tool,
-            command: mapping.operation?.command
-        });
-        return mapping;
-    }
-    catch (error) {
-        logger.error?.('Failed to map intent to operation', error);
-        throw error;
-    }
-}
-/**
- * Get parameters for a specific operation using Nushell's structured JSON output
- */
-async function getOperationParameters(command, logger) {
-    try {
-        // Build the full command name that Nushell expects
-        const commandName = `main ${command.join(' ')}`;
-        // Execute Nu script to get structured command metadata
-        const scriptPath = path.join((0, platform_utils_1.getScriptsDir)(), 'dot.nu');
-        const nuCommand = `source ${scriptPath}; scope commands | where name == "${commandName}" | to json`;
-        const { stdout, stderr } = await (0, platform_utils_1.execAsync)(`nu -c '${nuCommand}'`);
-        if (stderr) {
-            logger.warn?.('Nu scope commands produced stderr', { stderr });
-        }
-        // Parse JSON response
-        const commands = JSON.parse(stdout);
-        if (!commands || commands.length === 0) {
-            logger.warn?.('No command metadata found', { commandName });
-            return [];
-        }
-        const commandMetadata = commands[0];
-        const signatures = commandMetadata.signatures?.any || [];
-        // Filter and transform parameter data
-        const parameters = [];
-        for (const param of signatures) {
-            // Skip input/output parameters
-            if (param.parameter_type === 'input' || param.parameter_type === 'output') {
-                continue;
-            }
-            // Skip help parameter
-            if (param.parameter_name === 'help') {
-                continue;
-            }
-            // Map Nushell types to our types
-            let type = 'string';
-            if (param.syntax_shape === 'bool') {
-                type = 'boolean';
-            }
-            else if (param.syntax_shape === 'int') {
-                type = 'number';
-            }
-            else if (param.syntax_shape === 'string') {
-                type = 'string';
-            }
-            // Determine if required (positional parameters are typically required)
-            const required = param.parameter_type === 'positional' && !param.is_optional;
-            parameters.push({
-                name: param.parameter_name,
-                type,
-                required,
-                description: param.description || '',
-                default: param.parameter_default
-            });
-        }
-        logger.info?.('Retrieved operation parameters', {
-            command: commandName,
-            parameterCount: parameters.length
-        });
-        return parameters;
-    }
-    catch (error) {
-        logger.error?.('Failed to get operation parameters', error);
-        throw error;
-    }
-}
-/**
- * Create and persist a platform session
- */
-async function createSession(sessionId, intent, matchedOperation, parameters, logger) {
-    try {
-        const session = {
-            sessionId,
-            intent,
-            matchedOperation,
-            parameters,
-            answers: {},
-            currentStep: 'collectParameters',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
-        };
-        // Ensure session directory exists
-        const sessionDir = path.join(process.cwd(), 'tmp', 'sessions', 'platform');
-        if (!fs.existsSync(sessionDir)) {
-            fs.mkdirSync(sessionDir, { recursive: true });
-        }
-        // Write session file
-        const sessionPath = path.join(sessionDir, `${sessionId}.json`);
-        fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2), 'utf8');
-        logger.info?.('Created platform session', { sessionId, intent });
-        return session;
-    }
-    catch (error) {
-        logger.error?.('Failed to create platform session', error);
-        throw error;
-    }
-}
-/**
- * Load a platform session from file
- */
-function loadSession(sessionId, logger) {
-    try {
-        const sessionPath = path.join(process.cwd(), 'tmp', 'sessions', 'platform', `${sessionId}.json`);
-        if (!fs.existsSync(sessionPath)) {
-            logger.warn?.('Session file not found', { sessionId });
-            return null;
-        }
-        const sessionData = fs.readFileSync(sessionPath, 'utf8');
-        const session = JSON.parse(sessionData);
-        logger.info?.('Loaded platform session', { sessionId });
-        return session;
-    }
-    catch (error) {
-        logger.error?.('Failed to load platform session', error);
-        throw error;
-    }
-}
-/**
- * Execute a platform operation with collected parameters
- */
-async function executeOperation(session, answers, logger) {
-    try {
-        // Validate required parameters
-        const missingRequired = session.parameters
-            .filter(p => p.required && !(p.name in answers))
-            .map(p => p.name);
-        if (missingRequired.length > 0) {
-            return {
-                success: false,
-                error: `Missing required parameters: ${missingRequired.join(', ')}`,
-                missingParameters: missingRequired
-            };
-        }
-        // Merge answers with defaults for optional parameters
-        const finalAnswers = { ...answers };
-        for (const param of session.parameters) {
-            if (!(param.name in finalAnswers) && param.default !== undefined) {
-                finalAnswers[param.name] = param.default;
-            }
-        }
-        // Build Nu script command
-        const scriptPath = path.join((0, platform_utils_1.getScriptsDir)(), 'dot.nu');
-        const command = session.matchedOperation.command;
-        // Build command arguments
-        const args = [];
-        for (const param of session.parameters) {
-            const value = finalAnswers[param.name];
-            if (value !== undefined) {
-                args.push(`--${param.name}`);
-                args.push(String(value));
-            }
-        }
-        const fullCommand = `nu ${scriptPath} ${command.join(' ')} ${args.join(' ')}`;
-        logger.info?.('Executing platform operation', {
-            sessionId: session.sessionId,
-            command: fullCommand
-        });
-        const { stdout, stderr } = await (0, platform_utils_1.execAsync)(fullCommand);
-        if (stderr) {
-            logger.warn?.('Operation produced stderr', { stderr });
-        }
-        logger.info?.('Platform operation completed', {
-            sessionId: session.sessionId,
-            stdout: stdout.substring(0, 500) // Log first 500 chars
-        });
-        return {
-            success: true,
-            message: `Successfully executed ${session.matchedOperation.tool} ${session.matchedOperation.operation}`
-        };
-    }
-    catch (error) {
-        logger.error?.('Failed to execute platform operation', error);
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}

package/dist/tools/build-platform.d.ts

@@ -1,25 +0,0 @@
-/**
- * Build Platform Tool for MCP Server
- *
- * AI-powered tool that enables users to build and manage Kubernetes platforms
- * through natural language intent. Handles script discovery, parameter collection,
- * and execution transparently.
- *
- * Phase 1: Basic invocation and Nushell runtime validation
- */
-import { z } from 'zod';
-import { Logger } from '../core/error-handling';
-import { DotAI } from '../core/index';
-export declare const BUILD_PLATFORM_TOOL_NAME = "buildPlatform";
-export declare const BUILD_PLATFORM_TOOL_DESCRIPTION = "AI-powered platform operations tool for building and managing Kubernetes platforms. Use this to: (1) LIST/DISCOVER what tools and operations are available - use stage=\"list\" when user asks \"what can I install\", \"show available tools\", \"list platform capabilities\", (2) INSTALL/CREATE platform components like Argo CD, Crossplane, cert-manager, Kubernetes clusters through natural language intent. Handles tool installation, cluster creation, and platform configuration conversationally.";
-export declare const BUILD_PLATFORM_TOOL_INPUT_SCHEMA: {
-    stage: z.ZodOptional<z.ZodString>;
-    intent: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    answers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-};
-/**
- * Main tool handler - Phase 1 & 2: Script discovery and intent mapping
- */
-export declare function handleBuildPlatformTool(args: any, dotAI: DotAI, logger: Logger, requestId: string): Promise<any>;
-//# sourceMappingURL=build-platform.d.ts.map

package/dist/tools/build-platform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build-platform.d.ts","sourceRoot":"","sources":["../../src/tools/build-platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGhD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAItC,eAAO,MAAM,wBAAwB,kBAAkB,CAAC;AACxD,eAAO,MAAM,+BAA+B,mfAA2e,CAAC;AAuBxhB,eAAO,MAAM,gCAAgC;;;;;CAY5C,CAAC;AAEF;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,CAgQd"}

package/dist/tools/build-platform.js

@@ -1,277 +0,0 @@
-"use strict";
-/**
- * Build Platform Tool for MCP Server
- *
- * AI-powered tool that enables users to build and manage Kubernetes platforms
- * through natural language intent. Handles script discovery, parameter collection,
- * and execution transparently.
- *
- * Phase 1: Basic invocation and Nushell runtime validation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILD_PLATFORM_TOOL_INPUT_SCHEMA = exports.BUILD_PLATFORM_TOOL_DESCRIPTION = exports.BUILD_PLATFORM_TOOL_NAME = void 0;
-exports.handleBuildPlatformTool = handleBuildPlatformTool;
-const zod_1 = require("zod");
-const nushell_runtime_1 = require("../core/nushell-runtime");
-const platform_operations_1 = require("../core/platform-operations");
-const crypto_1 = require("crypto");
-// Tool metadata for MCP registration
-exports.BUILD_PLATFORM_TOOL_NAME = 'buildPlatform';
-exports.BUILD_PLATFORM_TOOL_DESCRIPTION = 'AI-powered platform operations tool for building and managing Kubernetes platforms. Use this to: (1) LIST/DISCOVER what tools and operations are available - use stage="list" when user asks "what can I install", "show available tools", "list platform capabilities", (2) INSTALL/CREATE platform components like Argo CD, Crossplane, cert-manager, Kubernetes clusters through natural language intent. Handles tool installation, cluster creation, and platform configuration conversationally.';
-/**
- * Create execution started response (terminal state - no further MCP calls needed)
- */
-function createExecutionResponse(tool, operation) {
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({
-                    success: true,
-                    execution: {
-                        tool,
-                        operation,
-                        status: 'started',
-                        message: `${tool} ${operation} execution started. Monitor progress using kubectl or other cluster tools. No further action required.`
-                    }
-                }, null, 2)
-            }]
-    };
-}
-// Tool input schema
-exports.BUILD_PLATFORM_TOOL_INPUT_SCHEMA = {
-    stage: zod_1.z.string().optional()
-        .describe('Workflow stage: "list" (discover all operations) or "submitAnswers" (submit answers and execute). Omit when providing intent for the first time.'),
-    intent: zod_1.z.string().optional()
-        .describe('Natural language intent describing what platform operation to perform (e.g., "Install Argo CD", "Create AWS cluster"). Used when stage is omitted.'),
-    sessionId: zod_1.z.string().optional()
-        .describe('Session ID for continuing a multi-step workflow (required for submitAnswers stage)'),
-    answers: zod_1.z.record(zod_1.z.any()).optional()
-        .describe('Parameter answers for submitAnswers stage (e.g., {"host-name": "example.com", "apply-apps": true})')
-};
-/**
- * Main tool handler - Phase 1 & 2: Script discovery and intent mapping
- */
-async function handleBuildPlatformTool(args, dotAI, logger, requestId) {
-    try {
-        const { stage, intent, sessionId, answers } = args;
-        logger.info('Processing buildPlatform tool request', {
-            requestId,
-            stage,
-            hasIntent: !!intent,
-            hasSessionId: !!sessionId,
-            hasAnswers: !!answers
-        });
-        // Validate required parameters - either stage or intent must be provided
-        if (!stage && !intent) {
-            logger.warn('buildPlatform request missing both stage and intent parameters', { requestId });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: {
-                                message: 'Either stage or intent parameter is required. Use stage: "list" to discover operations, or provide intent like "Install Argo CD"'
-                            }
-                        }, null, 2)
-                    }]
-            };
-        }
-        // Validate Nushell runtime availability
-        const runtime = new nushell_runtime_1.NushellRuntime();
-        const validation = await runtime.validateRuntime();
-        if (!validation.ready) {
-            logger.warn('Nushell runtime not available', {
-                requestId,
-                error: validation.message
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: {
-                                message: 'Nushell runtime required for platform operations',
-                                details: validation.message,
-                                installationUrl: validation.installationUrl
-                            }
-                        }, null, 2)
-                    }]
-            };
-        }
-        // Phase 2: Handle stage: 'list' - discover all operations
-        if (stage === 'list') {
-            logger.info('Discovering available operations', { requestId });
-            const operations = await (0, platform_operations_1.discoverOperations)(dotAI.ai, logger);
-            const result = {
-                success: true,
-                operations,
-                message: `Found ${operations.length} platform tools. Present to user as numbered list showing each tool's available operations (install/delete/create/etc). When user selects (by number or name), convert their selection to natural language intent and call this tool again with the 'intent' parameter (e.g., intent: 'Install Crossplane' or 'Delete ACK').`
-            };
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        }
-        // Phase 3: Handle stage: 'submitAnswers' - execute with collected parameters
-        if (stage === 'submitAnswers') {
-            if (!sessionId) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: {
-                                    message: 'sessionId is required for submitAnswers stage'
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            logger.info('Processing submitAnswers stage', { requestId, sessionId });
-            // Load session
-            const session = (0, platform_operations_1.loadSession)(sessionId, logger);
-            if (!session) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: {
-                                    message: `Session ${sessionId} not found`
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            // Execute operation with answers
-            const executionResult = await (0, platform_operations_1.executeOperation)(session, answers || {}, logger);
-            if (!executionResult.success) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: {
-                                    message: executionResult.error,
-                                    missingParameters: executionResult.missingParameters
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            return createExecutionResponse(session.matchedOperation.tool, session.matchedOperation.operation);
-        }
-        // Phase 3: Intent-based workflow with AI mapping and parameter discovery
-        const workflowSessionId = sessionId || `platform-${Date.now()}-${(0, crypto_1.randomUUID)()}`;
-        logger.info('Nushell runtime validated, starting intent mapping', {
-            requestId,
-            sessionId: workflowSessionId,
-            intent
-        });
-        // Discover operations for intent mapping
-        const operations = await (0, platform_operations_1.discoverOperations)(dotAI.ai, logger);
-        // Map intent to operation using AI
-        const mapping = await (0, platform_operations_1.mapIntentToOperation)(intent, operations, dotAI.ai, logger);
-        // Handle no match case
-        if (!mapping.matched) {
-            logger.info('No matching operation found for intent', {
-                requestId,
-                intent,
-                reason: mapping.reason
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: {
-                                message: mapping.reason || 'No matching operation found for the given intent',
-                                suggestion: 'Use stage: \'list\' to see all available operations'
-                            }
-                        }, null, 2)
-                    }]
-            };
-        }
-        // Get parameters for the matched operation
-        const parameters = await (0, platform_operations_1.getOperationParameters)(mapping.operation.command, logger);
-        logger.info('Intent mapped and parameters retrieved', {
-            requestId,
-            tool: mapping.operation.tool,
-            parameterCount: parameters.length
-        });
-        // Create and persist session
-        await (0, platform_operations_1.createSession)(workflowSessionId, intent, mapping.operation, parameters, logger);
-        // If no parameters, execute immediately (skip to submitAnswers stage)
-        if (parameters.length === 0) {
-            logger.info('No parameters required, executing immediately', {
-                requestId,
-                sessionId: workflowSessionId
-            });
-            // Reuse submitAnswers stage logic with empty answers
-            const session = (0, platform_operations_1.loadSession)(workflowSessionId, logger);
-            if (!session) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: {
-                                    message: `Session ${workflowSessionId} not found`
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            const executionResult = await (0, platform_operations_1.executeOperation)(session, {}, logger);
-            if (!executionResult.success) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: {
-                                    message: executionResult.error
-                                }
-                            }, null, 2)
-                        }]
-                };
-            }
-            return createExecutionResponse(session.matchedOperation.tool, session.matchedOperation.operation);
-        }
-        const result = {
-            success: true,
-            workflow: {
-                sessionId: workflowSessionId,
-                intent: intent,
-                matchedOperation: mapping.operation,
-                parameters,
-                nextStep: 'collectParameters',
-                message: `Found ${parameters.length} parameters for ${mapping.operation.tool} ${mapping.operation.operation}. Collect answers from user (one at a time or all at once - user decides via client agent), then call this tool again with stage: "submitAnswers", sessionId: "${workflowSessionId}", and answers: {param1: value1, ...}`
-            }
-        };
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2)
-                }]
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error('buildPlatform tool request failed', error, { requestId });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: {
-                            message: 'Tool execution failed',
-                            details: errorMessage
-                        }
-                    }, null, 2)
-                }]
-        };
-    }
-}

package/dist/tools/test-docs.d.ts

@@ -1,22 +0,0 @@
-/**
- * Test Docs Tool - Documentation testing workflow orchestrator
- */
-import { z } from 'zod';
-import { DotAI } from '../core/index';
-import { Logger } from '../core/error-handling';
-export declare const TESTDOCS_TOOL_NAME = "testDocs";
-export declare const TESTDOCS_TOOL_DESCRIPTION = "Test, validate, check, scan, verify, analyze, or review documentation files for accuracy, functionality, broken examples, outdated commands, invalid links, and overall quality. Use this tool whenever the user wants to test docs, validate documentation, check if examples work, scan for issues, verify commands, analyze doc quality, or review documentation content. IMPORTANT: This tool returns a workflow step with a \"prompt\" field - you must execute that prompt immediately to perform the actual documentation analysis.";
-export declare const TESTDOCS_TOOL_INPUT_SCHEMA: {
-    filePath: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    phase: z.ZodOptional<z.ZodEnum<["scan", "test", "analyze", "fix", "done"]>>;
-    sectionId: z.ZodOptional<z.ZodString>;
-    results: z.ZodOptional<z.ZodString>;
-    filePattern: z.ZodOptional<z.ZodString>;
-    interaction_id: z.ZodOptional<z.ZodString>;
-};
-/**
- * Handle test-docs tool request
- */
-export declare function handleTestDocsTool(args: any, _dotAI: DotAI | null, logger: Logger, requestId: string): Promise<any>;
-//# sourceMappingURL=test-docs.d.ts.map

package/dist/tools/test-docs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-docs.d.ts","sourceRoot":"","sources":["../../src/tools/test-docs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAOhD,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAC7C,eAAO,MAAM,yBAAyB,+gBAA6gB,CAAC;AAGpjB,eAAO,MAAM,0BAA0B;;;;;;;;CAQtC,CAAC;AAEF;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,KAAK,GAAG,IAAI,EACpB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,GAAG,CAAC,CAkWd"}