getmy-ruflo 3.5.43

package/v3/@claude-flow/cli/dist/src/mcp-tools/dev-tools.js

@@ -0,0 +1,713 @@
+/**
+ * Developer Power Tools — real execution tools for remote development
+ *
+ * These tools give a remote Claude instance full development capabilities
+ * on the host machine: build, test, git, code search, and file operations.
+ *
+ * All tools use real system calls — no mocks, no stubs.
+ */
+import { execFile, exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile, readdir, writeFile } from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+import { join, resolve, relative, extname } from 'path';
+const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
+// Security: block dangerous paths
+function validatePath(p) {
+    const resolved = resolve(p);
+    if (resolved.includes('..') && !existsSync(resolved)) {
+        throw new Error('Path traversal detected');
+    }
+    return resolved;
+}
+// Truncate output to prevent overwhelming responses
+function truncate(s, max = 50000) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max) + `\n... [truncated ${s.length - max} chars]`;
+}
+export const devTools = [
+    // =========================================================================
+    // BUILD & TEST
+    // =========================================================================
+    {
+        name: 'dev_build',
+        description: 'Run a build command (npm/yarn/pnpm) in a project directory. Returns stdout, stderr, exit code.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cwd: { type: 'string', description: 'Working directory (default: server cwd)' },
+                script: { type: 'string', description: 'Build script name (default: "build")' },
+                packageManager: { type: 'string', enum: ['npm', 'yarn', 'pnpm'], description: 'Package manager (default: auto-detect)' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const script = input.script || 'build';
+            let pm = input.packageManager;
+            if (!pm) {
+                if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+                    pm = 'pnpm';
+                else if (existsSync(join(cwd, 'yarn.lock')))
+                    pm = 'yarn';
+                else
+                    pm = 'npm';
+            }
+            try {
+                const { stdout, stderr } = await execAsync(`${pm} run ${script}`, {
+                    cwd,
+                    timeout: 300000,
+                    maxBuffer: 10 * 1024 * 1024,
+                    env: { ...process.env, FORCE_COLOR: '0' },
+                });
+                return { success: true, stdout: truncate(stdout), stderr: truncate(stderr), cwd, script, packageManager: pm };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    exitCode: err.code || 1,
+                    stdout: truncate(err.stdout || ''),
+                    stderr: truncate(err.stderr || ''),
+                    cwd,
+                    script,
+                };
+            }
+        },
+    },
+    {
+        name: 'dev_test',
+        description: 'Run tests with structured output. Captures pass/fail counts, coverage if available.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cwd: { type: 'string', description: 'Working directory' },
+                script: { type: 'string', description: 'Test script (default: "test")' },
+                pattern: { type: 'string', description: 'Test file pattern or name filter' },
+                coverage: { type: 'boolean', description: 'Run with coverage (default: false)' },
+                timeout: { type: 'number', description: 'Timeout in ms (default: 300000)' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const script = input.script || 'test';
+            const pattern = input.pattern;
+            const coverage = input.coverage;
+            const timeout = Math.min(input.timeout || 300000, 600000);
+            let pm = 'npm';
+            if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+                pm = 'pnpm';
+            else if (existsSync(join(cwd, 'yarn.lock')))
+                pm = 'yarn';
+            let cmd = `${pm} run ${script}`;
+            if (pattern)
+                cmd += ` -- ${pattern}`;
+            if (coverage)
+                cmd += ' -- --coverage';
+            try {
+                const { stdout, stderr } = await execAsync(cmd, {
+                    cwd,
+                    timeout,
+                    maxBuffer: 10 * 1024 * 1024,
+                    env: { ...process.env, FORCE_COLOR: '0', CI: '1' },
+                });
+                // Parse vitest/jest output for summary
+                const passMatch = stdout.match(/(\d+)\s+passed/);
+                const failMatch = stdout.match(/(\d+)\s+failed/);
+                const skipMatch = stdout.match(/(\d+)\s+skipped/);
+                return {
+                    success: true,
+                    passed: passMatch ? parseInt(passMatch[1]) : null,
+                    failed: failMatch ? parseInt(failMatch[1]) : 0,
+                    skipped: skipMatch ? parseInt(skipMatch[1]) : 0,
+                    stdout: truncate(stdout),
+                    stderr: truncate(stderr),
+                };
+            }
+            catch (err) {
+                const stdout = err.stdout || '';
+                const passMatch = stdout.match(/(\d+)\s+passed/);
+                const failMatch = stdout.match(/(\d+)\s+failed/);
+                return {
+                    success: false,
+                    passed: passMatch ? parseInt(passMatch[1]) : null,
+                    failed: failMatch ? parseInt(failMatch[1]) : null,
+                    stdout: truncate(stdout),
+                    stderr: truncate(err.stderr || ''),
+                };
+            }
+        },
+    },
+    {
+        name: 'dev_install',
+        description: 'Install project dependencies.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cwd: { type: 'string', description: 'Working directory' },
+                packages: { type: 'string', description: 'Specific packages to install (space-separated)' },
+                dev: { type: 'boolean', description: 'Install as dev dependency' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const packages = input.packages;
+            const dev = input.dev;
+            let pm = 'npm';
+            if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+                pm = 'pnpm';
+            else if (existsSync(join(cwd, 'yarn.lock')))
+                pm = 'yarn';
+            let cmd = `${pm} install`;
+            if (packages)
+                cmd += ` ${packages}`;
+            if (dev)
+                cmd += pm === 'npm' ? ' --save-dev' : ' -D';
+            cmd += ' --legacy-peer-deps';
+            try {
+                const { stdout, stderr } = await execAsync(cmd, { cwd, timeout: 300000, maxBuffer: 5 * 1024 * 1024 });
+                return { success: true, stdout: truncate(stdout), stderr: truncate(stderr) };
+            }
+            catch (err) {
+                return { success: false, stdout: truncate(err.stdout || ''), stderr: truncate(err.stderr || '') };
+            }
+        },
+    },
+    // =========================================================================
+    // GIT OPERATIONS
+    // =========================================================================
+    {
+        name: 'dev_git',
+        description: 'Execute git commands safely. Supports: status, log, diff, blame, branch, stash, show, checkout (files only), add, commit, push, pull, fetch.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Git subcommand (e.g., "status", "log --oneline -20", "diff HEAD~1", "blame src/foo.ts")' },
+                cwd: { type: 'string', description: 'Repository directory' },
+            },
+            required: ['command'],
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const command = input.command.trim();
+            // Block destructive git operations
+            const blocked = ['push --force', 'reset --hard', 'clean -f', 'branch -D', 'rebase -i'];
+            for (const b of blocked) {
+                if (command.includes(b)) {
+                    return { success: false, error: `Blocked: "git ${b}" is destructive. Use explicit terminal_execute if you really need this.` };
+                }
+            }
+            try {
+                const { stdout, stderr } = await execAsync(`git ${command}`, {
+                    cwd,
+                    timeout: 60000,
+                    maxBuffer: 10 * 1024 * 1024,
+                    env: { ...process.env, GIT_PAGER: 'cat' },
+                });
+                return { success: true, output: truncate(stdout), stderr: truncate(stderr) };
+            }
+            catch (err) {
+                return { success: false, output: truncate(err.stdout || ''), stderr: truncate(err.stderr || ''), exitCode: err.code };
+            }
+        },
+    },
+    {
+        name: 'dev_git_log_analyze',
+        description: 'Analyze git history for a file or directory. Returns structured commit data.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File or directory to analyze' },
+                cwd: { type: 'string', description: 'Repository directory' },
+                limit: { type: 'number', description: 'Max commits (default: 20)' },
+                since: { type: 'string', description: 'Since date (e.g., "2 weeks ago")' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const path = input.path || '.';
+            const limit = Math.min(input.limit || 20, 100);
+            const since = input.since;
+            let cmd = `git log --format="%H|%an|%ae|%aI|%s" -n ${limit}`;
+            if (since)
+                cmd += ` --since="${since}"`;
+            cmd += ` -- "${path}"`;
+            try {
+                const { stdout } = await execAsync(cmd, { cwd, timeout: 30000 });
+                const commits = stdout.trim().split('\n').filter(Boolean).map(line => {
+                    const [hash, author, email, date, ...msgParts] = line.split('|');
+                    return { hash: hash?.slice(0, 12), author, email, date, message: msgParts.join('|') };
+                });
+                // Also get file change stats
+                const { stdout: statOut } = await execAsync(`git log --format="" --numstat -n ${limit} -- "${path}"`, { cwd, timeout: 30000 });
+                const totalChanges = statOut.trim().split('\n').filter(Boolean).length;
+                return { success: true, commits, totalChanges, path, limit };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+    },
+    // =========================================================================
+    // CODE SEARCH & ANALYSIS
+    // =========================================================================
+    {
+        name: 'dev_search_code',
+        description: 'Search code across files using ripgrep (rg) or grep. Returns matching lines with file paths and line numbers.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Search pattern (regex supported)' },
+                cwd: { type: 'string', description: 'Directory to search' },
+                glob: { type: 'string', description: 'File glob filter (e.g., "*.ts", "src/**/*.py")' },
+                caseSensitive: { type: 'boolean', description: 'Case sensitive (default: false)' },
+                maxResults: { type: 'number', description: 'Max results (default: 50)' },
+                context: { type: 'number', description: 'Lines of context around match (default: 0)' },
+            },
+            required: ['pattern'],
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const pattern = input.pattern;
+            const glob = input.glob;
+            const caseSensitive = input.caseSensitive;
+            const maxResults = Math.min(input.maxResults || 50, 200);
+            const context = Math.min(input.context || 0, 10);
+            // Try rg first, fall back to grep
+            const useRg = await execAsync('rg --version', { timeout: 5000 }).then(() => true).catch(() => false);
+            let cmd;
+            if (useRg) {
+                cmd = `rg --json -m ${maxResults}`;
+                if (!caseSensitive)
+                    cmd += ' -i';
+                if (glob)
+                    cmd += ` -g "${glob}"`;
+                if (context > 0)
+                    cmd += ` -C ${context}`;
+                cmd += ` "${pattern.replace(/"/g, '\\"')}"`;
+            }
+            else {
+                cmd = `grep -rn`;
+                if (!caseSensitive)
+                    cmd += ' -i';
+                if (glob)
+                    cmd += ` --include="${glob}"`;
+                cmd += ` "${pattern.replace(/"/g, '\\"')}" .`;
+                cmd += ` | head -${maxResults}`;
+            }
+            try {
+                const { stdout } = await execAsync(cmd, { cwd, timeout: 30000, maxBuffer: 5 * 1024 * 1024 });
+                if (useRg) {
+                    // Parse rg JSON output
+                    const matches = [];
+                    for (const line of stdout.trim().split('\n').filter(Boolean)) {
+                        try {
+                            const obj = JSON.parse(line);
+                            if (obj.type === 'match') {
+                                matches.push({
+                                    file: obj.data?.path?.text,
+                                    line: obj.data?.line_number,
+                                    text: obj.data?.lines?.text?.trim(),
+                                });
+                            }
+                        }
+                        catch { /* skip non-JSON lines */ }
+                    }
+                    return { success: true, matches, count: matches.length, tool: 'ripgrep' };
+                }
+                else {
+                    // Parse grep output
+                    const matches = stdout.trim().split('\n').filter(Boolean).map(line => {
+                        const m = line.match(/^(.+?):(\d+):(.*)$/);
+                        return m ? { file: m[1], line: parseInt(m[2]), text: m[3].trim() } : { file: '', line: 0, text: line };
+                    });
+                    return { success: true, matches, count: matches.length, tool: 'grep' };
+                }
+            }
+            catch (err) {
+                if (err.code === 1)
+                    return { success: true, matches: [], count: 0, note: 'No matches found' };
+                return { success: false, error: err.message };
+            }
+        },
+    },
+    {
+        name: 'dev_find_files',
+        description: 'Find files by name, extension, or glob pattern. Returns paths with sizes and modification times.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'File name pattern (e.g., "*.test.ts", "package.json", "README*")' },
+                cwd: { type: 'string', description: 'Directory to search' },
+                maxDepth: { type: 'number', description: 'Max directory depth (default: 10)' },
+                maxResults: { type: 'number', description: 'Max results (default: 100)' },
+                type: { type: 'string', enum: ['file', 'directory', 'any'], description: 'Filter by type (default: file)' },
+            },
+            required: ['pattern'],
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const pattern = input.pattern;
+            const maxDepth = Math.min(input.maxDepth || 10, 20);
+            const maxResults = Math.min(input.maxResults || 100, 500);
+            const fileType = input.type || 'file';
+            // Use fd if available, fall back to find
+            const useFd = await execAsync('fd --version', { timeout: 5000 }).then(() => true).catch(() => false);
+            let cmd;
+            if (useFd) {
+                cmd = `fd "${pattern}" --max-depth ${maxDepth} --max-results ${maxResults}`;
+                if (fileType === 'file')
+                    cmd += ' --type f';
+                else if (fileType === 'directory')
+                    cmd += ' --type d';
+            }
+            else {
+                const typeFlag = fileType === 'file' ? '-type f' : fileType === 'directory' ? '-type d' : '';
+                cmd = `find . -maxdepth ${maxDepth} -name "${pattern}" ${typeFlag} | head -${maxResults}`;
+            }
+            try {
+                const { stdout } = await execAsync(cmd, { cwd, timeout: 30000 });
+                const paths = stdout.trim().split('\n').filter(Boolean);
+                // Get stat info for each file (up to 50)
+                const files = [];
+                for (const p of paths.slice(0, 50)) {
+                    try {
+                        const fullPath = join(cwd, p);
+                        const s = statSync(fullPath);
+                        files.push({
+                            path: p.replace(/\\/g, '/'),
+                            size: s.size,
+                            modified: s.mtime.toISOString(),
+                            isDirectory: s.isDirectory(),
+                        });
+                    }
+                    catch {
+                        files.push({ path: p.replace(/\\/g, '/'), size: 0, modified: '', isDirectory: false });
+                    }
+                }
+                return { success: true, files, count: paths.length, totalFound: paths.length };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+    },
+    // =========================================================================
+    // FILE OPERATIONS
+    // =========================================================================
+    {
+        name: 'dev_read_file',
+        description: 'Read a file\'s contents. Supports line range selection.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path (absolute or relative to cwd)' },
+                cwd: { type: 'string', description: 'Working directory for relative paths' },
+                startLine: { type: 'number', description: 'Start line (1-indexed, default: 1)' },
+                endLine: { type: 'number', description: 'End line (default: all)' },
+            },
+            required: ['path'],
+        },
+        handler: async (input) => {
+            const cwd = input.cwd || process.cwd();
+            const filePath = validatePath(resolve(cwd, input.path));
+            const startLine = Math.max(input.startLine || 1, 1);
+            const endLine = input.endLine;
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const lines = content.split('\n');
+                const end = endLine ? Math.min(endLine, lines.length) : lines.length;
+                const selected = lines.slice(startLine - 1, end);
+                return {
+                    success: true,
+                    path: filePath,
+                    content: truncate(selected.join('\n')),
+                    totalLines: lines.length,
+                    startLine,
+                    endLine: end,
+                    size: content.length,
+                };
+            }
+            catch (err) {
+                return { success: false, error: err.message, path: filePath };
+            }
+        },
+    },
+    {
+        name: 'dev_read_batch',
+        description: 'Read multiple files at once. Efficient for understanding a codebase.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                paths: { type: 'array', items: { type: 'string' }, description: 'Array of file paths to read' },
+                cwd: { type: 'string', description: 'Working directory for relative paths' },
+                maxPerFile: { type: 'number', description: 'Max lines per file (default: 200)' },
+            },
+            required: ['paths'],
+        },
+        handler: async (input) => {
+            const cwd = input.cwd || process.cwd();
+            const paths = input.paths;
+            const maxPerFile = Math.min(input.maxPerFile || 200, 500);
+            const results = [];
+            for (const p of paths.slice(0, 20)) {
+                try {
+                    const filePath = validatePath(resolve(cwd, p));
+                    const content = await readFile(filePath, 'utf-8');
+                    const lines = content.split('\n');
+                    results.push({
+                        path: p,
+                        content: lines.slice(0, maxPerFile).join('\n'),
+                        totalLines: lines.length,
+                        truncated: lines.length > maxPerFile,
+                    });
+                }
+                catch (err) {
+                    results.push({ path: p, error: err.message });
+                }
+            }
+            return { success: true, files: results, count: results.length };
+        },
+    },
+    {
+        name: 'dev_write_file',
+        description: 'Write content to a file. Creates parent directories if needed.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path' },
+                content: { type: 'string', description: 'File content to write' },
+                cwd: { type: 'string', description: 'Working directory for relative paths' },
+            },
+            required: ['path', 'content'],
+        },
+        handler: async (input) => {
+            const cwd = input.cwd || process.cwd();
+            const filePath = validatePath(resolve(cwd, input.path));
+            const content = input.content;
+            // Security: block writing to sensitive paths
+            const blocked = ['.env', 'credentials', '.ssh', 'id_rsa', 'id_ed25519'];
+            for (const b of blocked) {
+                if (filePath.toLowerCase().includes(b)) {
+                    return { success: false, error: `Blocked: writing to paths containing "${b}" is not allowed` };
+                }
+            }
+            try {
+                const { mkdir } = await import('fs/promises');
+                const dir = join(filePath, '..');
+                if (!existsSync(dir))
+                    await mkdir(dir, { recursive: true });
+                await writeFile(filePath, content, 'utf-8');
+                return { success: true, path: filePath, size: content.length };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+    },
+    {
+        name: 'dev_edit_file',
+        description: 'Apply a search-and-replace edit to a file. Finds old_string and replaces with new_string.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path' },
+                old_string: { type: 'string', description: 'Exact string to find and replace' },
+                new_string: { type: 'string', description: 'Replacement string' },
+                cwd: { type: 'string', description: 'Working directory' },
+                replaceAll: { type: 'boolean', description: 'Replace all occurrences (default: false — first only)' },
+            },
+            required: ['path', 'old_string', 'new_string'],
+        },
+        handler: async (input) => {
+            const cwd = input.cwd || process.cwd();
+            const filePath = validatePath(resolve(cwd, input.path));
+            const oldStr = input.old_string;
+            const newStr = input.new_string;
+            const replaceAll = input.replaceAll;
+            try {
+                const content = await readFile(filePath, 'utf-8');
+                const count = content.split(oldStr).length - 1;
+                if (count === 0) {
+                    return { success: false, error: 'old_string not found in file', path: filePath };
+                }
+                if (count > 1 && !replaceAll) {
+                    return { success: false, error: `old_string found ${count} times — set replaceAll: true or provide more context`, path: filePath };
+                }
+                const updated = replaceAll ? content.split(oldStr).join(newStr) : content.replace(oldStr, newStr);
+                await writeFile(filePath, updated, 'utf-8');
+                return { success: true, path: filePath, replacements: replaceAll ? count : 1 };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+    },
+    // =========================================================================
+    // DIRECTORY LISTING
+    // =========================================================================
+    {
+        name: 'dev_ls',
+        description: 'List directory contents with file sizes and types.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path (default: cwd)' },
+                cwd: { type: 'string', description: 'Working directory' },
+                recursive: { type: 'boolean', description: 'List recursively (default: false)' },
+                maxDepth: { type: 'number', description: 'Max depth for recursive listing (default: 2)' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = input.cwd || process.cwd();
+            const dirPath = validatePath(resolve(cwd, input.path || '.'));
+            const recursive = input.recursive;
+            const maxDepth = Math.min(input.maxDepth || 2, 5);
+            async function listDir(dir, depth) {
+                const entries = await readdir(dir, { withFileTypes: true });
+                const results = [];
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.') && entry.name !== '.github')
+                        continue;
+                    if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === '.git')
+                        continue;
+                    const fullPath = join(dir, entry.name);
+                    const relPath = relative(dirPath, fullPath).replace(/\\/g, '/');
+                    if (entry.isDirectory()) {
+                        results.push({ name: relPath + '/', type: 'directory' });
+                        if (recursive && depth < maxDepth) {
+                            results.push(...await listDir(fullPath, depth + 1));
+                        }
+                    }
+                    else {
+                        try {
+                            const s = statSync(fullPath);
+                            results.push({ name: relPath, type: 'file', size: s.size, ext: extname(entry.name) });
+                        }
+                        catch {
+                            results.push({ name: relPath, type: 'file', size: 0 });
+                        }
+                    }
+                }
+                return results;
+            }
+            try {
+                const entries = await listDir(dirPath, 0);
+                return { success: true, path: dirPath, entries, count: entries.length };
+            }
+            catch (err) {
+                return { success: false, error: err.message };
+            }
+        },
+    },
+    // =========================================================================
+    // LINT & FORMAT
+    // =========================================================================
+    {
+        name: 'dev_lint',
+        description: 'Run linter (ESLint, Ruff, etc.) and return structured results.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cwd: { type: 'string', description: 'Working directory' },
+                path: { type: 'string', description: 'File or directory to lint (default: ".")' },
+                fix: { type: 'boolean', description: 'Auto-fix (default: false)' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const path = input.path || '.';
+            const fix = input.fix;
+            // Detect linter
+            const hasEslint = existsSync(join(cwd, '.eslintrc.js')) || existsSync(join(cwd, '.eslintrc.json')) ||
+                existsSync(join(cwd, 'eslint.config.js')) || existsSync(join(cwd, 'eslint.config.mjs'));
+            const hasRuff = existsSync(join(cwd, 'ruff.toml')) || existsSync(join(cwd, 'pyproject.toml'));
+            let cmd;
+            if (hasEslint) {
+                cmd = `npx eslint ${path} --format json`;
+                if (fix)
+                    cmd += ' --fix';
+            }
+            else if (hasRuff) {
+                cmd = `ruff check ${path} --output-format json`;
+                if (fix)
+                    cmd += ' --fix';
+            }
+            else {
+                return { success: false, error: 'No supported linter config found (eslint or ruff)' };
+            }
+            try {
+                const { stdout, stderr } = await execAsync(cmd, { cwd, timeout: 60000, maxBuffer: 5 * 1024 * 1024 });
+                return { success: true, output: truncate(stdout), stderr: truncate(stderr), linter: hasEslint ? 'eslint' : 'ruff' };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    output: truncate(err.stdout || ''),
+                    stderr: truncate(err.stderr || ''),
+                    linter: hasEslint ? 'eslint' : 'ruff',
+                };
+            }
+        },
+    },
+    // =========================================================================
+    // PROJECT INFO
+    // =========================================================================
+    {
+        name: 'dev_project_info',
+        description: 'Get project structure overview: package.json info, directory tree, language breakdown.',
+        category: 'dev',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cwd: { type: 'string', description: 'Project directory' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = validatePath(input.cwd || process.cwd());
+            const info = { cwd };
+            // Read package.json
+            try {
+                const pkg = JSON.parse(await readFile(join(cwd, 'package.json'), 'utf-8'));
+                info.name = pkg.name;
+                info.version = pkg.version;
+                info.scripts = Object.keys(pkg.scripts || {});
+                info.dependencies = Object.keys(pkg.dependencies || {}).length;
+                info.devDependencies = Object.keys(pkg.devDependencies || {}).length;
+            }
+            catch { /* no package.json */ }
+            // Git info
+            try {
+                const { stdout: branch } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd });
+                const { stdout: remote } = await execAsync('git remote get-url origin', { cwd });
+                const { stdout: commitCount } = await execAsync('git rev-list --count HEAD', { cwd });
+                info.git = { branch: branch.trim(), remote: remote.trim(), commits: parseInt(commitCount.trim()) };
+            }
+            catch { /* not a git repo */ }
+            // File type breakdown (quick count)
+            try {
+                const { stdout } = await execAsync('find . -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/dist/*" -type f | sed "s/.*\\.//" | sort | uniq -c | sort -rn | head -15', { cwd, timeout: 10000 });
+                info.fileTypes = stdout.trim().split('\n').filter(Boolean).map(line => {
+                    const m = line.trim().match(/^(\d+)\s+(.+)$/);
+                    return m ? { count: parseInt(m[1]), ext: m[2] } : null;
+                }).filter(Boolean);
+            }
+            catch { /* skip on Windows if find not available */ }
+            return { success: true, ...info };
+        },
+    },
+];
+//# sourceMappingURL=dev-tools.js.map