@stellisoft/stellify-mcp 0.1.13 → 0.1.16

package/dist/index.js

@@ -1195,6 +1195,93 @@ 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)',
+                },
+            },
+        },
+    },
+    {
+        name: 'analyze_quality',
+        description: `Analyze Laravel code structure for quality issues. Detects missing relationships, fillables, casts, and route problems.
+
+Use this tool PROACTIVELY to:
+- Review code quality after creating models or controllers
+- Detect missing Eloquent relationships (belongsTo, hasMany)
+- Find migration fields not in $fillable
+- Suggest type casts for columns (json → array, datetime → datetime)
+- Identify broken route bindings (orphaned methods, missing controllers)
+
+ANALYSIS TYPES:
+- full: Comprehensive analysis of all categories with recommendations
+- relationships: Missing belongsTo/hasMany based on foreign keys
+- fillables: Migration fields not in Model $fillable array
+- casts: Columns that should have type casts
+- routes: Orphaned controller methods, routes pointing to missing methods
+
+EXAMPLE - Full analysis:
+{ "type": "full" }
+
+EXAMPLE - Check relationships only:
+{ "type": "relationships" }
+
+The response includes actionable suggestions like:
+- "Add belongsTo relationship: public function user() { return $this->belongsTo(User::class); }"
+- "Add 'published_at' to $fillable array"
+- "Add cast: 'metadata' => 'array'"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['full', 'relationships', 'fillables', 'casts', 'routes'],
+                    description: 'Type of analysis to run (default: full)',
+                },
+            },
+        },
+    },
 ];
 // 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 +1861,86 @@ 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),
+                        },
+                    ],
+                };
+            }
+            case 'analyze_quality': {
+                const result = await stellify.analyzeQuality(args);
+                const data = result.data || result;
+                const analysisType = args.type || 'full';
+                // Build message based on analysis type
+                let message = '';
+                const issues = data.issues || [];
+                if (analysisType === 'full') {
+                    const summary = data.summary || {};
+                    message = `Analyzed ${summary.models_analyzed || 0} models, ${summary.controllers_analyzed || 0} controllers`;
+                    if (summary.total_issues > 0) {
+                        message += ` - Found ${summary.total_issues} issue(s): ${summary.high_severity || 0} high, ${summary.medium_severity || 0} medium, ${summary.low_severity || 0} low`;
+                    }
+                    else {
+                        message += ' - No issues found';
+                    }
+                }
+                else {
+                    message = `Found ${issues.length} ${analysisType} issue(s)`;
+                }
+                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,12 @@ 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>;
+    analyzeQuality(params: {
+        type?: 'full' | 'relationships' | 'fillables' | 'casts' | 'routes';
+    }): Promise<any>;
 }

package/dist/stellify-client.js

@@ -150,4 +150,36 @@ 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;
+    }
+    // Code quality analysis - analyze Laravel structure for issues
+    async analyzeQuality(params) {
+        const type = params.type || 'full';
+        // Map type to endpoint
+        const endpoint = type === 'full' ? '/quality/analyze' :
+            type === 'relationships' ? '/quality/relationships' :
+                type === 'fillables' ? '/quality/fillables' :
+                    type === 'casts' ? '/quality/casts' :
+                        type === 'routes' ? '/quality/routes' :
+                            '/quality/analyze';
+        const response = await this.client.get(endpoint);
+        return response.data;
+    }
 }

package/package.json

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