@stellisoft/stellify-mcp 0.1.13 → 0.1.15

package/dist/index.js

@@ -1195,6 +1195,54 @@ Examples of capability requests:
             required: ['capability', 'description', 'use_case'],
         },
     },
+    {
+        name: 'analyze_performance',
+        description: `Analyze code execution performance from logs. Identifies slow methods, N+1 query patterns, high memory usage, and failure rates.
+
+Use this tool PROACTIVELY to:
+- Review performance after creating new methods
+- Identify optimization opportunities
+- Detect N+1 query patterns (high query counts)
+- Find methods that need caching or refactoring
+- Check failure rates and error patterns
+
+ANALYSIS TYPES:
+- full: Comprehensive report with all issues, recommendations, and statistics
+- slow_methods: Methods exceeding 500ms execution time
+- high_query_methods: Methods with >10 queries (potential N+1 problems)
+- high_memory_methods: Methods using >50MB memory
+- failure_rates: Methods with high error rates
+- trend: Performance trend over time (daily averages)
+
+EXAMPLE - Full analysis:
+{ "type": "full", "days": 7 }
+
+EXAMPLE - Check for N+1 queries:
+{ "type": "high_query_methods", "limit": 10 }
+
+The response includes actionable recommendations like:
+- "Consider eager loading relationships" for N+1 patterns
+- "Add database indexes" for slow queries
+- "Use chunking" for high memory usage`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['full', 'slow_methods', 'high_query_methods', 'high_memory_methods', 'failure_rates', 'trend'],
+                    description: 'Type of analysis to run (default: full)',
+                },
+                days: {
+                    type: 'number',
+                    description: 'Number of days to analyze (default: 7)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results for specific queries (default: 10)',
+                },
+            },
+        },
+    },
 ];
 // Server instructions for tool discovery (used by MCP Tool Search)
 const SERVER_INSTRUCTIONS = `Stellify is a coding platform where you code alongside AI on a codebase maintained and curated by AI. Build Laravel/PHP and Vue.js applications.
@@ -1774,6 +1822,52 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case 'analyze_performance': {
+                const result = await stellify.analyzePerformance(args);
+                const data = result.data || result;
+                const analysisType = args.type || 'full';
+                // Build message based on analysis type
+                let message = '';
+                if (analysisType === 'full') {
+                    message = data.summary || `Analyzed ${data.analyzed_executions || 0} executions`;
+                    if (data.issues?.length > 0) {
+                        message += ` - Found ${data.issues.length} potential issue(s)`;
+                    }
+                }
+                else if (analysisType === 'slow_methods') {
+                    const methods = data.slow_methods || data;
+                    message = `Found ${Array.isArray(methods) ? methods.length : 0} slow methods`;
+                }
+                else if (analysisType === 'high_query_methods') {
+                    const methods = data.high_query_methods || data;
+                    message = `Found ${Array.isArray(methods) ? methods.length : 0} methods with high query counts (potential N+1)`;
+                }
+                else if (analysisType === 'high_memory_methods') {
+                    const methods = data.high_memory_methods || data;
+                    message = `Found ${Array.isArray(methods) ? methods.length : 0} methods with high memory usage`;
+                }
+                else if (analysisType === 'failure_rates') {
+                    const methods = data.failure_rates || data;
+                    message = `Found ${Array.isArray(methods) ? methods.length : 0} methods with failures`;
+                }
+                else if (analysisType === 'trend') {
+                    const trend = data.trend || data;
+                    message = `Performance trend: ${Array.isArray(trend) ? trend.length : 0} days of data`;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message,
+                                analysis_type: analysisType,
+                                data,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/stellify-client.d.ts

@@ -158,4 +158,9 @@ export declare class StellifyClient {
         workaround?: string;
         priority?: 'low' | 'medium' | 'high' | 'critical';
     }): Promise<any>;
+    analyzePerformance(params: {
+        type?: 'full' | 'slow_methods' | 'high_query_methods' | 'high_memory_methods' | 'failure_rates' | 'trend';
+        days?: number;
+        limit?: number;
+    }): Promise<any>;
 }

package/dist/stellify-client.js

@@ -150,4 +150,23 @@ export class StellifyClient {
         const response = await this.client.post('/capabilities/request', params);
         return response.data;
     }
+    // Performance analysis - analyze execution logs for optimization opportunities
+    async analyzePerformance(params) {
+        const type = params.type || 'full';
+        const queryParams = {};
+        if (params.days)
+            queryParams.days = params.days;
+        if (params.limit)
+            queryParams.limit = params.limit;
+        // Map type to endpoint
+        const endpoint = type === 'full' ? '/performance/analyze' :
+            type === 'slow_methods' ? '/performance/slow-methods' :
+                type === 'high_query_methods' ? '/performance/high-query-methods' :
+                    type === 'high_memory_methods' ? '/performance/high-memory-methods' :
+                        type === 'failure_rates' ? '/performance/failure-rates' :
+                            type === 'trend' ? '/performance/trend' :
+                                '/performance/analyze';
+        const response = await this.client.get(endpoint, { params: queryParams });
+        return response.data;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellisoft/stellify-mcp",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "mcpName": "io.github.MattStellisoft/stellify-mcp",
   "description": "MCP server for Stellify - AI-native code generation platform",
   "main": "dist/index.js",