@stellisoft/stellify-mcp 0.1.24 → 0.1.26

package/dist/index.js

@@ -127,11 +127,15 @@ This creates an EMPTY file shell - no methods, statements, or template yet. The
 
 COMPLETE WORKFLOW:
 1. create_file → creates empty shell, returns file UUID
-2. create_statement + add_statement_code → add variables/imports (returns statement UUIDs)
-3. create_method + add_method_body → add functions (returns method UUIDs)
+2. create_statement_with_code → add variables/imports in ONE call (returns statement UUIDs)
+3. create_method with body param → add functions in ONE call (returns method UUIDs)
 4. html_to_elements → create template elements (returns element UUIDs)
 5. save_file → FINALIZE by wiring template/data arrays with all collected UUIDs
 
+LEGACY (still supported but prefer combined tools above):
+- create_statement + add_statement_code (2 calls instead of 1)
+- create_method + add_method_body + save_method for is_async (3 calls instead of 1)
+
 For PHP: Use type='class', 'model', 'controller', or 'middleware'.
 For Vue: Use type='js' and extension='vue'. Place in the 'js' directory.
 
@@ -180,11 +184,13 @@ The system resolves these to UUIDs automatically, creating missing dependencies
     },
     {
         name: 'create_method',
-        description: `Create a method signature in a file. This only creates the method declaration, not the body. Use add_method_body to add implementation.
+        description: `Create a method in a file. Can optionally include the body and async flag in a single call.
+
+**NEW: Combined creation** - You can now pass 'body' and 'is_async' to create the complete method in ONE call instead of three (create_method → add_method_body → save_method).
 
 Parameters are automatically created as clauses. The response includes the clause UUIDs for each parameter.
 
-Example request:
+Example request (simple - signature only):
 {
   "file": "file-uuid",
   "name": "verify",
@@ -196,14 +202,22 @@ Example request:
   ]
 }
 
