@stellisoft/stellify-mcp 0.1.2 → 0.1.5

package/dist/stellify-client.d.ts

@@ -1,3 +1,4 @@
+import { AxiosInstance } from 'axios';
 export interface StellifyConfig {
     apiUrl: string;
     apiToken: string;
@@ -5,8 +6,11 @@ export interface StellifyConfig {
 export interface CreateFileParams {
     directory?: string;
     name: string;
-    type: 'class' | 'model' | 'controller' | 'middleware';
+    type: 'class' | 'model' | 'controller' | 'middleware' | 'js';
     namespace?: string;
+    extension?: string;
+    code?: string;
+    auto_create_dependencies?: boolean;
 }
 export interface CreateMethodParams {
     file: string;
@@ -20,13 +24,13 @@ export interface CreateMethodParams {
     }>;
 }
 export interface AddMethodBodyParams {
-    file_uuid: string;
-    method_uuid: string;
+    file: string;
+    method: string;
     code: string;
 }
 export interface SearchMethodsParams {
     name?: string;
-    file_uuid?: string;
+    file?: string;
 }
 export interface SearchFilesParams {
     query: string;
@@ -42,14 +46,106 @@ export interface SearchFilesParams {
     sort?: 'created_at' | 'name' | 'type' | 'ai_rating' | 'usage_rating' | 'system_rating' | 'user_name';
     direction?: 'asc' | 'desc';
 }
+export interface CreateRouteParams {
+    project_id: string;
+    name: string;
+    path: string;
+    method: string;
+    type?: string;
+    data?: any;
+}
+export interface CreateElementParams {
+    type: string;
+    page?: string;
+    parent?: string;
+}
 export declare class StellifyClient {
-    private client;
+    client: AxiosInstance;
     constructor(config: StellifyConfig);
     createFile(params: CreateFileParams): Promise<any>;
     createMethod(params: CreateMethodParams): Promise<any>;
     addMethodBody(params: AddMethodBodyParams): Promise<any>;
+    addStatementCode(params: {
+        file: string;
+        statement: string;
+        code: string;
+    }): Promise<any>;
     searchMethods(params: SearchMethodsParams): Promise<any>;
     searchFiles(params: SearchFilesParams): Promise<any>;
-    getFile(uuid: string): Promise<any>;
-    getMethod(uuid: string): Promise<any>;
+    getFile(file: string): Promise<any>;
+    saveFile(file: string, data: any): Promise<any>;
+    getMethod(method: string): Promise<any>;
+    saveMethod(method: string, data: any): Promise<any>;
+    createStatement(params: {
+        file?: string;
+        method?: string;
+    }): Promise<any>;
+    getStatement(statement: string): Promise<any>;
+    saveStatement(statement: string, data: any): Promise<any>;
+    createRoute(params: CreateRouteParams): Promise<any>;
+    getRoute(route: string): Promise<any>;
+    searchRoutes(params: {
+        search?: string;
+        type?: string;
+    }): Promise<any>;
+    createElement(params: CreateElementParams): Promise<any>;
+    updateElement(element: string, data: any): Promise<any>;
+    getElement(element: string): Promise<any>;
+    getElementTree(element: string): Promise<any>;
+    deleteElement(route: string, current?: string, element?: string): Promise<any>;
+    searchElements(params: {
+        search?: string;
+        type?: string;
+        include_metadata?: boolean;
+        per_page?: number;
+    }): Promise<any>;
+    htmlToElements(params: {
+        elements: string;
+        page?: string;
+        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;
+    }): Promise<any>;
+    saveDirectory(uuid: string, data: any): Promise<any>;
+    getProject(): Promise<any>;
+    broadcastElementCommand(params: {
+        action: 'update' | 'batch' | 'delete' | 'create';
+        element?: string;
+        changes?: Record<string, any>;
+        updates?: Array<{
+            element: string;
+            changes: Record<string, any>;
+        }>;
+    }): Promise<any>;
 }

package/dist/stellify-client.js

@@ -23,6 +23,10 @@ export class StellifyClient {
         const response = await this.client.post('/code', params);
         return response.data;
     }
+    async addStatementCode(params) {
+        const response = await this.client.post('/code', params);
+        return response.data;
+    }
     async searchMethods(params) {
         const response = await this.client.get('/method/search', { params });
         return response.data;
@@ -31,12 +35,143 @@ export class StellifyClient {
         const response = await this.client.get('/file/search', { params });
         return response.data;
     }
-    async getFile(uuid) {
-        const response = await this.client.get(`/file/${uuid}`);
+    async getFile(file) {
+        const response = await this.client.get(`/file/${file}`);
+        return response.data;
+    }
+    async saveFile(file, data) {
+        const response = await this.client.put(`/file/${file}`, data);
+        return response.data;
+    }
+    async getMethod(method) {
+        const response = await this.client.get(`/method/${method}`);
+        return response.data;
+    }
+    async saveMethod(method, data) {
+        const response = await this.client.put(`/method/${method}`, data);
+        return response.data;
+    }
+    async createStatement(params) {
+        const response = await this.client.post('/statement', params);
+        return response.data;
+    }
+    async getStatement(statement) {
+        const response = await this.client.get(`/statement/${statement}`);
+        return response.data;
+    }
+    async saveStatement(statement, data) {
+        const response = await this.client.put(`/statement/${statement}`, data);
+        return response.data;
+    }
+    async createRoute(params) {
+        const response = await this.client.post('/route', params);
+        return response.data;
+    }
+    async getRoute(route) {
+        const response = await this.client.get(`/route/${route}`);
+        return response.data;
+    }
+    async searchRoutes(params) {
+        const response = await this.client.get('/route/search', { params });
+        return response.data;
+    }
+    async createElement(params) {
+        const response = await this.client.post('/element', params);
+        return response.data;
+    }
+    async updateElement(element, data) {
+        const response = await this.client.put(`/element/${element}`, data);
+        return response.data;
+    }
+    async getElement(element) {
+        const response = await this.client.get(`/element/${element}`);
+        return response.data;
+    }
+    async getElementTree(element) {
+        const response = await this.client.get(`/element/${element}/tree`);
+        return response.data;
+    }
+    async deleteElement(route, current, element) {
+        const routeParam = route || 'null';
+        const currentParam = current || 'null';
+        const response = await this.client.delete(`/element/${routeParam}/${currentParam}/${element}`);
+        return response.data;
+    }
+    async searchElements(params) {
+        const response = await this.client.get('/element/search', { params });
+        return response.data;
+    }
+    async htmlToElements(params) {
+        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}`);
+        return response.data;
+    }
+    async createDirectory(params) {
+        const response = await this.client.post('/directory', params);
+        return response.data;
+    }
+    async saveDirectory(uuid, data) {
+        const response = await this.client.put(`/directory/${uuid}`, { uuid, data });
+        return response.data;
+    }
+    // Project methods
+    async getProject() {
+        const response = await this.client.get('/getProject');
         return response.data;
     }
-    async getMethod(uuid) {
-        const response = await this.client.get(`/method/${uuid}`);
+    // Element command broadcast (real-time UI updates via WebSocket)
+    async broadcastElementCommand(params) {
+        const response = await this.client.post('/elements/command', params);
         return response.data;
     }
 }

package/manifest.json

@@ -0,0 +1,92 @@
+{
+  "manifest_version": "0.3",
+  "name": "stellify-mcp",
+  "display_name": "Stellify MCP",
+  "version": "0.1.2",
+  "description": "Build Laravel and Vue.js apps through conversation with AI-native structured code editing",
+  "long_description": "Stellify MCP bridges Claude with Stellify - an AI-native code generation platform. Unlike traditional file-based code, Stellify stores code as structured JSON in a database, enabling:\n\n- **Surgical, statement-level edits** - AI can modify specific code statements without risk of breaking surrounding code\n- **Queryable code** - Find all methods using a specific class, trace dependencies instantly\n- **34 specialized tools** for project management, file/method creation, Vue component building, UI elements, and a reusable code library\n- **Incremental development workflow** - Build applications step-by-step with full type safety\n\nSupports Laravel/PHP (controllers, models, middleware) and Vue.js (reactive components, event handlers, templates).",
+  "author": {
+    "name": "Stellisoft",
+    "email": "stellifysoftware@gmail.com",
+    "url": "https://stellisoft.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Stellify-Software-Ltd/stellify-mcp.git"
+  },
+  "homepage": "https://stellisoft.com",
+  "documentation": "https://github.com/Stellify-Software-Ltd/stellify-mcp#readme",
+  "support": "https://github.com/Stellify-Software-Ltd/stellify-mcp/issues",
+  "keywords": ["laravel", "vue", "php", "code-generation", "ai-native", "structured-code"],
+  "license": "MIT",
+  "server": {
+    "type": "node",
+    "entry_point": "dist/index.js",
+    "mcp_config": {
+      "command": "node",
+      "args": ["${__dirname}/dist/index.js"],
+      "env": {
+        "STELLIFY_API_URL": "${user_config.api_url}",
+        "STELLIFY_API_TOKEN": "${user_config.api_token}"
+      }
+    }
+  },
+  "tools": [
+    {"name": "get_project", "description": "Get the active project and directory structure"},
+    {"name": "create_file", "description": "Create a new file (class, model, controller, middleware, or Vue.js)"},
+    {"name": "get_file", "description": "Retrieve a file with all methods and statements"},
+    {"name": "save_file", "description": "Finalize file configuration"},
+    {"name": "get_directory", "description": "List directory contents"},
+    {"name": "create_directory", "description": "Create a new directory"},
+    {"name": "search_files", "description": "Find files by name or type"},
+    {"name": "create_method", "description": "Create method signatures with type hints"},
+    {"name": "add_method_body", "description": "Add implementation code to methods"},
+    {"name": "search_methods", "description": "Find methods by name or file"},
+    {"name": "create_statement", "description": "Create statements (non-method code)"},
+    {"name": "add_statement_code", "description": "Add code to statements"},
+    {"name": "get_statement", "description": "Retrieve statement with clauses"},
+    {"name": "create_route", "description": "Create new routes (web pages or API endpoints)"},
+    {"name": "get_route", "description": "Retrieve route details"},
+    {"name": "search_routes", "description": "Search for existing routes"},
+    {"name": "create_element", "description": "Create UI elements on pages"},
+    {"name": "update_element", "description": "Update elements with attributes and event handlers"},
+    {"name": "get_element", "description": "Retrieve a single element"},
+    {"name": "get_element_tree", "description": "Get element with full hierarchical structure"},
+    {"name": "delete_element", "description": "Delete element and children"},
+    {"name": "search_elements", "description": "Search elements by name, type, or content"},
+    {"name": "html_to_elements", "description": "Convert HTML to Stellify elements in one operation"},
+    {"name": "list_globals", "description": "List reusable code in application database"},
+    {"name": "get_global", "description": "Get full global file structure"},
+    {"name": "install_global", "description": "Install global file into project"},
+    {"name": "search_global_methods", "description": "Search framework/global methods"},
+    {"name": "list_modules", "description": "List available module packages"},
+    {"name": "get_module", "description": "Get module with all files"},
+    {"name": "create_module", "description": "Create new module for grouping globals"},
+    {"name": "add_file_to_module", "description": "Add file to module"},
+    {"name": "install_module", "description": "Install entire module into project"}
+  ],
+  "tools_generated": false,
+  "compatibility": {
+    "claude_desktop": ">=1.0.0",
+    "platforms": ["darwin", "win32", "linux"],
+    "runtimes": {
+      "node": ">=18.0.0"
+    }
+  },
+  "user_config": {
+    "api_token": {
+      "type": "string",
+      "title": "Stellify API Token",
+      "description": "Your Stellify API token (get from stellisoft.com/settings/tokens)",
+      "sensitive": true,
+      "required": true
+    },
+    "api_url": {
+      "type": "string",
+      "title": "Stellify API URL",
+      "description": "Stellify API endpoint URL",
+      "required": false,
+      "default": "https://stellisoft.com/api/v1"
+    }
+  }
+}

package/package.json

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

package/test-elements.js

@@ -0,0 +1,96 @@
+import { StellifyClient } from './dist/stellify-client.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const client = new StellifyClient({
+  apiUrl: process.env.STELLIFY_API_URL,
+  apiToken: process.env.STELLIFY_API_TOKEN,
+});
+
+const PROJECT_ID = 'b11ba1ac-ad5e-45c7-8285-57f0b7aa0196';
+
+async function testElements() {
+  console.log('Testing Stellify Element Creation with UUID...\n');
+
+  try {
+    // Test 1: Create a test route first
+    console.log('1. Creating test route...');
+    const timestamp = Date.now();
+    const route = await client.createRoute({
+      project_id: PROJECT_ID,
+      name: `Test Page ${timestamp}`,
+      path: `/test-elements-${timestamp}`,
+      method: 'GET',
+      type: 'web',
+    });
+    console.log('✅ Route created:', route.data.uuid);
+    console.log('');
+
+    // Test 2: Create an element on that route
+    console.log('2. Creating element (s-wrapper)...');
+    const element = await client.createElement({
+      page: route.data.uuid,
+      type: 's-wrapper',
+    });
+    console.log('✅ Element created:', JSON.stringify(element, null, 2));
+    console.log('');
+
+    // Test 3: Verify UUID is in the element data
+    console.log('3. Verifying UUID in element data...');
+    if (element.data && element.data.uuid) {
+      console.log('✅ UUID found at root level:', element.data.uuid);
+      console.log('   Matches element UUID:', element.uuid === element.data.uuid ? '✅ YES' : '❌ NO');
+    } else {
+      console.log('❌ UUID NOT found in element.data');
+      console.log('   Element data structure:', JSON.stringify(element.data, null, 2));
+    }
+    console.log('');
+
+    // Test 3b: Verify route's data array contains the element UUID
+    console.log('3b. Verifying route contains element UUID...');
+    const routeCheck = await client.client.get(`/route/${route.data.uuid}`);
+    const routeData = routeCheck.data.data;
+    if (routeData.data && Array.isArray(routeData.data) && routeData.data.includes(element.data.uuid)) {
+      console.log('✅ Route data array contains element UUID');
+      console.log('   Route data array:', routeData.data);
+    } else {
+      console.log('❌ Route data array does NOT contain element UUID');
+      console.log('   Route data:', JSON.stringify(routeData, null, 2));
+    }
+    console.log('');
+
+    // Test 4: Create a child element
+    console.log('4. Creating child element (s-input)...');
+    const childElement = await client.createElement({
+      type: 's-input',
+      parent: element.data.uuid,
+    });
+    console.log('✅ Child element created:', childElement.data.uuid);
+
+    // Verify child UUID
+    if (childElement.data && childElement.data.uuid) {
+      console.log('✅ UUID found in child element.data:', childElement.data.uuid);
+      console.log('   Has parent reference:', childElement.data.parent ? '✅ YES (' + childElement.data.parent + ')' : '❌ NO');
+    } else {
+      console.log('❌ UUID NOT found in child element.data');
+    }
+    console.log('');
+
+    console.log('🎉 Element creation test complete!');
+    console.log('\nCreated Resources:');
+    console.log(`  Route: ${route.data.uuid} (${route.data.path})`);
+    console.log(`  Parent Element: ${element.data.uuid}`);
+    console.log(`  Child Element: ${childElement.data.uuid}`);
+
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    if (error.response) {
+      console.error('Response data:', JSON.stringify(error.response.data, null, 2));
+      console.error('Response status:', error.response.status);
+    }
+    process.exit(1);
+  }
+}
+
+testElements();

package/test-full-workflow.js

@@ -0,0 +1,118 @@
+import { StellifyClient } from './dist/stellify-client.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const client = new StellifyClient({
+  apiUrl: process.env.STELLIFY_API_URL,
+  apiToken: process.env.STELLIFY_API_TOKEN,
+});
+
+const PROJECT_ID = 'b11ba1ac-ad5e-45c7-8285-57f0b7aa0196';
+
+async function testFullWorkflow() {
+  console.log('Testing Full Element Workflow: Create → Update with Attributes\n');
+
+  try {
+    // Step 1: Create route
+    console.log('1. Creating test route...');
+    const timestamp = Date.now();
+    const route = await client.createRoute({
+      project_id: PROJECT_ID,
+      name: `Contact Form ${timestamp}`,
+      path: `/contact-${timestamp}`,
+      method: 'GET',
+      type: 'web',
+    });
+    console.log('✅ Route created:', route.data.uuid);
+    console.log('');
+
+    // Step 2: Create form wrapper
+    console.log('2. Creating form wrapper (s-form)...');
+    const form = await client.createElement({
+      page: route.data.uuid,
+      type: 's-form',
+    });
+    console.log('✅ Form created:', form.data.uuid);
+    console.log('');
+
+    // Step 3: Update form with attributes
+    console.log('3. Updating form with HTML attributes...');
+    const updatedForm = await client.updateElement(form.data.uuid, {
+      name: 'Contact Form',
+      tag: 'form',
+      method: 'POST',
+      action: '/api/contact',
+      classes: ['space-y-4', 'max-w-md', 'mx-auto'],
+    });
+    console.log('✅ Form updated with attributes');
+    console.log('   Form data:', JSON.stringify(updatedForm.data, null, 2));
+    console.log('');
+
+    // Step 4: Create email input
+    console.log('4. Creating email input (s-input)...');
+    const emailInput = await client.createElement({
+      parent: form.data.uuid,
+      type: 's-input',
+    });
+    console.log('✅ Email input created:', emailInput.data.uuid);
+    console.log('');
+
+    // Step 5: Update email input with full attributes
+    console.log('5. Configuring email input with HTML attributes...');
+    const updatedEmail = await client.updateElement(emailInput.data.uuid, {
+      name: 'Email Field',
+      tag: 'input',
+      type: 'email',
+      placeholder: 'Enter your email',
+      required: true,
+      classes: ['form-input', 'w-full', 'px-4', 'py-2', 'border', 'rounded'],
+    });
+    console.log('✅ Email input configured');
+    console.log('   Input data:', JSON.stringify(updatedEmail.data, null, 2));
+    console.log('');
+
+    // Step 6: Create submit button
+    console.log('6. Creating submit button (s-wrapper)...');
+    const button = await client.createElement({
+      parent: form.data.uuid,
+      type: 's-wrapper',
+    });
+    console.log('✅ Button created:', button.data.uuid);
+    console.log('');
+
+    // Step 7: Update button with attributes
+    console.log('7. Configuring button with HTML attributes...');
+    const updatedButton = await client.updateElement(button.data.uuid, {
+      name: 'Submit Button',
+      tag: 'button',
+      type: 'submit',
+      text: 'Send Message',
+      classes: ['bg-blue-500', 'text-white', 'px-6', 'py-2', 'rounded', 'hover:bg-blue-600'],
+    });
+    console.log('✅ Button configured');
+    console.log('   Button data:', JSON.stringify(updatedButton.data, null, 2));
+    console.log('');
+
+    console.log('🎉 Full workflow test complete!');
+    console.log('\n📋 Summary:');
+    console.log(`  Route: ${route.data.uuid} (${route.data.path})`);
+    console.log(`  Form: ${form.data.uuid}`);
+    console.log(`  Email Input: ${emailInput.data.uuid}`);
+    console.log(`  Submit Button: ${button.data.uuid}`);
+    console.log('\n✨ Successfully built a complete contact form with:');
+    console.log('   - Form wrapper with POST action');
+    console.log('   - Email input with validation');
+    console.log('   - Submit button with styling');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    if (error.response) {
+      console.error('Response data:', JSON.stringify(error.response.data, null, 2));
+      console.error('Response status:', error.response.status);
+    }
+    process.exit(1);
+  }
+}
+
+testFullWorkflow();