@stellisoft/stellify-mcp 0.1.12 → 0.1.15

package/dist/index.js

@@ -178,6 +178,10 @@ The system resolves these to UUIDs automatically, creating missing dependencies
                     items: { type: 'string' },
                     description: 'Array of namespace strings to include as dependencies (e.g., ["App\\Models\\User", "Illuminate\\Support\\Facades\\Hash"]). These are resolved to UUIDs automatically.',
                 },
+                module: {
+                    type: 'string',
+                    description: 'Optional module name to group this file with related code (e.g., "blog-posts", "user-auth"). Module is auto-created if it doesn\'t exist.',
+                },
             },
             required: ['directory', 'name', 'type'],
         },
@@ -406,6 +410,10 @@ Example:
                     type: 'object',
                     description: 'Additional route data (title, description, element UUIDs)',
                 },
+                module: {
+                    type: 'string',
+                    description: 'Optional module name to group this route with related code (e.g., "blog-posts", "user-auth"). Module is auto-created if it doesn\'t exist.',
+                },
             },
             required: ['project_id', 'name', 'path', 'method'],
         },
@@ -654,150 +662,6 @@ IMPORTANT: Use the returned root element UUID in save_file's template array.`,
             required: ['elements'],
         },
     },
-    {
-        name: 'list_globals',
-        description: 'List all global files in the Application database. Globals are reusable, curated code (controllers, models, services) that can be installed into tenant projects.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'get_global',
-        description: 'Get a global file with all its methods, statements, and clauses. Returns the full structure of a reusable code file.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: {
-                    type: 'string',
-                    description: 'UUID of the global file to retrieve',
-                },
-            },
-            required: ['uuid'],
-        },
-    },
-    {
-        name: 'install_global',
-        description: 'Install a global file from the Application database into a tenant project. Copies the file, methods, and statements to the tenant database with the same UUIDs (for deduplication). Clauses remain shared in the Application DB.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                file_uuid: {
-                    type: 'string',
-                    description: 'UUID of the global file to install',
-                },
-                directory_uuid: {
-                    type: 'string',
-                    description: 'UUID of the directory in the tenant project to install the file into',
-                },
-            },
-            required: ['file_uuid', 'directory_uuid'],
-        },
-    },
-    {
-        name: 'search_global_methods',
-        description: 'Search for methods across the Application database (global/framework methods). Use this to find reusable Laravel framework methods, facades, and shared code.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: {
-                    type: 'string',
-                    description: 'Search query to find methods by name',
-                },
-            },
-            required: ['query'],
-        },
-    },
-    // Module tools (groups of globals)
-    {
-        name: 'list_modules',
-        description: 'List all available modules. A module is a named collection of related global files that can be installed together as a package.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'get_module',
-        description: 'Get a module with all its files. Returns the module metadata and list of global files it contains, in installation order.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                uuid: {
-                    type: 'string',
-                    description: 'UUID of the module to retrieve',
-                },
-            },
-            required: ['uuid'],
-        },
-    },
-    {
-        name: 'create_module',
-        description: 'Create a new module to group related global files together.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Unique name for the module (e.g., "laravel-sanctum-auth")',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Description of what the module provides',
-                },
-                version: {
-                    type: 'string',
-                    description: 'Version string (default: "1.0.0")',
-                },
-                tags: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Tags for categorization (e.g., ["auth", "api", "sanctum"])',
-                },
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'add_file_to_module',
-        description: 'Add a global file to a module. Files are installed in order when the module is installed.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                module_uuid: {
-                    type: 'string',
-                    description: 'UUID of the module',
-                },
-                file_uuid: {
-                    type: 'string',
-                    description: 'UUID of the global file to add',
-                },
-                order: {
-                    type: 'number',
-                    description: 'Installation order (optional, auto-increments if not specified)',
-                },
-            },
-            required: ['module_uuid', 'file_uuid'],
-        },
-    },
-    {
-        name: 'install_module',
-        description: 'Install all files from a module into a tenant project. Copies files, methods, and statements in the defined order. Clauses remain shared in the Application DB.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                module_uuid: {
-                    type: 'string',
-                    description: 'UUID of the module to install',
-                },
-                directory_uuid: {
-                    type: 'string',
-                    description: 'UUID of the directory in the tenant project to install files into',
-                },
-            },
-            required: ['module_uuid', 'directory_uuid'],
-        },
-    },
     // =============================================================================
     // STATEMENT & FILE MANAGEMENT TOOLS
     // =============================================================================
@@ -1331,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.
@@ -1372,7 +1284,20 @@ Examples of capabilities (packages you cannot write):
    - Call request_capability() to log it
    - INFORM THE USER: "This feature requires the [X] package which isn't installed in Stellify yet. I've logged a request. This cannot be built until the package is added."
 