+Example request (combined - with body and async):
+{
+  "file": "file-uuid",
+  "name": "fetchData",
+  "body": "const response = await Http.get('/api/data');\\nreturn response.data;",
+  "is_async": true
+}
+
 Example response includes:
 {
   "uuid": "method-uuid",
-  "name": "verify",
-  "returnType": "object",
-  "nullable": true,
+  "name": "fetchData",
+  "is_async": true,
   "parameters": ["clause-uuid-for-credentials"],
-  ...
+  "statements": {...},  // Only if body was provided
+  "clauses": {...}      // Only if body was provided
 }`,
         inputSchema: {
             type: 'object',
@@ -225,6 +239,10 @@ Example response includes:
                     type: 'boolean',
                     description: 'Whether the method is static (PHP only)',
                 },
+                is_async: {
+                    type: 'boolean',
+                    description: 'Whether the method is async (JavaScript/Vue only). Set to true for methods that use await.',
+                },
                 returnType: {
                     type: 'string',
                     description: 'Return type (e.g., "int", "string", "void", "object")',
@@ -259,6 +277,10 @@ Example response includes:
                         required: ['name'],
                     },
                 },
+                body: {
+                    type: 'string',
+                    description: 'Method body code (optional). If provided, automatically parses and adds the code. Example: "const response = await Http.get(\\"/api/data\\");\\nreturn response.data;"',
+                },
             },
             required: ['file', 'name'],
         },
@@ -294,12 +316,13 @@ IMPORTANT: This APPENDS to existing method statements. To REPLACE a method's cod
     },
     {
         name: 'save_method',
-        description: `Update an existing method's properties (name, visibility, returnType, nullable, parameters, data).
+        description: `Update an existing method's properties (name, visibility, returnType, nullable, parameters, data, is_async).
 
 Use this to modify a method after creation. For updating the method body, use add_method_body instead.
 
 Parameters:
 - data: Array of statement UUIDs that form the method body. Use this to reorder statements or remove unwanted statements from the method.
+- is_async: Set to true for JavaScript/Vue methods that use await.
 
 Example - Update return type:
 {
@@ -308,6 +331,12 @@ Example - Update return type:
   "nullable": true
 }
 
+Example - Mark method as async (for methods using await):
+{
+  "uuid": "method-uuid",
+  "is_async": true
+}
+
 Example - Remove duplicate/unwanted statements:
 {
   "uuid": "method-uuid",
@@ -351,6 +380,10 @@ Example - Remove duplicate/unwanted statements:
                     description: 'Array of statement UUIDs that form the method body. Use to reorder or remove statements.',
                     items: { type: 'string' },
                 },
+                is_async: {
+                    type: 'boolean',
+                    description: 'Whether the method is async (JavaScript/Vue only). Set to true for methods that use await.',
+                },
             },
             required: ['uuid'],
         },
@@ -374,16 +407,20 @@ Example - Remove duplicate/unwanted statements:
     },
     {
         name: 'delete_method',
-        description: 'Delete a method from a file by UUID. This permanently removes the method and all its code.',
+        description: 'Delete a method from a file by UUID. This permanently removes the method and all its code. Requires both the file UUID and method UUID.',
         inputSchema: {
             type: 'object',
             properties: {
+                file: {
+                    type: 'string',
+                    description: 'UUID of the file containing the method (required)',
+                },
                 uuid: {
                     type: 'string',
                     description: 'UUID of the method to delete',
                 },
             },
-            required: ['uuid'],
+            required: ['file', 'uuid'],
         },
     },
     {
@@ -784,6 +821,8 @@ Prefer SVG icons over emoji (encoding issues).`,
         name: 'create_statement',
         description: `Create an empty statement in a file. This is step 1 of 2 - you MUST call add_statement_code next to add the actual code.
 
+**ALTERNATIVE:** Use create_statement_with_code for a single-call approach that combines both steps.
+
 IMPORTANT: This is a TWO-STEP process:
 1. create_statement → returns statement UUID
 2. add_statement_code → adds the actual code to that statement
@@ -807,10 +846,42 @@ For Vue components, include the returned statement UUID in save_file's 'statemen
             },
         },
     },
+    {
+        name: 'create_statement_with_code',
+        description: `Create a statement with code in a SINGLE call. This combines create_statement and add_statement_code.
+
+**PREFERRED:** Use this instead of the two-step create_statement → add_statement_code process.
+
+Examples:
+- PHP: "use Illuminate\\Http\\Request;" or "private $items = [];"
+- JS/Vue: "const count = ref(0);" or "import { ref } from 'vue';"
+
+For Vue components, include the returned statement UUID in save_file's 'statements' array (NOT 'data' - that's for methods).`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file: {
+                    type: 'string',
+                    description: 'UUID of the file to add the statement to',
+                },
+                code: {
+                    type: 'string',
+                    description: 'The code for the statement (e.g., "const count = ref(0);")',
+                },
+                method: {
+                    type: 'string',
+                    description: 'UUID of the method to add the statement to (optional, for method body statements)',
+                },
+            },
+            required: ['file', 'code'],
+        },
+    },
     {
         name: 'add_statement_code',
         description: `Add code to an existing statement. This is step 2 of 2 - call this AFTER create_statement.
 
+**ALTERNATIVE:** Use create_statement_with_code for a single-call approach.
+
 The statement must already exist (created via create_statement). This parses and stores the code.
 
 Examples:
@@ -903,7 +974,12 @@ Vue SFC example:
     statements: [importStmtUuid, refStmtUuid]  // Statement UUIDs (imports, refs)
   })
 
