crewx 0.3.0 → 0.4.0-dev.1

package/dist/crewx.tool.js

@@ -1,1463 +0,0 @@
-"use strict";
-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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-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;
-    };
-})();
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var CrewXTool_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrewXTool = void 0;
-const common_1 = require("@nestjs/common");
-const nestjs_mcp_adapter_1 = require("@sowonai/nestjs-mcp-adapter");
-const zod_1 = require("zod");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const crypto = __importStar(require("crypto"));
-const ai_service_1 = require("./ai.service");
-const ai_provider_service_1 = require("./ai-provider.service");
-const project_service_1 = require("./project.service");
-const constants_1 = require("./constants");
-const error_utils_1 = require("./utils/error-utils");
-const parallel_processing_service_1 = require("./services/parallel-processing.service");
-const task_management_service_1 = require("./services/task-management.service");
-const result_formatter_service_1 = require("./services/result-formatter.service");
-const template_service_1 = require("./services/template.service");
-const document_loader_service_1 = require("./services/document-loader.service");
-const tool_call_service_1 = require("./services/tool-call.service");
-const agent_loader_service_1 = require("./services/agent-loader.service");
-const timeout_config_1 = require("./config/timeout.config");
-const remote_agent_service_1 = require("./services/remote-agent.service");
-let CrewXTool = CrewXTool_1 = class CrewXTool {
-    generateSecurityKey() {
-        return crypto.randomBytes(8).toString('hex');
-    }
-    buildToolsContext() {
-        const tools = this.toolCallService.list();
-        if (!tools || tools.length === 0) {
-            return undefined;
-        }
-        return {
-            list: tools.map(t => ({
-                name: t.name,
-                description: t.description,
-                input_schema: t.input_schema,
-                output_schema: t.output_schema,
-            })),
-            json: JSON.stringify(tools, null, 2),
-            count: tools.length,
-        };
-    }
-    async buildStructuredPayload(params) {
-        const { agentId, provider, mode, prompt, context, messages, platform, model } = params;
-        const safeMessages = Array.isArray(messages) ? messages : [];
-        let formattedHistory = '';
-        try {
-            if (safeMessages.length > 0) {
-                const template = '{{{formatConversation messages platform}}}';
-                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
-                formattedHistory = await processDocumentTemplate(template, this.documentLoaderService, {
-                    messages: safeMessages,
-                    platform: platform ?? 'cli',
-                });
-                formattedHistory = formattedHistory?.trim() ?? '';
-            }
-        }
-        catch (error) {
-            this.logger.warn(`Failed to format conversation history for structured payload: ${error?.message || error}`);
-        }
-        const normalizedContext = context?.trim() ?? '';
-        const payload = {
-            version: '1.0',
-            agent: {
-                id: agentId,
-                provider,
-                mode,
-                model: model || null,
-            },
-            prompt,
-            context: normalizedContext,
-            messages: safeMessages,
-            metadata: {
-                platform: platform ?? 'cli',
-                formattedHistory,
-                messageCount: safeMessages.length,
-                generatedAt: new Date().toISOString(),
-                originalContext: normalizedContext,
-            },
-        };
-        return JSON.stringify(payload);
-    }
-    constructor(aiService, aiProviderService, projectService, parallelProcessingService, taskManagementService, resultFormatterService, templateService, documentLoaderService, toolCallService, agentLoaderService, remoteAgentService) {
-        this.aiService = aiService;
-        this.aiProviderService = aiProviderService;
-        this.projectService = projectService;
-        this.parallelProcessingService = parallelProcessingService;
-        this.taskManagementService = taskManagementService;
-        this.resultFormatterService = resultFormatterService;
-        this.templateService = templateService;
-        this.documentLoaderService = documentLoaderService;
-        this.toolCallService = toolCallService;
-        this.agentLoaderService = agentLoaderService;
-        this.remoteAgentService = remoteAgentService;
-        this.logger = new common_1.Logger(CrewXTool_1.name);
-        this.timeoutConfig = (0, timeout_config_1.getTimeoutConfig)();
-    }
-    onModuleInit() {
-        this.toolCallService.setCrewXTool(this);
-        this.logger.log('CrewXTool registered to ToolCallService');
-    }
-    async getTaskLogs(input) {
-        this.logger.log('=== getTaskLogs called ===');
-        this.logger.log(`Input taskId: ${input.taskId}`);
-        try {
-            const logsContent = this.taskManagementService.getTaskLogsFromFile(input.taskId);
-            return {
-                content: [{ type: 'text', text: logsContent }],
-                isError: false
-            };
-        }
-        catch (error) {
-            this.logger.error('Error reading logs:', error);
-            return {
-                content: [{ type: 'text', text: `Error reading logs: ${error.message}` }],
-                isError: true
-            };
-        }
-    }
-    async checkAIProviders() {
-        this.logger.log('Checking AI provider availability');
-        try {
-            const availableProviders = await this.aiService.checkAvailableProviders();
-            const installation = await this.aiService.validateCLIInstallation();
-            const recommendations = this.getInstallationRecommendations(installation);
-            const responseText = `🤖 **AI Providers Status**
-
-**Available Providers:**
-${availableProviders.length > 0 ? availableProviders.map(p => `✅ ${p}`).join('\n') : '❌ No providers available'}
-
-**Installation Status:**
-• Claude CLI: ${installation.claude ? '✅ Installed' : '❌ Not Installed'}
-• Gemini CLI: ${installation.gemini ? '✅ Installed' : '❌ Not Installed'}  
-• Copilot CLI: ${installation.copilot ? '✅ Installed' : '❌ Not Installed'}
-
-**Recommendations:**
-${recommendations.map(r => `• ${r}`).join('\n')}`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText
-                    }
-                ],
-                success: true,
-                availableProviders,
-                installation: {
-                    claude: installation.claude,
-                    gemini: installation.gemini,
-                    copilot: installation.copilot,
-                },
-                recommendations,
-            };
-        }
-        catch (error) {
-            const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-            this.logger.error(`Provider check failed: ${errorMessage}`, (0, error_utils_1.getErrorStack)(error));
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ **AI Providers Check Failed**
-
-**Error:** ${errorMessage}
-
-No AI providers could be verified.`
-                    }
-                ],
-                success: false,
-                error: errorMessage,
-                availableProviders: [],
-                installation: {
-                    claude: { installed: false },
-                    gemini: { installed: false },
-                    copilot: { installed: false }
-                }
-            };
-        }
-    }
-    getInstallationRecommendations(installation) {
-        const recommendations = [];
-        if (!installation.claude) {
-            recommendations.push('Claude CLI installation: npm install -g @anthropic-ai/claude-code');
-        }
-        if (!installation.gemini) {
-            recommendations.push('Gemini CLI installation: npm install -g @google/gemini-cli');
-        }
-        if (!installation.copilot) {
-            recommendations.push('GitHub Copilot CLI installation: npm install -g @github/copilot-cli or gh extension install github/gh-copilot');
-        }
-        if (installation.claude && installation.gemini && installation.copilot) {
-            recommendations.push('All AI providers are available!');
-        }
-        return recommendations;
-    }
-    async listAgents() {
-        try {
-            const agents = await this.agentLoaderService.getAllAgents();
-            this.logger.log(`Retrieved ${agents.length} available agents`);
-            const agentsConfigPath = process.env.CREWX_CONFIG;
-            let yamlContent = '';
-            if (agentsConfigPath) {
-                try {
-                    const { readFile } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
-                    yamlContent = await readFile(agentsConfigPath, 'utf-8');
-                }
-                catch (error) {
-                    this.logger.warn('Could not read YAML file for display:', (0, error_utils_1.getErrorMessage)(error));
-                }
-            }
-            const responseText = `🤖 **Available AI Agents (${agents.length} total)**
-
-**Configuration Source:** ${process.env.CREWX_CONFIG ? 'External YAML file' : 'Built-in defaults'}
-${process.env.CREWX_CONFIG ? `**Config Path:** \`${process.env.CREWX_CONFIG}\`` : ''}
-
-**Parsed Agent Summary:**
-${agents.map((agent, index) => `${index + 1}. **${agent.id}**
-   - Provider: ${agent.provider}
-   - Working Dir: ${agent.workingDirectory}
-   ${agent.name ? `- Name: ${agent.name}` : ''}
-   ${agent.role ? `- Role: ${agent.role}` : ''}
-   ${agent.team ? `- Team: ${agent.team}` : ''}
-`).join('')}
-
-${yamlContent ? `**Full YAML Configuration:**
-\`\`\`yaml
-${yamlContent}
-\`\`\`
-
-**💡 Customization Guide:**
-You can customize agents by modifying the YAML file. Required fields:
-- \`id\`: Unique identifier
-- \`working_directory\`: Path for agent operations  
-- \`inline.provider\`: AI provider (claude/gemini/copilot)
-- \`inline.system_prompt\`: Agent's specialized instructions
-
-Optional fields (like \`name\`, \`role\`, \`team\`, etc.) can be added for better organization.` : `**Default Configuration:**
-No external YAML file configured. Using built-in agents.
-Set \`CREWX_CONFIG\` environment variable to use custom agents.
-
-**Example YAML Structure:**
-\`\`\`yaml
-agents:
-  - id: "your_agent_id"
-    name: "Your Agent Name"
-    role: "specialist"
-    working_directory: "/path/to/project"
-    inline:
-      type: "agent"
-      provider: "claude"
-      system_prompt: |
-        You are a specialized AI agent for...
-\`\`\``}
-
-**Recommendations:**
-
-**🚀 Performance Tip:** For optimal results, formulate queries in English. Testing shows English queries typically produce more detailed responses, faster processing times (20% improvement), and higher success rates compared to other languages.
-
-**Configuration Source:** ${process.env.CREWX_CONFIG ? 'External YAML file' : 'Default hardcoded values'}`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText
-                    }
-                ],
-                success: true,
-                availableAgents: agents,
-                totalCount: agents.length,
-                configurationSource: process.env.CREWX_CONFIG ? 'External YAML file' : 'Default hardcoded values'
-            };
-        }
-        catch (error) {
-            const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-            this.logger.error('Agent listing failed:', errorMessage);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ **Error loading agents:** ${errorMessage}
-
-**Fallback:** No agents available due to configuration error.`
-                    }
-                ],
-                success: false,
-                error: errorMessage,
-                availableAgents: [],
-                totalCount: 0
-            };
-        }
-    }
-    async queryAgent(args) {
-        const taskId = this.taskManagementService.createTask({
-            type: 'query',
-            provider: 'claude',
-            prompt: args.query,
-            agentId: args.agentId
-        });
-        const agentDescriptor = args.model ? `${args.agentId} (model: ${args.model})` : args.agentId;
-        this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Started query agent ${agentDescriptor}` });
-        try {
-            const { agentId, query, context, model, messages, platform } = args;
-            this.logger.log(`[${taskId}] Querying agent ${agentId}: ${query.substring(0, 50)}...`);
-            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Query: ${query.substring(0, 100)}...` });
-            if (model) {
-                this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Model: ${model}` });
-            }
-            const agents = await this.agentLoaderService.getAllAgents();
-            const agent = agents.find(a => a.id === agentId);
-            if (!agent) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ **Agent Not Found**
-
-**Error:** Agent '${agentId}' not found.
-
-**Available Agents:** ${agents.map(a => a.id).join(', ')}
-
-Please check the agent ID and try again.`
-                        }
-                    ],
-                    success: false,
-                    agent: agentId,
-                    error: `Agent '${agentId}' not found`,
-                    availableAgents: agents.map(a => a.id),
-                    readOnlyMode: true
-                };
-            }
-            if (agent.remote?.type === 'mcp-http') {
-                try {
-                    const remoteResult = await this.remoteAgentService.queryRemoteAgent(agent, {
-                        query,
-                        context,
-                        model,
-                        platform,
-                        messages,
-                    });
-                    const normalized = this.normalizeRemoteResult(agent, taskId, remoteResult, true);
-                    const logLevel = normalized.success ? 'info' : 'error';
-                    this.taskManagementService.addTaskLog(taskId, {
-                        level: logLevel,
-                        message: normalized.success
-                            ? 'Remote agent query completed successfully'
-                            : `Remote agent query failed: ${normalized.error || 'Unknown error'}`,
-                    });
-                    this.taskManagementService.completeTask(taskId, normalized, normalized.success !== false);
-                    return normalized;
-                }
-                catch (error) {
-                    const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-                    this.taskManagementService.addTaskLog(taskId, {
-                        level: 'error',
-                        message: `Remote agent query failed: ${errorMessage}`,
-                    });
-                    this.taskManagementService.completeTask(taskId, { success: false, error: errorMessage }, false);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ **Remote agent error**\n\n\
-${errorMessage}`,
-                            },
-                        ],
-                        success: false,
-                        agent: agentId,
-                        provider: 'remote',
-                        error: errorMessage,
-                        taskId,
-                        readOnlyMode: true,
-                        readOnly: true,
-                    };
-                }
-            }
-            const workingDir = agent.workingDirectory || process.cwd();
-            let systemPrompt = agent.systemPrompt || agent.description || `You are an expert ${agentId}.`;
-            const securityKey = this.generateSecurityKey();
-            if (systemPrompt) {
-                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
-                const contextMessages = messages && messages.length > 0 ? messages.slice(0, -1) : [];
-                const templateContext = {
-                    env: process.env,
-                    agent: {
-                        id: agent.id,
-                        name: agent.name || agent.id,
-                        provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
-                        model: model || agent.inline?.model,
-                        workingDirectory: workingDir,
-                    },
-                    mode: 'query',
-                    messages: contextMessages,
-                    platform: platform,
-                    tools: this.buildToolsContext(),
-                    vars: {
-                        security_key: securityKey,
-                    },
-                };
-                systemPrompt = await processDocumentTemplate(systemPrompt, this.documentLoaderService, templateContext);
-            }
-            systemPrompt += `
-
-Specialties: ${agent.specialties?.join(', ') || 'General'}
-Capabilities: ${agent.capabilities?.join(', ') || 'Analysis'}
-Working Directory: ${workingDir}`;
-            const wrappedQuery = `
-<user_query key="${securityKey}">
-${query}
-</user_query>`;
-            let fullPrompt = systemPrompt;
-            if (context) {
-                fullPrompt += `\n\n${context}`;
-            }
-            fullPrompt += `\n\n${wrappedQuery}`;
-            let response;
-            let provider;
-            if (Array.isArray(agent.provider)) {
-                if (agent.inline?.model || model) {
-                    provider = agent.provider[0] || 'claude';
-                }
-                else {
-                    provider = await this.getAvailableProvider(agent.provider);
-                    this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Using fallback provider: ${provider}` });
-                }
-            }
-            else {
-                provider = agent.provider || 'claude';
-            }
-            const agentOptions = this.getOptionsForAgent(agent, 'query', provider);
-            const modelToUse = model || agent.inline?.model;
-            const structuredPayload = await this.buildStructuredPayload({
-                agentId,
-                provider,
-                mode: 'query',
-                prompt: fullPrompt,
-                context,
-                messages,
-                platform: platform || 'cli',
-                model: modelToUse,
-            });
-            response = await this.aiService.queryAI(fullPrompt, provider, {
-                workingDirectory: workingDir,
-                timeout: this.timeoutConfig.parallel,
-                additionalArgs: agentOptions,
-                taskId,
-                model: modelToUse,
-                agentId,
-                securityKey,
-                messages,
-                pipedContext: structuredPayload,
-            });
-            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Query completed. Success: ${response.success}` });
-            this.taskManagementService.completeTask(taskId, response, response.success);
-            const responseText = response.success
-                ? response.content
-                : `❌ **Error**\n\`\`\`${response.error}\`\`\`\n\nAgent: ${agentId} (${response.provider}) · Task ID: \`${taskId}\``;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText
-                    }
-                ],
-                taskId: taskId,
-                success: response.success,
-                agent: agentId,
-                provider: response.provider,
-                query: query,
-                response: response.content,
-                readOnlyMode: true,
-                error: response.error,
-                workingDirectory: workingDir
-            };
-        }
-        catch (error) {
-            const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-            this.taskManagementService.addTaskLog(taskId, { level: 'error', message: `Query failed: ${errorMessage}` });
-            this.taskManagementService.completeTask(taskId, { error: errorMessage }, false);
-            this.logger.error(`[${taskId}] Agent query failed for ${args.agentId}:`, errorMessage);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ **Agent Query Failed**
-
-**Task ID:** ${taskId}
-**Agent:** ${args.agentId}
-**Error:** ${errorMessage}
-**Query:** ${args.query}
-
-Read-Only Mode: No files were modified.`
-                    }
-                ],
-                success: false,
-                agent: args.agentId,
-                error: errorMessage,
-                readOnlyMode: true
-            };
-        }
-    }
-    async executeAgent(args) {
-        const taskId = this.taskManagementService.createTask({
-            type: 'execute',
-            provider: 'claude',
-            prompt: args.task,
-            agentId: args.agentId
-        });
-        const agentDescriptor = args.model ? `${args.agentId} (model: ${args.model})` : args.agentId;
-        this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Started execute agent ${agentDescriptor}` });
-        try {
-            const { agentId, task, projectPath, context, model, messages, platform } = args;
-            this.logger.log(`[${taskId}] Executing agent ${agentId}: ${task.substring(0, 50)}...`);
-            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Task: ${task.substring(0, 100)}...` });
-            if (model) {
-                this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Model: ${model}` });
-            }
-            const agents = await this.agentLoaderService.getAllAgents();
-            const agent = agents.find(a => a.id === agentId);
-            if (!agent) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ **Agent Not Found**
-
-**Error:** Agent '${agentId}' not found.
-
-**Available Agents:** ${agents.map(a => a.id).join(', ')}
-
-Please check the agent ID and try again.`
-                        }
-                    ],
-                    success: false,
-                    agent: agentId,
-                    error: `Agent '${agentId}' not found`,
-                    availableAgents: agents.map(a => a.id),
-                    executionMode: true
-                };
-            }
-            if (agent.remote?.type === 'mcp-http') {
-                try {
-                    const remoteResult = await this.remoteAgentService.executeRemoteAgent(agent, {
-                        task,
-                        context,
-                        model,
-                        platform,
-                        messages,
-                    });
-                    const normalized = this.normalizeRemoteResult(agent, taskId, remoteResult, false);
-                    const logLevel = normalized.success ? 'info' : 'error';
-                    this.taskManagementService.addTaskLog(taskId, {
-                        level: logLevel,
-                        message: normalized.success
-                            ? 'Remote agent execute completed successfully'
-                            : `Remote agent execute failed: ${normalized.error || 'Unknown error'}`,
-                    });
-                    this.taskManagementService.completeTask(taskId, normalized, normalized.success !== false);
-                    return normalized;
-                }
-                catch (error) {
-                    const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-                    this.taskManagementService.addTaskLog(taskId, {
-                        level: 'error',
-                        message: `Remote agent execute failed: ${errorMessage}`,
-                    });
-                    this.taskManagementService.completeTask(taskId, { success: false, error: errorMessage }, false);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `❌ **Remote agent error**\n\n${errorMessage}`,
-                            },
-                        ],
-                        success: false,
-                        agent: agentId,
-                        provider: 'remote',
-                        error: errorMessage,
-                        taskId,
-                        executionMode: true,
-                        readOnly: false,
-                    };
-                }
-            }
-            const workingDir = projectPath || agent.workingDirectory || './';
-            let systemPrompt = agent.systemPrompt || agent.description || `You are an expert ${agentId}.`;
-            const securityKey = this.generateSecurityKey();
-            if (systemPrompt) {
-                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
-                const contextMessages = messages && messages.length > 0 ? messages.slice(0, -1) : [];
-                const templateContext = {
-                    env: process.env,
-                    agent: {
-                        id: agent.id,
-                        name: agent.name || agent.id,
-                        provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
-                        model: model || agent.inline?.model,
-                        workingDirectory: workingDir,
-                    },
-                    mode: 'execute',
-                    messages: contextMessages,
-                    platform: platform,
-                    tools: this.buildToolsContext(),
-                    vars: {
-                        security_key: securityKey,
-                    },
-                };
-                systemPrompt = await processDocumentTemplate(systemPrompt, this.documentLoaderService, templateContext);
-            }
-            systemPrompt += `
-Specialties: ${agent.specialties?.join(', ') || 'General'}
-Capabilities: ${agent.capabilities?.join(', ') || 'Implementation'}
-Working Directory: ${workingDir}`;
-            const fullPrompt = context
-                ? `${systemPrompt}
-${context}
-
-Task: ${task}
-`
-                : `${systemPrompt}
-
-Task: ${task}
-`;
-            let response;
-            let provider;
-            if (Array.isArray(agent.provider)) {
-                if (agent.inline?.model || model) {
-                    provider = agent.provider[0] || 'claude';
-                }
-                else {
-                    provider = await this.getAvailableProvider(agent.provider);
-                    this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Using fallback provider: ${provider}` });
-                }
-            }
-            else {
-                provider = agent.provider || 'claude';
-            }
-            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Using provider: ${provider}` });
-            const agentOptions = this.getOptionsForAgent(agent, 'execute', provider);
-            const modelToUse = model || agent.inline?.model;
-            const structuredPayload = await this.buildStructuredPayload({
-                agentId,
-                provider,
-                mode: 'execute',
-                prompt: fullPrompt,
-                context,
-                messages,
-                platform: platform || 'cli',
-                model: modelToUse,
-            });
-            response = await this.aiService.executeAI(fullPrompt, provider, {
-                workingDirectory: workingDir,
-                timeout: 1200000,
-                taskId: taskId,
-                additionalArgs: agentOptions,
-                model: modelToUse,
-                agentId,
-                messages,
-                pipedContext: structuredPayload,
-            });
-            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Execution completed. Success: ${response.success}` });
-            this.taskManagementService.completeTask(taskId, response, response.success);
-            const responseText = response.success ? response.content : `❌ Execution Failed: ${response.error}`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText
-                    }
-                ],
-                success: response.success,
-                taskId: taskId,
-                agent: agentId,
-                provider: response.provider,
-                implementation: response.content,
-                error: response.error,
-                recommendations: []
-            };
-        }
-        catch (error) {
-            const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-            this.taskManagementService.addTaskLog(taskId, { level: 'error', message: `Execution failed: ${errorMessage}` });
-            this.taskManagementService.completeTask(taskId, { error: errorMessage }, false);
-            this.logger.error(`[${taskId}] Agent execution failed for ${args.agentId}:`, errorMessage);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ Execution Failed: ${errorMessage}`
-                    }
-                ],
-                success: false,
-                taskId: taskId,
-                agent: args.agentId,
-                provider: 'unknown',
-                implementation: null,
-                error: errorMessage,
-                recommendations: []
-            };
-        }
-    }
-    normalizeRemoteResult(agent, taskId, remoteResult, readOnly) {
-        const normalizedAgentId = remoteResult?.agent ?? agent.remote?.agentId ?? agent.id;
-        const provider = remoteResult?.provider ?? 'remote';
-        let content = remoteResult?.content;
-        if (!Array.isArray(content) || content.length === 0) {
-            const fallback = remoteResult?.response ??
-                remoteResult?.implementation ??
-                remoteResult?.message ??
-                remoteResult?.output;
-            const text = typeof fallback === 'string'
-                ? fallback
-                : JSON.stringify(fallback ?? remoteResult, null, 2);
-            content = [
-                {
-                    type: 'text',
-                    text,
-                },
-            ];
-        }
-        return {
-            ...remoteResult,
-            content,
-            agent: normalizedAgentId,
-            provider,
-            taskId: remoteResult?.taskId ?? taskId,
-            success: remoteResult?.success !== false,
-            readOnlyMode: readOnly,
-            readOnly,
-        };
-    }
-    getOptionsForAgent(agent, mode, provider) {
-        try {
-            if (agent.options && typeof agent.options === 'object' && !Array.isArray(agent.options)) {
-                const modeOptions = agent.options[mode];
-                if (modeOptions && typeof modeOptions === 'object' && !Array.isArray(modeOptions)) {
-                    if (provider) {
-                        const simpleProviderName = provider.includes('/') ? provider.split('/').pop() : provider;
-                        if (simpleProviderName && modeOptions[simpleProviderName]) {
-                            return modeOptions[simpleProviderName];
-                        }
-                        if (modeOptions[provider]) {
-                            return modeOptions[provider];
-                        }
-                    }
-                    if (modeOptions['default']) {
-                        return modeOptions['default'];
-                    }
-                    return [];
-                }
-                return modeOptions || [];
-            }
-            if (agent.options && Array.isArray(agent.options)) {
-                return agent.options;
-            }
-            return [];
-        }
-        catch (error) {
-            this.logger.warn(`Failed to get options for agent ${agent.id}: ${error}`);
-            return [];
-        }
-    }
-    async queryAgentParallel(args) {
-        try {
-            const { queries } = args;
-            this.logger.log(`Starting parallel agent queries (${queries.length} queries)`);
-            if (!queries || queries.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ **No Queries Provided**
-
-Please provide at least one query in the queries array.
-
-**Example:**
-\`\`\`json
-{
-  "queries": [
-    {
-      "agentId": "gmail_mcp_developer",
-      "query": "Analyze the README"
-    },
-    {
-      "agentId": "frontend_developer", 
-      "query": "Explain the component structure"
-    }
-  ]
-}
-\`\`\``
-                        }
-                    ],
-                    success: false,
-                    error: 'No queries provided',
-                    results: []
-                };
-            }
-            queries.forEach((q, index) => {
-                this.logger.log(`Query ${index + 1}: ${q.agentId} -> "${q.query.substring(0, 50)}..."`);
-            });
-            const startTime = Date.now();
-            const queryPromises = queries.map(async (q, index) => {
-                const queryStart = Date.now();
-                try {
-                    const result = await this.queryAgent({
-                        agentId: q.agentId,
-                        query: q.query,
-                        context: q.context,
-                        model: q.model,
-                        messages: q.messages,
-                        platform: q.platform
-                    });
-                    const duration = Date.now() - queryStart;
-                    return {
-                        index: index + 1,
-                        agentId: q.agentId,
-                        query: q.query,
-                        success: result.success !== false,
-                        response: result.response || result.content?.[0]?.text,
-                        provider: result.provider,
-                        duration,
-                        taskId: result.taskId
-                    };
-                }
-                catch (error) {
-                    const duration = Date.now() - queryStart;
-                    return {
-                        index: index + 1,
-                        agentId: q.agentId,
-                        query: q.query,
-                        success: false,
-                        error: error.message,
-                        duration
-                    };
-                }
-            });
-            const results = await Promise.all(queryPromises);
-            const totalDuration = Date.now() - startTime;
-            const successCount = results.filter(r => r.success).length;
-            const failureCount = results.length - successCount;
-            const summary = {
-                total: results.length,
-                successful: successCount,
-                failed: failureCount,
-                totalDuration,
-                averageDuration: results.reduce((sum, r) => sum + r.duration, 0) / results.length
-            };
-            this.logger.log(`Parallel queries completed: ${successCount} success, ${failureCount} failed, ${totalDuration}ms total`);
-            const enhancedResults = results;
-            const formattedResult = this.resultFormatterService.formatParallelResult(enhancedResults, {
-                total: summary.total,
-                success: summary.successful,
-                failed: summary.failed,
-                totalDuration: summary.totalDuration,
-                averageDuration: summary.averageDuration,
-                fastest: Math.min(...results.map(r => r.duration)),
-                slowest: Math.max(...results.map(r => r.duration)),
-                timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - summary.totalDuration)
-            }, true);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: formattedResult.mcp
-                    }
-                ],
-                success: true,
-                summary: {
-                    totalQueries: summary.total,
-                    successful: summary.successful,
-                    failed: summary.failed,
-                    totalDuration: summary.totalDuration,
-                    averageDuration: summary.averageDuration
-                },
-                results: enhancedResults,
-                performance: {
-                    fastestQuery: Math.min(...results.map(r => r.duration)),
-                    slowestQuery: Math.max(...results.map(r => r.duration)),
-                    timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - summary.totalDuration)
-                },
-                readOnlyMode: true
-            };
-        }
-        catch (error) {
-            const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-            this.logger.error('Parallel agent queries failed:', errorMessage);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ **Parallel Agent Queries Failed**
-
-**Error:** ${errorMessage}
-
-**Total Queries:** ${args.queries?.length || 0}
-
-Read-Only Mode: No files were modified.`
-                    }
-                ],
-                success: false,
-                error: errorMessage,
-                results: [],
-                readOnlyMode: true
-            };
-        }
-    }
-    async executeAgentParallel(args) {
-        try {
-            const { tasks } = args;
-            this.logger.log(`Starting parallel agent execution (${tasks.length} tasks)`);
-            if (!tasks || tasks.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `❌ **No Tasks Provided**
-
-Please provide at least one task in the tasks array.
-
-**Example:**
-\`\`\`json
-{
-  "tasks": [
-    {
-      "task": "Create a utility function for handling timeouts"
-    },
-    {
-      "agentId": "crewx_developer_claude",
-      "task": "Write unit tests for the new utility function"
-    },
-    {
-      "agentId": "crewx_developer_gemini",
-      "task": "Review the implementation for edge cases"
-    }
-  ]
-}
-\`\`\``
-                        }
-                    ],
-                    success: false,
-                    error: 'No tasks provided',
-                    results: []
-                };
-            }
-            tasks.forEach((t, index) => {
-                this.logger.log(`Task ${index + 1}: ${t.agentId} -> "${t.task.substring(0, 50)}..."`);
-            });
-            const startTime = Date.now();
-            const results = await Promise.all(tasks.map(async (taskItem, index) => {
-                const taskStartTime = Date.now();
-                try {
-                    const result = await this.executeAgent({
-                        agentId: taskItem.agentId,
-                        task: taskItem.task,
-                        projectPath: taskItem.projectPath,
-                        context: taskItem.context,
-                    });
-                    const taskDuration = Date.now() - taskStartTime;
-                    return {
-                        index: index + 1,
-                        agentId: taskItem.agentId,
-                        task: taskItem.task,
-                        success: result.success,
-                        implementation: result.implementation || result.error,
-                        provider: result.provider,
-                        duration: taskDuration,
-                        error: result.error,
-                        context: taskItem.context,
-                        workingDirectory: taskItem.projectPath || `Default for ${taskItem.agentId}`,
-                        recommendations: result.recommendations || [],
-                        taskId: result.taskId
-                    };
-                }
-                catch (error) {
-                    const taskDuration = Date.now() - taskStartTime;
-                    return {
-                        index: index + 1,
-                        agentId: taskItem.agentId,
-                        task: taskItem.task,
-                        success: false,
-                        implementation: null,
-                        provider: 'unknown',
-                        duration: taskDuration,
-                        error: error.message || 'Unknown error occurred',
-                        context: taskItem.context,
-                        workingDirectory: taskItem.projectPath || `Default for ${taskItem.agentId}`,
-                        recommendations: [],
-                        taskId: null
-                    };
-                }
-            }));
-            const totalDuration = Date.now() - startTime;
-            const successCount = results.filter(r => r.success).length;
-            const failureCount = results.length - successCount;
-            this.logger.log(`Parallel execution completed: ${successCount} success, ${failureCount} failed, ${totalDuration}ms total`);
-            const responseText = `⚡ **Parallel Agent Execution Results**
-
-**Summary:**
-- Total Tasks: ${results.length}
-- Successful: ${successCount}
-- Failed: ${failureCount}
-- Total Duration: ${totalDuration}ms
-- Average Duration: ${Math.round(totalDuration / results.length)}ms per task
-
-**Individual Results:**
-
-${results.map(result => `---
-**${result.index}. Agent: ${result.agentId}** (${result.provider}) - ${result.duration}ms
-**Task:** ${result.task}
-**Status:** ${result.success ? '✅ Success' : '❌ Failed'}
-**Working Directory:** ${result.workingDirectory}
-${result.context ? `**Context:** ${result.context}\n` : ''}
-**Implementation:**
-${result.success ? result.implementation : `Error: ${result.error}`}
-
-${result.recommendations.length > 0 ? `**Recommendations:**
-${result.recommendations.map((recommendation) => `• ${recommendation}`).join('\n')}` : ''}
-`).join('\n')}
-
-**Performance Insights:**
-- Fastest Task: ${Math.min(...results.map(r => r.duration))}ms
-- Slowest Task: ${Math.max(...results.map(r => r.duration))}ms
-- Parallel processing saved approximately ${Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - totalDuration)}ms compared to sequential execution
-
-**⚠️ Important Notes:**
-- All tasks were executed in IMPLEMENTATION MODE with potential file modifications
-- Review all provided implementations before applying changes
-- Test in development environment first
-- Consider backing up files before making modifications`;
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: responseText
-                    }
-                ],
-                success: true,
-                summary: {
-                    totalTasks: results.length,
-                    successful: successCount,
-                    failed: failureCount,
-                    totalDuration,
-                    averageDuration: Math.round(totalDuration / results.length)
-                },
-                results: results,
-                performance: {
-                    fastestTask: Math.min(...results.map(r => r.duration)),
-                    slowestTask: Math.max(...results.map(r => r.duration)),
-                    timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - totalDuration)
-                },
-                executionMode: true
-            };
-        }
-        catch (error) {
-            const errorMessage = (0, error_utils_1.getErrorMessage)(error);
-            this.logger.error('Parallel agent execution failed:', errorMessage);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ **Parallel Agent Execution Failed**
-
-**Error:** ${errorMessage}
-
-**Total Tasks:** ${args.tasks?.length || 0}
-
-Execution Mode: Implementation guidance could not be provided.`
-                    }
-                ],
-                success: false,
-                error: errorMessage,
-                results: [],
-                executionMode: true
-            };
-        }
-    }
-    async clearAllLogs() {
-        try {
-            const logsDir = path.join(process.cwd(), '.crewx', 'logs');
-            if (!fs.existsSync(logsDir)) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `📁 **Log Directory Status**
-
-❌ **No logs directory found**
-
-The logs directory \`.crewx/logs\` does not exist. Nothing to clean.
-
-**Path checked:** \`${logsDir}\`
-`
-                        }
-                    ],
-                    success: true,
-                    message: 'No logs directory found',
-                    path: logsDir
-                };
-            }
-            const files = fs.readdirSync(logsDir);
-            const logFiles = files.filter(file => file.endsWith('.log'));
-            if (logFiles.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `📁 **Log Directory Status**
-
-✅ **Already clean**
-
-The logs directory exists but contains no log files to clean.
-
-**Directory:** \`${logsDir}\`
-**Total files:** ${files.length}
-**Log files:** 0
-`
-                        }
-                    ],
-                    success: true,
-                    message: 'No log files to clean',
-                    path: logsDir,
-                    totalFiles: files.length,
-                    logFiles: 0
-                };
-            }
-            let totalSize = 0;
-            let deletedCount = 0;
-            const deletedFiles = [];
-            for (const file of logFiles) {
-                const filePath = path.join(logsDir, file);
-                try {
-                    const stats = fs.statSync(filePath);
-                    totalSize += stats.size;
-                    fs.unlinkSync(filePath);
-                    deletedCount++;
-                    deletedFiles.push(file);
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to delete log file ${file}:`, error);
-                }
-            }
-            const formatSize = (bytes) => {
-                if (bytes === 0)
-                    return '0 B';
-                const k = 1024;
-                const sizes = ['B', 'KB', 'MB', 'GB'];
-                const i = Math.floor(Math.log(bytes) / Math.log(k));
-                return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-            };
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `🗑️ **Log Cleanup Complete**
-
-✅ **Successfully cleared all log files**
-
-**Directory:** \`${logsDir}\`
-**Files deleted:** ${deletedCount}
-**Total space freed:** ${formatSize(totalSize)}
-
-${deletedCount > 10 ?
-                            `**Sample deleted files:**
-${deletedFiles.slice(0, 10).map(f => `  • ${f}`).join('\n')}
-  • ... and ${deletedCount - 10} more files` :
-                            `**Deleted files:**
-${deletedFiles.map(f => `  • ${f}`).join('\n')}`}
-
-The logs directory is now clean and ready for new task logs. 🧹✨
-`
-                    }
-                ],
-                success: true,
-                message: 'All log files cleared successfully',
-                path: logsDir,
-                deletedCount,
-                totalSize,
-                deletedFiles: deletedFiles.slice(0, 20)
-            };
-        }
-        catch (error) {
-            this.logger.error('Failed to clear logs:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `❌ **Log Cleanup Failed**
-
-**Error:** ${error.message}
-
-Please check permissions and try again, or manually delete files from \`.crewx/logs/\` directory.
-`
-                    }
-                ],
-                success: false,
-                error: error.message
-            };
-        }
-    }
-    async getAvailableProvider(providerConfig) {
-        const defaultFallbackOrder = ['claude', 'gemini', 'copilot'];
-        let fallbackOrder;
-        if (!providerConfig) {
-            fallbackOrder = defaultFallbackOrder;
-        }
-        else if (Array.isArray(providerConfig)) {
-            fallbackOrder = providerConfig;
-        }
-        else {
-            fallbackOrder = [providerConfig, ...defaultFallbackOrder.filter(p => p !== providerConfig)];
-        }
-        for (const providerName of fallbackOrder) {
-            const provider = this.aiProviderService.getProvider(providerName);
-            if (provider) {
-                const isAvailable = await provider.isAvailable();
-                if (isAvailable) {
-                    if (fallbackOrder.indexOf(providerName) > 0) {
-                        this.logger.log(`Using fallback provider: ${providerName} (tried: ${fallbackOrder.slice(0, fallbackOrder.indexOf(providerName)).join(', ')})`);
-                    }
-                    return providerName;
-                }
-            }
-        }
-        this.logger.warn('No providers available, defaulting to claude');
-        return 'claude';
-    }
-};
-exports.CrewXTool = CrewXTool;
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}getTaskLogs`,
-        description: 'Get task logs by task ID to monitor progress and detailed execution logs.',
-        input: {
-            taskId: zod_1.z.string().optional().describe('Task ID to get logs for. If not provided, returns all recent tasks.')
-        },
-        annotations: {
-            title: 'Get Task Logs',
-            readOnlyHint: true,
-            desctructiveHint: false
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "getTaskLogs", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}checkAIProviders`,
-        description: 'Check the status of available AI CLI tools (Claude, Gemini, GitHub Copilot).',
-        input: {},
-        annotations: {
-            title: 'Check AI Providers Status',
-            readOnlyHint: true,
-            desctructiveHint: false
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "checkAIProviders", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}listAgents`,
-        description: 'List available specialist AI agents that can be utilized. Each agent is specialized in a specific domain.',
-        input: {},
-        annotations: {
-            title: 'List Available AI Agents',
-            readOnlyHint: true,
-            desctructiveHint: false
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "listAgents", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}queryAgent`,
-        description: 'Query a specific specialist agent (read-only mode). You can request code analysis, explanations, reviews, etc. No file modifications will be performed.',
-        input: {
-            agentId: zod_1.z.string().describe('Agent ID to query (e.g., frontend_developer, backend_developer, devops_engineer, security_analyst, or custom agents)'),
-            query: zod_1.z.string().describe('Question or request to ask the agent'),
-            projectPath: zod_1.z.string().describe('Absolute path of the project to analyze').optional(),
-            context: zod_1.z.string().describe('Additional context or background information').optional(),
-            model: zod_1.z.string().describe('Model to use for this query (e.g., sonnet, gemini-2.5-pro, gpt-5)').optional(),
-            messages: zod_1.z.array(zod_1.z.object({
-                text: zod_1.z.string(),
-                isAssistant: zod_1.z.boolean(),
-                metadata: zod_1.z.record(zod_1.z.any()).optional(),
-            })).describe('Conversation history to provide as context (oldest → newest)').optional(),
-        },
-        annotations: {
-            title: 'Query Specialist Agent (Read-Only)',
-            readOnlyHint: true,
-            desctructiveHint: false
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "queryAgent", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}executeAgent`,
-        description: 'Execute tasks through a specialist agent. Can provide implementation guidance, code examples, and actionable solutions.',
-        input: {
-            agentId: zod_1.z.string().describe('Agent ID to execute (e.g., frontend_developer, backend_developer, devops_engineer, security_analyst, or custom agents)'),
-            task: zod_1.z.string().describe('Task or implementation request for the agent to perform'),
-            projectPath: zod_1.z.string().describe('Absolute path of the project to work on').optional(),
-            context: zod_1.z.string().describe('Additional context or background information').optional(),
-            model: zod_1.z.string().describe('Model to use for this execution (e.g., sonnet, gemini-2.5-pro, gpt-5)').optional(),
-            messages: zod_1.z.array(zod_1.z.object({
-                text: zod_1.z.string(),
-                isAssistant: zod_1.z.boolean(),
-                metadata: zod_1.z.record(zod_1.z.any()).optional(),
-            })).describe('Conversation history to provide as context (oldest → newest)').optional(),
-        },
-        annotations: {
-            title: 'Execute Agent Task (Can Modify Files)',
-            readOnlyHint: false,
-            desctructiveHint: true
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "executeAgent", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}queryAgentParallel`,
-        description: 'Query multiple specialist agents simultaneously in parallel (read-only mode). Efficiently send multiple tasks to the same agent or different questions to various agents.',
-        input: {
-            queries: zod_1.z.array(zod_1.z.object({
-                agentId: zod_1.z.string().describe('Agent ID to query (e.g., frontend_developer, backend_developer, gmail_mcp_developer, etc.)'),
-                query: zod_1.z.string().describe('Question or request to ask the agent'),
-                projectPath: zod_1.z.string().describe('Absolute path of the project to analyze').optional(),
-                context: zod_1.z.string().describe('Additional context or background information').optional(),
-                model: zod_1.z.string().describe('Model to use for this query').optional(),
-                messages: zod_1.z.array(zod_1.z.object({
-                    text: zod_1.z.string(),
-                    isAssistant: zod_1.z.boolean(),
-                    metadata: zod_1.z.record(zod_1.z.any()).optional(),
-                })).describe('Conversation history to provide as context (oldest → newest)').optional(),
-            })).describe('Array of queries to process in parallel'),
-        },
-        annotations: {
-            title: 'Query Multiple Agents in Parallel (Read-Only)',
-            readOnlyHint: true,
-            desctructiveHint: false
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "queryAgentParallel", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}executeAgentParallel`,
-        description: 'Execute multiple tasks through specialist agents simultaneously in parallel (execution mode). Efficiently distribute implementation work across multiple agents.',
-        input: {
-            tasks: zod_1.z.array(zod_1.z.object({
-                agentId: zod_1.z.string().describe('Agent ID to execute (e.g., frontend_developer, backend_developer, crewx_developer_claude, etc.)'),
-                task: zod_1.z.string().describe('Task or implementation request for the agent to perform'),
-                projectPath: zod_1.z.string().describe('Absolute path of the project to work on').optional(),
-                context: zod_1.z.string().describe('Additional context or background information').optional(),
-                model: zod_1.z.string().describe('Model to use for this execution').optional(),
-                messages: zod_1.z.array(zod_1.z.object({
-                    text: zod_1.z.string(),
-                    isAssistant: zod_1.z.boolean(),
-                    metadata: zod_1.z.record(zod_1.z.any()).optional(),
-                })).describe('Conversation history to provide as context (oldest → newest)').optional(),
-            })).describe('Array of tasks to execute in parallel'),
-        },
-        annotations: {
-            title: 'Execute Multiple Agent Tasks in Parallel (Can Modify Files)',
-            readOnlyHint: false,
-            desctructiveHint: true
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "executeAgentParallel", null);
-__decorate([
-    (0, nestjs_mcp_adapter_1.McpTool)({
-        server: constants_1.SERVER_NAME,
-        name: `${constants_1.PREFIX_TOOL_NAME}clearAllLogs`,
-        description: 'Clear all log files from the .crewx/logs directory to clean up accumulated task logs',
-        input: {},
-        annotations: {
-            title: 'Clear All Logs',
-            readOnlyHint: false,
-        }
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], CrewXTool.prototype, "clearAllLogs", null);
-exports.CrewXTool = CrewXTool = CrewXTool_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [ai_service_1.AIService,
-        ai_provider_service_1.AIProviderService,
-        project_service_1.ProjectService,
-        parallel_processing_service_1.ParallelProcessingService,
-        task_management_service_1.TaskManagementService,
-        result_formatter_service_1.ResultFormatterService,
-        template_service_1.TemplateService,
-        document_loader_service_1.DocumentLoaderService,
-        tool_call_service_1.ToolCallService,
-        agent_loader_service_1.AgentLoaderService,
-        remote_agent_service_1.RemoteAgentService])
-], CrewXTool);
-//# sourceMappingURL=crewx.tool.js.map