@stellisoft/stellify-mcp 0.1.10 → 0.1.12

package/dist/index.js

@@ -1058,6 +1058,154 @@ For PERSISTENT changes (saved to database), use update_element or html_to_elemen
             required: ['action'],
         },
     },
+    {
+        name: 'create_resources',
+        description: `Scaffold a complete resource stack in ONE operation. Creates Model, Controller, Service, and Migration together.
+
+This is the FASTEST way to bootstrap new features! Instead of 20+ individual API calls, create everything at once.
+
+WHAT IT CREATES:
+- Model: With $fillable, $casts, and relationship methods
+- Controller: With index, store, show, update, destroy actions
+- Service (optional): Business logic layer with list, find, create, update, delete methods
+- Migration: With proper column types based on field definitions
+
+EXAMPLE - Create a User resource:
+{
+  "name": "User",
+  "fields": [
+    { "name": "name", "type": "string" },
+    { "name": "email", "type": "string", "unique": true },
+    { "name": "password", "type": "string" },
+    { "name": "is_active", "type": "boolean", "default": true }
+  ],
+  "relationships": [
+    { "type": "hasMany", "model": "Post" }
+  ],
+  "controller": true,
+  "service": true,
+  "migration": true
+}
+
+FIELD TYPES:
+- string, text, longtext (text fields)
+- integer, int, bigint (numbers)
+- boolean, bool (true/false)
+- float, double, decimal (decimals)
+- date, datetime, timestamp (dates)
+- json (JSON/array data)
+- email (string with email validation)
+
+FIELD OPTIONS:
+- nullable: Allow NULL values
+- unique: Add unique constraint
+- required: Require in validation (default: true for store)
+- default: Default value
+- max: Maximum length/value
+
+RELATIONSHIP TYPES:
+- hasOne: One-to-one (User hasOne Profile)
+- hasMany: One-to-many (User hasMany Posts)
+- belongsTo: Inverse of hasOne/hasMany (Post belongsTo User)
+- belongsToMany: Many-to-many (User belongsToMany Roles)
+
+Returns UUIDs for all created files so you can customize them further if needed.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Resource name in PascalCase (e.g., "User", "BlogPost", "OrderItem")',
+                },
+                fields: {
+                    type: 'array',
+                    description: 'Array of field definitions for the model and migration',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: {
+                                type: 'string',
+                                description: 'Field name in snake_case (e.g., "first_name", "is_active")',
+                            },
+                            type: {
+                                type: 'string',
+                                enum: ['string', 'integer', 'int', 'bigint', 'boolean', 'bool', 'float', 'double', 'decimal', 'date', 'datetime', 'timestamp', 'text', 'longtext', 'json', 'email'],
+                                description: 'Field data type',
+                            },
+                            nullable: {
+                                type: 'boolean',
+                                description: 'Allow NULL values (default: false)',
+                            },
+                            unique: {
+                                type: 'boolean',
+                                description: 'Add unique constraint (default: false)',
+                            },
+                            required: {
+                                type: 'boolean',
+                                description: 'Require in validation for store action (default: true)',
+                            },
+                            default: {
+                                description: 'Default value for the field',
+                            },
+                            max: {
+                                type: 'integer',
+                                description: 'Maximum length/value for validation',
+                            },
+                        },
+                        required: ['name'],
+                    },
+                },
+                relationships: {
+                    type: 'array',
+                    description: 'Array of relationship definitions',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                enum: ['hasOne', 'hasMany', 'belongsTo', 'belongsToMany'],
+                                description: 'Relationship type',
+                            },
+                            model: {
+                                type: 'string',
+                                description: 'Related model name in PascalCase',
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Custom method name (defaults to camelCase of model)',
+                            },
+                        },
+                        required: ['type', 'model'],
+                    },
+                },
+                controller: {
+                    type: 'boolean',
+                    description: 'Create controller with CRUD actions (default: true)',
+                },
+                service: {
+                    type: 'boolean',
+                    description: 'Create service class for business logic (default: false)',
+                },
+                migration: {
+                    type: 'boolean',
+                    description: 'Create database migration (default: true)',
+                },
+                routes: {
+                    type: 'boolean',
+                    description: 'Create API routes (default: true)',
+                },
+                soft_deletes: {
+                    type: 'boolean',
+                    description: 'Add soft delete support to model and migration (default: false)',
+                },
+                api: {
+                    type: 'boolean',
+                    description: 'Generate API-style responses (default: true)',
+                },
+            },
+            required: ['name'],
+        },
+    },
     {
         name: 'run_code',
         description: `Execute a method in the Stellify project environment and return the output.
@@ -1122,6 +1270,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.
@@ -1136,7 +1345,34 @@ 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.`;
 // Create MCP server
 const server = new Server({
     name: 'stellify-mcp',
@@ -1691,6 +1927,59 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case 'create_resources': {
+                const result = await stellify.createResources(args);
+                const data = result.data || result;
+                const stats = data.statistics || {};
+                // Build summary of what was created
+                const created = [];
+                if (data.model)
+                    created.push(`Model (${data.model.uuid})`);
+                if (data.controller)
+                    created.push(`Controller (${data.controller.uuid})`);
+                if (data.service)
+                    created.push(`Service (${data.service.uuid})`);
+                if (data.migration)
+                    created.push(`Migration (${data.migration.uuid})`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Created ${args.name} resource: ${created.join(', ')} (${stats.files || 0} files, ${stats.methods || 0} methods)`,
+                                data: {
+                                    name: data.name,
+                                    model: data.model ? {
+                                        uuid: data.model.uuid,
+                                        name: data.model.name,
+                                        namespace: data.model.namespace,
+                                        methods: data.model.methods,
+                                    } : null,
+                                    controller: data.controller ? {
+                                        uuid: data.controller.uuid,
+                                        name: data.controller.name,
+                                        namespace: data.controller.namespace,
+                                        methods: data.controller.methods,
+                                    } : null,
+                                    service: data.service ? {
+                                        uuid: data.service.uuid,
+                                        name: data.service.name,
+                                        namespace: data.service.namespace,
+                                        methods: data.service.methods,
+                                    } : null,
+                                    migration: data.migration ? {
+                                        uuid: data.migration.uuid,
+                                        name: data.migration.name,
+                                        table: data.migration.table,
+                                    } : null,
+                                    statistics: stats,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             case 'run_code': {
                 const result = await stellify.runCode(args);
                 const benchmarkInfo = args.benchmark
@@ -1714,6 +2003,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

@@ -148,6 +148,29 @@ export declare class StellifyClient {
             changes: Record<string, any>;
         }>;
     }): Promise<any>;
+    createResources(params: {
+        name: string;
+        fields?: Array<{
+            name: string;
+            type?: string;
+            nullable?: boolean;
+            unique?: boolean;
+            required?: boolean;
+            default?: any;
+            max?: number;
+        }>;
+        relationships?: Array<{
+            type: 'hasOne' | 'hasMany' | 'belongsTo' | 'belongsToMany';
+            model: string;
+            name?: string;
+        }>;
+        controller?: boolean;
+        service?: boolean;
+        migration?: boolean;
+        routes?: boolean;
+        soft_deletes?: boolean;
+        api?: boolean;
+    }): Promise<any>;
     runCode(params: {
         file: string;
         method: string;
@@ -155,4 +178,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

@@ -172,6 +172,11 @@ export class StellifyClient {
         const response = await this.client.post('/elements/command', params);
         return response.data;
     }
+    // Resource scaffolding - create Model, Controller, Service, Migration in one call
+    async createResources(params) {
+        const response = await this.client.post('/resources', params);
+        return response.data;
+    }
     // Code execution - runs a specific method by file and method UUID
     async runCode(params) {
         const { file, method, ...body } = params;
@@ -181,4 +186,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.10",
+  "version": "0.1.12",
   "mcpName": "io.github.MattStellisoft/stellify-mcp",
   "description": "MCP server for Stellify - AI-native code generation platform",
   "main": "dist/index.js",