@dcyfr/ai 1.0.4 → 2.1.0

package/dist/ai/src/mcp-auto-configuration.d.ts

@@ -0,0 +1,232 @@
+/**
+ * MCP Auto-Configuration System
+ * TLP:CLEAR
+ *
+ * Automatically configures MCP servers based on detected agent capabilities
+ * and workspace requirements. Provides intelligent MCP server selection and
+ * lifecycle management for optimal agent performance.
+ *
+ * @version 1.0.0
+ * @date 2026-02-14
+ * @module dcyfr-ai/mcp/auto-configuration
+ */
+import { EventEmitter } from 'events';
+import type { MCPServerConfig, MCPServerManifest, MCPServerStatus } from '../mcp/types.js';
+import type { AgentCapabilityManifest } from './types/agent-capabilities.js';
+/**
+ * MCP server capability mapping
+ */
+export interface MCPCapabilityMapping {
+    /**
+     * Server name/identifier
+     */
+    serverName: string;
+    /**
+     * Capabilities that trigger this server's inclusion
+     */
+    requiredCapabilities: string[];
+    /**
+     * Optional capabilities that benefit from this server
+     */
+    optionalCapabilities?: string[];
+    /**
+     * Minimum number of agents needing this server to auto-configure
+     */
+    minAgentThreshold?: number;
+    /**
+     * Server priority (1-10, higher = more important)
+     */
+    priority: number;
+    /**
+     * Configuration template for this server
+     */
+    configTemplate: MCPServerConfig;
+    /**
+     * Custom environment variables based on workspace detection
+     */
+    dynamicEnv?: (workspace: string) => Record<string, string>;
+}
+/**
+ * Auto-configuration system configuration
+ */
+export interface MCPAutoConfigOptions {
+    /**
+     * Workspace root path for configuration generation
+     */
+    workspaceRoot: string;
+    /**
+     * Enable automatic server startup
+     */
+    autoStartServers?: boolean;
+    /**
+     * Enable server health monitoring
+     */
+    healthMonitoring?: boolean;
+    /**
+     * Custom capability mappings to extend defaults
+     */
+    customMappings?: MCPCapabilityMapping[];
+    /**
+     * Minimum agent threshold for auto-configuration
+     */
+    globalMinThreshold?: number;
+    /**
+     * Configuration file output path
+     */
+    configOutputPath?: string;
+}
+/**
+ * Configuration generation result
+ */
+export interface ConfigGenerationResult {
+    /**
+     * Generated MCP servers
+     */
+    servers: ConfiguredMCPServer[];
+    /**
+     * Configuration written to file
+     */
+    configFilePath?: string;
+    /**
+     * Servers that were started
+     */
+    startedServers: string[];
+    /**
+     * Configuration warnings
+     */
+    warnings: string[];
+    /**
+     * Server recommendation explanations
+     */
+    recommendations: ServerRecommendation[];
+}
+/**
+ * Configured MCP server
+ */
+export interface ConfiguredMCPServer {
+    /**
+     * Server configuration
+     */
+    config: MCPServerConfig;
+    /**
+     * Reason for inclusion
+     */
+    reason: string;
+    /**
+     * Number of agents benefiting from this server
+     */
+    benefitingAgents: number;
+    /**
+     * Related capability IDs
+     */
+    relatedCapabilities: string[];
+}
+/**
+ * Server recommendation
+ */
+export interface ServerRecommendation {
+    /**
+     * Server name
+     */
+    serverName: string;
+    /**
+     * Recommendation type
+     */
+    type: 'required' | 'recommended' | 'optional';
+    /**
+     * Explanation
+     */
+    explanation: string;
+    /**
+     * Affected agent count
+     */
+    affectedAgents: number;
+}
+/**
+ * MCP Server Auto-Configuration System
+ *
+ * Analyzes agent capabilities and automatically configures appropriate
+ * MCP servers to support agent operations efficiently.
+ */
+export declare class MCPAutoConfiguration extends EventEmitter {
+    private registry;
+    private options;
+    private capabilityMappings;
+    private registeredAgents;
+    constructor(options: MCPAutoConfigOptions);
+    /**
+     * Default capability to MCP server mappings
+     */
+    private getDefaultCapabilityMappings;
+    /**
+     * Setup event handlers
+     */
+    private setupEventHandlers;
+    /**
+     * Register agent for auto-configuration analysis
+     */
+    registerAgent(manifest: AgentCapabilityManifest): Promise<void>;
+    /**
+     * Unregister agent
+     */
+    unregisterAgent(agentId: string): Promise<void>;
+    /**
+     * Analyze current agents and generate MCP server configuration
+     */
+    generateConfiguration(): Promise<ConfigGenerationResult>;
+    /**
+     * Reconfigure servers based on current agent set
+     */
+    reconfigureServers(): Promise<ConfigGenerationResult>;
+    /**
+     * Analyze agent capabilities and count usage
+     */
+    private analyzeCapabilities;
+    /**
+     * Determine which servers are required based on capability analysis
+     */
+    private determineRequiredServers;
+    /**
+     * Configure servers with dynamic environment and workspace-specific settings
+     */
+    private configureServers;
+    /**
+     * Generate human-readable reason for server inclusion
+     */
+    private generateServerReason;
+    /**
+     * Count agents that would benefit from this server
+     */
+    private countBenefitingAgents;
+    /**
+     * Generate configuration recommendations
+     */
+    private generateRecommendations;
+    /**
+     * Write configuration to file
+     */
+    private writeConfigurationFile;
+    /**
+     * Get current server status
+     */
+    getServerStatus(): Promise<Array<{
+        name: string;
+        status: MCPServerStatus;
+        config: MCPServerConfig;
+        manifest?: MCPServerManifest;
+    }>>;
+    /**
+     * Health check all configured servers
+     */
+    healthCheckServers(): Promise<Map<string, boolean>>;
+    /**
+     * Cleanup and shutdown
+     */
+    shutdown(): Promise<void>;
+}
+/**
+ * Factory function for creating auto-configuration system
+ */
+export declare function createMCPAutoConfiguration(options: MCPAutoConfigOptions): MCPAutoConfiguration;
+export default MCPAutoConfiguration;
+//# sourceMappingURL=mcp-auto-configuration.d.ts.map

