@democratize-quality/mcp-server 1.1.8 → 1.2.0

package/src/tools/browser/type.js

@@ -1,174 +0,0 @@
-const ToolBase = require('../base/ToolBase');
-const browserService = require('../../services/browserService');
-
-/**
- * Browser Type Tool
- * Types text into a specific input field in the browser with Playwright-style locators
- */
-class BrowserTypeTool extends ToolBase {
-    static definition = {
-        name: "browser_type",
-        description: "Types text into a specific input field in the browser.",
-        input_schema: {
-            type: "object",
-            properties: {
-                browserId: {
-                    type: "string",
-                    description: "The ID of the browser instance."
-                },
-                locatorType: {
-                    type: "string",
-                    enum: ["css", "xpath", "text", "role", "label", "placeholder", "testId", "altText"],
-                    default: "css",
-                    description: "The type of locator to use"
-                },
-                locatorValue: {
-                    type: "string",
-                    description: "The locator value (CSS selector, XPath, text content, etc.)"
-                },
-                text: {
-                    type: "string",
-                    description: "The text to type into the input field."
-                },
-                // Keep backward compatibility
-                selector: {
-                    type: "string",
-                    description: "The CSS selector of the input field (deprecated, use locatorType and locatorValue instead)."
-                },
-                options: {
-                    type: "object",
-                    properties: {
-                        timeout: {
-                            type: "number",
-                            default: 30000,
-                            description: "Timeout in milliseconds"
-                        },
-                        delay: {
-                            type: "number",
-                            default: 0,
-                            description: "Delay between keystrokes in milliseconds"
-                        },
-                        clear: {
-                            type: "boolean",
-                            default: true,
-                            description: "Clear the field before typing"
-                        },
-                        noWaitAfter: {
-                            type: "boolean",
-                            default: false,
-                            description: "Do not wait for navigation after typing"
-                        }
-                    },
-                    description: "Additional typing options"
-                }
-            },
-            anyOf: [
-                { required: ["browserId", "locatorType", "locatorValue", "text"] },
-                { required: ["browserId", "selector", "text"] }
-            ]
-        },
-        output_schema: {
-            type: "object",
-            properties: {
-                success: { type: "boolean", description: "Indicates if the typing was successful." },
-                locatorType: { type: "string", description: "The locator type that was used." },
-                locatorValue: { type: "string", description: "The locator value that was used." },
-                text: { type: "string", description: "The text that was typed." },
-                browserId: { type: "string", description: "The browser instance ID that was used." },
-                elementFound: { type: "boolean", description: "Whether the element was found." },
-                message: { type: "string", description: "Success or error message." }
-            },
-            required: ["success", "browserId"]
-        }
-    };
-
-    async execute(parameters) {
-        const { browserId, locatorType, locatorValue, selector, text, options = {} } = parameters;
-
-        // Handle backward compatibility
-        let finalLocatorType, finalLocatorValue;
-        if (selector) {
-            finalLocatorType = "css";
-            finalLocatorValue = selector;
-        } else {
-            finalLocatorType = locatorType || "css";
-            finalLocatorValue = locatorValue;
-        }
-
-        console.error(`[BrowserTypeTool] Typing in browser ${browserId} with locator: ${finalLocatorType}="${finalLocatorValue}"`);
-
-        try {
-            // Convert Playwright-style locator to appropriate format for browser service
-            const elementSelector = this.convertLocatorToSelector(finalLocatorType, finalLocatorValue);
-            
-            await browserService.typeIntoElement(browserId, elementSelector, text, options);
-            
-            console.error(`[BrowserTypeTool] Successfully typed in browser: ${browserId}`);
-            
-            return { 
-                success: true, 
-                browserId: browserId,
-                locatorType: finalLocatorType,
-                locatorValue: finalLocatorValue,
-                text: text,
-                elementFound: true,
-                message: `Successfully typed "${text}" into element with ${finalLocatorType} locator: ${finalLocatorValue}`
-            };
-        } catch (error) {
-            console.error(`[BrowserTypeTool] Failed to type in element:`, error.message);
-            
-            return {
-                success: false,
-                browserId: browserId,
-                locatorType: finalLocatorType,
-                locatorValue: finalLocatorValue,
-                text: text,
-                elementFound: false,
-                message: `Failed to type into element: ${error.message}`
-            };
-        }
-    }
-
-    /**
-     * Convert Playwright-style locator to CSS selector or XPath
-     */
-    convertLocatorToSelector(locatorType, locatorValue) {
-        switch (locatorType) {
-            case "css":
-                return locatorValue;
-            
-            case "xpath":
-                return locatorValue;
-            
-            case "text":
-                // Convert text locator to XPath for input elements
-                return `//input[contains(@placeholder, "${locatorValue}")] | //input[contains(@value, "${locatorValue}")] | //textarea[contains(text(), "${locatorValue}")] | //label[contains(text(), "${locatorValue}")]/following-sibling::input | //label[contains(text(), "${locatorValue}")]/following::input[1]`;
-            
-            case "role":
-                // Convert role locator to CSS attribute selector
-                return `[role="${locatorValue}"]`;
-            
-            case "label":
-                // Convert label locator to XPath for label association
-                return `//input[@aria-label="${locatorValue}"] | //input[@id=//label[contains(text(), "${locatorValue}")]/@for] | //label[contains(text(), "${locatorValue}")]/following-sibling::input | //label[contains(text(), "${locatorValue}")]/following::input[1]`;
-            
-            case "placeholder":
-                // Convert placeholder locator to CSS attribute selector
-                return `[placeholder="${locatorValue}"]`;
-            
-            case "testId":
-                // Convert test ID to CSS attribute selector (assuming data-testid)
-                return `[data-testid="${locatorValue}"]`;
-            
-            case "altText":
-                // Convert alt text to CSS attribute selector (less common for input fields)
-                return `[alt="${locatorValue}"]`;
-            
-            default:
-                // Default to CSS selector
-                return locatorValue;
-        }
-    }
-}
-
-module.exports = BrowserTypeTool;

