@stellisoft/stellify-mcp 0.1.11 → 0.1.13

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
     // =============================================================================
@@ -1270,6 +1134,67 @@ SECURITY: Code runs in a sandboxed environment with limited permissions.`,
             required: ['file', 'method'],
         },
     },
+    {
+        name: 'get_capabilities',
+        description: `List available system-level capabilities in the Stellify framework.
+
+Returns what's currently available for:
+- Authentication (Sanctum, session, etc.)
+- File storage (local, S3, etc.)
+- Email/notifications
+- Queues/jobs
+- Caching
+- Other installed packages and services
+
+Use this BEFORE attempting to build features that might require system capabilities.
+If a capability you need is not listed, use request_capability to log it.`,
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'request_capability',
+        description: `Log a missing system-level capability request.
+
+Use this when you encounter a user requirement that needs framework-level functionality
+that doesn't exist in Stellify. This creates a ticket in the Stellify backlog.
+
+DO NOT try to build system capabilities yourself - log them here instead.
+
+Examples of capability requests:
+- "Need WebSocket support for real-time chat"
+- "Need S3 file upload with signed URLs"
+- "Need scheduled task runner for daily reports"
+- "Need OAuth2 social login (Google, GitHub)"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                capability: {
+                    type: 'string',
+                    description: 'Short name for the capability (e.g., "websocket-support", "s3-uploads", "social-oauth")',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Detailed description of what capability is needed',
+                },
+                use_case: {
+                    type: 'string',
+                    description: 'The user requirement that triggered this request',
+                },
+                workaround: {
+                    type: 'string',
+                    description: 'Any temporary workaround, or "blocked" if none exists',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high', 'critical'],
+                    description: 'Suggested priority based on user need (default: medium)',
+                },
+            },
+            required: ['capability', 'description', 'use_case'],
+        },
+    },
 ];
 // 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.
@@ -1284,7 +1209,47 @@ Key concepts:
 - Code is stored as structured JSON, enabling surgical AI edits at the statement level
 - Files contain methods and statements (code outside methods)
 - Vue components link to UI elements via the 'template' field
-- Event handlers (click, submit) wire UI elements to methods by UUID`;
+- Event handlers (click, submit) wire UI elements to methods by UUID
+
+## Framework Capabilities (Libraries/Packages)
+
+**CRITICAL: You write BUSINESS LOGIC only. Capabilities are installed packages/libraries (Sanctum, Stripe, AWS SDK, etc.) that Stellify provides. You CANNOT create these by writing code.**
+
+Examples of capabilities (packages you cannot write):
+- Authentication: laravel/sanctum, laravel/socialite
+- Payments: stripe/stripe-php
+- Storage: aws/aws-sdk-php, league/flysystem-aws-s3-v3
+- Email: mailgun/mailgun-php, aws/aws-sdk-php (SES)
+- Search: meilisearch/meilisearch-php, algolia/algoliasearch-client-php
+- WebSocket: laravel/reverb
+
+**WORKFLOW:**
+
+1. When a user requests functionality that might need a package/library, call get_capabilities() FIRST.
+
+2. If status is "available" → package is installed, proceed with business logic.
+
+3. If status is "needs_config" → package installed but needs API keys. INFORM THE USER to configure it in Project Settings.
+
+4. If status is "not_available" or doesn't exist:
+   - STOP IMMEDIATELY
+   - 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.
+
+## 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',
@@ -1575,143 +1540,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);
@@ -1915,6 +1743,37 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case 'get_capabilities': {
+                const result = await stellify.getCapabilities();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'Available framework capabilities',
+                                capabilities: result.data || result,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'request_capability': {
+                const result = await stellify.requestCapability(args);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Capability request logged: "${args.capability}"`,
+                                request_id: result.data?.uuid || result.uuid,
+                                data: result.data || result,
+                            }, 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;
@@ -178,4 +150,12 @@ export declare class StellifyClient {
         timeout?: number;
         benchmark?: boolean;
     }): Promise<any>;
+    getCapabilities(): Promise<any>;
+    requestCapability(params: {
+        capability: string;
+        description: string;
+        use_case: string;
+        workaround?: string;
+        priority?: 'low' | 'medium' | 'high' | 'critical';
+    }): 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}`);
@@ -186,4 +140,14 @@ export class StellifyClient {
         const response = await this.client.put(`/code/${file}/${method}`, body);
         return response.data;
     }
+    // Framework capabilities - list what's available
+    async getCapabilities() {
+        const response = await this.client.get('/capabilities');
+        return response.data;
+    }
+    // Request a missing capability - logs to backlog
+    async requestCapability(params) {
+        const response = await this.client.post('/capabilities/request', params);
+        return response.data;
+    }
 }

package/package.json

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