erosolar-cli 1.7.195 → 1.7.197

package/dist/tools/devTools.js

@@ -0,0 +1,2305 @@
+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