-For <script setup> content, the order in statements array determines output order.`,
+For <script setup> content, the order in statements array determines output order.
+
+DEPENDENCY RESOLUTION (includes array):
+The 'includes' array accepts BOTH UUIDs and namespace strings.
+Namespace strings (e.g., "Illuminate\\Http\\JsonResponse") are automatically resolved to UUIDs.
+This works the same as create_file's dependency resolution.`,
         inputSchema: {
             type: 'object',
             properties: {
@@ -942,7 +1018,7 @@ For <script setup> content, the order in statements array determines output orde
                 includes: {
                     type: 'array',
                     items: { type: 'string' },
-                    description: 'Array of file UUIDs to import',
+                    description: 'Array of file UUIDs OR namespace strings to import. Namespace strings (e.g., "Illuminate\\\\Http\\\\JsonResponse") are auto-resolved to UUIDs.',
                 },
                 models: {
                     type: 'array',
@@ -975,12 +1051,16 @@ WARNING: This is destructive and cannot be undone. Make sure the file is not ref
         inputSchema: {
             type: 'object',
             properties: {
+                directory: {
+                    type: 'string',
+                    description: 'UUID of the directory containing the file (get from get_project directories array or get_file response)',
+                },
                 uuid: {
                     type: 'string',
                     description: 'UUID of the file to delete',
                 },
             },
-            required: ['uuid'],
+            required: ['directory', 'uuid'],
         },
     },
     {
@@ -1086,6 +1166,8 @@ Creates: Model ($fillable, $casts, relationships), Controller (CRUD actions), Se
 
 IMPORTANT: Routes are NOT auto-wired. After creation, use create_route with the returned controller UUID and method UUIDs.
 
+IMPORTANT: After creation, check the controller methods for return types and parameter types. If methods use classes not already in includes (e.g., JsonResponse), add those class UUIDs to the controller's includes via save_file.
+
 Response includes controller.methods array with {uuid, name} for each action (index, store, update, destroy).`,
         inputSchema: {
             type: 'object',
@@ -1378,7 +1460,7 @@ The response includes actionable suggestions like:
     },
 ];
 // 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.
+const SERVER_INSTRUCTIONS = `Stellify is a coding platform where you code alongside AI on a codebase maintained and curated by AI. Build Laravel, stellify-framework, and Vue.js applications.
 
 Use Stellify tools when:
 - Building PHP controllers, models, middleware, or classes
@@ -1404,18 +1486,33 @@ Key concepts:
 
 1. get_project → find 'js' directory UUID (or create it)
 2. create_file → type='js', extension='vue' for the component
-3. Create statements for imports:
-   - "import { ref } from 'vue';" (REQUIRED for ref())
-   - "import { Http, List } from 'stellify-framework';" (for Stellify classes)
+3. **Create a template route** for editor access:
+   - create_route with name like "notes-template" or "component-name-template"
+   - This route is NOT where the component displays - it's only for accessing the template in the Stellify visual editor
+   - The actual display route (e.g., "/notes") will have just \`<div id="app"></div>\` where Vue mounts
+4. Create statements for imports using **create_statement_with_code** (ONE call each):
+   - create_statement_with_code(file, "import { ref, onMounted } from 'vue';")
+   - create_statement_with_code(file, "import { Http } from 'stellify-framework';")
    NOTE: The npm package is "stellify-framework" (NOT @stellify/core)
-4. Create statements for data: "const count = ref(0);"
-5. create_method + add_method_body → functions
-6. html_to_elements → template (no 'page' param for components)
-7. update_element → wire click handlers to method UUIDs
-8. save_file with: extension='vue', template=[elementUuid], data=[methodUuids], statements=[importUuids, refUuids]
-9. **MANDATORY: Create app.js entry file** (see "CRITICAL: JavaScript Entry File" section below)
-10. Create web route for the page
-11. **MANDATORY: Add a div with id="app"** to the page using html_to_elements:
+5. Create statements for reactive data: create_statement_with_code(file, "const notes = ref([]);")
+6. **create_method with body and is_async** (ONE call instead of three). Example:
+   \`\`\`
+   create_method({
+     file: fileUuid,
+     name: "fetchNotes",
+     body: "const response = await Http.get('/api/notes');\\nnotes.value = response.data || [];",
+     is_async: true
+   })
+   \`\`\`
+7. Create statement for onMounted: create_statement_with_code(file, "onMounted(fetchNotes);")
+8. html_to_elements → template **with page=templateRouteUuid** (attach to the template route for editor access)
+9. update_element → wire click handlers to method UUIDs
+10. save_file with: extension='vue', template=[elementUuid], data=[methodUuids], statements=[importUuids, refUuids, onMountedUuid]
+    - **data = method UUIDs only** (functions)
+    - **statements = statement UUIDs** (imports, refs, onMounted)
+11. **MANDATORY: Create app.js entry file** (see "CRITICAL: JavaScript Entry File" section below)
+12. Create web route for the display page (e.g., "/notes")
+13. **MANDATORY: Add a div with id="app"** to the display page using html_to_elements:
     - html_to_elements with page=routeUuid and elements='<div id="app"></div>'
     - This is where Vue mounts the component. Without it, nothing renders!
 
@@ -1424,8 +1521,33 @@ Key concepts:
 Use for SHOW/DISPLAY/DEMONSTRATE requests - sends instant WebSocket updates to browser.
 Use html_to_elements/update_element for permanent/saved changes.
 
+## CRITICAL: Http Response Handling (Most Common Error)
+
+**This is the #1 cause of "notes not displaying" bugs.**
+
+When fetching data from API endpoints, stellify-framework's Http class returns the JSON body DIRECTLY - it does NOT wrap responses like axios does.
+
+Laravel pagination returns: \`{ data: [...items], current_page: 1, per_page: 15, ... }\`
+
+Since Http.get() returns this JSON directly (no axios wrapper), you access the array with ONE \`.data\`:
+
+\`\`\`javascript
+// CORRECT - Http returns JSON directly, .data gets the paginated array
+const response = await Http.get('/api/notes');
+notes.value = response.data || [];
+
+// WRONG - Double .data (axios habit) - returns undefined, notes stay empty!
+const response = await Http.get('/api/notes');
+notes.value = response.data.data || [];  // BUG: response.data.data is undefined
+\`\`\`
+
+**Why this mistake happens:** With axios, you write \`response.data.data\` because axios wraps the HTTP response (\`response.data\` unwraps axios, then \`.data\` gets the pagination array). Stellify's Http skips the wrapper, so you only need ONE \`.data\`.
+
+**Symptom:** Notes exist in database, API returns them, but UI shows empty list or "No notes yet" message.
+
 ## Common Pitfalls
 
+- **Vue template editor access:** Templates MUST be attached to a route for users to edit them in the visual editor. Create a separate "template route" (e.g., "notes-template") and pass its UUID to html_to_elements. This is different from the display route where the component renders.
 - **Stellify imports:** Use "stellify-framework" package (NOT @stellify/core)
   CORRECT: import { Http, List, Form } from 'stellify-framework';
   WRONG: import { Http } from '@stellify/core';
@@ -1434,33 +1556,50 @@ Use html_to_elements/update_element for permanent/saved changes.
 - add_method_body APPENDS, doesn't replace - create new method to replace
 - 'data' array = method UUIDs, 'statements' array = import/variable UUIDs
 - For buttons in forms, set inputType: "button" to prevent auto-submit
+- **Async methods:** Methods using await MUST be marked async. Use is_async: true in create_method (preferred) or save_method
+- **onMounted:** Use direct method reference: "onMounted(fetchNotes);"
+  The assembler automatically outputs lifecycle hooks after method definitions.
+
+## CRITICAL: Nullable Refs and v-if Guards
 
-## Framework Capabilities (Libraries/Packages)
+**This causes "Cannot read properties of null" errors.**
 
-**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.**
+When using a nullable ref (e.g., \`const editingNote = ref(null)\`) with v-model or property access in templates, you MUST guard with an explicit v-if that checks the ref is not null.
 
-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
+**WRONG - v-else does NOT protect against null evaluation:**
+\`\`\`html
+<template v-if="!editingItem">
+  <!-- view mode -->
+</template>
+<template v-else>
+  <input v-model="editingItem.title" />  <!-- ERROR: editingItem could be null -->
+</template>
+\`\`\`
 
-**WORKFLOW:**
+**CORRECT - explicit v-if with null check:**
+\`\`\`html
+<template v-if="!editingItem || editingItem.id !== item.id">
+  <!-- view mode -->
+</template>
+<template v-if="editingItem && editingItem.id === item.id">
+  <input v-model="editingItem.title" />  <!-- Safe: editingItem is guaranteed non-null -->
+</template>
+\`\`\`
 
-1. When a user requests functionality that might need a package/library, check the capabilities list from get_project FIRST.
+**Why v-else fails:** Vue evaluates v-model bindings during compilation/render setup, before the v-else condition is fully applied. The explicit v-if with \`editingItem &&\` ensures the binding is only evaluated when the ref exists.
 
-2. If status is "available" → package is installed, proceed with business logic.
+**Inline editing pattern (CRUD apps):**
+1. Create ref: \`const editingItem = ref(null);\`
+2. View template: \`v-if="!editingItem || editingItem.id !== item.id"\`
+3. Edit template: \`v-if="editingItem && editingItem.id === item.id"\` (NOT v-else!)
+4. Start editing: \`editingItem.value = { ...item };\`
+5. Cancel/save: \`editingItem.value = null;\`
 
-3. If status is "needs_config" → package installed but needs API keys. INFORM THE USER to configure it in Project Settings.
+## Stack and Business Logic
 
-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."
+**Default stack:** Laravel (PHP), stellify-framework (JS), and Vue.js. Available capabilities (optional packages/libraries) are returned by \`get_project\`. Use \`get_stellify_framework_api\` for the stellify-framework API reference.
 
-**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.
+**All business logic** (controllers, models, middleware, etc.) goes in the tenant DB via MCP tools. If a required capability is not available, use \`request_capability\` to log it.
 
 ## Project Modules (Code Organization)
 
@@ -1520,7 +1659,7 @@ Example app.js structure:
 // Create MCP server
 const server = new Server({
     name: 'stellify-mcp',
-    version: '0.1.24',
+    version: '0.1.26',
 }, {
     capabilities: {
         tools: {},
@@ -1599,15 +1738,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'create_method': {
                 const result = await stellify.createMethod(args);
                 const methodData = result.data || result;
+                const hasBody = !!args.body;
+                const response = {
+                    success: true,
+                    message: hasBody
+                        ? `Created method "${args.name}" with body (UUID: ${methodData.uuid})`
+                        : `Created method "${args.name}" (UUID: ${methodData.uuid})`,
+                    method: methodData,
+                };
+                // Include statements and clauses if body was provided
+                if (result.statements) {
+                    response.statements = result.statements;
+                }
+                if (result.clauses) {
+                    response.clauses = result.clauses;
+                }
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Created method "${args.name}" (UUID: ${methodData.uuid})`,
-                                method: methodData,
-                            }, null, 2),
+                            text: JSON.stringify(response, null, 2),
                         },
                     ],
                 };