package/src/tools/index.js

@@ -1,95 +0,0 @@
-const ToolRegistry = require('./base/ToolRegistry');
-const path = require('path');
-
-/**
- * Initialize and configure the tool registry
- * This file serves as the main entry point for the tools system
- */
-
-// Create the global tool registry instance
-const toolRegistry = new ToolRegistry();
-
-/**
- * Initialize the tool registry by discovering and loading all tools
- * @param {boolean} debugMode - Whether to enable debug logging
- * @returns {Promise<ToolRegistry>} - The initialized tool registry
- */
-async function initializeTools(debugMode = false) {
-    if (debugMode) {
-        console.error('[Tools] Initializing tool system...');
-    }
-    
-    try {
-        // Get the tools directory path
-        const toolsDir = path.join(__dirname);
-        
-        // Discover and load all tools
-        await toolRegistry.discoverTools(toolsDir, debugMode);
-        
-        // Log registry statistics
-        const stats = toolRegistry.getStats();
-        console.error(`[Tools] Tool system initialized successfully:`);
-        console.error(`[Tools] - Total tools: ${stats.total_tools}`);
-        if (debugMode) {
-            console.error(`[Tools] - Available tools: ${stats.tool_names.join(', ')}`);
-        }
-        
-        return toolRegistry;
-        
-    } catch (error) {
-        console.error('[Tools] Failed to initialize tool system:', error.message);
-        throw error;
-    }
-}
-
-/**
- * Get the tool registry instance
- * @returns {ToolRegistry} - The tool registry instance
- */
-function getToolRegistry() {
-    return toolRegistry;
-}
-
-/**
- * Get all tool definitions for MCP tools/list response
- * @returns {Array} - Array of tool definitions
- */
-function getToolDefinitions() {
-    return toolRegistry.getDefinitions();
-}
-
-/**
- * Execute a tool by name
- * @param {string} toolName - The name of the tool to execute
- * @param {object} parameters - The parameters to pass to the tool
- * @returns {Promise<object>} - The tool execution result
- */
-async function executeTool(toolName, parameters) {
-    return await toolRegistry.executeTool(toolName, parameters);
-}
-
-/**
- * Check if a tool is available
- * @param {string} toolName - The name of the tool to check
- * @returns {boolean} - True if the tool is available
- */
-function isToolAvailable(toolName) {
-    return toolRegistry.hasTool(toolName);
-}
-
-/**
- * Get list of available tool names
- * @returns {Array<string>} - Array of available tool names
- */
-function getAvailableTools() {
-    return toolRegistry.getToolNames();
-}
-
-module.exports = {
-    initializeTools,
-    getToolRegistry,
-    getToolDefinitions,
-    executeTool,
-    isToolAvailable,
-    getAvailableTools
-};

