@hailer/mcp 0.1.15 → 0.1.16

package/dist/modules/bug-reports/giuseppe-lsp.d.ts

@@ -1,6 +1,25 @@
 /**
- * Giuseppe LSP Module - Code analysis via TypeScript compiler
+ * Giuseppe LSP Module - Full LSP client for code intelligence
+ * Spawns typescript-language-server and communicates via JSON-RPC
  */
+export interface LspSymbol {
+    name: string;
+    kind: string;
+    line: number;
+    character: number;
+}
+export interface LspReference {
+    file: string;
+    line: number;
+    character: number;
+}
+export interface LspDiagnostic {
+    file: string;
+    line: number;
+    character: number;
+    message: string;
+    severity: 'error' | 'warning' | 'info';
+}
 export interface CodeIssue {
     file: string;
     line: number;
@@ -12,31 +31,83 @@ export interface CodeIssue {
 export interface AnalysisResult {
     success: boolean;
     issues: CodeIssue[];
+    unusedProps: {
+        name: string;
+        line: number;
+        file?: string;
+    }[];
     summary: string;
 }
 export declare class GiuseppeLsp {
+    private server;
+    private requestId;
+    private pendingRequests;
+    private buffer;
+    private initialized;
+    private rootPath;
     /**
-     * Analyze a project for TypeScript errors
+     * Start the LSP server for a project
      */
-    analyzeProject(projectPath: string): Promise<AnalysisResult>;
+    start(projectPath: string): Promise<boolean>;
+    /**
+     * Stop the LSP server
+     */
+    stop(): Promise<void>;
+    /**
+     * Initialize LSP connection
+     */
+    private initialize;
+    /**
+     * Open a document for analysis
+     */
+    openDocument(filePath: string): Promise<void>;
     /**
-     * Analyze a single file
+     * Get all symbols in a document
+     */
+    getDocumentSymbols(filePath: string): Promise<LspSymbol[]>;
+    /**
+     * Find all references to a symbol at a position
+     */
+    findReferences(filePath: string, line: number, character: number): Promise<LspReference[]>;
+    /**
+     * Get hover info for a symbol
+     */
+    hover(filePath: string, line: number, character: number): Promise<string | null>;
+    /**
+     * Find unused props in a React component
+     * Checks if props declared in interface are actually destructured in function params
+     */
+    findUnusedProps(filePath: string): Promise<{
+        name: string;
+        line: number;
+    }[]>;
+    /**
+     * Full analysis of a file
      */
     analyzeFile(filePath: string): Promise<AnalysisResult>;
     /**
-     * Check if code compiles after a fix
+     * Analyze a project for issues
      */
-    validateFix(projectPath: string): Promise<{
-        valid: boolean;
-        errors: string[];
-    }>;
+    analyzeProject(projectPath: string): Promise<AnalysisResult>;
     /**
-     * Find unused exports/variables in a file
+     * Analyze specific files and filter by bug keywords
+     * This is the targeted analysis method - only looks at relevant files
      */
-    findDeadCode(projectPath: string): Promise<CodeIssue[]>;
+    analyzeRelevantFiles(projectPath: string, filePaths: string[], bugKeywords: string[]): Promise<AnalysisResult>;
     /**
-     * Parse tsc output into structured issues
+     * Validate a fix compiles
      */
-    private parseTscOutput;
+    validateFix(projectPath: string): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+    private sendRequest;
+    private sendNotification;
+    private handleData;
+    private flattenSymbols;
+    private symbolKindToString;
+    private getLineNumber;
+    private findProjectRoot;
+    private findSourceFiles;
 }
 //# sourceMappingURL=giuseppe-lsp.d.ts.map

package/dist/modules/bug-reports/giuseppe-lsp.js

@@ -1,6 +1,7 @@
 "use strict";
 /**
- * Giuseppe LSP Module - Code analysis via TypeScript compiler
+ * Giuseppe LSP Module - Full LSP client for code intelligence
+ * Spawns typescript-language-server and communicates via JSON-RPC
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -39,27 +40,233 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GiuseppeLsp = void 0;
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)({ component: 'giuseppe-lsp' });
 class GiuseppeLsp {
+    server = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    buffer = '';
+    initialized = false;
+    rootPath = null;
     /**
-     * Analyze a project for TypeScript errors
+     * Start the LSP server for a project
      */
-    async analyzeProject(projectPath) {
+    async start(projectPath) {
+        if (this.server && this.rootPath === projectPath) {
+            return true; // Already running for this project
+        }
+        await this.stop(); // Stop any existing server
         try {
-            logger.info(`Analyzing project: ${projectPath}`);
-            const result = (0, child_process_1.execSync)('npx tsc --noEmit --pretty false 2>&1 || true', {
+            this.rootPath = projectPath;
+            this.server = (0, child_process_1.spawn)('typescript-language-server', ['--stdio'], {
                 cwd: projectPath,
-                encoding: 'utf-8',
-                maxBuffer: 10 * 1024 * 1024
+                env: { ...process.env }
+            });
+            this.server.stdout?.on('data', (data) => this.handleData(data));
+            this.server.stderr?.on('data', (data) => logger.debug('LSP stderr', { data: data.toString() }));
+            this.server.on('error', (err) => logger.error('LSP server error', { error: err }));
+            this.server.on('close', () => {
+                this.server = null;
+                this.initialized = false;
             });
-            const issues = this.parseTscOutput(result, projectPath);
+            // Initialize LSP
+            await this.initialize(projectPath);
+            this.initialized = true;
+            logger.info('LSP server started', { projectPath });
+            return true;
+        }
+        catch (error) {
+            logger.error('Failed to start LSP server', { error });
+            return false;
+        }
+    }
+    /**
+     * Stop the LSP server
+     */
+    async stop() {
+        if (this.server) {
+            this.server.kill();
+            this.server = null;
+            this.initialized = false;
+            this.rootPath = null;
+        }
+    }
+    /**
+     * Initialize LSP connection
+     */
+    async initialize(rootPath) {
+        const rootUri = `file://${rootPath}`;
+        await this.sendRequest('initialize', {
+            processId: process.pid,
+            rootUri,
+            rootPath,
+            capabilities: {
+                textDocument: {
+                    documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+                    references: {},
+                    definition: {},
+                    hover: {},
+                    publishDiagnostics: { relatedInformation: true }
+                }
+            },
+            workspaceFolders: [{ uri: rootUri, name: path.basename(rootPath) }]
+        });
+        this.sendNotification('initialized', {});
+    }
+    /**
+     * Open a document for analysis
+     */
+    async openDocument(filePath) {
+        if (!this.server)
+            return;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const uri = `file://${filePath}`;
+        const languageId = filePath.endsWith('.tsx') ? 'typescriptreact' : 'typescript';
+        this.sendNotification('textDocument/didOpen', {
+            textDocument: {
+                uri,
+                languageId,
+                version: 1,
+                text: content
+            }
+        });
+    }
+    /**
+     * Get all symbols in a document
+     */
+    async getDocumentSymbols(filePath) {
+        if (!this.initialized) {
+            await this.start(path.dirname(filePath));
+        }
+        await this.openDocument(filePath);
+        const uri = `file://${filePath}`;
+        const result = await this.sendRequest('textDocument/documentSymbol', {
+            textDocument: { uri }
+        });
+        return this.flattenSymbols(result || []);
+    }
+    /**
+     * Find all references to a symbol at a position
+     */
+    async findReferences(filePath, line, character) {
+        if (!this.initialized) {
+            await this.start(path.dirname(filePath));
+        }
+        await this.openDocument(filePath);
+        const uri = `file://${filePath}`;
+        const result = await this.sendRequest('textDocument/references', {
+            textDocument: { uri },
+            position: { line: line - 1, character: character - 1 }, // LSP is 0-indexed
+            context: { includeDeclaration: true }
+        });
+        return (result || []).map((ref) => ({
+            file: ref.uri.replace('file://', ''),
+            line: ref.range.start.line + 1,
+            character: ref.range.start.character + 1
+        }));
+    }
+    /**
+     * Get hover info for a symbol
+     */
+    async hover(filePath, line, character) {
+        if (!this.initialized) {
+            await this.start(path.dirname(filePath));
+        }
+        await this.openDocument(filePath);
+        const uri = `file://${filePath}`;
+        const result = await this.sendRequest('textDocument/hover', {
+            textDocument: { uri },
+            position: { line: line - 1, character: character - 1 }
+        });
+        if (result?.contents) {
+            if (typeof result.contents === 'string')
+                return result.contents;
+            if (result.contents.value)
+                return result.contents.value;
+            if (Array.isArray(result.contents))
+                return result.contents.map((c) => c.value || c).join('\n');
+        }
+        return null;
+    }
+    /**
+     * Find unused props in a React component
+     * Checks if props declared in interface are actually destructured in function params
+     */
+    async findUnusedProps(filePath) {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const unusedProps = [];
+        // Find interface props (e.g., interface BallProps { x: number; onDrag?: () => void; })
+        const interfaceMatch = content.match(/interface\s+(\w+Props)\s*\{([^}]+)\}/);
+        if (!interfaceMatch)
+            return [];
+        const interfaceName = interfaceMatch[1];
+        const propsBlock = interfaceMatch[2];
+        // Extract all prop names from interface
+        const propMatches = [...propsBlock.matchAll(/(\w+)\??:/g)];
+        const declaredProps = propMatches.map(m => ({
+            name: m[1],
+            line: this.getLineNumber(content, m.index)
+        }));
+        // Find the function that uses this Props interface
+        // Matches: function Foo({ x, y }: FooProps) or const Foo = ({ x, y }: FooProps) =>
+        const funcPattern = new RegExp(`(?:function\\s+\\w+|const\\s+\\w+\\s*=)\\s*\\(\\s*\\{([^}]*)\\}\\s*:\\s*${interfaceName}`, 's');
+        const funcMatch = content.match(funcPattern);
+        if (!funcMatch) {
+            // Can't find function, fall back to checking if prop is used anywhere in file
+            for (const prop of declaredProps) {
+                // Count occurrences of prop name (excluding interface declaration)
+                const propRegex = new RegExp(`\\b${prop.name}\\b`, 'g');
+                const matches = content.match(propRegex);
+                if (matches && matches.length <= 1) {
+                    unusedProps.push(prop);
+                }
+            }
+            return unusedProps;
+        }
+        // Get destructured props from function params
+        const destructuredBlock = funcMatch[1];
+        const destructuredProps = new Set([...destructuredBlock.matchAll(/(\w+)/g)].map(m => m[1]));
+        // Props in interface but not in destructuring = unused
+        for (const prop of declaredProps) {
+            if (!destructuredProps.has(prop.name)) {
+                unusedProps.push(prop);
+            }
+        }
+        return unusedProps;
+    }
+    /**
+     * Full analysis of a file
+     */
+    async analyzeFile(filePath) {
+        try {
+            const projectPath = this.findProjectRoot(filePath);
+            await this.start(projectPath);
+            const symbols = await this.getDocumentSymbols(filePath);
+            const unusedProps = await this.findUnusedProps(filePath);
+            // Check for symbols with only 1 reference (dead code)
+            const issues = [];
+            for (const symbol of symbols) {
+                if (['Function', 'Method', 'Variable', 'Constant'].includes(symbol.kind)) {
+                    const refs = await this.findReferences(filePath, symbol.line, symbol.character);
+                    if (refs.length === 1) {
+                        issues.push({
+                            file: filePath,
+                            line: symbol.line,
+                            column: symbol.character,
+                            message: `'${symbol.name}' is declared but never used`,
+                            code: 'unused',
+                            severity: 'warning'
+                        });
+                    }
+                }
+            }
             return {
-                success: issues.filter(i => i.severity === 'error').length === 0,
+                success: true,
                 issues,
-                summary: issues.length === 0
-                    ? 'No issues found'
-                    : `Found ${issues.length} issue(s)`
+                unusedProps,
+                summary: `Found ${issues.length} unused symbols, ${unusedProps.length} unused props`
             };
         }
         catch (error) {
@@ -67,76 +274,211 @@ class GiuseppeLsp {
             return {
                 success: false,
                 issues: [],
+                unusedProps: [],
                 summary: `Analysis failed: ${error}`
             };
         }
     }
     /**
-     * Analyze a single file
+     * Analyze a project for issues
      */
-    async analyzeFile(filePath) {
-        const projectPath = path.dirname(filePath);
-        const result = await this.analyzeProject(projectPath);
-        const fileName = path.basename(filePath);
-        result.issues = result.issues.filter(i => i.file.endsWith(fileName));
-        result.summary = result.issues.length === 0
-            ? `No issues in ${fileName}`
-            : `Found ${result.issues.length} issue(s) in ${fileName}`;
-        return result;
+    async analyzeProject(projectPath) {
+        await this.start(projectPath);
+        // Find all TS/TSX files
+        const files = this.findSourceFiles(projectPath);
+        const allIssues = [];
+        const allUnusedProps = [];
+        for (const file of files.slice(0, 10)) { // Limit to first 10 files for performance
+            const result = await this.analyzeFile(file);
+            allIssues.push(...result.issues);
+            // Add file path to each unused prop for better context
+            const propsWithFile = result.unusedProps.map(p => ({ ...p, file: file.replace(projectPath + '/', '') }));
+            allUnusedProps.push(...propsWithFile);
+        }
+        return {
+            success: true,
+            issues: allIssues,
+            unusedProps: allUnusedProps,
+            summary: `Analyzed ${files.length} files: ${allIssues.length} issues, ${allUnusedProps.length} unused props`
+        };
+    }
+    /**
+     * Analyze specific files and filter by bug keywords
+     * This is the targeted analysis method - only looks at relevant files
+     */
+    async analyzeRelevantFiles(projectPath, filePaths, bugKeywords) {
+        await this.start(projectPath);
+        const allIssues = [];
+        const allUnusedProps = [];
+        const keywordsLower = bugKeywords.map(k => k.toLowerCase());
+        for (const relativePath of filePaths) {
+            const fullPath = path.join(projectPath, relativePath);
+            if (!fs.existsSync(fullPath))
+                continue;
+            const result = await this.analyzeFile(fullPath);
+            // Filter issues to match bug keywords
+            const relevantIssues = result.issues.filter(issue => {
+                const msgLower = issue.message.toLowerCase();
+                return keywordsLower.some(kw => msgLower.includes(kw));
+            });
+            allIssues.push(...relevantIssues);
+            // Filter unused props to match bug keywords
+            const relevantProps = result.unusedProps.filter(prop => {
+                const propLower = prop.name.toLowerCase();
+                return keywordsLower.some(kw => propLower.includes(kw));
+            });
+            const propsWithFile = relevantProps.map(p => ({ ...p, file: relativePath }));
+            allUnusedProps.push(...propsWithFile);
+        }
+        // If no keyword matches, return all findings from these files (fallback)
+        if (allIssues.length === 0 && allUnusedProps.length === 0) {
+            for (const relativePath of filePaths) {
+                const fullPath = path.join(projectPath, relativePath);
+                if (!fs.existsSync(fullPath))
+                    continue;
+                const result = await this.analyzeFile(fullPath);
+                allIssues.push(...result.issues);
+                const propsWithFile = result.unusedProps.map(p => ({ ...p, file: relativePath }));
+                allUnusedProps.push(...propsWithFile);
+            }
+        }
+        logger.info('Targeted LSP analysis complete', {
+            filesAnalyzed: filePaths.length,
+            keywords: bugKeywords,
+            issuesFound: allIssues.length,
+            unusedPropsFound: allUnusedProps.length
+        });
+        return {
+            success: true,
+            issues: allIssues,
+            unusedProps: allUnusedProps,
+            summary: `Targeted analysis of ${filePaths.length} files: ${allIssues.length} relevant issues, ${allUnusedProps.length} relevant unused props`
+        };
     }
     /**
-     * Check if code compiles after a fix
+     * Validate a fix compiles
      */
     async validateFix(projectPath) {
         const result = await this.analyzeProject(projectPath);
         const errors = result.issues
             .filter(i => i.severity === 'error')
             .map(i => `${i.file}:${i.line} - ${i.message}`);
-        return {
-            valid: errors.length === 0,
-            errors
-        };
+        return { valid: errors.length === 0, errors };
     }
-    /**
-     * Find unused exports/variables in a file
-     */
-    async findDeadCode(projectPath) {
-        try {
-            const result = (0, child_process_1.execSync)('npx tsc --noEmit --noUnusedLocals --noUnusedParameters --pretty false 2>&1 || true', {
-                cwd: projectPath,
-                encoding: 'utf-8',
-                maxBuffer: 10 * 1024 * 1024
+    // === Private helpers ===
+    sendRequest(method, params) {
+        return new Promise((resolve, reject) => {
+            if (!this.server?.stdin) {
+                reject(new Error('LSP server not running'));
+                return;
+            }
+            const id = ++this.requestId;
+            this.pendingRequests.set(id, { resolve, reject });
+            const message = JSON.stringify({ jsonrpc: '2.0', id, method, params });
+            const content = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n${message}`;
+            this.server.stdin.write(content);
+            // Timeout after 10s
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request ${method} timed out`));
+                }
+            }, 10000);
+        });
+    }
+    sendNotification(method, params) {
+        if (!this.server?.stdin)
+            return;
+        const message = JSON.stringify({ jsonrpc: '2.0', method, params });
+        const content = `Content-Length: ${Buffer.byteLength(message)}\r\n\r\n${message}`;
+        this.server.stdin.write(content);
+    }
+    handleData(data) {
+        this.buffer += data.toString();
+        while (true) {
+            const headerEnd = this.buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1)
+                break;
+            const header = this.buffer.slice(0, headerEnd);
+            const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+            if (!lengthMatch)
+                break;
+            const contentLength = parseInt(lengthMatch[1], 10);
+            const contentStart = headerEnd + 4;
+            if (this.buffer.length < contentStart + contentLength)
+                break;
+            const content = this.buffer.slice(contentStart, contentStart + contentLength);
+            this.buffer = this.buffer.slice(contentStart + contentLength);
+            try {
+                const message = JSON.parse(content);
+                if (message.id !== undefined && this.pendingRequests.has(message.id)) {
+                    const { resolve, reject } = this.pendingRequests.get(message.id);
+                    this.pendingRequests.delete(message.id);
+                    if (message.error) {
+                        reject(new Error(message.error.message));
+                    }
+                    else {
+                        resolve(message.result);
+                    }
+                }
+            }
+            catch (e) {
+                logger.error('Failed to parse LSP message', { error: e });
+            }
+        }
+    }
+    flattenSymbols(symbols, result = []) {
+        for (const sym of symbols) {
+            result.push({
+                name: sym.name,
+                kind: this.symbolKindToString(sym.kind),
+                line: (sym.range?.start?.line ?? sym.location?.range?.start?.line ?? 0) + 1,
+                character: (sym.range?.start?.character ?? sym.location?.range?.start?.character ?? 0) + 1
             });
-            return this.parseTscOutput(result, projectPath)
-                .filter(i => i.message.includes('declared but') || i.message.includes('never used'));
+            if (sym.children) {
+                this.flattenSymbols(sym.children, result);
+            }
         }
-        catch (error) {
-            logger.error('Dead code analysis failed', { error });
-            return [];
+        return result;
+    }
+    symbolKindToString(kind) {
+        const kinds = {
+            1: 'File', 2: 'Module', 3: 'Namespace', 4: 'Package',
+            5: 'Class', 6: 'Method', 7: 'Property', 8: 'Field',
+            9: 'Constructor', 10: 'Enum', 11: 'Interface', 12: 'Function',
+            13: 'Variable', 14: 'Constant', 15: 'String', 16: 'Number',
+            17: 'Boolean', 18: 'Array', 19: 'Object', 20: 'Key',
+            21: 'Null', 22: 'EnumMember', 23: 'Struct', 24: 'Event',
+            25: 'Operator', 26: 'TypeParameter'
+        };
+        return kinds[kind] || 'Unknown';
+    }
+    getLineNumber(content, index) {
+        return content.slice(0, index).split('\n').length;
+    }
+    findProjectRoot(filePath) {
+        let dir = path.dirname(filePath);
+        while (dir !== '/') {
+            if (fs.existsSync(path.join(dir, 'package.json')) ||
+                fs.existsSync(path.join(dir, 'tsconfig.json'))) {
+                return dir;
+            }
+            dir = path.dirname(dir);
         }
+        return path.dirname(filePath);
     }
-    /**
-     * Parse tsc output into structured issues
-     */
-    parseTscOutput(output, basePath) {
-        const issues = [];
-        const lines = output.split('\n');
-        // Pattern: src/file.ts(10,5): error TS2304: Cannot find name 'foo'.
-        const pattern = /^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(TS\d+):\s*(.+)$/;
-        for (const line of lines) {
-            const match = line.match(pattern);
-            if (match) {
-                issues.push({
-                    file: path.resolve(basePath, match[1]),
-                    line: parseInt(match[2], 10),
-                    column: parseInt(match[3], 10),
-                    severity: match[4],
-                    code: match[5],
-                    message: match[6]
-                });
+    findSourceFiles(dir, files = []) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules' && entry.name !== 'dist') {
+                this.findSourceFiles(fullPath, files);
+            }
+            else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
+                files.push(fullPath);
             }
         }
-        return issues;
+        return files;
     }
 }
 exports.GiuseppeLsp = GiuseppeLsp;

package/dist/modules/bug-reports/index.d.ts

@@ -63,6 +63,7 @@ export declare class BugReportsModule {
 }
 export type { BugReportsConfig, BugReport, FixResult, AppRegistryEntry, WorkflowDiscoveryResult } from './types';
 export { BugMonitor } from './bug-monitor';
+export { GiuseppeAgent } from './giuseppe-agent';
 export { GiuseppeBot } from './giuseppe-bot';
 export { loadConfig, discoverWorkflow, getDefaultConfig } from './bug-config';
 export { PendingRegistry, PendingItem } from './pending-registry';