@@ -1658,15 +1808,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'delete_method': {
-                const { uuid } = args;
-                const result = await stellify.deleteMethod(uuid);
+                const { file, uuid } = args;
+                const result = await stellify.deleteMethod(file, uuid);
                 return {
                     content: [
                         {
                             type: 'text',
                             text: JSON.stringify({
                                 success: true,
-                                message: `Deleted method ${uuid}`,
+                                message: `Deleted method ${uuid} from file ${file}`,
                                 data: result,
                             }, null, 2),
                         },
@@ -1929,6 +2079,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case 'create_statement_with_code': {
+                const result = await stellify.createStatementWithCode(args);
+                const statementData = result.data || result;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Created statement with code (UUID: ${statementData.uuid})`,
+                                statement: statementData.statement || statementData,
+                                statements: statementData.statements,
+                                clauses: statementData.clauses,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             case 'add_statement_code': {
                 const result = await stellify.addStatementCode(args);
                 return {
@@ -2008,15 +2176,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case 'delete_file': {
-                const { uuid } = args;
-                const result = await stellify.deleteFile(uuid);
+                const { directory, uuid } = args;
+                const result = await stellify.deleteFile(directory, uuid);
                 return {
                     content: [
                         {
                             type: 'text',
                             text: JSON.stringify({
                                 success: true,
-                                message: `Deleted file ${uuid}`,
+                                message: `Deleted file ${uuid} from directory ${directory}`,
                                 data: result,
                             }, null, 2),
                         },

package/dist/stellify-client.d.ts

@@ -17,11 +17,16 @@ export interface CreateMethodParams {
     name: string;
     visibility?: 'public' | 'protected' | 'private';
     is_static?: boolean;
+    is_async?: boolean;
     returnType?: string;
+    nullable?: boolean;
     parameters?: Array<{
         name: string;
-        type: string;
+        type?: string;
+        datatype?: string;
+        value?: string;
     }>;
+    body?: string;
 }
 export interface AddMethodBodyParams {
     file: string;
@@ -76,14 +81,19 @@ export declare class StellifyClient {
     searchFiles(params: SearchFilesParams): Promise<any>;
     getFile(file: string): Promise<any>;
     saveFile(file: string, data: any): Promise<any>;
-    deleteFile(file: string): Promise<any>;
+    deleteFile(directory: string, file: string): Promise<any>;
     getMethod(method: string): Promise<any>;
     saveMethod(method: string, data: any): Promise<any>;
-    deleteMethod(method: string): Promise<any>;
+    deleteMethod(file: string, method: string): Promise<any>;
     createStatement(params: {
         file?: string;
         method?: string;
     }): Promise<any>;
+    createStatementWithCode(params: {
+        file: string;
+        code: string;
+        method?: string;
+    }): Promise<any>;
     getStatement(statement: string): Promise<any>;
     deleteStatement(file: string, method: string, statement: string): Promise<any>;
     saveStatement(statement: string, data: any): Promise<any>;

package/dist/stellify-client.js

@@ -43,8 +43,8 @@ export class StellifyClient {
         const response = await this.client.put(`/file/${file}`, data);
         return response.data;
     }
-    async deleteFile(file) {
-        const response = await this.client.delete(`/file/${file}`);
+    async deleteFile(directory, file) {
+        const response = await this.client.delete(`/file/${directory}/${file}`);
         return response.data;
     }
     async getMethod(method) {
@@ -55,14 +55,19 @@ export class StellifyClient {
         const response = await this.client.put(`/method/${method}`, data);
         return response.data;
     }
-    async deleteMethod(method) {
-        const response = await this.client.delete(`/method/${method}`);
+    async deleteMethod(file, method) {
+        const response = await this.client.delete(`/method/${file}/${method}`);
         return response.data;
     }
     async createStatement(params) {
         const response = await this.client.post('/statement', params);
         return response.data;
     }
+    // NEW: Combined create statement with code in a single call
+    async createStatementWithCode(params) {
+        const response = await this.client.post('/statement/with-code', params);
+        return response.data;
+    }
     async getStatement(statement) {
         const response = await this.client.get(`/statement/${statement}`);
         return response.data;

package/package.json

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

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/Stellify-Software-Ltd/stellify-mcp",
     "source": "github"
   },
-  "version": "0.1.24",
+  "version": "0.1.26",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@stellisoft/stellify-mcp",
-      "version": "0.1.24",
+      "version": "0.1.26",
       "transport": {
         "type": "stdio"
       },