package/dist/ai/src/mcp-auto-configuration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-auto-configuration.d.ts","sourceRoot":"","sources":["../../../packages/ai/src/mcp-auto-configuration.ts"],"names":[],"mappings":"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"}

package/dist/ai/src/mcp-auto-configuration.js

@@ -0,0 +1,445 @@
+/**
+ * MCP Auto-Configuration System
+ * TLP:CLEAR
+ *
+ * Automatically configures MCP servers based on detected agent capabilities
+ * and workspace requirements. Provides intelligent MCP server selection and
+ * lifecycle management for optimal agent performance.
+ *
+ * @version 1.0.0
+ * @date 2026-02-14
+ * @module dcyfr-ai/mcp/auto-configuration
+ */
+import { EventEmitter } from 'events';
+import { MCPRegistry } from '../mcp/mcp-registry.js';
+/**
+ * MCP Server Auto-Configuration System
+ *
+ * Analyzes agent capabilities and automatically configures appropriate
+ * MCP servers to support agent operations efficiently.
+ */
+export class MCPAutoConfiguration extends EventEmitter {
+    registry;
+    options;
+    capabilityMappings;
+    registeredAgents = new Map();
+    constructor(options) {
+        super();
+        this.options = {
+            autoStartServers: true,
+            healthMonitoring: true,
+            globalMinThreshold: 1,
+            configOutputPath: '.mcp.json',
+            ...options,
+        };
+        this.registry = new MCPRegistry({
+            autoDiscover: false,
+            healthMonitoring: this.options.healthMonitoring,
+        });
+        this.capabilityMappings = this.getDefaultCapabilityMappings();
+        if (this.options.customMappings) {
+            this.capabilityMappings.push(...this.options.customMappings);
+        }
+        this.setupEventHandlers();
+    }
+    /**
+     * Default capability to MCP server mappings
+     */
+    getDefaultCapabilityMappings() {
+        return [
+            {
+                serverName: 'dcyfr-designtokens',
+                requiredCapabilities: ['design_token_compliance', 'pattern_enforcement'],
+                optionalCapabilities: ['ui_component_generation'],
+                minAgentThreshold: 1,
+                priority: 9,
+                configTemplate: {
+                    name: 'dcyfr-designtokens',
+                    description: 'DCYFR Design Token validation and enforcement',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['@dcyfr/ai', 'mcp:tokens'],
+                    enabled: true,
+                    tier: 'project',
+                    tags: ['design', 'tokens', 'validation'],
+                },
+                dynamicEnv: (workspace) => ({
+                    DCYFR_WORKSPACE_ROOT: workspace,
+                    DCYFR_DESIGN_TOKENS_PATH: `${workspace}/src/lib/design-tokens.ts`,
+                }),
+            },
+            {
+                serverName: 'dcyfr-analytics',
+                requiredCapabilities: ['performance_monitoring', 'telemetry_tracking'],
+                optionalCapabilities: ['user_behavior_analysis'],
+                minAgentThreshold: 2,
+                priority: 7,
+                configTemplate: {
+                    name: 'dcyfr-analytics',
+                    description: 'DCYFR Analytics and performance monitoring',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['@dcyfr/ai', 'mcp:analytics'],
+                    enabled: true,
+                    tier: 'project',
+                    tags: ['analytics', 'performance', 'monitoring'],
+                },
+                dynamicEnv: (workspace) => ({
+                    DCYFR_WORKSPACE_ROOT: workspace,
+                    REDIS_URL: process.env.REDIS_URL || 'redis://localhost:6379',
+                }),
+            },
+            {
+                serverName: 'dcyfr-contentmanager',
+                requiredCapabilities: ['content_management', 'blog_post_creation'],
+                optionalCapabilities: ['seo_optimization', 'markdown_processing'],
+                minAgentThreshold: 1,
+                priority: 8,
+                configTemplate: {
+                    name: 'dcyfr-contentmanager',
+                    description: 'DCYFR Content management for blog and documentation',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['@dcyfr/ai', 'mcp:content'],
+                    enabled: true,
+                    tier: 'project',
+                    tags: ['content', 'blog', 'mdx'],
+                },
+                dynamicEnv: (workspace) => ({
+                    DCYFR_WORKSPACE_ROOT: workspace,
+                    DCYFR_CONTENT_DIR: `${workspace}/src/content`,
+                }),
+            },
+            {
+                serverName: 'dcyfr-promptintel',
+                requiredCapabilities: ['security_scanning', 'threat_detection'],
+                optionalCapabilities: ['prompt_injection_prevention'],
+                minAgentThreshold: 1,
+                priority: 10,
+                configTemplate: {
+                    name: 'dcyfr-promptintel',
+                    description: 'DCYFR AI threat intelligence and prompt security',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['@dcyfr/ai', 'mcp:promptintel'],
+                    enabled: true,
+                    tier: 'private',
+                    tags: ['security', 'ai-safety', 'threats'],
+                },
+                dynamicEnv: (workspace) => ({
+                    DCYFR_WORKSPACE_ROOT: workspace,
+                    DCYFR_SECURITY_LEVEL: 'HIGH',
+                }),
+            },
+            {
+                serverName: 'dcyfr-delegation',
+                requiredCapabilities: ['task_delegation', 'workflow_orchestration'],
+                optionalCapabilities: ['agent_coordination'],
+                minAgentThreshold: 3,
+                priority: 6,
+                configTemplate: {
+                    name: 'dcyfr-delegation',
+                    description: 'DCYFR Delegation monitoring and coordination',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['@dcyfr/ai', 'mcp:delegation'],
+                    enabled: true,
+                    tier: 'private',
+                    tags: ['delegation', 'coordination', 'workflow'],
+                },
+                dynamicEnv: (workspace) => ({
+                    DCYFR_WORKSPACE_ROOT: workspace,
+                    DCYFR_DELEGATION_MAX_DEPTH: '10',
+                }),
+            },
+            // Standard MCP servers for common capabilities
+            {
+                serverName: 'playwright',
+                requiredCapabilities: ['browser_automation', 'e2e_testing'],
+                optionalCapabilities: ['web_scraping', 'ui_testing'],
+                minAgentThreshold: 1,
+                priority: 5,
+                configTemplate: {
+                    name: 'playwright',
+                    description: 'Browser automation and testing',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['-y', '@executeautomation/playwright-mcp-server'],
+                    enabled: true,
+                    tier: 'public',
+                    tags: ['browser', 'testing', 'automation'],
+                },
+            },
+            {
+                serverName: 'filesystem',
+                requiredCapabilities: ['file_operations', 'directory_management'],
+                optionalCapabilities: ['code_generation', 'template_processing'],
+                minAgentThreshold: 1,
+                priority: 4,
+                configTemplate: {
+                    name: 'filesystem',
+                    description: 'File system operations',
+                    transport: 'stdio',
+                    command: 'npx',
+                    args: ['-y', '@modelcontextprotocol/server-filesystem'],
+                    enabled: true,
+                    tier: 'public',
+                    tags: ['filesystem', 'files', 'storage'],
+                },
+                dynamicEnv: (workspace) => ({
+                    ALLOWED_DIRECTORIES: workspace,
+                }),
+            },
+        ];
+    }
+    /**
+     * Setup event handlers
+     */
+    setupEventHandlers() {
+        // Event handlers would be configured if MCPRegistry supported events
+        // Currently MCPRegistry doesn't extend EventEmitter
+    }
+    /**
+     * Register agent for auto-configuration analysis
+     */
+    async registerAgent(manifest) {
+        this.registeredAgents.set(manifest.agent_id, manifest);
+        this.emit('agent_registered', { agentId: manifest.agent_id });
+        // Auto-reconfigure if enabled
+        if (this.options.autoStartServers) {
+            await this.reconfigureServers();
+        }
+    }
+    /**
+     * Unregister agent
+     */
+    async unregisterAgent(agentId) {
+        this.registeredAgents.delete(agentId);
+        this.emit('agent_unregistered', { agentId });
+        // Auto-reconfigure to potentially remove unused servers
+        if (this.options.autoStartServers) {
+            await this.reconfigureServers();
+        }
+    }
+    /**
+     * Analyze current agents and generate MCP server configuration
+     */
+    async generateConfiguration() {
+        const capabilityCount = this.analyzeCapabilities();
+        const requiredServers = this.determineRequiredServers(capabilityCount);
+        const configuredServers = this.configureServers(requiredServers);
+        const result = {
+            servers: configuredServers,
+            startedServers: [],
+            warnings: [],
+            recommendations: this.generateRecommendations(capabilityCount, requiredServers),
+        };
+        // Write configuration file if specified
+        if (this.options.configOutputPath) {
+            await this.writeConfigurationFile(configuredServers, this.options.configOutputPath);
+            result.configFilePath = this.options.configOutputPath;
+        }
+        // Start servers if auto-start is enabled
+        if (this.options.autoStartServers) {
+            for (const server of configuredServers) {
+                try {
+                    await this.registry.registerServer(server.config);
+                    result.startedServers.push(server.config.name);
+                }
+                catch (error) {
+                    result.warnings.push(`Failed to start server ${server.config.name}: ${error.message}`);
+                }
+            }
+        }
+        this.emit('configuration_generated', result);
+        return result;
+    }
+    /**
+     * Reconfigure servers based on current agent set
+     */
+    async reconfigureServers() {
+        return this.generateConfiguration();
+    }
+    /**
+     * Analyze agent capabilities and count usage
+     */
+    analyzeCapabilities() {
+        const capabilityCount = new Map();
+        for (const manifest of this.registeredAgents.values()) {
+            for (const capability of manifest.capabilities) {
+                capabilityCount.set(capability.capability_id, (capabilityCount.get(capability.capability_id) || 0) + 1);
+            }
+        }
+        return capabilityCount;
+    }
+    /**
+     * Determine which servers are required based on capability analysis
+     */
+    determineRequiredServers(capabilityCount) {
+        const requiredServers = [];
+        for (const mapping of this.capabilityMappings) {
+            const requiredCapCount = mapping.requiredCapabilities.reduce((sum, cap) => {
+                return sum + (capabilityCount.get(cap) || 0);
+            }, 0);
+            const optionalCapCount = (mapping.optionalCapabilities || []).reduce((sum, cap) => {
+                return sum + (capabilityCount.get(cap) || 0);
+            }, 0);
+            const totalRelevantAgents = requiredCapCount + optionalCapCount;
+            const minThreshold = mapping.minAgentThreshold || this.options.globalMinThreshold || 1;
+            // Include server if it has required capabilities or meets threshold
+            if (requiredCapCount > 0 || totalRelevantAgents >= minThreshold) {
+                requiredServers.push(mapping);
+            }
+        }
+        // Sort by priority (higher priority first)
+        return requiredServers.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Configure servers with dynamic environment and workspace-specific settings
+     */
+    configureServers(requiredServers) {
+        const configured = [];
+        for (const mapping of requiredServers) {
+            const config = { ...mapping.configTemplate };
+            // Apply dynamic environment variables
+            if (mapping.dynamicEnv) {
+                config.env = {
+                    ...config.env,
+                    ...mapping.dynamicEnv(this.options.workspaceRoot),
+                };
+            }
+            configured.push({
+                config,
+                reason: this.generateServerReason(mapping),
+                benefitingAgents: this.countBenefitingAgents(mapping),
+                relatedCapabilities: [...mapping.requiredCapabilities, ...(mapping.optionalCapabilities || [])],
+            });
+        }
+        return configured;
+    }
+    /**
+     * Generate human-readable reason for server inclusion
+     */
+    generateServerReason(mapping) {
+        const agentCount = this.countBenefitingAgents(mapping);
+        const capabilityList = mapping.requiredCapabilities.slice(0, 2).join(', ');
+        return `Required by ${agentCount} agent(s) for ${capabilityList}${mapping.requiredCapabilities.length > 2 ? ' and more' : ''}`;
+    }
+    /**
+     * Count agents that would benefit from this server
+     */
+    countBenefitingAgents(mapping) {
+        let count = 0;
+        const allCapabilities = [...mapping.requiredCapabilities, ...(mapping.optionalCapabilities || [])];
+        for (const manifest of this.registeredAgents.values()) {
+            const hasRelevantCapability = manifest.capabilities.some(cap => allCapabilities.includes(cap.capability_id));
+            if (hasRelevantCapability) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Generate configuration recommendations
+     */
+    generateRecommendations(capabilityCount, requiredServers) {
+        const recommendations = [];
+        for (const mapping of requiredServers) {
+            const agentCount = this.countBenefitingAgents(mapping);
+            const requiredCapCount = mapping.requiredCapabilities.reduce((sum, cap) => sum + (capabilityCount.get(cap) || 0), 0);
+            let type;
+            let explanation;
+            if (requiredCapCount > 0) {
+                type = 'required';
+                explanation = `Essential for ${requiredCapCount} capabilities across ${agentCount} agents`;
+            }
+            else if (agentCount >= (mapping.minAgentThreshold || 1)) {
+                type = 'recommended';
+                explanation = `Beneficial for ${agentCount} agents with complementary capabilities`;
+            }
+            else {
+                type = 'optional';
+                explanation = `May improve performance for ${agentCount} agents`;
+            }
+            recommendations.push({
+                serverName: mapping.serverName,
+                type,
+                explanation,
+                affectedAgents: agentCount,
+            });
+        }
+        return recommendations;
+    }
+    /**
+     * Write configuration to file
+     */
+    async writeConfigurationFile(servers, filePath) {
+        const config = {
+            mcpServers: servers.reduce((acc, server) => {
+                acc[server.config.name] = {
+                    ...server.config,
+                    // Add metadata for human readers
+                    _metadata: {
+                        reason: server.reason,
+                        benefitingAgents: server.benefitingAgents,
+                        relatedCapabilities: server.relatedCapabilities,
+                        autoConfigured: true,
+                        configuredAt: new Date().toISOString(),
+                    },
+                };
+                return acc;
+            }, {}),
+        };
+        const fs = await import('fs/promises');
+        const path = await import('path');
+        const absolutePath = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(this.options.workspaceRoot, filePath);
+        await fs.writeFile(absolutePath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * Get current server status
+     */
+    async getServerStatus() {
+        const servers = this.registry.getAvailableServers();
+        return servers.map((server) => ({
+            name: server.config.name,
+            status: server.status,
+            config: server.config,
+            manifest: server.manifest,
+        }));
+    }
+    /**
+     * Health check all configured servers
+     */
+    async healthCheckServers() {
+        const results = new Map();
+        const servers = this.registry.getAvailableServers();
+        for (const server of servers) {
+            try {
+                // Health check by checking if server has 'available' status
+                const isHealthy = server.status === 'available';
+                results.set(server.config.name, isHealthy);
+            }
+            catch (error) {
+                results.set(server.config.name, false);
+            }
+        }
+        return results;
+    }
+    /**
+     * Cleanup and shutdown
+     */
+    async shutdown() {
+        this.removeAllListeners();
+        await this.registry.shutdown();
+    }
+}
+/**
+ * Factory function for creating auto-configuration system
+ */
+export function createMCPAutoConfiguration(options) {
+    return new MCPAutoConfiguration(options);
+}
+export default MCPAutoConfiguration;
+//# sourceMappingURL=mcp-auto-configuration.js.map