package/src/utils/agentInstaller.js

@@ -1,418 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { promisify } = require('util');
-
-const readFile = promisify(fs.readFile);
-const writeFile = promisify(fs.writeFile);
-const mkdir = promisify(fs.mkdir);
-const copyFile = promisify(fs.copyFile);
-const stat = promisify(fs.stat);
-const readdir = promisify(fs.readdir);
-const symlink = promisify(fs.symlink);
-const unlink = promisify(fs.unlink);
-const lstat = promisify(fs.lstat);
-
-/**
- * Agent Installer - Handles installation of Agent Skills and MCP configuration
- */
-class AgentInstaller {
-    constructor(options = {}) {
-        this.verbose = options.verbose || false;
-        this.targetDir = options.targetDir || process.cwd();
-        this.sourceDir = options.sourceDir || path.join(__dirname, '..', '..');
-    }
-
-    /**
-     * Main installation function
-     */
-    async install() {
-        console.log('🚀 Installing Democratize Quality Agent Skills...\n');
-
-        try {
-            // Step 1: Install Agent Skills
-            await this.installSkills();
-            
-            // Step 2: Install Chat Modes
-            await this.installChatModes();
-            
-            // Step 3: Setup MCP configuration
-            await this.setupMCPConfiguration();
-            
-            // Step 4: Show completion message
-            this.showCompletionMessage();
-            
-        } catch (error) {
-            console.error('❌ Installation failed:', error.message);
-            if (this.verbose) {
-                console.error('Stack trace:', error.stack);
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * Install Agent Skills to .agents/skills/ with symlinks for compatibility
-     */
-    async installSkills() {
-        console.log('📁 Installing Agent Skills...');
-        
-        const sourceSkillsDir = path.join(this.sourceDir, 'src', 'skills');
-        const primarySkillsDir = path.join(this.targetDir, '.agents', 'skills');
-        
-        // Create primary skills directory
-        try {
-            await mkdir(primarySkillsDir, { recursive: true });
-        } catch (error) {
-            if (error.code !== 'EEXIST') {
-                throw new Error(`Failed to create .agents/skills directory: ${error.message}`);
-            }
-        }
-        
-        // Get list of skill directories
-        let skillDirs;
-        try {
-            const allItems = await readdir(sourceSkillsDir);
-            // Filter for directories only
-            skillDirs = [];
-            for (const item of allItems) {
-                const itemPath = path.join(sourceSkillsDir, item);
-                const itemStat = await stat(itemPath);
-                if (itemStat.isDirectory()) {
-                    skillDirs.push(item);
-                }
-            }
-        } catch (error) {
-            throw new Error(`Failed to read source skills directory: ${error.message}`);
-        }
-        
-        if (skillDirs.length === 0) {
-            console.log('   ⚠️  No skills found to install');
-            return;
-        }
-        
-        // Copy each skill directory
-        for (const skillDir of skillDirs) {
-            const sourceSkillPath = path.join(sourceSkillsDir, skillDir);
-            const targetSkillPath = path.join(primarySkillsDir, skillDir);
-            
-            try {
-                await this.copyDirectory(sourceSkillPath, targetSkillPath);
-                console.log(`   ✅ ${skillDir}/`);
-            } catch (error) {
-                console.error(`   ❌ Failed to copy ${skillDir}: ${error.message}`);
-                throw error;
-            }
-        }
-        
-        console.log('');
-        
-        // Create symlinks for maximum compatibility
-        await this.createCompatibilitySymlinks(primarySkillsDir);
-    }
-
-    /**
-     * Recursively copy a directory
-     */
-    async copyDirectory(source, target) {
-        await mkdir(target, { recursive: true });
-        
-        const items = await readdir(source);
-        
-        for (const item of items) {
-            const sourcePath = path.join(source, item);
-            const targetPath = path.join(target, item);
-            const itemStat = await stat(sourcePath);
-            
-            if (itemStat.isDirectory()) {
-                await this.copyDirectory(sourcePath, targetPath);
-            } else {
-                await copyFile(sourcePath, targetPath);
-            }
-        }
-    }
-
-    /**
-     * Create symlinks for compatibility with different tools
-     */
-    async createCompatibilitySymlinks(primarySkillsDir) {
-        console.log('🔗 Creating compatibility symlinks...');
-        
-        const symlinks = [
-            { from: primarySkillsDir, to: path.join(this.targetDir, '.github', 'skills') },
-            { from: primarySkillsDir, to: path.join(this.targetDir, '.claude', 'skills') }
-        ];
-        
-        for (const link of symlinks) {
-            try {
-                // Check if symlink or directory already exists
-                try {
-                    const linkStat = await lstat(link.to);
-                    if (linkStat.isSymbolicLink()) {
-                        // Remove existing symlink
-                        await unlink(link.to);
-                        if (this.verbose) {
-                            console.log(`   🔄 Removed existing symlink: ${path.relative(this.targetDir, link.to)}`);
-                        }
-                    } else if (linkStat.isDirectory()) {
-                        console.log(`   ⚠️  Directory already exists, skipping symlink: ${path.relative(this.targetDir, link.to)}`);
-                        continue;
-                    }
-                } catch (error) {
-                    if (error.code !== 'ENOENT') {
-                        throw error;
-                    }
-                    // Path doesn't exist, proceed with symlink creation
-                }
-                
-                // Create parent directory if it doesn't exist
-                const parentDir = path.dirname(link.to);
-                await mkdir(parentDir, { recursive: true });
-                
-                // Create relative symlink
-                const relativeTarget = path.relative(path.dirname(link.to), link.from);
-                await symlink(relativeTarget, link.to, 'dir');
-                console.log(`   ✅ ${path.relative(this.targetDir, link.to)} → ${path.relative(this.targetDir, link.from)}`);
-            } catch (error) {
-                console.warn(`   ⚠️  Could not create symlink ${path.relative(this.targetDir, link.to)}: ${error.message}`);
-                if (this.verbose) {
-                    console.warn(`       (This is not critical - skills will still work from .agents/skills/)`);
-                }
-            }
-        }
-        
-        console.log('');
-    }
-
-    /**
-     * Install Chat Modes to .github/agents/
-     */
-    async installChatModes() {
-        console.log('💬 Installing Chat Modes...');
-        
-        const sourceChatModesDir = path.join(this.sourceDir, 'src', 'chatmodes');
-        const targetAgentsDir = path.join(this.targetDir, '.github', 'agents');
-        
-        // Create .github/agents directory
-        try {
-            await mkdir(targetAgentsDir, { recursive: true });
-        } catch (error) {
-            if (error.code !== 'EEXIST') {
-                throw new Error(`Failed to create .github/agents directory: ${error.message}`);
-            }
-        }
-        
-        // Get list of chatmode files
-        let chatModeFiles;
-        try {
-            const allItems = await readdir(sourceChatModesDir);
-            // Filter for .chatmode.md files only
-            chatModeFiles = allItems.filter(item => item.endsWith('.chatmode.md'));
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                console.log('   ⚠️  No chatmodes directory found, skipping...');
-                console.log('');
-                return;
-            }
-            throw new Error(`Failed to read source chatmodes directory: ${error.message}`);
-        }
-        
-        if (chatModeFiles.length === 0) {
-            console.log('   ⚠️  No chatmode files found to install');
-            console.log('');
-            return;
-        }
-        
-        // Copy each chatmode file
-        for (const chatModeFile of chatModeFiles) {
-            const sourcePath = path.join(sourceChatModesDir, chatModeFile);
-            const targetPath = path.join(targetAgentsDir, chatModeFile);
-            
-            try {
-                await copyFile(sourcePath, targetPath);
-                console.log(`   ✅ ${chatModeFile}`);
-            } catch (error) {
-                console.error(`   ❌ Failed to copy ${chatModeFile}: ${error.message}`);
-                throw error;
-            }
-        }
-        
-        console.log('');
-    }
-
-    /**
-     * Setup MCP configuration in .vscode/mcp.json
-     */
-    async setupMCPConfiguration() {
-        console.log('⚙️  Setting up MCP configuration...');
-        
-        const vscodeDir = path.join(this.targetDir, '.vscode');
-        const mcpConfigPath = path.join(vscodeDir, 'mcp.json');
-        
-        // Create .vscode directory if it doesn't exist
-        try {
-            await mkdir(vscodeDir, { recursive: true });
-        } catch (error) {
-            if (error.code !== 'EEXIST') {
-                throw new Error(`Failed to create .vscode directory: ${error.message}`);
-            }
-        }
-        
-        // Check if mcp.json already exists
-        let existingConfig = null;
-        let configExists = false;
-        
-        try {
-            await stat(mcpConfigPath);
-            configExists = true;
-            console.log('   📋 Found existing .vscode/mcp.json');
-            
-            const configContent = await readFile(mcpConfigPath, 'utf8');
-            existingConfig = JSON.parse(configContent);
-            
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                console.log('   📋 Creating new .vscode/mcp.json');
-                configExists = false;
-            } else if (error instanceof SyntaxError) {
-                throw new Error(`Existing mcp.json is malformed: ${error.message}`);
-            } else {
-                throw new Error(`Failed to read existing mcp.json: ${error.message}`);
-            }
-        }
-        
-        // Create new server configuration
-        const newServerConfig = {
-            type: "stdio",
-            command: "npx",
-            args: ["@democratize-quality/mcp-server@latest"],
-            cwd: "${workspaceFolder}",
-            env: {
-                OUTPUT_DIR: "./api-test-reports"
-            }
-        };
-        
-        let finalConfig;
-        
-        if (configExists && existingConfig) {
-            // Handle existing configuration
-            await this.handleExistingMCPConfig(existingConfig, newServerConfig, mcpConfigPath);
-            return;
-        } else {
-            // Create new configuration
-            finalConfig = {
-                servers: {
-                    "democratize-quality": newServerConfig
-                },
-                inputs: []
-            };
-        }
-        
-        // Write the configuration
-        try {
-            await writeFile(mcpConfigPath, JSON.stringify(finalConfig, null, 2), 'utf8');
-            console.log('   ✅ MCP configuration created');
-        } catch (error) {
-            throw new Error(`Failed to write mcp.json: ${error.message}`);
-        }
-        
-        console.log('');
-    }
-
-    /**
-     * Handle existing MCP configuration
-     */
-    async handleExistingMCPConfig(existingConfig, newServerConfig, mcpConfigPath) {
-        // Ensure servers object exists
-        if (!existingConfig.servers) {
-            existingConfig.servers = {};
-        }
-        
-        // Check if democratize-quality server already exists
-        if (existingConfig.servers['democratize-quality']) {
-            console.log('   🔍 Found existing "democratize-quality" server configuration');
-            
-            const existingServer = existingConfig.servers['democratize-quality'];
-            console.log('   Current configuration:');
-            console.log('   ', JSON.stringify(existingServer, null, 4));
-            console.log('   \n   Proposed configuration:');
-            console.log('   ', JSON.stringify(newServerConfig, null, 4));
-            
-            // For now, we'll update automatically with backup
-            // In a real implementation, you might want to prompt the user
-            console.log('   💾 Creating backup and updating configuration...');
-            
-            // Create backup
-            const backupPath = `${mcpConfigPath}.backup.${new Date().toISOString().replace(/[:.]/g, '-')}`;
-            await writeFile(backupPath, JSON.stringify(existingConfig, null, 2), 'utf8');
-            console.log(`   📄 Backup created: ${path.basename(backupPath)}`);
-        }
-        
-        // Update configuration
-        const updatedConfig = {
-            ...existingConfig,
-            servers: {
-                ...existingConfig.servers,
-                'democratize-quality': newServerConfig
-            },
-            inputs: existingConfig.inputs || []
-        };
-        
-        // Write updated configuration
-        try {
-            await writeFile(mcpConfigPath, JSON.stringify(updatedConfig, null, 2), 'utf8');
-            console.log('   ✅ MCP configuration updated');
-        } catch (error) {
-            throw new Error(`Failed to update mcp.json: ${error.message}`);
-        }
-    }
-
-    /**
-     * Show completion message with next steps
-     */
-    showCompletionMessage() {
-        console.log('🎉 Installation complete!\n');
-        
-        console.log('📁 Agent Skills installed to:');
-        console.log('   → .agents/skills/api-planning/');
-        console.log('   → .agents/skills/test-generation/');
-        console.log('   → .agents/skills/test-execution/');
-        console.log('   → .agents/skills/test-healing/');
-        console.log('   → .github/skills/ (symlink for GitHub Copilot)');
-        console.log('   → .claude/skills/ (symlink for Claude Code)\n');
-        
-        console.log('💬 Chat Modes installed to:');
-        console.log('   → .github/agents/🌐 api-planner.chatmode.md');
-        console.log('   → .github/agents/🌐 api-generator.chatmode.md');
-        console.log('   → .github/agents/🌐 api-healer.chatmode.md\n');
-        
-        console.log('⚙️  MCP configuration updated:');
-        console.log('   → .vscode/mcp.json (democratize-quality server added/updated)\n');
-        
-        console.log('🚀 Next steps:');
-        console.log('   1. Restart VS Code / IDE to reload configuration');
-        console.log('   2. Use skills in your AI coding assistant:');
-        console.log('      • /api-planning - Create comprehensive API test plans');
-        console.log('      • /test-generation - Generate executable API tests');
-        console.log('      • /test-execution - Execute API tests from test plans');
-        console.log('      • /test-healing - Debug and fix failing API tests');
-        console.log('   3. Skills work automatically when you mention relevant tasks!');
-        console.log('   4. Example: "Help me create an API test plan for my REST API"\n');
-        
-        console.log('✨ Compatible with:');
-        console.log('   • GitHub Copilot (VS Code, CLI)');
-        console.log('   • Codex CLI (OpenAI)');
-        console.log('   • Claude Code');
-        
-        console.log('📚 For more information, visit: https://github.com/uppadhyayraj/democratize-quality-mcp-server');
-    }
-
-    /**
-     * Rollback installation (future feature)
-     */
-    async rollback() {
-        console.log('🔄 Rollback functionality will be implemented in a future version');
-        // TODO: Implement rollback functionality
-    }
-}
-
-module.exports = AgentInstaller;