dev-mcp-server 0.0.2 → 1.0.0

package/src/tools/GitTool.js

@@ -0,0 +1,212 @@
+/**
+ * Full git workflow integration: status, diff, commit, branch, log, review.
+ */
+
+const BashTool = require('./BashTool');
+const llm = require('../utils/llmClient');
+const logger = require('../utils/logger');
+const costTracker = require('../utils/costTracker');
+
+class GitTool {
+    /**
+     * Check if a directory is inside a git repository
+     */
+    async isGitRepo(cwd = process.cwd()) {
+        const result = await BashTool.execute('git rev-parse --is-inside-work-tree', { cwd, approved: true });
+        return result.exitCode === 0;
+    }
+
+    /**
+     * Get full git status
+     */
+    async status(cwd = process.cwd()) {
+        const isRepo = await this.isGitRepo(cwd);
+        if (!isRepo) return { branch: '(not a git repo)', ahead: 0, behind: 0, staged: [], unstaged: [], untracked: [], recentCommits: [], error: 'Not a git repository' };
+
+        const [statusResult, branchResult] = await Promise.all([
+            BashTool.execute('git status --porcelain=v2 --branch', { cwd, approved: true }),
+            BashTool.execute('git log --oneline -5', { cwd, approved: true }),
+        ]);
+
+        return this._parseStatus(statusResult.stdout || '', branchResult.stdout || '');
+    }
+
+    _parseStatus(statusOutput, logOutput) {
+        const lines = statusOutput.split('\n').filter(Boolean);
+        const result = { branch: '', ahead: 0, behind: 0, staged: [], unstaged: [], untracked: [], recentCommits: [] };
+
+        for (const line of lines) {
+            if (line.startsWith('# branch.oid')) continue;
+            if (line.startsWith('# branch.head')) result.branch = line.split(' ')[2];
+            if (line.startsWith('# branch.ab')) {
+                const m = line.match(/\+(\d+)\s+-(\d+)/);
+                if (m) { result.ahead = parseInt(m[1]); result.behind = parseInt(m[2]); }
+            }
+            if (line.startsWith('1 ') || line.startsWith('2 ')) {
+                const xy = line.slice(2, 4);
+                const file = line.split('\t').pop();
+                if (xy[0] !== '.' && xy[0] !== '?') result.staged.push({ status: xy[0], file });
+                if (xy[1] !== '.' && xy[1] !== '?') result.unstaged.push({ status: xy[1], file });
+            }
+            if (line.startsWith('? ')) result.untracked.push(line.slice(2));
+        }
+
+        result.recentCommits = logOutput.split('\n').filter(Boolean).slice(0, 5);
+        return result;
+    }
+
+    /**
+     * Get diff (staged, unstaged, or specific file)
+     */
+    async diff(options = {}) {
+        const { cwd = process.cwd(), staged = false, file, stat = false } = options;
+        const isRepo = await this.isGitRepo(cwd);
+        if (!isRepo) return { diff: '', hasChanges: false, staged, error: 'Not a git repository' };
+
+        const flags = [
+            staged ? '--staged' : '',
+            stat ? '--stat' : '',
+            '--no-color',
+            file ? `-- ${JSON.stringify(file)}` : '',
+        ].filter(Boolean).join(' ');
+
+        const result = await BashTool.execute(`git diff ${flags}`, { cwd, approved: true });
+        return {
+            diff: result.stdout || '',
+            hasChanges: (result.stdout || '').trim().length > 0,
+            staged,
+        };
+    }
+
+    /**
+     * Stage files and create a commit with AI-generated message
+     */
+    async commit(options = {}) {
+        const { cwd = process.cwd(), files = ['.'], message, autoMessage = false } = options;
+        const isRepo = await this.isGitRepo(cwd);
+        if (!isRepo) return { success: false, message: 'Not a git repository' };
+
+        // Stage files
+        const stageCmd = `git add ${files.map(f => JSON.stringify(f)).join(' ')}`;
+        const stageResult = await BashTool.execute(stageCmd, { cwd, approved: true });
+        if (stageResult.exitCode !== 0) return { success: false, message: stageResult.stderr || 'git add failed' };
+
+        // Get staged diff for context
+        const diffResult = await this.diff({ cwd, staged: true });
+        if (!diffResult.hasChanges) return { success: false, message: 'Nothing staged to commit' };
+
+        let commitMessage = message;
+        if (!commitMessage || autoMessage) {
+            commitMessage = await this._generateCommitMessage(diffResult.diff);
+        }
+
+        const result = await BashTool.execute(`git commit -m ${JSON.stringify(commitMessage)}`, { cwd, approved: true });
+        if (result.exitCode !== 0) return { success: false, message: result.stderr || 'commit failed' };
+
+        return {
+            success: true,
+            message: commitMessage,
+            output: result.stdout,
+            autoGenerated: !message || autoMessage,
+        };
+    }
+
+    async _generateCommitMessage(diff) {
+        if (!diff || diff.trim().length === 0) return 'chore: update files';
+        const truncatedDiff = diff.slice(0, 4000);
+        try {
+            const response = await llm.chat({
+                model: llm.model('fast'),
+                max_tokens: 150,
+                messages: [{
+                    role: 'user',
+                    content: `Generate a concise git commit message in conventional commits format (type: description) for this diff. Reply ONLY with the commit message, no explanation.\n\nDiff:\n${truncatedDiff}`,
+                }],
+            });
+            costTracker.record({
+                model: llm.model('fast'),
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+                queryType: 'git-commit',
+            });
+            return response.content[0].text.trim().replace(/^["']|["']$/g, '');
+        } catch {
+            return 'chore: update files';
+        }
+    }
+
+    /**
+     * AI-powered code review of staged changes or a file
+     */
+    async review(options = {}) {
+        const { cwd = process.cwd(), staged = false, file, focus = '' } = options;
+        const diffResult = await this.diff({ cwd, staged, file });
+        if (!diffResult.hasChanges) return { review: 'No changes to review.', hasIssues: false };
+
+        const diff = diffResult.diff.slice(0, 6000);
+        const focusInstruction = focus
+            ? `Focus especially on: ${focus}`
+            : 'Focus on: bugs, security issues, performance problems, code style, and maintainability.';
+
+        try {
+            const response = await llm.chat({
+                model: llm.model('smart'),
+                max_tokens: 1500,
+                system: `You are a senior software engineer conducting a code review. Be direct and specific.
+Format your review as:
+## Summary
+(1-2 sentences)
+
+## Issues Found
+(list any bugs, security problems, or critical issues — be specific with line references)
+
+## Suggestions
+(improvements, not blockers)
+
+## Verdict
+LGTM | Needs Changes | Blocking Issues`,
+                messages: [{ role: 'user', content: `Review this diff:\n${focusInstruction}\n\n\`\`\`diff\n${diff}\n\`\`\`` }],
+            });
+            costTracker.record({ model: llm.model('smart'), inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens, queryType: 'git-review' });
+            const reviewText = response.content[0].text;
+            return { review: reviewText, hasIssues: /blocking issues|needs changes/i.test(reviewText), diff: diffResult.diff };
+        } catch (e) {
+            return { review: `Review failed: ${e.message}`, hasIssues: false };
+        }
+    }
+
+    /**
+     * Get commit log
+     */
+    async log(options = {}) {
+        const { cwd = process.cwd(), limit = 10, file, oneline = false } = options;
+        const isRepo = await this.isGitRepo(cwd);
+        if (!isRepo) return oneline ? [] : [];
+
+        const format = oneline ? '--oneline' : '--pretty=format:"%H|%an|%ae|%ad|%s" --date=short';
+        const fileFlag = file ? `-- ${JSON.stringify(file)}` : '';
+        const result = await BashTool.execute(`git log -${limit} ${format} ${fileFlag}`, { cwd, approved: true });
+        if (result.exitCode !== 0) return [];
+        if (oneline) return result.stdout.split('\n').filter(Boolean);
+        return result.stdout.split('\n').filter(Boolean).map(line => {
+            const [hash, author, email, date, ...subjectParts] = line.replace(/^"|"$/g, '').split('|');
+            return { hash: hash?.slice(0, 8), author, email, date, subject: subjectParts.join('|') };
+        });
+    }
+
+    /**
+     * List branches
+     */
+    async branches(cwd = process.cwd()) {
+        const isRepo = await this.isGitRepo(cwd);
+        if (!isRepo) return [];
+        const result = await BashTool.execute('git branch -a --sort=-committerdate', { cwd, approved: true });
+        if (result.exitCode !== 0) return [];
+        return result.stdout.split('\n').filter(Boolean).map(b => ({
+            name: b.replace(/^\*?\s+/, '').trim(),
+            current: b.startsWith('*'),
+        }));
+    }
+}
+
+module.exports = new GitTool();

package/src/tools/GrepTool.js

@@ -0,0 +1,199 @@
+/**
+ * GrepTool — ripgrep-based content search with fallback.
+ * Searches for patterns across the codebase quickly without needing to ingest first.
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+const path = require('path');
+const logger = require('../utils/logger');
+
+// Check if ripgrep is available
+let RG_AVAILABLE = null;
+async function checkRg() {
+    if (RG_AVAILABLE !== null) return RG_AVAILABLE;
+    try {
+        await execAsync('rg --version');
+        RG_AVAILABLE = true;
+    } catch {
+        RG_AVAILABLE = false;
+    }
+    return RG_AVAILABLE;
+}
+
+class GrepTool {
+    /**
+     * Search for a pattern in files
+     * @param {string} pattern  - regex or literal string
+     * @param {object} opts
+     *   cwd          - directory to search in
+     *   glob         - file glob filter (e.g. '*.js')
+     *   ignoreCase   - case-insensitive
+     *   maxResults   - limit results
+     *   contextLines - lines of context around each match
+     *   literal      - treat pattern as literal string (no regex)
+     */
+    async search(pattern, opts = {}) {
+        const {
+            cwd = process.cwd(),
+            glob,
+            ignoreCase = false,
+            maxResults = 50,
+            contextLines = 2,
+            literal = false,
+        } = opts;
+
+        const useRg = await checkRg();
+
+        if (useRg) {
+            return this._rgSearch(pattern, { cwd, glob, ignoreCase, maxResults, contextLines, literal });
+        } else {
+            return this._nativeSearch(pattern, { cwd, glob, ignoreCase, maxResults });
+        }
+    }
+
+    async _rgSearch(pattern, opts) {
+        const { cwd, glob, ignoreCase, maxResults, contextLines, literal } = opts;
+
+        const flags = [
+            '--json',
+            `--max-count=${maxResults}`,
+            `--context=${contextLines}`,
+            ignoreCase ? '--ignore-case' : '',
+            literal ? '--fixed-strings' : '',
+            glob ? `--glob '${glob}'` : '',
+            '--hidden',
+            '--no-follow',
+            // Standard ignores
+            '--glob !node_modules',
+            '--glob !.git',
+            '--glob !dist',
+            '--glob !build',
+            '--glob !*.min.js',
+        ].filter(Boolean).join(' ');
+
+        const cmd = `rg ${flags} ${JSON.stringify(pattern)}`;
+
+        try {
+            const { stdout } = await execAsync(cmd, { cwd, maxBuffer: 5 * 1024 * 1024 });
+            return this._parseRgJson(stdout, maxResults);
+        } catch (err) {
+            if (err.code === 1) return { matches: [], total: 0, tool: 'ripgrep', note: 'No matches found' };
+            throw new Error(`ripgrep error: ${err.message}`);
+        }
+    }
+
+    _parseRgJson(output, maxResults) {
+        const lines = output.trim().split('\n').filter(Boolean);
+        const matches = [];
+        let total = 0;
+
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.type === 'match') {
+                    total++;
+                    if (matches.length < maxResults) {
+                        matches.push({
+                            file: obj.data.path.text,
+                            lineNumber: obj.data.line_number,
+                            line: obj.data.lines.text.trimEnd(),
+                            submatches: obj.data.submatches?.map(s => s.match?.text) || [],
+                        });
+                    }
+                }
+            } catch { }
+        }
+
+        return { matches, total, tool: 'ripgrep' };
+    }
+
+    async _nativeSearch(pattern, opts) {
+        const { cwd, ignoreCase, maxResults } = opts;
+        const { glob: globModule } = require('glob');
+        const fs = require('fs');
+
+        const files = await globModule('**/*', {
+            cwd,
+            absolute: true,
+            nodir: true,
+            ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**'],
+        });
+
+        const regex = new RegExp(pattern, ignoreCase ? 'gi' : 'g');
+        const matches = [];
+
+        for (const file of files) {
+            if (matches.length >= maxResults) break;
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const lines = content.split('\n');
+                lines.forEach((line, idx) => {
+                    if (matches.length < maxResults && regex.test(line)) {
+                        matches.push({
+                            file: path.relative(cwd, file),
+                            lineNumber: idx + 1,
+                            line: line.trimEnd(),
+                            submatches: [],
+                        });
+                    }
+                    regex.lastIndex = 0;
+                });
+            } catch { }
+        }
+
+        return { matches, total: matches.length, tool: 'native-grep' };
+    }
+
+    /**
+     * Quick search: find all definitions of a symbol (function, class, const)
+     */
+    async findDefinitions(symbol, cwd = process.cwd()) {
+        const patterns = [
+            `function ${symbol}`,
+            `class ${symbol}`,
+            `const ${symbol}\\s*=`,
+            `let ${symbol}\\s*=`,
+            `var ${symbol}\\s*=`,
+            `${symbol}\\s*\\(`,           // method definition
+            `exports\\.${symbol}`,
+            `module\\.exports.*${symbol}`,
+        ];
+
+        const allMatches = [];
+        for (const p of patterns) {
+            try {
+                const result = await this.search(p, { cwd, maxResults: 10 });
+                allMatches.push(...result.matches);
+            } catch { }
+        }
+
+        // Deduplicate by file+line
+        const seen = new Set();
+        return allMatches.filter(m => {
+            const key = `${m.file}:${m.lineNumber}`;
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+        });
+    }
+
+    /**
+     * Find all imports/requires of a module
+     */
+    async findImports(moduleName, cwd = process.cwd()) {
+        const pattern = `(import|require).*['"]${moduleName}['"]`;
+        return this.search(pattern, { cwd, maxResults: 30 });
+    }
+
+    /**
+     * Find all TODO/FIXME/HACK/BUG comments
+     */
+    async findTodos(cwd = process.cwd()) {
+        const pattern = '(TODO|FIXME|HACK|BUG|XXX|NOTE)\\s*[:\\-]?';
+        return this.search(pattern, { cwd, maxResults: 100, ignoreCase: true });
+    }
+}
+
+module.exports = new GrepTool();