-**NEVER write code that belongs in a package.** If you find yourself writing OAuth flows, payment processing, S3 clients, email transport, search indexing, or similar infrastructure - STOP. That's a capability request, not business logic.`;
+**NEVER write code that belongs in a package.** If you find yourself writing OAuth flows, payment processing, S3 clients, email transport, search indexing, or similar infrastructure - STOP. That's a capability request, not business logic.
+
+## Project Modules (Code Organization)
+
+When building features, group related files by passing a "module" parameter.
+
+**WORKFLOW:** Simply include the 'module' parameter when creating files or routes:
+
+- create_file(..., module: "blog-posts") - auto-groups file
+- create_route(..., module: "blog-posts") - auto-groups route
+
+Modules are auto-created if they don't exist. This helps users see all code related to a feature grouped together.
+
+Example module names: "user-auth", "blog-posts", "product-catalog", "order-management", "admin-dashboard"`;
 // Create MCP server
 const server = new Server({
     name: 'stellify-mcp',
@@ -1663,143 +1588,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
-            case 'list_globals': {
-                const result = await stellify.listGlobals();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Found ${result.data?.length || 0} globals`,
-                                globals: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_global': {
-                const { uuid } = args;
-                const result = await stellify.getGlobal(uuid);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                global: result,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'install_global': {
-                const result = await stellify.installGlobal(args);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Installed global "${result.data?.file_name}" (${result.data?.methods_copied} methods, ${result.data?.statements_copied} statements)`,
-                                data: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'search_global_methods': {
-                const result = await stellify.searchGlobalMethods(args);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Found ${result.data?.length || 0} global methods`,
-                                methods: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            // Module handlers
-            case 'list_modules': {
-                const result = await stellify.listModules();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Found ${result.data?.length || 0} modules`,
-                                modules: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'get_module': {
-                const { uuid } = args;
-                const result = await stellify.getModule(uuid);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                module: result.module,
-                                files: result.files,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'create_module': {
-                const result = await stellify.createModule(args);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Created module "${result.data?.name}"`,
-                                data: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'add_file_to_module': {
-                const result = await stellify.addFileToModule(args);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Added "${result.data?.file_name}" to module (order: ${result.data?.order})`,
-                                data: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'install_module': {
-                const result = await stellify.installModule(args);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Installed module "${result.data?.module_name}" (${result.data?.files_installed} files, ${result.data?.methods_copied} methods, ${result.data?.statements_copied} statements)`,
-                                data: result.data,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
             // Statement & File Management handlers
             case 'get_statement': {
                 const result = await stellify.getStatement(args.uuid);
@@ -2034,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

@@ -105,34 +105,6 @@ export declare class StellifyClient {
         selection?: string;
         test?: boolean;
     }): Promise<any>;
-    listGlobals(): Promise<any>;
-    getGlobal(uuid: string): Promise<any>;
-    installGlobal(params: {
-        file_uuid: string;
-        directory_uuid: string;
-    }): Promise<any>;
-    searchGlobalMethods(params: {
-        query: string;
-    }): Promise<any>;
-    listModules(): Promise<any>;
-    getModule(module: string): Promise<any>;
-    createModule(params: {
-        name: string;
-        description?: string;
-        version?: string;
-        tags?: string[];
-    }): Promise<any>;
-    addFileToModule(params: {
-        module: string;
-        file: string;
-        order?: number;
-    }): Promise<any>;
-    removeFileFromModule(module: string, file: string): Promise<any>;
-    installModule(params: {
-        module: string;
-        directory: string;
-    }): Promise<any>;
-    deleteModule(uuid: string): Promise<any>;
     getDirectory(uuid: string): Promise<any>;
     createDirectory(params: {
         name: string;
@@ -186,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

@@ -103,52 +103,6 @@ export class StellifyClient {
         const response = await this.client.post('/html/elements', params);
         return response.data;
     }
-    // Global methods (Application DB)
-    async listGlobals() {
-        const response = await this.client.get('/globals/');
-        return response.data;
-    }
-    async getGlobal(uuid) {
-        const response = await this.client.get(`/globals/file/${uuid}`);
-        return response.data;
-    }
-    async installGlobal(params) {
-        const response = await this.client.post('/globals/install', params);
-        return response.data;
-    }
-    async searchGlobalMethods(params) {
-        const response = await this.client.post('/method/search-global', params);
-        return response.data;
-    }
-    // Module methods (groups of globals)
-    async listModules() {
-        const response = await this.client.get('/modules/');
-        return response.data;
-    }
-    async getModule(module) {
-        const response = await this.client.get(`/modules/${module}`);
-        return response.data;
-    }
-    async createModule(params) {
-        const response = await this.client.post('/modules/', params);
-        return response.data;
-    }
-    async addFileToModule(params) {
-        const response = await this.client.post('/modules/add-file', params);
-        return response.data;
-    }
-    async removeFileFromModule(module, file) {
-        const response = await this.client.delete(`/modules/${module}/file/${file}`);
-        return response.data;
-    }
-    async installModule(params) {
-        const response = await this.client.post('/modules/install', params);
-        return response.data;
-    }
-    async deleteModule(uuid) {
-        const response = await this.client.delete(`/modules/${module}`);
-        return response.data;
-    }
     // Directory methods
     async getDirectory(uuid) {
         const response = await this.client.get(`/directory/${uuid}`);
@@ -196,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.12",
+  "version": "0.1.15",
   "mcpName": "io.github.MattStellisoft/stellify-mcp",
   "description": "MCP server for Stellify - AI-native code generation platform",
   "main": "dist/index.js",