erosolar-cli 1.7.194 → 1.7.195

package/dist/tools/devTools.js

@@ -1,2305 +0,0 @@
-import { exec } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-import { verifiedSuccess, verifiedFailure, createCommandCheck, OutputPatterns, analyzeOutput, } from '../core/resultVerification.js';
-const execAsync = promisify(exec);
-export function createDevTools(workingDir) {
-    return [
-        {
-            name: 'run_tests',
-            description: 'Execute test suite using npm test or other test runners',
-            parameters: {
-                type: 'object',
-                properties: {
-                    testPattern: {
-                        type: 'string',
-                        description: 'Optional test pattern or file to run specific tests',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds (default: 60000)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const testPatternArg = args['testPattern'];
-                const testPattern = typeof testPatternArg === 'string' && testPatternArg.trim() ? testPatternArg.trim() : undefined;
-                const timeoutArg = args['timeout'];
-                const timeout = typeof timeoutArg === 'number' && Number.isFinite(timeoutArg) && timeoutArg > 0 ? timeoutArg : 300000; // 5 min default
-                const startTime = Date.now();
-                try {
-                    // Check if package.json exists
-                    const packageJsonPath = join(workingDir, 'package.json');
-                    if (!existsSync(packageJsonPath)) {
-                        return verifiedFailure('Cannot run tests', 'package.json not found in working directory', ['Initialize npm project with `npm init`', 'Navigate to correct directory'], [{ check: 'package.json exists', passed: false, details: 'File not found' }]);
-                    }
-                    // Build test command
-                    let command = 'npm test';
-                    if (testPattern) {
-                        // Try to detect test runner and build appropriate command
-                        const packageInfo = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                        const scripts = packageInfo.scripts || {};
-                        const testScript = scripts['test'] ?? '';
-                        if (testScript.includes('jest')) {
-                            command = `npx jest ${testPattern}`;
-                        }
-                        else if (testScript.includes('vitest')) {
-                            command = `npx vitest run ${testPattern}`;
-                        }
-                        else if (testScript.includes('mocha')) {
-                            command = `npx mocha ${testPattern}`;
-                        }
-                        else {
-                            // Fallback to npm test with pattern
-                            command = `npm test -- ${testPattern}`;
-                        }
-                    }
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10, // 10MB
-                    });
-                    const durationMs = Date.now() - startTime;
-                    const combinedOutput = [stdout, stderr].filter(Boolean).join('\n');
-                    // Analyze for test failure patterns
-                    const analysis = analyzeOutput(combinedOutput, OutputPatterns.npm, 0);
-                    const commandCheck = createCommandCheck('Test execution', 0, combinedOutput);
-                    if (analysis.isFailure) {
-                        return verifiedFailure('Tests failed', `Command: ${command}\n\nOutput:\n${combinedOutput}`, ['Review failing tests', 'Fix test assertions or code'], [commandCheck], durationMs);
-                    }
-                    return verifiedSuccess('Tests passed', `Command: ${command}\n\nOutput:\n${combinedOutput || '(no output)'}`, [commandCheck], durationMs);
-                }
-                catch (error) {
-                    const durationMs = Date.now() - startTime;
-                    const combinedError = [error.stdout, error.stderr, error.message].filter(Boolean).join('\n');
-                    if (error.killed) {
-                        return verifiedFailure(`Tests timed out after ${timeout}ms`, `The test command was killed after exceeding the timeout.\nPartial output:\n${combinedError || '(none)'}`, ['Increase timeout if tests legitimately need more time', 'Check for infinite loops or hanging tests'], [{ check: 'Timeout', passed: false, details: `Exceeded ${timeout}ms` }], durationMs);
-                    }
-                    return verifiedFailure(`Tests failed with exit code ${error.code ?? 1}`, `Error output:\n${combinedError || '(none)'}`, ['Review test failures', 'Fix failing tests'], [createCommandCheck('Test execution', error.code ?? 1, combinedError)], durationMs);
-                }
-            },
-        },
-        {
-            name: 'install_dependencies',
-            description: 'Install project dependencies using npm, yarn, or pnpm',
-            parameters: {
-                type: 'object',
-                properties: {
-                    packageManager: {
-                        type: 'string',
-                        enum: ['npm', 'yarn', 'pnpm'],
-                        description: 'Package manager to use (default: npm)',
-                    },
-                    production: {
-                        type: 'boolean',
-                        description: 'Install only production dependencies',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const packageManager = typeof args['packageManager'] === 'string' ? args['packageManager'] : 'npm';
-                const production = args['production'] === true;
-                const startTime = Date.now();
-                try {
-                    let command;
-                    if (packageManager === 'npm') {
-                        // Use npm install instead of npm ci if no package-lock.json exists
-                        const hasLockFile = existsSync(join(workingDir, 'package-lock.json'));
-                        command = hasLockFile
-                            ? (production ? 'npm ci --production' : 'npm ci')
-                            : (production ? 'npm install --production' : 'npm install');
-                    }
-                    else if (packageManager === 'yarn') {
-                        command = production ? 'yarn install --production' : 'yarn install';
-                    }
-                    else if (packageManager === 'pnpm') {
-                        command = production ? 'pnpm install --prod' : 'pnpm install';
-                    }
-                    else {
-                        return verifiedFailure(`Unsupported package manager: ${packageManager}`, 'Supported package managers: npm, yarn, pnpm', ['Use npm, yarn, or pnpm as the packageManager']);
-                    }
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd: workingDir,
-                        timeout: 300000, // 5 minutes
-                        maxBuffer: 1024 * 1024 * 10,
-                    });
-                    const durationMs = Date.now() - startTime;
-                    const combinedOutput = [stdout, stderr].filter(Boolean).join('\n');
-                    const analysis = analyzeOutput(combinedOutput, OutputPatterns.npm, 0);
-                    const commandCheck = createCommandCheck('Dependency installation', 0, combinedOutput);
-                    if (analysis.isFailure) {
-                        return verifiedFailure('Dependency installation had errors', `Command: ${command}\n\nOutput:\n${combinedOutput}`, ['Check for version conflicts', 'Clear npm cache and retry', 'Check network connectivity'], [commandCheck], durationMs);
-                    }
-                    return verifiedSuccess('Dependencies installed successfully', `Command: ${command}\n\nOutput:\n${combinedOutput || '(no output)'}`, [commandCheck], durationMs);
-                }
-                catch (error) {
-                    const durationMs = Date.now() - startTime;
-                    const combinedError = [error.stdout, error.stderr, error.message].filter(Boolean).join('\n');
-                    if (error.killed) {
-                        return verifiedFailure('Dependency installation timed out', `The installation was killed after exceeding 5 minute timeout.\nPartial output:\n${combinedError || '(none)'}`, ['Check network connectivity', 'Consider using run_in_background for slow connections'], [{ check: 'Timeout', passed: false, details: 'Exceeded 5 minutes' }], durationMs);
-                    }
-                    return verifiedFailure(`Dependency installation failed with exit code ${error.code ?? 1}`, `Error output:\n${combinedError || '(none)'}`, ['Review error message', 'Check package.json syntax', 'Clear npm cache: npm cache clean --force'], [createCommandCheck('Dependency installation', error.code ?? 1, combinedError)], durationMs);
-                }
-            },
-        },
-        {
-            name: 'check_package_info',
-            description: 'Get information about project dependencies and scripts from package.json',
-            parameters: {
-                type: 'object',
-                properties: {
-                    detail: {
-                        type: 'string',
-                        enum: ['basic', 'dependencies', 'scripts', 'full'],
-                        description: 'Level of detail to include',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const detailArg = args['detail'];
-                const detail = typeof detailArg === 'string' && detailArg.trim() ? detailArg : 'basic';
-                try {
-                    const packageJsonPath = join(workingDir, 'package.json');
-                    if (!existsSync(packageJsonPath)) {
-                        return 'Error: package.json not found';
-                    }
-                    const packageInfo = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                    const output = [];
-                    output.push(`# Package Info: ${packageInfo.name || 'Unnamed'} v${packageInfo.version || 'Unknown'}`);
-                    output.push('');
-                    if (detail === 'basic' || detail === 'full') {
-                        output.push('## Basic Info');
-                        output.push(`- Name: ${packageInfo.name || 'Not specified'}`);
-                        output.push(`- Version: ${packageInfo.version || 'Not specified'}`);
-                        output.push('');
-                    }
-                    if ((detail === 'scripts' || detail === 'full') && packageInfo.scripts) {
-                        output.push('## Scripts');
-                        Object.entries(packageInfo.scripts).forEach(([name, script]) => {
-                            output.push(`- ${name}: ${script}`);
-                        });
-                        output.push('');
-                    }
-                    if ((detail === 'dependencies' || detail === 'full') && packageInfo.dependencies) {
-                        output.push('## Dependencies');
-                        Object.entries(packageInfo.dependencies).forEach(([name, version]) => {
-                            output.push(`- ${name}: ${version}`);
-                        });
-                        output.push('');
-                    }
-                    if ((detail === 'dependencies' || detail === 'full') && packageInfo.devDependencies) {
-                        output.push('## Dev Dependencies');
-                        Object.entries(packageInfo.devDependencies).forEach(([name, version]) => {
-                            output.push(`- ${name}: ${version}`);
-                        });
-                        output.push('');
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Error reading package.json: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-        {
-            name: 'run_build',
-            description: 'Execute build process using npm run build or other build commands',
-            parameters: {
-                type: 'object',
-                properties: {
-                    buildCommand: {
-                        type: 'string',
-                        description: 'Custom build command (defaults to npm run build)',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds (default: 300000)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const buildCommandArg = args['buildCommand'];
-                const buildCommand = typeof buildCommandArg === 'string' && buildCommandArg.trim()
-                    ? buildCommandArg
-                    : 'npm run build';
-                const timeoutArg = args['timeout'];
-                const timeout = typeof timeoutArg === 'number' && Number.isFinite(timeoutArg) && timeoutArg > 0 ? timeoutArg : 300000; // 5 minutes
-                try {
-                    const { stdout, stderr } = await execAsync(buildCommand, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10,
-                    });
-                    let result = `Build command: ${buildCommand}\n\n`;
-                    if (stdout)
-                        result += `stdout:\n${stdout}\n`;
-                    if (stderr)
-                        result += `stderr:\n${stderr}\n`;
-                    return result || 'Build completed (no output)';
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return `Error: Build command timed out after ${timeout}ms`;
-                    }
-                    return `Error running build: ${error.message}\nstderr: ${error.stderr || 'none'}`;
-                }
-            },
-        },
-        {
-            name: 'npm_publish',
-            description: 'Publish package to npm registry. Handles the full workflow: check login, commit changes, bump version, build, and publish.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    versionBump: {
-                        type: 'string',
-                        enum: ['patch', 'minor', 'major', 'prepatch', 'preminor', 'premajor', 'prerelease'],
-                        description: 'Version bump type (default: patch)',
-                    },
-                    commitMessage: {
-                        type: 'string',
-                        description: 'Commit message for uncommitted changes (if any). If not provided and there are uncommitted changes, will fail.',
-                    },
-                    tag: {
-                        type: 'string',
-                        description: 'npm tag for the release (default: latest)',
-                    },
-                    dryRun: {
-                        type: 'boolean',
-                        description: 'If true, performs all steps except the actual publish',
-                    },
-                    skipBuild: {
-                        type: 'boolean',
-                        description: 'Skip the build step (use if build is handled by npm prepare script)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const versionBump = typeof args['versionBump'] === 'string' ? args['versionBump'] : 'patch';
-                const commitMessage = typeof args['commitMessage'] === 'string' ? args['commitMessage'] : undefined;
-                const tag = typeof args['tag'] === 'string' ? args['tag'] : 'latest';
-                const dryRun = args['dryRun'] === true;
-                const skipBuild = args['skipBuild'] === true;
-                const steps = [];
-                const errors = [];
-                try {
-                    // Step 1: Check npm login status
-                    steps.push('## Step 1: Checking npm login status');
-                    try {
-                        const { stdout: whoami } = await execAsync('npm whoami', { cwd: workingDir, timeout: 30000 });
-                        steps.push(`✓ Logged in as: ${whoami.trim()}`);
-                    }
-                    catch (e) {
-                        errors.push('✗ Not logged into npm. Run `npm login` first.');
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    // Step 2: Check for uncommitted changes
-                    steps.push('');
-                    steps.push('## Step 2: Checking git status');
-                    try {
-                        const { stdout: gitStatus } = await execAsync('git status --porcelain', { cwd: workingDir, timeout: 10000 });
-                        if (gitStatus.trim()) {
-                            if (commitMessage) {
-                                steps.push(`Found uncommitted changes, committing with message: "${commitMessage}"`);
-                                await execAsync('git add .', { cwd: workingDir, timeout: 30000 });
-                                await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd: workingDir, timeout: 30000 });
-                                steps.push('✓ Changes committed');
-                            }
-                            else {
-                                errors.push('✗ Uncommitted changes found. Provide a commitMessage or commit manually first.');
-                                errors.push('Changed files:');
-                                gitStatus.trim().split('\n').forEach(line => errors.push(`  ${line}`));
-                                return [...steps, '', '## Errors', ...errors].join('\n');
-                            }
-                        }
-                        else {
-                            steps.push('✓ Working directory clean');
-                        }
-                    }
-                    catch (e) {
-                        steps.push(`Warning: Could not check git status: ${e.message}`);
-                    }
-                    // Step 3: Read current version
-                    steps.push('');
-                    steps.push('## Step 3: Reading package info');
-                    const packageJsonPath = join(workingDir, 'package.json');
-                    if (!existsSync(packageJsonPath)) {
-                        errors.push('✗ package.json not found');
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    const packageInfo = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                    steps.push(`✓ Package: ${packageInfo.name} v${packageInfo.version}`);
-                    // Step 4: Build (unless skipped)
-                    if (!skipBuild) {
-                        steps.push('');
-                        steps.push('## Step 4: Building project');
-                        try {
-                            const { stderr: buildErr } = await execAsync('npm run build', {
-                                cwd: workingDir,
-                                timeout: 300000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push('✓ Build completed');
-                            if (buildErr && !buildErr.includes('npm WARN')) {
-                                steps.push(`Build stderr: ${buildErr.substring(0, 500)}`);
-                            }
-                        }
-                        catch (e) {
-                            errors.push(`✗ Build failed: ${e.message}`);
-                            return [...steps, '', '## Errors', ...errors].join('\n');
-                        }
-                    }
-                    else {
-                        steps.push('');
-                        steps.push('## Step 4: Build skipped (skipBuild=true)');
-                    }
-                    // Step 5: Version bump
-                    steps.push('');
-                    steps.push('## Step 5: Bumping version');
-                    try {
-                        const { stdout: versionOut } = await execAsync(`npm version ${versionBump}`, {
-                            cwd: workingDir,
-                            timeout: 30000,
-                        });
-                        const newVersion = versionOut.trim();
-                        steps.push(`✓ Version bumped to ${newVersion}`);
-                    }
-                    catch (e) {
-                        errors.push(`✗ Version bump failed: ${e.message}`);
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    // Step 6: Publish
-                    steps.push('');
-                    steps.push('## Step 6: Publishing to npm');
-                    if (dryRun) {
-                        steps.push('⚠ DRY RUN - skipping actual publish');
-                        try {
-                            const { stdout: dryRunOut } = await execAsync(`npm publish --dry-run --tag ${tag}`, {
-                                cwd: workingDir,
-                                timeout: 120000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push('Dry run output:');
-                            steps.push(dryRunOut.substring(0, 2000));
-                        }
-                        catch (e) {
-                            steps.push(`Dry run warning: ${e.message}`);
-                        }
-                    }
-                    else {
-                        try {
-                            const { stdout: publishOut } = await execAsync(`npm publish --tag ${tag}`, {
-                                cwd: workingDir,
-                                timeout: 120000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push(`✓ Published successfully`);
-                            // Extract package info from output
-                            const match = publishOut.match(/\+ ([^\s]+)/);
-                            if (match) {
-                                steps.push(`Published: ${match[1]}`);
-                            }
-                        }
-                        catch (e) {
-                            errors.push(`✗ Publish failed: ${e.message}`);
-                            return [...steps, '', '## Errors', ...errors].join('\n');
-                        }
-                    }
-                    // Step 7: Push to git
-                    steps.push('');
-                    steps.push('## Step 7: Pushing to git');
-                    try {
-                        await execAsync('git push && git push --tags', { cwd: workingDir, timeout: 60000 });
-                        steps.push('✓ Pushed commits and tags to remote');
-                    }
-                    catch (e) {
-                        steps.push(`Warning: Could not push to git: ${e.message}`);
-                    }
-                    // Summary
-                    steps.push('');
-                    steps.push('## Summary');
-                    const updatedPackage = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                    steps.push(`✓ ${updatedPackage.name}@${updatedPackage.version} ${dryRun ? '(dry run)' : 'published'}`);
-                    return steps.join('\n');
-                }
-                catch (error) {
-                    errors.push(`Unexpected error: ${error.message}`);
-                    return [...steps, '', '## Errors', ...errors].join('\n');
-                }
-            },
-        },
-        {
-            name: 'npm_check_auth',
-            description: 'Check npm authentication status and registry configuration',
-            parameters: {
-                type: 'object',
-                properties: {},
-                additionalProperties: false,
-            },
-            handler: async () => {
-                const output = ['# npm Authentication Status', ''];
-                try {
-                    // Check whoami
-                    try {
-                        const { stdout: whoami } = await execAsync('npm whoami', { cwd: workingDir, timeout: 30000 });
-                        output.push(`✓ Logged in as: **${whoami.trim()}**`);
-                    }
-                    catch {
-                        output.push('✗ Not logged in to npm');
-                        output.push('');
-                        output.push('To login, run: `npm login`');
-                        return output.join('\n');
-                    }
-                    // Check registry
-                    try {
-                        const { stdout: registry } = await execAsync('npm config get registry', { cwd: workingDir, timeout: 10000 });
-                        output.push(`Registry: ${registry.trim()}`);
-                    }
-                    catch {
-                        output.push('Registry: (could not determine)');
-                    }
-                    // Check token
-                    output.push('');
-                    output.push('## Token Status');
-                    try {
-                        const { stdout: tokenList } = await execAsync('npm token list 2>/dev/null | head -5', {
-                            cwd: workingDir,
-                            timeout: 30000,
-                            shell: '/bin/bash',
-                        });
-                        if (tokenList.trim()) {
-                            output.push('Active tokens found');
-                        }
-                    }
-                    catch {
-                        output.push('Could not list tokens (this is normal)');
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Error checking npm auth: ${error.message}`;
-                }
-            },
-        },
-        // ========================================================================
-        // PyPI Publishing Tools
-        // ========================================================================
-        {
-            name: 'python_publish',
-            description: 'Publish Python package to PyPI. Handles the full workflow: check auth, commit changes, bump version, build, and publish.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    versionBump: {
-                        type: 'string',
-                        enum: ['patch', 'minor', 'major'],
-                        description: 'Version bump type (default: patch)',
-                    },
-                    commitMessage: {
-                        type: 'string',
-                        description: 'Commit message for uncommitted changes (if any)',
-                    },
-                    dryRun: {
-                        type: 'boolean',
-                        description: 'If true, performs all steps except the actual publish',
-                    },
-                    testPypi: {
-                        type: 'boolean',
-                        description: 'Publish to TestPyPI instead of PyPI (default: false)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const versionBump = typeof args['versionBump'] === 'string' ? args['versionBump'] : 'patch';
-                const commitMessage = typeof args['commitMessage'] === 'string' ? args['commitMessage'] : undefined;
-                const dryRun = args['dryRun'] === true;
-                const testPypi = args['testPypi'] === true;
-                const steps = [];
-                const errors = [];
-                try {
-                    // Step 1: Detect Python project type and check auth
-                    steps.push('## Step 1: Detecting project type and checking authentication');
-                    const hasPoetry = existsSync(join(workingDir, 'pyproject.toml'));
-                    const hasSetupPy = existsSync(join(workingDir, 'setup.py'));
-                    const hasSetupCfg = existsSync(join(workingDir, 'setup.cfg'));
-                    let projectType = 'unknown';
-                    let currentVersion = '';
-                    if (hasPoetry) {
-                        const pyprojectContent = readFileSync(join(workingDir, 'pyproject.toml'), 'utf-8');
-                        if (pyprojectContent.includes('[tool.poetry]')) {
-                            projectType = 'poetry';
-                            const versionMatch = pyprojectContent.match(/version\s*=\s*"([^"]+)"/);
-                            if (versionMatch)
-                                currentVersion = versionMatch[1] || '';
-                            steps.push(`✓ Detected Poetry project (v${currentVersion})`);
-                            // Check Poetry auth
-                            try {
-                                await execAsync('poetry config pypi-token.pypi', { cwd: workingDir, timeout: 10000 });
-                                steps.push('✓ Poetry PyPI token configured');
-                            }
-                            catch {
-                                steps.push('⚠ PyPI token may not be configured. Run: poetry config pypi-token.pypi <token>');
-                            }
-                        }
-                    }
-                    if (projectType === 'unknown' && (hasSetupPy || hasSetupCfg)) {
-                        projectType = 'setuptools';
-                        // Try to get version from setup.py or setup.cfg
-                        if (hasSetupPy) {
-                            const setupContent = readFileSync(join(workingDir, 'setup.py'), 'utf-8');
-                            const versionMatch = setupContent.match(/version\s*=\s*['"]([^'"]+)['"]/);
-                            if (versionMatch)
-                                currentVersion = versionMatch[1] || '';
-                        }
-                        steps.push(`✓ Detected setuptools project${currentVersion ? ` (v${currentVersion})` : ''}`);
-                        // Check twine auth
-                        try {
-                            await execAsync('twine --version', { cwd: workingDir, timeout: 10000 });
-                            steps.push('✓ Twine is available');
-                        }
-                        catch {
-                            errors.push('✗ Twine not found. Install with: pip install twine');
-                            return [...steps, '', '## Errors', ...errors].join('\n');
-                        }
-                    }
-                    if (projectType === 'unknown') {
-                        errors.push('✗ Could not detect Python project type. Need pyproject.toml (Poetry) or setup.py/setup.cfg (setuptools)');
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    // Step 2: Check for uncommitted changes
-                    steps.push('');
-                    steps.push('## Step 2: Checking git status');
-                    try {
-                        const { stdout: gitStatus } = await execAsync('git status --porcelain', { cwd: workingDir, timeout: 10000 });
-                        if (gitStatus.trim()) {
-                            if (commitMessage) {
-                                steps.push(`Found uncommitted changes, committing with message: "${commitMessage}"`);
-                                await execAsync('git add .', { cwd: workingDir, timeout: 30000 });
-                                await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd: workingDir, timeout: 30000 });
-                                steps.push('✓ Changes committed');
-                            }
-                            else {
-                                errors.push('✗ Uncommitted changes found. Provide a commitMessage or commit manually first.');
-                                gitStatus.trim().split('\n').forEach(line => errors.push(`  ${line}`));
-                                return [...steps, '', '## Errors', ...errors].join('\n');
-                            }
-                        }
-                        else {
-                            steps.push('✓ Working directory clean');
-                        }
-                    }
-                    catch (e) {
-                        steps.push(`Warning: Could not check git status: ${e.message}`);
-                    }
-                    // Step 3: Bump version
-                    steps.push('');
-                    steps.push('## Step 3: Bumping version');
-                    try {
-                        if (projectType === 'poetry') {
-                            const { stdout: versionOut } = await execAsync(`poetry version ${versionBump}`, {
-                                cwd: workingDir,
-                                timeout: 30000,
-                            });
-                            steps.push(`✓ ${versionOut.trim()}`);
-                        }
-                        else {
-                            // For setuptools, use bump2version if available, otherwise manual
-                            try {
-                                await execAsync(`bump2version ${versionBump}`, { cwd: workingDir, timeout: 30000 });
-                                steps.push(`✓ Version bumped with bump2version`);
-                            }
-                            catch {
-                                steps.push(`⚠ bump2version not available. Please manually update version in setup.py/setup.cfg`);
-                            }
-                        }
-                    }
-                    catch (e) {
-                        errors.push(`✗ Version bump failed: ${e.message}`);
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    // Step 4: Build
-                    steps.push('');
-                    steps.push('## Step 4: Building package');
-                    try {
-                        if (projectType === 'poetry') {
-                            await execAsync('poetry build', {
-                                cwd: workingDir,
-                                timeout: 120000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push('✓ Built with Poetry');
-                        }
-                        else {
-                            // Clean old builds
-                            await execAsync('rm -rf dist/ build/ *.egg-info', { cwd: workingDir, timeout: 10000, shell: '/bin/bash' });
-                            await execAsync('python -m build', {
-                                cwd: workingDir,
-                                timeout: 120000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push('✓ Built with python -m build');
-                        }
-                    }
-                    catch (e) {
-                        errors.push(`✗ Build failed: ${e.message}`);
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    // Step 5: Publish
-                    steps.push('');
-                    steps.push('## Step 5: Publishing to PyPI');
-                    const repository = testPypi ? 'testpypi' : 'pypi';
-                    if (dryRun) {
-                        steps.push(`⚠ DRY RUN - would publish to ${repository}`);
-                        steps.push('Files that would be uploaded:');
-                        try {
-                            const { stdout: distFiles } = await execAsync('ls -la dist/', { cwd: workingDir, timeout: 10000 });
-                            steps.push(distFiles);
-                        }
-                        catch {
-                            steps.push('  (could not list dist files)');
-                        }
-                    }
-                    else {
-                        try {
-                            if (projectType === 'poetry') {
-                                const publishCmd = testPypi
-                                    ? 'poetry publish -r testpypi'
-                                    : 'poetry publish';
-                                await execAsync(publishCmd, {
-                                    cwd: workingDir,
-                                    timeout: 120000,
-                                    maxBuffer: 1024 * 1024 * 10,
-                                });
-                            }
-                            else {
-                                const uploadUrl = testPypi
-                                    ? '--repository-url https://test.pypi.org/legacy/'
-                                    : '';
-                                await execAsync(`twine upload ${uploadUrl} dist/*`, {
-                                    cwd: workingDir,
-                                    timeout: 120000,
-                                    maxBuffer: 1024 * 1024 * 10,
-                                });
-                            }
-                            steps.push(`✓ Published to ${repository}`);
-                        }
-                        catch (e) {
-                            errors.push(`✗ Publish failed: ${e.message}`);
-                            return [...steps, '', '## Errors', ...errors].join('\n');
-                        }
-                    }
-                    // Step 6: Git commit version bump and push
-                    steps.push('');
-                    steps.push('## Step 6: Committing version bump and pushing');
-                    try {
-                        const { stdout: gitStatus } = await execAsync('git status --porcelain', { cwd: workingDir, timeout: 10000 });
-                        if (gitStatus.trim()) {
-                            await execAsync('git add .', { cwd: workingDir, timeout: 30000 });
-                            await execAsync('git commit -m "Bump version"', { cwd: workingDir, timeout: 30000 });
-                            steps.push('✓ Version bump committed');
-                        }
-                        await execAsync('git push && git push --tags', { cwd: workingDir, timeout: 60000 });
-                        steps.push('✓ Pushed to remote');
-                    }
-                    catch (e) {
-                        steps.push(`Warning: Could not push to git: ${e.message}`);
-                    }
-                    // Summary
-                    steps.push('');
-                    steps.push('## Summary');
-                    steps.push(`✓ Python package ${dryRun ? '(dry run)' : 'published'} to ${repository}`);
-                    return steps.join('\n');
-                }
-                catch (error) {
-                    errors.push(`Unexpected error: ${error.message}`);
-                    return [...steps, '', '## Errors', ...errors].join('\n');
-                }
-            },
-        },
-        {
-            name: 'pypi_check_auth',
-            description: 'Check PyPI authentication status for both Poetry and twine',
-            parameters: {
-                type: 'object',
-                properties: {},
-                additionalProperties: false,
-            },
-            handler: async () => {
-                const output = ['# PyPI Authentication Status', ''];
-                // Check Poetry
-                output.push('## Poetry');
-                try {
-                    const { stdout: poetryConfig } = await execAsync('poetry config --list 2>/dev/null | grep pypi', {
-                        cwd: workingDir,
-                        timeout: 10000,
-                        shell: '/bin/bash',
-                    });
-                    if (poetryConfig.includes('pypi-token')) {
-                        output.push('✓ PyPI token configured in Poetry');
-                    }
-                    else {
-                        output.push('✗ No PyPI token in Poetry');
-                        output.push('  Set with: poetry config pypi-token.pypi <your-token>');
-                    }
-                }
-                catch {
-                    output.push('Poetry not available or not configured');
-                }
-                // Check twine/pip
-                output.push('');
-                output.push('## Twine/pip');
-                try {
-                    await execAsync('twine --version', { cwd: workingDir, timeout: 10000 });
-                    output.push('✓ Twine is installed');
-                    // Check for .pypirc
-                    const homedir = process.env['HOME'] || '';
-                    if (existsSync(join(homedir, '.pypirc'))) {
-                        output.push('✓ .pypirc found in home directory');
-                    }
-                    else {
-                        output.push('⚠ No .pypirc found. Twine will prompt for credentials.');
-                    }
-                }
-                catch {
-                    output.push('✗ Twine not installed');
-                    output.push('  Install with: pip install twine');
-                }
-                // Check for TWINE_* env vars
-                output.push('');
-                output.push('## Environment Variables');
-                const twineUser = process.env['TWINE_USERNAME'];
-                const twinePass = process.env['TWINE_PASSWORD'];
-                if (twineUser) {
-                    output.push(`✓ TWINE_USERNAME set: ${twineUser}`);
-                }
-                if (twinePass) {
-                    output.push('✓ TWINE_PASSWORD is set');
-                }
-                if (!twineUser && !twinePass) {
-                    output.push('No TWINE_* environment variables set');
-                }
-                return output.join('\n');
-            },
-        },
-        // ========================================================================
-        // Cargo (Rust) Publishing Tools
-        // ========================================================================
-        {
-            name: 'cargo_publish',
-            description: 'Publish Rust crate to crates.io. Handles the full workflow: check auth, commit changes, bump version, build, and publish.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    versionBump: {
-                        type: 'string',
-                        enum: ['patch', 'minor', 'major'],
-                        description: 'Version bump type (default: patch)',
-                    },
-                    commitMessage: {
-                        type: 'string',
-                        description: 'Commit message for uncommitted changes (if any)',
-                    },
-                    dryRun: {
-                        type: 'boolean',
-                        description: 'If true, performs all steps except the actual publish',
-                    },
-                    allowDirty: {
-                        type: 'boolean',
-                        description: 'Allow publishing with uncommitted changes (default: false)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const versionBump = typeof args['versionBump'] === 'string' ? args['versionBump'] : 'patch';
-                const commitMessage = typeof args['commitMessage'] === 'string' ? args['commitMessage'] : undefined;
-                const dryRun = args['dryRun'] === true;
-                const allowDirty = args['allowDirty'] === true;
-                const steps = [];
-                const errors = [];
-                try {
-                    // Step 1: Check Cargo.toml exists and auth
-                    steps.push('## Step 1: Checking project and authentication');
-                    const cargoTomlPath = join(workingDir, 'Cargo.toml');
-                    if (!existsSync(cargoTomlPath)) {
-                        errors.push('✗ Cargo.toml not found. This is not a Rust project.');
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    const cargoContent = readFileSync(cargoTomlPath, 'utf-8');
-                    const nameMatch = cargoContent.match(/name\s*=\s*"([^"]+)"/);
-                    const versionMatch = cargoContent.match(/version\s*=\s*"([^"]+)"/);
-                    const crateName = nameMatch ? nameMatch[1] : 'unknown';
-                    const currentVersion = versionMatch ? versionMatch[1] : '0.0.0';
-                    steps.push(`✓ Found crate: ${crateName} v${currentVersion}`);
-                    // Check cargo login
-                    try {
-                        const { stdout: whoami } = await execAsync('cargo owner --list 2>/dev/null | head -1', {
-                            cwd: workingDir,
-                            timeout: 30000,
-                            shell: '/bin/bash',
-                        });
-                        if (whoami.trim()) {
-                            steps.push(`✓ Logged in to crates.io`);
-                        }
-                    }
-                    catch {
-                        steps.push('⚠ Could not verify crates.io login. Make sure you ran `cargo login`');
-                    }
-                    // Step 2: Check for uncommitted changes
-                    steps.push('');
-                    steps.push('## Step 2: Checking git status');
-                    try {
-                        const { stdout: gitStatus } = await execAsync('git status --porcelain', { cwd: workingDir, timeout: 10000 });
-                        if (gitStatus.trim()) {
-                            if (commitMessage) {
-                                steps.push(`Found uncommitted changes, committing with message: "${commitMessage}"`);
-                                await execAsync('git add .', { cwd: workingDir, timeout: 30000 });
-                                await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd: workingDir, timeout: 30000 });
-                                steps.push('✓ Changes committed');
-                            }
-                            else if (!allowDirty) {
-                                errors.push('✗ Uncommitted changes found. Provide a commitMessage, commit manually, or use allowDirty=true.');
-                                gitStatus.trim().split('\n').forEach(line => errors.push(`  ${line}`));
-                                return [...steps, '', '## Errors', ...errors].join('\n');
-                            }
-                            else {
-                                steps.push('⚠ Uncommitted changes present (allowDirty=true)');
-                            }
-                        }
-                        else {
-                            steps.push('✓ Working directory clean');
-                        }
-                    }
-                    catch (e) {
-                        steps.push(`Warning: Could not check git status: ${e.message}`);
-                    }
-                    // Step 3: Bump version
-                    steps.push('');
-                    steps.push('## Step 3: Bumping version');
-                    // Parse current version
-                    const versionParts = (currentVersion || '0.0.0').split('.').map(p => parseInt(p, 10) || 0);
-                    let [major = 0, minor = 0, patch = 0] = versionParts;
-                    switch (versionBump) {
-                        case 'major':
-                            major++;
-                            minor = 0;
-                            patch = 0;
-                            break;
-                        case 'minor':
-                            minor++;
-                            patch = 0;
-                            break;
-                        case 'patch':
-                        default:
-                            patch++;
-                            break;
-                    }
-                    const newVersion = `${major}.${minor}.${patch}`;
-                    // Update Cargo.toml
-                    const updatedCargo = cargoContent.replace(/version\s*=\s*"[^"]+"/, `version = "${newVersion}"`);
-                    const fs = await import('node:fs/promises');
-                    await fs.writeFile(cargoTomlPath, updatedCargo, 'utf-8');
-                    steps.push(`✓ Version bumped: ${currentVersion} → ${newVersion}`);
-                    // Update Cargo.lock
-                    try {
-                        await execAsync('cargo check', { cwd: workingDir, timeout: 120000 });
-                        steps.push('✓ Cargo.lock updated');
-                    }
-                    catch (e) {
-                        steps.push(`Warning: cargo check had issues: ${e.message}`);
-                    }
-                    // Step 4: Build and test
-                    steps.push('');
-                    steps.push('## Step 4: Building and testing');
-                    try {
-                        await execAsync('cargo build --release', {
-                            cwd: workingDir,
-                            timeout: 300000,
-                            maxBuffer: 1024 * 1024 * 10,
-                        });
-                        steps.push('✓ Release build successful');
-                        await execAsync('cargo test', {
-                            cwd: workingDir,
-                            timeout: 300000,
-                            maxBuffer: 1024 * 1024 * 10,
-                        });
-                        steps.push('✓ Tests passed');
-                    }
-                    catch (e) {
-                        errors.push(`✗ Build/test failed: ${e.message}`);
-                        return [...steps, '', '## Errors', ...errors].join('\n');
-                    }
-                    // Step 5: Publish
-                    steps.push('');
-                    steps.push('## Step 5: Publishing to crates.io');
-                    if (dryRun) {
-                        steps.push('⚠ DRY RUN - would publish to crates.io');
-                        try {
-                            const { stdout: dryRunOut } = await execAsync('cargo publish --dry-run', {
-                                cwd: workingDir,
-                                timeout: 120000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push('Dry run output:');
-                            steps.push(dryRunOut.substring(0, 2000));
-                        }
-                        catch (e) {
-                            steps.push(`Dry run notes: ${e.message}`);
-                        }
-                    }
-                    else {
-                        try {
-                            const publishFlags = allowDirty ? '--allow-dirty' : '';
-                            await execAsync(`cargo publish ${publishFlags}`, {
-                                cwd: workingDir,
-                                timeout: 180000,
-                                maxBuffer: 1024 * 1024 * 10,
-                            });
-                            steps.push(`✓ Published ${crateName}@${newVersion} to crates.io`);
-                        }
-                        catch (e) {
-                            errors.push(`✗ Publish failed: ${e.message}`);
-                            return [...steps, '', '## Errors', ...errors].join('\n');
-                        }
-                    }
-                    // Step 6: Git commit and push
-                    steps.push('');
-                    steps.push('## Step 6: Committing and pushing');
-                    try {
-                        await execAsync('git add Cargo.toml Cargo.lock', { cwd: workingDir, timeout: 10000 });
-                        await execAsync(`git commit -m "Release v${newVersion}"`, { cwd: workingDir, timeout: 30000 });
-                        await execAsync(`git tag -a "v${newVersion}" -m "Release v${newVersion}"`, { cwd: workingDir, timeout: 10000 });
-                        steps.push(`✓ Created tag v${newVersion}`);
-                        await execAsync('git push && git push --tags', { cwd: workingDir, timeout: 60000 });
-                        steps.push('✓ Pushed to remote');
-                    }
-                    catch (e) {
-                        steps.push(`Warning: Could not push to git: ${e.message}`);
-                    }
-                    // Summary
-                    steps.push('');
-                    steps.push('## Summary');
-                    steps.push(`✓ ${crateName}@${newVersion} ${dryRun ? '(dry run)' : 'published to crates.io'}`);
-                    return steps.join('\n');
-                }
-                catch (error) {
-                    errors.push(`Unexpected error: ${error.message}`);
-                    return [...steps, '', '## Errors', ...errors].join('\n');
-                }
-            },
-        },
-        {
-            name: 'cargo_check_auth',
-            description: 'Check crates.io authentication status',
-            parameters: {
-                type: 'object',
-                properties: {},
-                additionalProperties: false,
-            },
-            handler: async () => {
-                const output = ['# Crates.io Authentication Status', ''];
-                // Check if cargo is available
-                try {
-                    const { stdout: cargoVersion } = await execAsync('cargo --version', { cwd: workingDir, timeout: 10000 });
-                    output.push(`✓ ${cargoVersion.trim()}`);
-                }
-                catch {
-                    output.push('✗ Cargo not found. Install Rust from https://rustup.rs');
-                    return output.join('\n');
-                }
-                // Check credentials file
-                const homedir = process.env['HOME'] || '';
-                const credentialsPath = join(homedir, '.cargo', 'credentials.toml');
-                const legacyCredentialsPath = join(homedir, '.cargo', 'credentials');
-                output.push('');
-                output.push('## Credentials');
-                if (existsSync(credentialsPath) || existsSync(legacyCredentialsPath)) {
-                    output.push('✓ Credentials file found');
-                    output.push('  To update token, run: cargo login');
-                }
-                else {
-                    output.push('✗ No credentials file found');
-                    output.push('  Run: cargo login <your-api-token>');
-                    output.push('  Get token from: https://crates.io/settings/tokens');
-                }
-                // Check CARGO_REGISTRY_TOKEN env var
-                output.push('');
-                output.push('## Environment Variables');
-                if (process.env['CARGO_REGISTRY_TOKEN']) {
-                    output.push('✓ CARGO_REGISTRY_TOKEN is set');
-                }
-                else {
-                    output.push('CARGO_REGISTRY_TOKEN not set (optional)');
-                }
-                return output.join('\n');
-            },
-        },
-        // ========================================================================
-        // Git Workflow Tools
-        // ========================================================================
-        {
-            name: 'git_release',
-            description: 'Create a git release with tag, changelog generation, and optional GitHub release',
-            parameters: {
-                type: 'object',
-                properties: {
-                    version: {
-                        type: 'string',
-                        description: 'Version tag (e.g., v1.0.0). If not provided, will auto-generate based on commits.',
-                    },
-                    message: {
-                        type: 'string',
-                        description: 'Release message/description',
-                    },
-                    generateChangelog: {
-                        type: 'boolean',
-                        description: 'Auto-generate changelog from commits since last tag (default: true)',
-                    },
-                    pushTag: {
-                        type: 'boolean',
-                        description: 'Push the tag to remote (default: true)',
-                    },
-                    createGithubRelease: {
-                        type: 'boolean',
-                        description: 'Create a GitHub release using gh CLI (default: false)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const version = typeof args['version'] === 'string' ? args['version'] : undefined;
-                const message = typeof args['message'] === 'string' ? args['message'] : undefined;
-                const generateChangelog = args['generateChangelog'] !== false;
-                const pushTag = args['pushTag'] !== false;
-                const createGithubRelease = args['createGithubRelease'] === true;
-                const output = ['# Git Release', ''];
-                try {
-                    // Get last tag
-                    let lastTag = '';
-                    try {
-                        const { stdout } = await execAsync('git describe --tags --abbrev=0 2>/dev/null || echo ""', {
-                            cwd: workingDir,
-                            timeout: 10000,
-                            shell: '/bin/bash',
-                        });
-                        lastTag = stdout.trim();
-                    }
-                    catch {
-                        // No tags exist
-                    }
-                    // Determine version
-                    let tagVersion = version;
-                    if (!tagVersion) {
-                        if (lastTag) {
-                            // Increment patch version
-                            const match = lastTag.match(/v?(\d+)\.(\d+)\.(\d+)/);
-                            if (match) {
-                                const [, major, minor, patch] = match;
-                                tagVersion = `v${major}.${minor}.${parseInt(patch || '0', 10) + 1}`;
-                            }
-                            else {
-                                tagVersion = 'v0.0.1';
-                            }
-                        }
-                        else {
-                            tagVersion = 'v0.0.1';
-                        }
-                    }
-                    output.push(`Version: ${tagVersion}`);
-                    output.push(`Previous: ${lastTag || '(none)'}`);
-                    // Generate changelog
-                    let changelog = '';
-                    if (generateChangelog) {
-                        output.push('');
-                        output.push('## Changelog');
-                        try {
-                            const range = lastTag ? `${lastTag}..HEAD` : 'HEAD';
-                            const { stdout: commits } = await execAsync(`git log ${range} --pretty=format:"- %s (%h)" --no-merges 2>/dev/null | head -50`, { cwd: workingDir, timeout: 10000, shell: '/bin/bash' });
-                            changelog = commits.trim() || 'No commits since last release';
-                            output.push(changelog);
-                        }
-                        catch {
-                            changelog = 'Could not generate changelog';
-                            output.push(changelog);
-                        }
-                    }
-                    // Create tag
-                    output.push('');
-                    output.push('## Creating Tag');
-                    const tagMessage = message || `Release ${tagVersion}\n\n${changelog}`;
-                    try {
-                        await execAsync(`git tag -a "${tagVersion}" -m "${tagMessage.replace(/"/g, '\\"')}"`, {
-                            cwd: workingDir,
-                            timeout: 30000,
-                        });
-                        output.push(`✓ Created tag: ${tagVersion}`);
-                    }
-                    catch (e) {
-                        output.push(`✗ Failed to create tag: ${e.message}`);
-                        return output.join('\n');
-                    }
-                    // Push tag
-                    if (pushTag) {
-                        output.push('');
-                        output.push('## Pushing Tag');
-                        try {
-                            await execAsync(`git push origin "${tagVersion}"`, { cwd: workingDir, timeout: 60000 });
-                            output.push(`✓ Pushed tag to origin`);
-                        }
-                        catch (e) {
-                            output.push(`✗ Failed to push tag: ${e.message}`);
-                        }
-                    }
-                    // Create GitHub release
-                    if (createGithubRelease) {
-                        output.push('');
-                        output.push('## Creating GitHub Release');
-                        try {
-                            const releaseNotes = changelog || message || `Release ${tagVersion}`;
-                            await execAsync(`gh release create "${tagVersion}" --title "${tagVersion}" --notes "${releaseNotes.replace(/"/g, '\\"')}"`, { cwd: workingDir, timeout: 60000 });
-                            output.push(`✓ Created GitHub release`);
-                        }
-                        catch (e) {
-                            output.push(`✗ Failed to create GitHub release: ${e.message}`);
-                            output.push('Make sure gh CLI is installed and authenticated');
-                        }
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Error creating release: ${error.message}`;
-                }
-            },
-        },
-        {
-            name: 'git_sync',
-            description: 'Sync local branch with remote - fetch, pull, and optionally push',
-            parameters: {
-                type: 'object',
-                properties: {
-                    branch: {
-                        type: 'string',
-                        description: 'Branch to sync (default: current branch)',
-                    },
-                    push: {
-                        type: 'boolean',
-                        description: 'Push local commits after pulling (default: false)',
-                    },
-                    rebase: {
-                        type: 'boolean',
-                        description: 'Use rebase instead of merge when pulling (default: false)',
-                    },
-                    stashChanges: {
-                        type: 'boolean',
-                        description: 'Stash uncommitted changes before sync, restore after (default: true)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const branch = typeof args['branch'] === 'string' ? args['branch'] : undefined;
-                const push = args['push'] === true;
-                const rebase = args['rebase'] === true;
-                const stashChanges = args['stashChanges'] !== false;
-                const output = ['# Git Sync', ''];
-                let stashed = false;
-                try {
-                    // Get current branch if not specified
-                    let targetBranch = branch;
-                    if (!targetBranch) {
-                        const { stdout } = await execAsync('git branch --show-current', { cwd: workingDir, timeout: 10000 });
-                        targetBranch = stdout.trim();
-                    }
-                    output.push(`Branch: ${targetBranch}`);
-                    // Check for uncommitted changes
-                    const { stdout: status } = await execAsync('git status --porcelain', { cwd: workingDir, timeout: 10000 });
-                    const hasChanges = status.trim().length > 0;
-                    if (hasChanges && stashChanges) {
-                        output.push('');
-                        output.push('## Stashing Changes');
-                        await execAsync('git stash push -m "git_sync auto-stash"', { cwd: workingDir, timeout: 30000 });
-                        output.push('✓ Stashed uncommitted changes');
-                        stashed = true;
-                    }
-                    else if (hasChanges) {
-                        output.push('');
-                        output.push('⚠ Warning: Uncommitted changes present, sync may fail');
-                    }
-                    // Fetch
-                    output.push('');
-                    output.push('## Fetching');
-                    await execAsync('git fetch --all --prune', { cwd: workingDir, timeout: 60000 });
-                    output.push('✓ Fetched from all remotes');
-                    // Pull
-                    output.push('');
-                    output.push('## Pulling');
-                    const pullCmd = rebase ? `git pull --rebase origin ${targetBranch}` : `git pull origin ${targetBranch}`;
-                    try {
-                        const { stdout: pullOut } = await execAsync(pullCmd, { cwd: workingDir, timeout: 120000 });
-                        output.push(`✓ Pulled from origin/${targetBranch}`);
-                        if (pullOut.includes('Already up to date')) {
-                            output.push('Already up to date');
-                        }
-                    }
-                    catch (e) {
-                        output.push(`✗ Pull failed: ${e.message}`);
-                        if (stashed) {
-                            await execAsync('git stash pop', { cwd: workingDir, timeout: 30000 });
-                            output.push('✓ Restored stashed changes');
-                        }
-                        return output.join('\n');
-                    }
-                    // Push
-                    if (push) {
-                        output.push('');
-                        output.push('## Pushing');
-                        try {
-                            await execAsync(`git push origin ${targetBranch}`, { cwd: workingDir, timeout: 60000 });
-                            output.push(`✓ Pushed to origin/${targetBranch}`);
-                        }
-                        catch (e) {
-                            output.push(`✗ Push failed: ${e.message}`);
-                        }
-                    }
-                    // Restore stash
-                    if (stashed) {
-                        output.push('');
-                        output.push('## Restoring Changes');
-                        try {
-                            await execAsync('git stash pop', { cwd: workingDir, timeout: 30000 });
-                            output.push('✓ Restored stashed changes');
-                        }
-                        catch (e) {
-                            output.push(`⚠ Failed to restore stash: ${e.message}`);
-                            output.push('Run `git stash pop` manually');
-                        }
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    if (stashed) {
-                        try {
-                            await execAsync('git stash pop', { cwd: workingDir, timeout: 30000 });
-                        }
-                        catch {
-                            // Ignore
-                        }
-                    }
-                    return `Error syncing: ${error.message}`;
-                }
-            },
-        },
-        {
-            name: 'git_cleanup',
-            description: 'Clean up git repository - prune branches, garbage collect, remove untracked files',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pruneBranches: {
-                        type: 'boolean',
-                        description: 'Delete local branches that have been merged (default: true)',
-                    },
-                    pruneRemote: {
-                        type: 'boolean',
-                        description: 'Prune remote-tracking branches (default: true)',
-                    },
-                    gc: {
-                        type: 'boolean',
-                        description: 'Run garbage collection (default: true)',
-                    },
-                    cleanUntracked: {
-                        type: 'boolean',
-                        description: 'Remove untracked files (DANGEROUS - default: false)',
-                    },
-                    dryRun: {
-                        type: 'boolean',
-                        description: 'Show what would be done without making changes',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pruneBranches = args['pruneBranches'] !== false;
-                const pruneRemote = args['pruneRemote'] !== false;
-                const gc = args['gc'] !== false;
-                const cleanUntracked = args['cleanUntracked'] === true;
-                const dryRun = args['dryRun'] === true;
-                const output = ['# Git Cleanup', ''];
-                if (dryRun)
-                    output.push('**DRY RUN - no changes will be made**\n');
-                try {
-                    // Prune remote-tracking branches
-                    if (pruneRemote) {
-                        output.push('## Remote-tracking Branches');
-                        if (dryRun) {
-                            const { stdout } = await execAsync('git remote prune origin --dry-run', {
-                                cwd: workingDir,
-                                timeout: 30000,
-                            });
-                            output.push(stdout.trim() || 'No stale branches to prune');
-                        }
-                        else {
-                            const { stdout } = await execAsync('git remote prune origin', { cwd: workingDir, timeout: 30000 });
-                            output.push(stdout.trim() || '✓ No stale branches to prune');
-                        }
-                        output.push('');
-                    }
-                    // Find and delete merged branches
-                    if (pruneBranches) {
-                        output.push('## Merged Local Branches');
-                        const { stdout: currentBranch } = await execAsync('git branch --show-current', {
-                            cwd: workingDir,
-                            timeout: 10000,
-                        });
-                        const { stdout: mergedBranches } = await execAsync('git branch --merged | grep -v "\\*" | grep -v "main" | grep -v "master" | grep -v "develop"', { cwd: workingDir, timeout: 10000, shell: '/bin/bash' }).catch(() => ({ stdout: '' }));
-                        const branches = mergedBranches
-                            .split('\n')
-                            .map((b) => b.trim())
-                            .filter((b) => b && b !== currentBranch.trim());
-                        if (branches.length === 0) {
-                            output.push('No merged branches to delete');
-                        }
-                        else {
-                            for (const branch of branches) {
-                                if (dryRun) {
-                                    output.push(`Would delete: ${branch}`);
-                                }
-                                else {
-                                    try {
-                                        await execAsync(`git branch -d "${branch}"`, { cwd: workingDir, timeout: 10000 });
-                                        output.push(`✓ Deleted: ${branch}`);
-                                    }
-                                    catch {
-                                        output.push(`✗ Could not delete: ${branch}`);
-                                    }
-                                }
-                            }
-                        }
-                        output.push('');
-                    }
-                    // Clean untracked files
-                    if (cleanUntracked) {
-                        output.push('## Untracked Files');
-                        if (dryRun) {
-                            const { stdout } = await execAsync('git clean -n -d', { cwd: workingDir, timeout: 30000 });
-                            output.push(stdout.trim() || 'No untracked files to remove');
-                        }
-                        else {
-                            const { stdout } = await execAsync('git clean -f -d', { cwd: workingDir, timeout: 30000 });
-                            output.push(stdout.trim() || '✓ No untracked files to remove');
-                        }
-                        output.push('');
-                    }
-                    // Garbage collection
-                    if (gc && !dryRun) {
-                        output.push('## Garbage Collection');
-                        await execAsync('git gc --auto', { cwd: workingDir, timeout: 300000 });
-                        output.push('✓ Garbage collection complete');
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Error during cleanup: ${error.message}`;
-                }
-            },
-        },
-        // ========================================================================
-        // Docker Tools
-        // ========================================================================
-        {
-            name: 'docker_build',
-            description: 'Build a Docker image with optional tagging and pushing to registry',
-            parameters: {
-                type: 'object',
-                properties: {
-                    tag: {
-                        type: 'string',
-                        description: 'Image tag (e.g., myapp:latest)',
-                    },
-                    dockerfile: {
-                        type: 'string',
-                        description: 'Path to Dockerfile (default: Dockerfile)',
-                    },
-                    context: {
-                        type: 'string',
-                        description: 'Build context path (default: .)',
-                    },
-                    push: {
-                        type: 'boolean',
-                        description: 'Push to registry after building (default: false)',
-                    },
-                    noCache: {
-                        type: 'boolean',
-                        description: 'Build without cache (default: false)',
-                    },
-                    buildArgs: {
-                        type: 'object',
-                        description: 'Build arguments as key-value pairs',
-                    },
-                    platform: {
-                        type: 'string',
-                        description: 'Target platform (e.g., linux/amd64,linux/arm64)',
-                    },
-                },
-                required: ['tag'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const tag = args['tag'];
-                const dockerfile = typeof args['dockerfile'] === 'string' ? args['dockerfile'] : 'Dockerfile';
-                const context = typeof args['context'] === 'string' ? args['context'] : '.';
-                const push = args['push'] === true;
-                const noCache = args['noCache'] === true;
-                const buildArgs = args['buildArgs'];
-                const platform = typeof args['platform'] === 'string' ? args['platform'] : undefined;
-                const output = ['# Docker Build', ''];
-                try {
-                    // Build command
-                    let cmd = `docker build -t "${tag}" -f "${dockerfile}"`;
-                    if (noCache)
-                        cmd += ' --no-cache';
-                    if (platform)
-                        cmd += ` --platform ${platform}`;
-                    if (buildArgs) {
-                        for (const [key, value] of Object.entries(buildArgs)) {
-                            cmd += ` --build-arg ${key}="${value}"`;
-                        }
-                    }
-                    cmd += ` "${context}"`;
-                    output.push(`## Building Image`);
-                    output.push(`Command: ${cmd}`);
-                    output.push('');
-                    const { stderr } = await execAsync(cmd, {
-                        cwd: workingDir,
-                        timeout: 600000, // 10 minutes
-                        maxBuffer: 1024 * 1024 * 50,
-                    });
-                    output.push('✓ Build completed');
-                    if (stderr && !stderr.includes('deprecated')) {
-                        output.push(`Warnings: ${stderr.substring(0, 500)}`);
-                    }
-                    // Push if requested
-                    if (push) {
-                        output.push('');
-                        output.push('## Pushing Image');
-                        try {
-                            await execAsync(`docker push "${tag}"`, { cwd: workingDir, timeout: 300000 });
-                            output.push(`✓ Pushed ${tag}`);
-                        }
-                        catch (e) {
-                            output.push(`✗ Push failed: ${e.message}`);
-                        }
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Docker build failed: ${error.message}\n${error.stderr || ''}`;
-                }
-            },
-        },
-        {
-            name: 'docker_compose',
-            description: 'Run docker-compose commands (up, down, restart, logs, etc.)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    action: {
-                        type: 'string',
-                        enum: ['up', 'down', 'restart', 'logs', 'ps', 'build', 'pull', 'stop', 'start'],
-                        description: 'Docker compose action',
-                    },
-                    services: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Specific services to target (default: all)',
-                    },
-                    detach: {
-                        type: 'boolean',
-                        description: 'Run in detached mode (for up/restart)',
-                    },
-                    build: {
-                        type: 'boolean',
-                        description: 'Build images before starting (for up)',
-                    },
-                    follow: {
-                        type: 'boolean',
-                        description: 'Follow log output (for logs)',
-                    },
-                    tail: {
-                        type: 'number',
-                        description: 'Number of lines to show from end of logs',
-                    },
-                    composeFile: {
-                        type: 'string',
-                        description: 'Path to compose file (default: docker-compose.yml)',
-                    },
-                },
-                required: ['action'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const action = args['action'];
-                const services = Array.isArray(args['services']) ? args['services'] : [];
-                const detach = args['detach'] === true;
-                const build = args['build'] === true;
-                const follow = args['follow'] === true;
-                const tail = typeof args['tail'] === 'number' ? args['tail'] : undefined;
-                const composeFile = typeof args['composeFile'] === 'string' ? args['composeFile'] : undefined;
-                const output = ['# Docker Compose', ''];
-                try {
-                    // Build command
-                    let cmd = 'docker compose';
-                    if (composeFile)
-                        cmd += ` -f "${composeFile}"`;
-                    cmd += ` ${action}`;
-                    // Action-specific options
-                    if (action === 'up') {
-                        if (detach)
-                            cmd += ' -d';
-                        if (build)
-                            cmd += ' --build';
-                    }
-                    if (action === 'logs') {
-                        if (follow)
-                            cmd += ' -f';
-                        if (tail)
-                            cmd += ` --tail=${tail}`;
-                    }
-                    if (services.length > 0) {
-                        cmd += ` ${services.join(' ')}`;
-                    }
-                    output.push(`Command: ${cmd}`);
-                    output.push('');
-                    const timeout = action === 'logs' && follow ? 30000 : 300000;
-                    const { stdout, stderr } = await execAsync(cmd, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10,
-                    });
-                    if (stdout)
-                        output.push(stdout.substring(0, 5000));
-                    if (stderr && !stderr.includes('deprecated')) {
-                        output.push(`Stderr: ${stderr.substring(0, 1000)}`);
-                    }
-                    output.push('');
-                    output.push(`✓ ${action} completed`);
-                    return output.join('\n');
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return `${output.join('\n')}\n\n(Command timed out - may still be running)`;
-                    }
-                    return `Docker compose ${action} failed: ${error.message}\n${error.stderr || ''}`;
-                }
-            },
-        },
-        // ========================================================================
-        // Project Scaffolding Tools
-        // ========================================================================
-        {
-            name: 'project_init',
-            description: 'Initialize a new project with common configurations (git, eslint, prettier, typescript, etc.)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    type: {
-                        type: 'string',
-                        enum: ['node', 'typescript', 'react', 'nextjs', 'python', 'go'],
-                        description: 'Project type',
-                    },
-                    name: {
-                        type: 'string',
-                        description: 'Project name',
-                    },
-                    git: {
-                        type: 'boolean',
-                        description: 'Initialize git repository (default: true)',
-                    },
-                    eslint: {
-                        type: 'boolean',
-                        description: 'Add ESLint configuration (for JS/TS projects, default: true)',
-                    },
-                    prettier: {
-                        type: 'boolean',
-                        description: 'Add Prettier configuration (default: true)',
-                    },
-                    docker: {
-                        type: 'boolean',
-                        description: 'Add Dockerfile and docker-compose.yml (default: false)',
-                    },
-                    ci: {
-                        type: 'string',
-                        enum: ['github', 'gitlab', 'none'],
-                        description: 'Add CI configuration (default: none)',
-                    },
-                },
-                required: ['type'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const projectType = args['type'];
-                const projectName = typeof args['name'] === 'string' ? args['name'] : 'my-project';
-                const initGit = args['git'] !== false;
-                const addEslint = args['eslint'] !== false;
-                const addPrettier = args['prettier'] !== false;
-                const addDocker = args['docker'] === true;
-                const ci = typeof args['ci'] === 'string' ? args['ci'] : 'none';
-                const output = [`# Project Initialization: ${projectName}`, ''];
-                output.push(`Type: ${projectType}`);
-                output.push('');
-                try {
-                    // Initialize based on type
-                    output.push('## Creating Project');
-                    switch (projectType) {
-                        case 'node':
-                            await execAsync('npm init -y', { cwd: workingDir, timeout: 30000 });
-                            output.push('✓ Initialized npm project');
-                            break;
-                        case 'typescript':
-                            await execAsync('npm init -y && npm install typescript @types/node --save-dev', {
-                                cwd: workingDir,
-                                timeout: 120000,
-                            });
-                            await execAsync('npx tsc --init', { cwd: workingDir, timeout: 30000 });
-                            output.push('✓ Initialized TypeScript project');
-                            break;
-                        case 'react':
-                            await execAsync(`npx create-react-app ${projectName} --template typescript`, {
-                                cwd: workingDir,
-                                timeout: 300000,
-                            });
-                            output.push('✓ Created React app');
-                            break;
-                        case 'nextjs':
-                            await execAsync(`npx create-next-app@latest ${projectName} --typescript --eslint --tailwind --app`, {
-                                cwd: workingDir,
-                                timeout: 300000,
-                            });
-                            output.push('✓ Created Next.js app');
-                            break;
-                        case 'python':
-                            await execAsync('python3 -m venv .venv', { cwd: workingDir, timeout: 60000 });
-                            output.push('✓ Created Python virtual environment');
-                            break;
-                        case 'go':
-                            await execAsync(`go mod init ${projectName}`, { cwd: workingDir, timeout: 30000 });
-                            output.push('✓ Initialized Go module');
-                            break;
-                    }
-                    // Git
-                    if (initGit) {
-                        output.push('');
-                        output.push('## Git');
-                        try {
-                            await execAsync('git init', { cwd: workingDir, timeout: 10000 });
-                            output.push('✓ Initialized git repository');
-                        }
-                        catch {
-                            output.push('Git already initialized or failed');
-                        }
-                    }
-                    // ESLint (for JS/TS projects)
-                    if (addEslint && ['node', 'typescript', 'react', 'nextjs'].includes(projectType)) {
-                        output.push('');
-                        output.push('## ESLint');
-                        try {
-                            await execAsync('npm install eslint --save-dev', { cwd: workingDir, timeout: 120000 });
-                            output.push('✓ Installed ESLint');
-                        }
-                        catch (e) {
-                            output.push(`ESLint setup: ${e.message}`);
-                        }
-                    }
-                    // Prettier
-                    if (addPrettier) {
-                        output.push('');
-                        output.push('## Prettier');
-                        try {
-                            await execAsync('npm install prettier --save-dev', { cwd: workingDir, timeout: 120000 });
-                            output.push('✓ Installed Prettier');
-                        }
-                        catch (e) {
-                            output.push(`Prettier setup: ${e.message}`);
-                        }
-                    }
-                    // Docker
-                    if (addDocker) {
-                        output.push('');
-                        output.push('## Docker');
-                        output.push('Add Dockerfile and docker-compose.yml manually based on your needs');
-                    }
-                    // CI
-                    if (ci !== 'none') {
-                        output.push('');
-                        output.push(`## CI (${ci})`);
-                        if (ci === 'github') {
-                            output.push('Add .github/workflows/ci.yml for GitHub Actions');
-                        }
-                        else if (ci === 'gitlab') {
-                            output.push('Add .gitlab-ci.yml for GitLab CI');
-                        }
-                    }
-                    output.push('');
-                    output.push('## Summary');
-                    output.push(`✓ Project ${projectName} initialized as ${projectType}`);
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Project initialization failed: ${error.message}`;
-                }
-            },
-        },
-        // ========================================================================
-        // Environment & Secret Management
-        // ========================================================================
-        {
-            name: 'env_check',
-            description: 'Check environment configuration and required variables',
-            parameters: {
-                type: 'object',
-                properties: {
-                    envFile: {
-                        type: 'string',
-                        description: 'Path to .env file to check (default: .env)',
-                    },
-                    exampleFile: {
-                        type: 'string',
-                        description: 'Path to .env.example to compare against',
-                    },
-                    requiredVars: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'List of required environment variables to check',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const envFile = typeof args['envFile'] === 'string' ? args['envFile'] : '.env';
-                const exampleFile = typeof args['exampleFile'] === 'string' ? args['exampleFile'] : '.env.example';
-                const requiredVars = Array.isArray(args['requiredVars']) ? args['requiredVars'] : [];
-                const output = ['# Environment Check', ''];
-                try {
-                    const envPath = join(workingDir, envFile);
-                    const examplePath = join(workingDir, exampleFile);
-                    // Parse env file
-                    const parseEnvFile = (content) => {
-                        const vars = new Map();
-                        for (const line of content.split('\n')) {
-                            const trimmed = line.trim();
-                            if (trimmed && !trimmed.startsWith('#')) {
-                                const [key, ...valueParts] = trimmed.split('=');
-                                if (key) {
-                                    vars.set(key.trim(), valueParts.join('=').trim());
-                                }
-                            }
-                        }
-                        return vars;
-                    };
-                    // Check .env exists
-                    let envVars = new Map();
-                    if (existsSync(envPath)) {
-                        const content = readFileSync(envPath, 'utf-8');
-                        envVars = parseEnvFile(content);
-                        output.push(`✓ Found ${envFile} with ${envVars.size} variables`);
-                    }
-                    else {
-                        output.push(`✗ ${envFile} not found`);
-                    }
-                    // Compare with example
-                    if (existsSync(examplePath)) {
-                        output.push('');
-                        output.push(`## Comparing with ${exampleFile}`);
-                        const exampleContent = readFileSync(examplePath, 'utf-8');
-                        const exampleVars = parseEnvFile(exampleContent);
-                        const missing = [];
-                        const extra = [];
-                        for (const key of exampleVars.keys()) {
-                            if (!envVars.has(key)) {
-                                missing.push(key);
-                            }
-                        }
-                        for (const key of envVars.keys()) {
-                            if (!exampleVars.has(key)) {
-                                extra.push(key);
-                            }
-                        }
-                        if (missing.length > 0) {
-                            output.push(`✗ Missing variables: ${missing.join(', ')}`);
-                        }
-                        else {
-                            output.push('✓ All example variables are defined');
-                        }
-                        if (extra.length > 0) {
-                            output.push(`ℹ Extra variables: ${extra.join(', ')}`);
-                        }
-                    }
-                    // Check required vars
-                    if (requiredVars.length > 0) {
-                        output.push('');
-                        output.push('## Required Variables');
-                        const missingRequired = [];
-                        const emptyRequired = [];
-                        for (const varName of requiredVars) {
-                            const value = envVars.get(varName) ?? process.env[varName];
-                            if (value === undefined) {
-                                missingRequired.push(varName);
-                            }
-                            else if (value === '') {
-                                emptyRequired.push(varName);
-                            }
-                            else {
-                                output.push(`✓ ${varName}: set`);
-                            }
-                        }
-                        if (missingRequired.length > 0) {
-                            output.push(`✗ Missing: ${missingRequired.join(', ')}`);
-                        }
-                        if (emptyRequired.length > 0) {
-                            output.push(`⚠ Empty: ${emptyRequired.join(', ')}`);
-                        }
-                    }
-                    // Check for sensitive patterns in .env
-                    output.push('');
-                    output.push('## Security Check');
-                    const sensitivePatterns = ['password', 'secret', 'key', 'token', 'credential'];
-                    const exposedSecrets = [];
-                    for (const [key, value] of envVars.entries()) {
-                        const lowerKey = key.toLowerCase();
-                        if (sensitivePatterns.some((p) => lowerKey.includes(p)) && value && value !== '***') {
-                            exposedSecrets.push(key);
-                        }
-                    }
-                    if (exposedSecrets.length > 0) {
-                        output.push(`⚠ Sensitive variables found: ${exposedSecrets.length}`);
-                        output.push('Make sure .env is in .gitignore');
-                    }
-                    else {
-                        output.push('✓ No obvious sensitive data patterns found');
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Environment check failed: ${error.message}`;
-                }
-            },
-        },
-        // ========================================================================
-        // Process & Service Management
-        // ========================================================================
-        {
-            name: 'service_status',
-            description: 'Check status of common development services (databases, caches, etc.)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    services: {
-                        type: 'array',
-                        items: {
-                            type: 'string',
-                            enum: ['postgres', 'mysql', 'redis', 'mongodb', 'elasticsearch', 'docker', 'nginx', 'node'],
-                        },
-                        description: 'Services to check (default: auto-detect)',
-                    },
-                    ports: {
-                        type: 'array',
-                        items: { type: 'number' },
-                        description: 'Additional ports to check',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const services = Array.isArray(args['services']) ? args['services'] : [];
-                const ports = Array.isArray(args['ports']) ? args['ports'] : [];
-                const output = ['# Service Status', ''];
-                const serviceConfig = {
-                    postgres: { port: 5432, process: 'postgres' },
-                    mysql: { port: 3306, process: 'mysql' },
-                    redis: { port: 6379, process: 'redis' },
-                    mongodb: { port: 27017, process: 'mongod' },
-                    elasticsearch: { port: 9200, process: 'java' },
-                    docker: { port: 2375, process: 'docker' },
-                    nginx: { port: 80, process: 'nginx' },
-                    node: { port: 3000, process: 'node' },
-                };
-                const checkPort = async (port) => {
-                    try {
-                        const { stdout } = await execAsync(`lsof -i :${port} -sTCP:LISTEN 2>/dev/null | head -1`, {
-                            cwd: workingDir,
-                            timeout: 5000,
-                            shell: '/bin/bash',
-                        });
-                        return stdout.trim().length > 0;
-                    }
-                    catch {
-                        return false;
-                    }
-                };
-                const checkProcess = async (name) => {
-                    try {
-                        const { stdout } = await execAsync(`pgrep -x "${name}" 2>/dev/null`, {
-                            cwd: workingDir,
-                            timeout: 5000,
-                            shell: '/bin/bash',
-                        });
-                        return stdout.trim().length > 0;
-                    }
-                    catch {
-                        return false;
-                    }
-                };
-                // Check specified services
-                const servicesToCheck = services.length > 0 ? services : Object.keys(serviceConfig);
-                output.push('## Services');
-                for (const service of servicesToCheck) {
-                    const config = serviceConfig[service];
-                    if (!config)
-                        continue;
-                    const portOpen = await checkPort(config.port);
-                    const processRunning = config.process ? await checkProcess(config.process) : false;
-                    const status = portOpen ? '✓' : processRunning ? '⚠' : '✗';
-                    const detail = portOpen ? `listening on :${config.port}` : processRunning ? 'process running' : 'not detected';
-                    output.push(`${status} ${service}: ${detail}`);
-                }
-                // Check additional ports
-                if (ports.length > 0) {
-                    output.push('');
-                    output.push('## Custom Ports');
-                    for (const port of ports) {
-                        const open = await checkPort(port);
-                        output.push(`${open ? '✓' : '✗'} Port ${port}: ${open ? 'in use' : 'available'}`);
-                    }
-                }
-                // Docker status
-                output.push('');
-                output.push('## Docker');
-                try {
-                    const { stdout: dockerPs } = await execAsync('docker ps --format "{{.Names}}: {{.Status}}" 2>/dev/null', {
-                        cwd: workingDir,
-                        timeout: 10000,
-                        shell: '/bin/bash',
-                    });
-                    if (dockerPs.trim()) {
-                        output.push('Running containers:');
-                        dockerPs.split('\n').forEach((line) => {
-                            if (line.trim())
-                                output.push(`  ${line.trim()}`);
-                        });
-                    }
-                    else {
-                        output.push('No running containers');
-                    }
-                }
-                catch {
-                    output.push('Docker not available');
-                }
-                return output.join('\n');
-            },
-        },
-        {
-            name: 'kill_port',
-            description: 'Kill process running on a specific port',
-            parameters: {
-                type: 'object',
-                properties: {
-                    port: {
-                        type: 'number',
-                        description: 'Port number to free up',
-                    },
-                    force: {
-                        type: 'boolean',
-                        description: 'Force kill with SIGKILL instead of SIGTERM (default: false)',
-                    },
-                },
-                required: ['port'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const port = args['port'];
-                const force = args['force'] === true;
-                const output = [`# Kill Process on Port ${port}`, ''];
-                try {
-                    // Find process on port
-                    const { stdout: lsofOut } = await execAsync(`lsof -i :${port} -sTCP:LISTEN 2>/dev/null`, {
-                        cwd: workingDir,
-                        timeout: 10000,
-                        shell: '/bin/bash',
-                    });
-                    if (!lsofOut.trim()) {
-                        return `No process found listening on port ${port}`;
-                    }
-                    output.push('## Process Info');
-                    output.push(lsofOut.trim());
-                    output.push('');
-                    // Extract PID
-                    const lines = lsofOut.split('\n').filter((l) => l.trim());
-                    if (lines.length < 2) {
-                        return `Could not find process on port ${port}`;
-                    }
-                    const pidMatch = lines[1]?.match(/\S+\s+(\d+)/);
-                    if (!pidMatch) {
-                        return `Could not extract PID from lsof output`;
-                    }
-                    const pid = pidMatch[1];
-                    const signal = force ? 'KILL' : 'TERM';
-                    output.push(`## Killing Process`);
-                    output.push(`PID: ${pid}`);
-                    output.push(`Signal: ${signal}`);
-                    await execAsync(`kill -${signal} ${pid}`, { cwd: workingDir, timeout: 10000 });
-                    output.push(`✓ Sent ${signal} signal to process ${pid}`);
-                    // Wait and verify
-                    await new Promise((r) => setTimeout(r, 1000));
-                    try {
-                        const { stdout: checkOut } = await execAsync(`lsof -i :${port} -sTCP:LISTEN 2>/dev/null`, {
-                            cwd: workingDir,
-                            timeout: 5000,
-                            shell: '/bin/bash',
-                        });
-                        if (checkOut.trim()) {
-                            output.push(`⚠ Process may still be running. Try with force=true`);
-                        }
-                        else {
-                            output.push(`✓ Port ${port} is now free`);
-                        }
-                    }
-                    catch {
-                        output.push(`✓ Port ${port} is now free`);
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Failed to kill process on port ${port}: ${error.message}`;
-                }
-            },
-        },
-        // ========================================================================
-        // Dependency Management
-        // ========================================================================
-        {
-            name: 'deps_audit',
-            description: 'Audit dependencies for security vulnerabilities and outdated packages',
-            parameters: {
-                type: 'object',
-                properties: {
-                    fix: {
-                        type: 'boolean',
-                        description: 'Attempt to fix vulnerabilities automatically (default: false)',
-                    },
-                    checkOutdated: {
-                        type: 'boolean',
-                        description: 'Check for outdated packages (default: true)',
-                    },
-                    level: {
-                        type: 'string',
-                        enum: ['info', 'low', 'moderate', 'high', 'critical'],
-                        description: 'Minimum vulnerability level to report (default: moderate)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const fix = args['fix'] === true;
-                const checkOutdated = args['checkOutdated'] !== false;
-                const level = typeof args['level'] === 'string' ? args['level'] : 'moderate';
-                const output = ['# Dependency Audit', ''];
-                try {
-                    // npm audit
-                    output.push('## Security Audit');
-                    try {
-                        const auditCmd = fix ? 'npm audit fix' : `npm audit --audit-level=${level}`;
-                        const { stdout: auditOut, stderr: auditErr } = await execAsync(auditCmd, {
-                            cwd: workingDir,
-                            timeout: 120000,
-                            maxBuffer: 1024 * 1024 * 10,
-                        });
-                        output.push(auditOut.substring(0, 3000) || '✓ No vulnerabilities found');
-                        if (auditErr && !auditErr.includes('npm WARN')) {
-                            output.push(`Warnings: ${auditErr.substring(0, 500)}`);
-                        }
-                    }
-                    catch (e) {
-                        // npm audit returns non-zero if vulnerabilities found
-                        if (e.stdout) {
-                            output.push(e.stdout.substring(0, 3000));
-                        }
-                        else {
-                            output.push(`Audit check: ${e.message}`);
-                        }
-                    }
-                    // Check outdated
-                    if (checkOutdated) {
-                        output.push('');
-                        output.push('## Outdated Packages');
-                        try {
-                            const { stdout: outdatedOut } = await execAsync('npm outdated --json 2>/dev/null', {
-                                cwd: workingDir,
-                                timeout: 60000,
-                                shell: '/bin/bash',
-                            });
-                            if (outdatedOut.trim() && outdatedOut !== '{}') {
-                                const outdated = JSON.parse(outdatedOut);
-                                const entries = Object.entries(outdated);
-                                if (entries.length > 0) {
-                                    output.push(`Found ${entries.length} outdated package(s):`);
-                                    for (const [pkg, info] of entries.slice(0, 20)) {
-                                        output.push(`  ${pkg}: ${info.current} → ${info.wanted} (latest: ${info.latest})`);
-                                    }
-                                    if (entries.length > 20) {
-                                        output.push(`  ... and ${entries.length - 20} more`);
-                                    }
-                                }
-                                else {
-                                    output.push('✓ All packages are up to date');
-                                }
-                            }
-                            else {
-                                output.push('✓ All packages are up to date');
-                            }
-                        }
-                        catch {
-                            output.push('Could not check outdated packages');
-                        }
-                    }
-                    // License check
-                    output.push('');
-                    output.push('## License Info');
-                    try {
-                        const { stdout: licenseOut } = await execAsync('npx license-checker --summary 2>/dev/null', {
-                            cwd: workingDir,
-                            timeout: 60000,
-                            shell: '/bin/bash',
-                        });
-                        if (licenseOut.trim()) {
-                            output.push(licenseOut.substring(0, 1000));
-                        }
-                    }
-                    catch {
-                        output.push('License checker not available (install with: npm i -g license-checker)');
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Dependency audit failed: ${error.message}`;
-                }
-            },
-        },
-        {
-            name: 'deps_update',
-            description: 'Update dependencies to latest versions',
-            parameters: {
-                type: 'object',
-                properties: {
-                    mode: {
-                        type: 'string',
-                        enum: ['patch', 'minor', 'major', 'latest'],
-                        description: 'Update mode - patch (safest), minor, major, or latest (default: minor)',
-                    },
-                    packages: {
-                        type: 'array',
-                        items: { type: 'string' },
-                        description: 'Specific packages to update (default: all)',
-                    },
-                    dryRun: {
-                        type: 'boolean',
-                        description: 'Show what would be updated without making changes',
-                    },
-                    runTests: {
-                        type: 'boolean',
-                        description: 'Run tests after update to verify (default: true)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const mode = typeof args['mode'] === 'string' ? args['mode'] : 'minor';
-                const packages = Array.isArray(args['packages']) ? args['packages'] : [];
-                const dryRun = args['dryRun'] === true;
-                const runTests = args['runTests'] !== false;
-                const output = ['# Dependency Update', ''];
-                output.push(`Mode: ${mode}`);
-                if (dryRun)
-                    output.push('**DRY RUN**');
-                output.push('');
-                try {
-                    if (dryRun) {
-                        // Just check what would be updated
-                        output.push('## Would Update');
-                        const { stdout } = await execAsync('npm outdated --json 2>/dev/null || true', {
-                            cwd: workingDir,
-                            timeout: 60000,
-                            shell: '/bin/bash',
-                        });
-                        if (stdout.trim() && stdout !== '{}') {
-                            const outdated = JSON.parse(stdout);
-                            for (const [pkg, info] of Object.entries(outdated)) {
-                                if (packages.length === 0 || packages.includes(pkg)) {
-                                    const target = mode === 'latest' ? info.latest : mode === 'major' ? info.latest : info.wanted;
-                                    output.push(`  ${pkg}: ${info.current} → ${target}`);
-                                }
-                            }
-                        }
-                        else {
-                            output.push('All packages are up to date');
-                        }
-                        return output.join('\n');
-                    }
-                    // Perform update
-                    output.push('## Updating');
-                    let updateCmd = 'npm update';
-                    if (packages.length > 0) {
-                        updateCmd = `npm update ${packages.join(' ')}`;
-                    }
-                    if (mode === 'latest' || mode === 'major') {
-                        // For major updates, use npm-check-updates
-                        output.push('Major/latest updates require npm-check-updates');
-                        try {
-                            const ncuCmd = packages.length > 0
-                                ? `npx npm-check-updates -u ${packages.join(' ')}`
-                                : 'npx npm-check-updates -u';
-                            await execAsync(ncuCmd, { cwd: workingDir, timeout: 120000 });
-                            await execAsync('npm install', { cwd: workingDir, timeout: 300000 });
-                            output.push('✓ Updated package.json and installed');
-                        }
-                        catch (e) {
-                            output.push(`Update failed: ${e.message}`);
-                            return output.join('\n');
-                        }
-                    }
-                    else {
-                        const { stdout: updateOut } = await execAsync(updateCmd, {
-                            cwd: workingDir,
-                            timeout: 300000,
-                        });
-                        output.push(updateOut.substring(0, 2000) || '✓ Updated');
-                    }
-                    // Run tests
-                    if (runTests) {
-                        output.push('');
-                        output.push('## Verifying');
-                        try {
-                            await execAsync('npm test', { cwd: workingDir, timeout: 300000 });
-                            output.push('✓ Tests passed');
-                        }
-                        catch (e) {
-                            output.push(`⚠ Tests failed: ${e.message}`);
-                            output.push('Consider reverting: git checkout package.json package-lock.json && npm install');
-                        }
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Dependency update failed: ${error.message}`;
-                }
-            },
-        },
-    ];
-}
-//# sourceMappingURL=devTools.js.map