erosolar-cli 1.6.21 → 1.6.22

package/dist/tools/devTools.js

@@ -471,6 +471,1265 @@ export function createDevTools(workingDir) {
                 }
             },
         },
+        // ========================================================================
+        // 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