gufi-cli 0.1.25 → 0.1.27

package/dist/mcp.js

@@ -122,6 +122,204 @@ async function developerRequest(path, options = {}, retry = true) {
     return res.json();
 }
 // ════════════════════════════════════════════════════════════════════════════
+// File Field Normalization
+// ════════════════════════════════════════════════════════════════════════════
+/**
+ * MIME types by extension
+ */
+const MIME_TYPES = {
+    // Images
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    // Documents
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    // Other
+    json: "application/json",
+    xml: "application/xml",
+    zip: "application/zip",
+    txt: "text/plain",
+    csv: "text/csv",
+};
+/**
+ * Get MIME type from filename extension
+ */
+function getMimeFromFilename(filename) {
+    const ext = filename.split(".").pop()?.toLowerCase() || "";
+    return MIME_TYPES[ext] || "application/octet-stream";
+}
+/**
+ * Generate unique file ID
+ */
+function generateFileId() {
+    return `file_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Normalize a single file object - ensures all required fields are present
+ * Input: { url, name } (minimum required)
+ * Output: { id, url, name, mime, uploaded_at }
+ */
+function normalizeFileObject(file) {
+    // Validate required fields
+    if (!file.url || typeof file.url !== "string") {
+        throw new Error("File field error: 'url' is required and must be a string");
+    }
+    if (!file.name || typeof file.name !== "string") {
+        throw new Error("File field error: 'name' is required and must be a string");
+    }
+    // Validate url format (must be company_X/... path or full URL)
+    const isValidPath = file.url.startsWith("company_") || file.url.startsWith("http");
+    if (!isValidPath) {
+        throw new Error(`File field error: 'url' must start with 'company_X/' or be a full URL. Got: ${file.url}`);
+    }
+    // Return normalized object with auto-generated fields
+    return {
+        id: file.id || generateFileId(),
+        url: file.url,
+        name: file.name,
+        mime: file.mime || getMimeFromFilename(file.name),
+        uploaded_at: file.uploaded_at || new Date().toISOString(),
+    };
+}
+/**
+ * Normalize file fields in data object
+ * Detects file fields (arrays with objects containing 'url') and normalizes them
+ */
+function normalizeFileFields(data) {
+    if (!data || typeof data !== "object")
+        return data;
+    const normalized = { ...data };
+    for (const [key, value] of Object.entries(normalized)) {
+        // Check if it's a file field (array with objects containing 'url')
+        if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object" && value[0] !== null) {
+            // Check if first item has 'url' property (indicates file field)
+            if ("url" in value[0]) {
+                normalized[key] = value.map(normalizeFileObject);
+            }
+        }
+    }
+    return normalized;
+}
+// ════════════════════════════════════════════════════════════════════════════
+// Relation Field Validation
+// ════════════════════════════════════════════════════════════════════════════
+/**
+ * Extract entity ID from table name (e.g., "m617_t20413" → "20413")
+ */
+function extractEntityIdFromTable(tableName) {
+    const match = tableName.match(/m\d+_t(\d+)/);
+    return match ? match[1] : null;
+}
+/**
+ * Cache for entity schemas to avoid repeated API calls
+ */
+const entitySchemaCache = new Map();
+const CACHE_TTL = 60000; // 1 minute
+/**
+ * Get entity schema with caching
+ */
+async function getEntitySchema(entityId, companyId) {
+    const cacheKey = `${companyId}:${entityId}`;
+    const cached = entitySchemaCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        return cached.fields;
+    }
+    try {
+        const data = await apiRequest(`/api/schema/entities/${entityId}`, {
+            headers: { "X-Company-ID": companyId },
+        }, companyId);
+        const fields = data.fields || [];
+        entitySchemaCache.set(cacheKey, { fields, timestamp: Date.now() });
+        return fields;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Resolve a reference path (e.g., "ecommerce.clientes") to a table name
+ */
+async function resolveRefToTable(ref, companyId) {
+    try {
+        const schemaData = await apiRequest("/api/company/schema", {
+            headers: { "X-Company-ID": companyId },
+        }, companyId);
+        const modules = schemaData.modules || schemaData.data?.modules || [];
+        const [moduleName, entityName] = ref.split(".");
+        for (const mod of modules) {
+            if (mod.name !== moduleName)
+                continue;
+            for (const sub of mod.submodules || []) {
+                for (const ent of sub.entities || []) {
+                    if (ent.name === entityName) {
+                        return ent.ui?.tableName || `m${ent.ui?.moduleId}_t${ent.ui?.entityId}`;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors, validation is best-effort
+    }
+    return null;
+}
+/**
+ * Validate relation fields in data - checks if referenced IDs exist
+ * Returns { valid: true } or { valid: false, errors: [...] }
+ */
+async function validateRelationFields(tableName, companyId, data) {
+    const errors = [];
+    // Extract entity ID from table name
+    const entityId = extractEntityIdFromTable(tableName);
+    if (!entityId) {
+        return { valid: true, errors: [] }; // Can't validate without entity ID
+    }
+    // Get entity schema to find relation fields
+    const fields = await getEntitySchema(entityId, companyId);
+    if (!fields.length) {
+        return { valid: true, errors: [] }; // Can't validate without schema
+    }
+    // Find relation fields
+    const relationFields = fields.filter((f) => f.type === "relation" && f.settings?.ref);
+    for (const field of relationFields) {
+        const fieldName = field.name;
+        const value = data[fieldName];
+        // Skip if no value provided
+        if (value === undefined || value === null || value === "")
+            continue;
+        // Get the ID to validate
+        const refId = typeof value === "object" ? value.id : value;
+        if (!refId || typeof refId !== "number")
+            continue;
+        // Resolve the reference to a table name
+        const refTable = await resolveRefToTable(field.settings.ref, companyId);
+        if (!refTable)
+            continue;
+        // Check if the ID exists in the referenced table
+        try {
+            const result = await apiRequest(`/api/tables/${refTable}/getOne`, {
+                method: "POST",
+                body: JSON.stringify({ id: refId }),
+            }, companyId);
+            if (!result || !result.data) {
+                errors.push(`Relation '${fieldName}': ID ${refId} does not exist in ${field.settings.ref}`);
+            }
+        }
+        catch (e) {
+            // If we get an error, the ID probably doesn't exist
+            errors.push(`Relation '${fieldName}': ID ${refId} not found in ${field.settings.ref} (${e.message || 'not found'})`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+// ════════════════════════════════════════════════════════════════════════════
 // Tool Definitions - Descriptions loaded from docs/mcp/tool-descriptions.json
 // ════════════════════════════════════════════════════════════════════════════
 // Load tool descriptions from centralized documentation
@@ -172,8 +370,35 @@ const TOOLS = [
             type: "object",
             properties: {
                 company_id: { type: "string", description: "Company ID (optional if user has only one company)" },
-                module_id: { type: "string", description: "Filter by specific module ID" },
+                format: { type: "string", description: "Output format: 'flat' (text, default) or 'json' (structured)" },
+            },
+        },
+    },
+    {
+        name: "gufi_schema_modify",
+        description: getDesc("gufi_schema_modify"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                company_id: { type: "string", description: "Company ID (optional if user has only one company)" },
+                preview: { type: "boolean", description: "If true, show what would be done without executing (dry run)" },
+                operations: {
+                    type: "array",
+                    description: "Array of operations to execute",
+                    items: {
+                        type: "object",
+                        properties: {
+                            op: { type: "string", description: "Operation: add_field, update_field, remove_field, add_entity, update_entity, remove_entity" },
+                            entity: { type: "string", description: "Entity reference: id, name, or 'module.entity'" },
+                            module: { type: "string", description: "Module reference (for add_entity)" },
+                            field: { type: "object", description: "Field definition (for add_field)" },
+                            field_name: { type: "string", description: "Field name (for update_field, remove_field)" },
+                            changes: { type: "object", description: "Changes to apply (for update_*)" },
+                        },
+                    },
+                },
             },
+            required: ["operations"],
         },
     },
     {
@@ -226,33 +451,47 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
-                module_id: { type: "string", description: "Module ID (auto-detects company)" },
+                module_id: { type: "string", description: "Module ID" },
+                company_id: { type: "string", description: "Company ID (required - module IDs are local per company)" },
             },
-            required: ["module_id"],
+            required: ["module_id", "company_id"],
         },
     },
     {
-        name: "gufi_module_update",
-        description: getDesc("gufi_module_update"),
+        name: "gufi_entity",
+        description: getDesc("gufi_entity"),
         inputSchema: {
             type: "object",
             properties: {
-                module_id: { type: "string", description: "Module ID" },
-                definition: { type: "object", description: "Full module JSON definition with name, displayName, icon, submodules array" },
+                entity_id: { type: "string", description: "Entity ID" },
+                company_id: { type: "string", description: "Company ID (required - entity IDs are local per company)" },
             },
-            required: ["module_id", "definition"],
+            required: ["entity_id", "company_id"],
         },
     },
     {
-        name: "gufi_module_create",
-        description: getDesc("gufi_module_create"),
+        name: "gufi_field",
+        description: getDesc("gufi_field"),
         inputSchema: {
             type: "object",
             properties: {
-                company_id: { type: "string", description: "Company ID" },
-                definition: { type: "object", description: "Module JSON definition" },
+                entity: { type: "string", description: "Entity reference: id, name, or 'module.entity'" },
+                field: { type: "string", description: "Field name" },
+                company_id: { type: "string", description: "Company ID (required)" },
             },
-            required: ["company_id", "definition"],
+            required: ["entity", "field", "company_id"],
+        },
+    },
+    {
+        name: "gufi_relations",
+        description: getDesc("gufi_relations"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                module_id: { type: "string", description: "Module ID (optional - if omitted, shows all relations in company)" },
+                company_id: { type: "string", description: "Company ID (required)" },
+            },
+            required: ["company_id"],
         },
     },
     // ─────────────────────────────────────────────────────────────────────────
@@ -276,8 +515,9 @@ const TOOLS = [
             type: "object",
             properties: {
                 automation_id: { type: "string", description: "Automation script ID" },
+                company_id: { type: "string", description: "Company ID (required - automation IDs are local per company)" },
             },
-            required: ["automation_id"],
+            required: ["automation_id", "company_id"],
         },
     },
     {
@@ -301,8 +541,9 @@ const TOOLS = [
             type: "object",
             properties: {
                 entity_id: { type: "string", description: "Entity ID (from module schema)" },
+                company_id: { type: "string", description: "Company ID (required - entity IDs are local per company)" },
             },
-            required: ["entity_id"],
+            required: ["entity_id", "company_id"],
         },
     },
     {
@@ -312,12 +553,13 @@ const TOOLS = [
             type: "object",
             properties: {
                 entity_id: { type: "string", description: "Entity ID" },
+                company_id: { type: "string", description: "Company ID (required - entity IDs are local per company)" },
                 automations: {
                     type: "object",
                     description: "Automation configuration with on_create, on_update, on_delete, on_click arrays",
                 },
             },
-            required: ["entity_id", "automations"],
+            required: ["entity_id", "company_id", "automations"],
         },
     },
     {
@@ -336,21 +578,41 @@ const TOOLS = [
     // ─────────────────────────────────────────────────────────────────────────
     // Data (CRUD)
     // ─────────────────────────────────────────────────────────────────────────
+    {
+        name: "gufi_data",
+        description: getDesc("gufi_data"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: { type: "string", description: "Action: list, get, create, update, delete" },
+                table: { type: "string", description: "Table name (physical ID like m360_t16192)" },
+                company_id: { type: "string", description: "Company ID (required)" },
+                id: { type: "number", description: "Row ID (for get, update, delete)" },
+                data: { type: "object", description: "Row data (for create, update)" },
+                limit: { type: "number", description: "Number of rows for list (default 20)" },
+                offset: { type: "number", description: "Offset for pagination (default 0)" },
+                sort: { type: "string", description: "Field to sort by (default: id)" },
+                order: { type: "string", description: "ASC or DESC (default: DESC)" },
+                filter: { type: "string", description: "Filter expression (field=value)" },
+            },
+            required: ["action", "table", "company_id"],
+        },
+    },
     {
         name: "gufi_rows",
         description: getDesc("gufi_rows"),
         inputSchema: {
             type: "object",
             properties: {
-                table: { type: "string", description: "Table name (physical ID like m360_t16192, NOT logical names)" },
-                company_id: { type: "string", description: "Company ID (required if table is not physical ID format)" },
+                table: { type: "string", description: "Table name (physical ID like m360_t16192)" },
+                company_id: { type: "string", description: "Company ID (required - table names may collide between companies)" },
                 limit: { type: "number", description: "Number of rows (default 20)" },
                 offset: { type: "number", description: "Offset for pagination (default 0)" },
                 sort: { type: "string", description: "Field to sort by (default: id)" },
                 order: { type: "string", description: "ASC or DESC (default: DESC)" },
                 filter: { type: "string", description: "Filter expression (field=value)" },
             },
-            required: ["table"],
+            required: ["table", "company_id"],
         },
     },
     {
@@ -360,10 +622,10 @@ const TOOLS = [
             type: "object",
             properties: {
                 table: { type: "string", description: "Table name (physical ID like m360_t16192)" },
-                company_id: { type: "string", description: "Company ID (required if table is not physical ID format)" },
+                company_id: { type: "string", description: "Company ID (required - table names may collide between companies)" },
                 id: { type: "number", description: "Row ID" },
             },
-            required: ["table", "id"],
+            required: ["table", "company_id", "id"],
         },
     },
     {
@@ -373,10 +635,10 @@ const TOOLS = [
             type: "object",
             properties: {
                 table: { type: "string", description: "Table name (physical ID like m360_t16192)" },
-                company_id: { type: "string", description: "Company ID (required if table is not physical ID format)" },
+                company_id: { type: "string", description: "Company ID (required - table names may collide between companies)" },
                 data: { type: "object", description: "Row data as key-value pairs" },
             },
-            required: ["table", "data"],
+            required: ["table", "company_id", "data"],
         },
     },
     {
@@ -386,11 +648,11 @@ const TOOLS = [
             type: "object",
             properties: {
                 table: { type: "string", description: "Table name (physical ID like m360_t16192)" },
-                company_id: { type: "string", description: "Company ID (required if table is not physical ID format)" },
+                company_id: { type: "string", description: "Company ID (required - table names may collide between companies)" },
                 id: { type: "number", description: "Row ID" },
                 data: { type: "object", description: "Fields to update" },
             },
-            required: ["table", "id", "data"],
+            required: ["table", "company_id", "id", "data"],
         },
     },
     {
@@ -400,10 +662,10 @@ const TOOLS = [
             type: "object",
             properties: {
                 table: { type: "string", description: "Table name (physical ID like m360_t16192)" },
-                company_id: { type: "string", description: "Company ID (required if table is not physical ID format)" },
+                company_id: { type: "string", description: "Company ID (required - table names may collide between companies)" },
                 id: { type: "number", description: "Row ID" },
             },
-            required: ["table", "id"],
+            required: ["table", "company_id", "id"],
         },
     },
     // ─────────────────────────────────────────────────────────────────────────
@@ -427,8 +689,9 @@ const TOOLS = [
             properties: {
                 key: { type: "string", description: "Variable name (uppercase recommended)" },
                 value: { type: "string", description: "Variable value" },
+                company_id: { type: "string", description: "Company ID (required)" },
             },
-            required: ["key", "value"],
+            required: ["key", "value", "company_id"],
         },
     },
     {
@@ -438,8 +701,9 @@ const TOOLS = [
             type: "object",
             properties: {
                 key: { type: "string", description: "Variable name to delete" },
+                company_id: { type: "string", description: "Company ID (required)" },
             },
-            required: ["key"],
+            required: ["key", "company_id"],
         },
     },
     // ─────────────────────────────────────────────────────────────────────────
@@ -503,6 +767,20 @@ const TOOLS = [
             required: ["view_id"],
         },
     },
+    {
+        name: "gufi_view_create",
+        description: getDesc("gufi_view_create"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "View name (e.g., 'Sales Dashboard')" },
+                template: { type: "string", description: "Template: 'dashboard', 'table', 'form', or 'blank'" },
+                package_id: { type: "string", description: "Package ID to add the view to (optional)" },
+                description: { type: "string", description: "View description (optional)" },
+            },
+            required: ["name", "template"],
+        },
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Packages (Marketplace Distribution)
     // ─────────────────────────────────────────────────────────────────────────
@@ -691,6 +969,22 @@ const TOOLS = [
             required: ["package_id"],
         },
     },
+    {
+        name: "gufi_link_view",
+        description: getDesc("gufi_link_view"),
+        inputSchema: {
+            type: "object",
+            properties: {
+                package_id: { type: "string", description: "Package ID" },
+                module_id: { type: "string", description: "Package module ID (from gufi_package)" },
+                submodule_name: { type: "string", description: "Submodule name to add the view to" },
+                view_id: { type: "number", description: "Marketplace view ID to link" },
+                label: { type: "string", description: "Display name for the view in the menu" },
+                icon: { type: "string", description: "Lucide icon name (e.g., 'BarChart3', 'Package')" },
+            },
+            required: ["package_id", "module_id", "submodule_name", "view_id", "label"],
+        },
+    },
 ];
 // ════════════════════════════════════════════════════════════════════════════
 // Tool Handlers
@@ -966,54 +1260,95 @@ const toolHandlers = {
         }
     },
     async gufi_schema(params) {
-        // Use /api/company/schema which has full entity info including IDs
-        const data = await apiRequest("/api/company/schema", {
-            headers: params.company_id ? { "X-Company-ID": params.company_id } : {},
-        }, params.company_id);
-        const modulesRaw = data.modules || data.data?.modules || [];
-        // Build modules with proper entity IDs
-        const modules = [];
-        for (const mod of modulesRaw) {
-            let moduleId;
-            const entities = [];
-            // First pass: find moduleId
-            for (const sub of mod.submodules || []) {
-                for (const ent of sub.entities || []) {
-                    if (ent.ui?.moduleId) {
-                        moduleId = ent.ui.moduleId;
-                        break;
+        // Use the new /api/schema/readable endpoint for FLAT format (default)
+        // This returns human-readable text optimized for Claude comprehension
+        if (params.format === "json") {
+            // JSON format for programmatic use
+            const data = await apiRequest("/api/company/schema", {
+                headers: params.company_id ? { "X-Company-ID": params.company_id } : {},
+            }, params.company_id);
+            const modulesRaw = data.modules || data.data?.modules || [];
+            const modules = [];
+            for (const mod of modulesRaw) {
+                let moduleId;
+                const entities = [];
+                for (const sub of mod.submodules || []) {
+                    for (const ent of sub.entities || []) {
+                        if (ent.ui?.moduleId)
+                            moduleId = ent.ui.moduleId;
+                        const entityId = ent.ui?.entityId || ent.pk_id || ent.id;
+                        entities.push({
+                            id: entityId,
+                            name: ent.name,
+                            label: ent.label,
+                            table: moduleId && entityId ? `m${moduleId}_t${entityId}` : null,
+                            fields: (ent.fields || []).map((f) => ({
+                                name: f.name,
+                                type: f.type,
+                                label: f.label,
+                                required: f.required,
+                            })),
+                        });
                     }
                 }
-                if (moduleId)
-                    break;
-            }
-            // Second pass: build entities with proper table names
-            for (const sub of mod.submodules || []) {
-                for (const ent of sub.entities || []) {
-                    const entityId = ent.ui?.entityId || ent.pk_id || ent.id;
-                    entities.push({
-                        id: entityId,
-                        name: ent.name,
-                        label: ent.label,
-                        table: moduleId && entityId ? `m${moduleId}_t${entityId}` : null,
-                        fields: (ent.fields || []).map((f) => ({
-                            name: f.name,
-                            type: f.type,
-                            label: f.label,
-                        })),
-                    });
-                }
-            }
-            if (params.module_id && String(moduleId) !== params.module_id) {
-                continue;
+                modules.push({
+                    id: moduleId,
+                    name: mod.name || mod.displayName,
+                    entities,
+                });
             }
-            modules.push({
-                id: moduleId,
-                name: mod.name || mod.displayName,
-                entities,
-            });
+            return { format: "json", modules };
+        }
+        // Default: FLAT text format optimized for Claude comprehension
+        const url = `${getApiUrl()}/api/schema/readable`;
+        let token = getToken();
+        if (!token) {
+            token = await autoLogin();
+            if (!token)
+                throw new Error("Not logged in. Run: gufi login");
+        }
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            "X-Client": "mcp",
+        };
+        if (params.company_id) {
+            headers["X-Company-ID"] = params.company_id;
+        }
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`API Error ${response.status}: ${text}`);
         }
-        return { modules };
+        // Return as plain text for maximum readability
+        const schema = await response.text();
+        return { format: "flat", schema };
+    },
+    async gufi_schema_modify(params) {
+        // Use the new /api/schema/operations endpoint for semantic operations
+        const result = await apiRequest("/api/schema/operations", {
+            method: "POST",
+            body: JSON.stringify({
+                operations: params.operations,
+                preview: params.preview || false,
+            }),
+        }, params.company_id);
+        if (params.preview) {
+            return {
+                preview: true,
+                operations_count: params.operations.length,
+                would_execute: result.preview || result.results?.map((r) => ({
+                    op: r.op,
+                    description: r.message,
+                    sql: r.sql || null,
+                })),
+                hint: "Set preview: false to execute these operations",
+            };
+        }
+        return {
+            success: result.success,
+            results: result.results,
+            summary: result.results?.map((r) => r.message).join("; "),
+        };
     },
     async gufi_docs(params) {
         // Map topics to file names
@@ -1144,49 +1479,201 @@ const toolHandlers = {
         };
     },
     async gufi_module(params) {
-        const result = await detectCompanyFromModule(params.module_id);
-        if (!result) {
-            throw new Error(`Module ${params.module_id} not found`);
+        // 💜 Use relational endpoint /api/schema/modules/:id
+        const data = await apiRequest(`/api/schema/modules/${params.module_id}`, {
+            headers: { "X-Company-ID": params.company_id },
+        }, params.company_id);
+        const { module, submodules, entities } = data;
+        if (!module) {
+            throw new Error(`Module ${params.module_id} not found in company ${params.company_id}`);
         }
-        const { module, companyId } = result;
-        // Clean JSON definition
-        const cleanSubmodules = (module.submodules || []).map((sub) => ({
-            ...sub,
-            entities: (sub.entities || []).map((ent) => {
-                const { permissions, ui, ...cleanEnt } = ent;
-                return cleanEnt;
-            }),
-        }));
+        // Build submodules with entities (lightweight, no field definitions)
+        const submodulesWithEntities = submodules.map((sub) => {
+            const subEntities = entities.filter((e) => e.submodule_id === sub.id);
+            return {
+                id: sub.id,
+                name: sub.name,
+                label: sub.label,
+                position: sub.position,
+                entities: subEntities.map((e) => ({
+                    id: e.id,
+                    name: e.name,
+                    label: e.label,
+                    kind: e.kind,
+                    tableName: `m${module.id}_t${e.id}`,
+                    fieldCount: parseInt(e.field_count) || 0,
+                    // Include view_spec if present
+                    ...(e.view_spec && { view_spec: e.view_spec }),
+                })),
+            };
+        });
+        // Extract relations from entities for quick reference
+        const relations = [];
+        // Note: Full field details require gufi_entity call
         return {
-            module_id: module._moduleId,
-            company_id: companyId,
-            definition: {
+            module_id: params.module_id,
+            company_id: params.company_id,
+            module: {
+                id: module.id,
                 name: module.name,
-                displayName: module.displayName || module.label,
+                display_name: module.display_name,
                 icon: module.icon,
-                submodules: cleanSubmodules,
+                position: module.position,
             },
+            submodules: submodulesWithEntities,
+            entityCount: entities.length,
+            hint: "Use gufi_entity({ entity_id, company_id }) to see fields and relations for a specific entity",
         };
     },
-    async gufi_module_update(params) {
-        const result = await detectCompanyFromModule(params.module_id);
-        if (!result) {
-            throw new Error(`Module ${params.module_id} not found`);
+    async gufi_entity(params) {
+        // 💜 Fetch entity with all fields from relational endpoint
+        const data = await apiRequest(`/api/schema/entities/${params.entity_id}`, {
+            headers: { "X-Company-ID": params.company_id },
+        }, params.company_id);
+        const { entity, fields } = data;
+        if (!entity) {
+            throw new Error(`Entity ${params.entity_id} not found in company ${params.company_id}`);
         }
-        const response = await apiRequest(`/api/company/modules/${params.module_id}`, {
-            method: "PUT",
-            body: JSON.stringify({ json: params.definition }),
-            headers: { "X-Company-ID": result.companyId },
+        const tableName = `m${entity.module_id}_t${entity.id}`;
+        // Extract relations for quick reference
+        const relations = fields
+            .filter((f) => f.type === "relation" && f.settings?.ref)
+            .map((f) => ({
+            field: f.name,
+            ref: f.settings.ref,
+            display: f.settings.display || "id",
+        }));
+        // Format fields for readability
+        const formattedFields = fields.map((f) => {
+            const constraints = [];
+            if (f.required)
+                constraints.push("required");
+            if (f.settings?.unique)
+                constraints.push("unique");
+            if (f.settings?.ref)
+                constraints.push(`→ ${f.settings.ref}`);
+            if (f.settings?.options?.length > 0) {
+                const opts = f.settings.options.slice(0, 5).map((o) => o.value || o);
+                constraints.push(`[${opts.join("|")}${f.settings.options.length > 5 ? "..." : ""}]`);
+            }
+            return {
+                name: f.name,
+                type: f.type,
+                label: f.label,
+                ...(constraints.length > 0 && { constraints: constraints.join(", ") }),
+                ...(f.settings && Object.keys(f.settings).length > 0 && { settings: f.settings }),
+            };
         });
-        return { success: true, module_id: params.module_id };
+        return {
+            entity_id: params.entity_id,
+            company_id: params.company_id,
+            entity: {
+                id: entity.id,
+                name: entity.name,
+                label: entity.label,
+                kind: entity.kind,
+                tableName,
+                moduleName: entity.module_name,
+                submoduleName: entity.submodule_name,
+                ...(entity.view_spec && { view_spec: entity.view_spec }),
+            },
+            fields: formattedFields,
+            relations,
+            fieldCount: fields.length,
+            hint: "Use gufi_schema_modify to add/update/remove fields",
+        };
     },
-    async gufi_module_create(params) {
-        const response = await apiRequest("/api/company/modules", {
-            method: "POST",
-            body: JSON.stringify({ json: params.definition }),
+    async gufi_field(params) {
+        // 💜 Get a single field's full details
+        // First resolve entity to ID if needed
+        const schemaData = await apiRequest("/api/company/schema", {
             headers: { "X-Company-ID": params.company_id },
-        });
-        return { success: true, module: response.data || response };
+        }, params.company_id);
+        const modules = schemaData.modules || schemaData.data?.modules || [];
+        let targetEntity = null;
+        let targetField = null;
+        // Search for entity by id, name, or module.entity path
+        const entityRef = params.entity;
+        const [modulePart, entityPart] = entityRef.includes(".") ? entityRef.split(".") : [null, entityRef];
+        for (const mod of modules) {
+            for (const sub of mod.submodules || []) {
+                for (const ent of sub.entities || []) {
+                    const matchesId = String(ent.ui?.entityId || ent.id) === entityRef;
+                    const matchesName = ent.name === (entityPart || entityRef);
+                    const matchesPath = modulePart && mod.name === modulePart && ent.name === entityPart;
+                    if (matchesId || matchesName || matchesPath) {
+                        targetEntity = { ...ent, moduleName: mod.name, submoduleName: sub.name };
+                        targetField = (ent.fields || []).find((f) => f.name === params.field);
+                        break;
+                    }
+                }
+                if (targetEntity)
+                    break;
+            }
+            if (targetEntity)
+                break;
+        }
+        if (!targetEntity) {
+            throw new Error(`Entity "${params.entity}" not found in company ${params.company_id}`);
+        }
+        if (!targetField) {
+            const availableFields = (targetEntity.fields || []).map((f) => f.name).slice(0, 10);
+            throw new Error(`Field "${params.field}" not found in entity "${targetEntity.name}". Available: ${availableFields.join(", ")}${availableFields.length >= 10 ? "..." : ""}`);
+        }
+        return {
+            entity: targetEntity.name,
+            field: {
+                name: targetField.name,
+                type: targetField.type,
+                label: targetField.label,
+                required: targetField.required || false,
+                settings: targetField.settings || {},
+            },
+            modify_hint: `gufi_schema_modify({ operations: [{ op: "update_field", entity: "${targetEntity.name}", field_name: "${params.field}", changes: { ... } }] })`,
+        };
+    },
+    async gufi_relations(params) {
+        // 💜 Get all relations in a module (or all modules if not specified)
+        const schemaData = await apiRequest("/api/company/schema", {
+            headers: { "X-Company-ID": params.company_id },
+        }, params.company_id);
+        const modules = schemaData.modules || schemaData.data?.modules || [];
+        const relations = [];
+        for (const mod of modules) {
+            // Skip if module_id specified and doesn't match
+            const moduleId = mod.submodules?.[0]?.entities?.[0]?.ui?.moduleId;
+            if (params.module_id && String(moduleId) !== params.module_id)
+                continue;
+            for (const sub of mod.submodules || []) {
+                for (const ent of sub.entities || []) {
+                    const entityPath = `${mod.name}.${ent.name}`;
+                    for (const field of ent.fields || []) {
+                        if (field.type === "relation" && field.settings?.ref) {
+                            relations.push({
+                                from: entityPath,
+                                field: field.name,
+                                to: field.settings.ref,
+                                display: field.settings.display || "id",
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Group by source entity for readability
+        const grouped = {};
+        for (const rel of relations) {
+            if (!grouped[rel.from])
+                grouped[rel.from] = [];
+            grouped[rel.from].push({ field: rel.field, to: rel.to, display: rel.display });
+        }
+        return {
+            company_id: params.company_id,
+            ...(params.module_id && { module_id: params.module_id }),
+            total_relations: relations.length,
+            relations_by_entity: grouped,
+            flat_list: relations,
+        };
     },
     // ─────────────────────────────────────────────────────────────────────────
     // Automations
@@ -1205,16 +1692,21 @@ const toolHandlers = {
         };
     },
     async gufi_automation(params) {
-        const result = await detectCompanyFromAutomation(params.automation_id);
-        if (!result) {
-            throw new Error(`Automation ${params.automation_id} not found`);
+        // 💜 Fetch automation directly from specified company (IDs are local per company)
+        const data = await apiRequest("/api/automation-scripts", {
+            headers: { "X-Company-ID": params.company_id },
+        });
+        const automations = Array.isArray(data) ? data : data.data || [];
+        const found = automations.find((a) => String(a.id) === params.automation_id);
+        if (!found) {
+            throw new Error(`Automation ${params.automation_id} not found in company ${params.company_id}`);
         }
         return {
-            id: result.automation.id,
-            name: result.automation.name,
-            description: result.automation.description,
-            company_id: result.companyId,
-            code: result.automation.code || "",
+            id: found.id,
+            name: found.name,
+            description: found.description,
+            company_id: params.company_id,
+            code: found.code || "",
         };
     },
     async gufi_automation_create(params) {
@@ -1230,16 +1722,24 @@ const toolHandlers = {
         return { success: true, automation: response.data || response };
     },
     async gufi_entity_automations(params) {
-        const response = await apiRequest(`/api/entities/${params.entity_id}/automations`);
+        const response = await apiRequest(`/api/entities/${params.entity_id}/automations`, {
+            headers: { "X-Company-ID": params.company_id },
+        }, params.company_id);
         const data = response.data || response;
-        return { automations: data.automations || data || [] };
+        return {
+            entity_id: params.entity_id,
+            company_id: params.company_id,
+            automations: data.automations || data || [],
+            availableScripts: data.availableScripts || [],
+        };
     },
     async gufi_entity_automations_update(params) {
         const response = await apiRequest(`/api/entities/${params.entity_id}/automations`, {
             method: "PUT",
             body: JSON.stringify(params.automations),
-        });
-        return { success: true };
+            headers: { "X-Company-ID": params.company_id },
+        }, params.company_id);
+        return { success: true, entity_id: params.entity_id, company_id: params.company_id };
     },
     async gufi_automations_executions(params) {
         let endpoint = `/api/automation-executions?limit=${params.limit || 20}`;
@@ -1254,8 +1754,82 @@ const toolHandlers = {
     // ─────────────────────────────────────────────────────────────────────────
     // Data (CRUD)
     // ─────────────────────────────────────────────────────────────────────────
+    async gufi_data(params) {
+        // 💜 Unified data tool - all CRUD operations in one
+        const { action, table, company_id } = params;
+        switch (action) {
+            case "list": {
+                const limit = params.limit || 20;
+                const offset = params.offset || 0;
+                const body = {
+                    pagination: { current: Math.floor(offset / limit) + 1, pageSize: limit },
+                    sorters: [{ field: params.sort || "id", order: params.order || "desc" }],
+                    filters: [],
+                };
+                if (params.filter) {
+                    const [field, value] = params.filter.split("=");
+                    if (field && value)
+                        body.filters.push({ field, operator: "eq", value });
+                }
+                const result = await apiRequest(`/api/tables/${table}/list`, {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, company_id);
+                return { action: "list", table, total: result.total, rows: result.data || [] };
+            }
+            case "get": {
+                if (!params.id)
+                    throw new Error("id is required for 'get' action");
+                const result = await apiRequest(`/api/tables/${table}/getOne`, {
+                    method: "POST",
+                    body: JSON.stringify({ id: params.id }),
+                }, company_id);
+                return { action: "get", table, id: params.id, row: result.data || result };
+            }
+            case "create": {
+                if (!params.data)
+                    throw new Error("data is required for 'create' action");
+                // 💜 Validate relation fields before creating
+                const createValidation = await validateRelationFields(table, company_id, params.data);
+                if (!createValidation.valid) {
+                    throw new Error(`Relation validation failed:\n${createValidation.errors.join("\n")}`);
+                }
+                const result = await apiRequest(`/api/tables/${table}`, {
+                    method: "POST",
+                    body: JSON.stringify(params.data),
+                }, company_id);
+                return { action: "create", table, success: true, id: result.id || result.data?.id, row: result.data || result };
+            }
+            case "update": {
+                if (!params.id)
+                    throw new Error("id is required for 'update' action");
+                if (!params.data)
+                    throw new Error("data is required for 'update' action");
+                // 💜 Validate relation fields before updating
+                const updateValidation = await validateRelationFields(table, company_id, params.data);
+                if (!updateValidation.valid) {
+                    throw new Error(`Relation validation failed:\n${updateValidation.errors.join("\n")}`);
+                }
+                const result = await apiRequest(`/api/tables/${table}/${params.id}`, {
+                    method: "PUT",
+                    body: JSON.stringify(params.data),
+                }, company_id);
+                return { action: "update", table, success: true, id: params.id, row: result.data || result };
+            }
+            case "delete": {
+                if (!params.id)
+                    throw new Error("id is required for 'delete' action");
+                await apiRequest(`/api/tables/${table}/${params.id}`, {
+                    method: "DELETE",
+                }, company_id);
+                return { action: "delete", table, success: true, id: params.id };
+            }
+            default:
+                throw new Error(`Unknown action: ${action}. Use: list, get, create, update, delete`);
+        }
+    },
     async gufi_rows(params) {
-        const companyId = params.company_id || await detectCompanyFromTable(params.table);
+        // 💜 company_id is now required - IDs are local per company
         const limit = params.limit || 20;
         const offset = params.offset || 0;
         const body = {
@@ -1272,51 +1846,64 @@ const toolHandlers = {
         const result = await apiRequest(`/api/tables/${params.table}/list`, {
             method: "POST",
             body: JSON.stringify(body),
-        }, companyId);
+        }, params.company_id);
         return {
             table: params.table,
+            company_id: params.company_id,
             total: result.total,
             rows: result.data || [],
         };
     },
     async gufi_row(params) {
-        const companyId = params.company_id || await detectCompanyFromTable(params.table);
         const result = await apiRequest(`/api/tables/${params.table}/getOne`, {
             method: "POST",
             body: JSON.stringify({ id: params.id }),
-        }, companyId);
+        }, params.company_id);
         return {
             table: params.table,
+            company_id: params.company_id,
             id: params.id,
             row: result.data || result,
         };
     },
     async gufi_row_create(params) {
-        const companyId = params.company_id || await detectCompanyFromTable(params.table);
+        // Normalize file fields (auto-generate id, mime, uploaded_at)
+        const normalizedData = normalizeFileFields(params.data);
+        // 💜 Validate relation fields before creating
+        const validation = await validateRelationFields(params.table, params.company_id, normalizedData);
+        if (!validation.valid) {
+            throw new Error(`Relation validation failed:\n${validation.errors.join("\n")}`);
+        }
         const result = await apiRequest(`/api/tables/${params.table}`, {
             method: "POST",
-            body: JSON.stringify(params.data),
-        }, companyId);
+            body: JSON.stringify(normalizedData),
+        }, params.company_id);
         return {
             success: true,
+            company_id: params.company_id,
             id: result.id || result.data?.id,
             row: result.data || result,
         };
     },
     async gufi_row_update(params) {
-        const companyId = params.company_id || await detectCompanyFromTable(params.table);
+        // Normalize file fields (auto-generate id, mime, uploaded_at)
+        const normalizedData = normalizeFileFields(params.data);
+        // 💜 Validate relation fields before updating
+        const validation = await validateRelationFields(params.table, params.company_id, normalizedData);
+        if (!validation.valid) {
+            throw new Error(`Relation validation failed:\n${validation.errors.join("\n")}`);
+        }
         const result = await apiRequest(`/api/tables/${params.table}/${params.id}`, {
             method: "PUT",
-            body: JSON.stringify(params.data),
-        }, companyId);
-        return { success: true, row: result.data || result };
+            body: JSON.stringify(normalizedData),
+        }, params.company_id);
+        return { success: true, company_id: params.company_id, row: result.data || result };
     },
     async gufi_row_delete(params) {
-        const companyId = params.company_id || await detectCompanyFromTable(params.table);
         await apiRequest(`/api/tables/${params.table}/${params.id}`, {
             method: "DELETE",
-        }, companyId);
-        return { success: true };
+        }, params.company_id);
+        return { success: true, company_id: params.company_id };
     },
     // ─────────────────────────────────────────────────────────────────────────
     // Environment Variables
@@ -1329,14 +1916,14 @@ const toolHandlers = {
         await apiRequest("/api/cli/env", {
             method: "POST",
             body: JSON.stringify({ key: params.key, value: params.value }),
-        });
-        return { success: true };
+        }, params.company_id);
+        return { success: true, company_id: params.company_id };
     },
     async gufi_env_delete(params) {
         await apiRequest(`/api/cli/env/${encodeURIComponent(params.key)}`, {
             method: "DELETE",
-        });
-        return { success: true };
+        }, params.company_id);
+        return { success: true, company_id: params.company_id };
     },
     // ─────────────────────────────────────────────────────────────────────────
     // Views
@@ -1392,6 +1979,516 @@ const toolHandlers = {
                 : `❌ ${response.errors?.length || 0} errors, ${response.warnings?.length || 0} warnings`,
         };
     },
+    async gufi_view_create(params) {
+        // Generate safe function name
+        const safeName = params.name.replace(/[^a-zA-Z0-9]/g, "");
+        // Template generators
+        const getBlankTemplate = (name, fnName) => ({
+            index: `// ${name}
+import React from 'react';
+import { Package } from 'lucide-react';
+import { type FeatureProps } from '@/sdk';
+
+export { featureConfig } from './core/dataProvider';
+
+export default function ${fnName}View({ id, gufi }: FeatureProps) {
+  const viewSpec = gufi?.context?.viewSpec || {};
+
+  return (
+    <div className="flex flex-col min-h-screen bg-gradient-to-br from-violet-50/40 via-white to-purple-50/40 p-6">
+      <header className="mb-6">
+        <h1 className="text-xl font-bold flex items-center gap-2">
+          <Package className="w-5 h-5 text-violet-600" />
+          ${name}
+        </h1>
+      </header>
+
+      <div className="bg-white rounded-xl border shadow-sm p-6">
+        <p className="text-gray-600">Start building your view here!</p>
+        <p className="text-sm text-gray-400 mt-2">
+          viewSpec.mainTable: {viewSpec.mainTable || 'Not configured'}
+        </p>
+      </div>
+    </div>
+  );
+}
+`,
+            dataProvider: `import type { FeatureConfig } from '@/sdk';
+
+export const featureConfig: FeatureConfig = {
+  dataSources: {
+    mainTable: {
+      type: 'table',
+      module: 'default',
+      entity: 'items',
+      label: 'Main Table'
+    }
+  },
+  inputs: {},
+  seedData: {
+    description: { es: 'Vista', en: 'View' },
+    data: {},
+    order: []
+  }
+};
+`,
+        });
+        const getDashboardTemplate = (name, fnName) => ({
+            index: `// ${name}
+import React, { useState, useEffect } from 'react';
+import { Package, TrendingUp, Users, DollarSign } from 'lucide-react';
+import { cn, toastError, type FeatureProps } from '@/sdk';
+import { Button, Card, CardContent, CardHeader, CardTitle } from '@/sdk';
+
+export { featureConfig } from './core/dataProvider';
+
+export default function ${fnName}View({ id, gufi }: FeatureProps) {
+  const dataProvider = gufi?.dataProvider;
+  const viewSpec = gufi?.context?.viewSpec || {};
+  const isPreview = gufi?.context?.isPreview;
+  const seedData = gufi?.seedData;
+
+  const [data, setData] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [stats, setStats] = useState({ total: 0, active: 0, revenue: 0 });
+
+  useEffect(() => {
+    const load = async () => {
+      setLoading(true);
+
+      if (isPreview && seedData?.data) {
+        const items = seedData.data.items || [];
+        setData(items);
+        setStats({
+          total: items.length,
+          active: items.filter((i: any) => i.status === 'active').length,
+          revenue: items.reduce((acc: number, i: any) => acc + (i.amount || 0), 0)
+        });
+        setLoading(false);
+        return;
+      }
+
+      if (!dataProvider || !viewSpec.mainTable) {
+        setLoading(false);
+        return;
+      }
+
+      try {
+        const res = await dataProvider.getList({
+          resource: viewSpec.mainTable,
+          pagination: { current: 1, pageSize: 100 },
+        });
+        setData(res.data || []);
+      } catch (err) {
+        toastError('Error loading data');
+      }
+      setLoading(false);
+    };
+    load();
+  }, [dataProvider, viewSpec.mainTable, seedData, isPreview]);
+
+  if (loading) {
+    return (
+      <div className="p-6 space-y-4">
+        {[1,2,3].map(i => (
+          <div key={i} className="h-24 bg-gray-100 rounded-xl animate-pulse" />
+        ))}
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col min-h-screen bg-gradient-to-br from-violet-50/40 via-white to-purple-50/40 p-6">
+      <header className="mb-6">
+        <h1 className="text-2xl font-bold flex items-center gap-2">
+          <Package className="w-6 h-6 text-violet-600" />
+          ${name}
+        </h1>
+      </header>
+
+      <div className="grid grid-cols-1 md:grid-cols-3 gap-4 mb-6">
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-gray-500">Total</CardTitle>
+            <Users className="w-4 h-4 text-violet-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">{stats.total}</div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-gray-500">Active</CardTitle>
+            <TrendingUp className="w-4 h-4 text-green-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold text-green-600">{stats.active}</div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-gray-500">Revenue</CardTitle>
+            <DollarSign className="w-4 h-4 text-violet-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">\${stats.revenue.toLocaleString()}</div>
+          </CardContent>
+        </Card>
+      </div>
+
+      <Card className="flex-1">
+        <CardHeader>
+          <CardTitle>Records</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="space-y-2">
+            {data.slice(0, 10).map((item, i) => (
+              <div key={item.id || i} className="p-3 bg-gray-50 rounded-lg flex justify-between">
+                <span>{item.name || item.nombre || 'Item ' + (i + 1)}</span>
+                <span className="text-gray-500">{item.status || '-'}</span>
+              </div>
+            ))}
+            {data.length === 0 && (
+              <div className="text-center text-gray-500 py-8">No data available</div>
+            )}
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+`,
+            dataProvider: `import type { FeatureConfig } from '@/sdk';
+
+export const featureConfig: FeatureConfig = {
+  dataSources: {
+    mainTable: {
+      type: 'table',
+      module: 'default',
+      entity: 'items',
+      label: 'Main Data'
+    }
+  },
+  inputs: {
+    title: {
+      type: 'text',
+      label: 'Dashboard Title',
+      default: '${name}'
+    }
+  },
+  seedData: {
+    description: {
+      es: 'Dashboard de ejemplo',
+      en: 'Example dashboard'
+    },
+    data: {
+      items: [
+        { id: 1, name: 'Item 1', status: 'active', amount: 1500 },
+        { id: 2, name: 'Item 2', status: 'active', amount: 2300 },
+        { id: 3, name: 'Item 3', status: 'pending', amount: 800 },
+      ]
+    },
+    order: ['items']
+  }
+};
+`,
+        });
+        const getTableTemplate = (name, fnName) => ({
+            index: `// ${name}
+import React, { useState, useEffect } from 'react';
+import { TableIcon, Search } from 'lucide-react';
+import { cn, toastError, type FeatureProps } from '@/sdk';
+import { Input, Button } from '@/sdk';
+
+export { featureConfig } from './core/dataProvider';
+
+export default function ${fnName}View({ id, gufi }: FeatureProps) {
+  const dataProvider = gufi?.dataProvider;
+  const viewSpec = gufi?.context?.viewSpec || {};
+  const isPreview = gufi?.context?.isPreview;
+  const seedData = gufi?.seedData;
+
+  const [data, setData] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [search, setSearch] = useState('');
+
+  useEffect(() => {
+    const load = async () => {
+      setLoading(true);
+      if (isPreview && seedData?.data) {
+        setData(seedData.data.items || []);
+        setLoading(false);
+        return;
+      }
+      if (!dataProvider || !viewSpec.mainTable) {
+        setLoading(false);
+        return;
+      }
+      try {
+        const res = await dataProvider.getList({
+          resource: viewSpec.mainTable,
+          pagination: { current: 1, pageSize: 50 },
+        });
+        setData(res.data || []);
+      } catch (err) {
+        toastError('Error loading data');
+      }
+      setLoading(false);
+    };
+    load();
+  }, [dataProvider, viewSpec.mainTable, seedData, isPreview]);
+
+  const filtered = data.filter(item =>
+    !search || JSON.stringify(item).toLowerCase().includes(search.toLowerCase())
+  );
+
+  if (loading) {
+    return (
+      <div className="p-6">
+        <div className="h-10 bg-gray-100 rounded animate-pulse mb-4" />
+        {[1,2,3,4,5].map(i => (
+          <div key={i} className="h-12 bg-gray-50 rounded animate-pulse mb-2" />
+        ))}
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col min-h-screen bg-gradient-to-br from-violet-50/40 via-white to-purple-50/40 p-6">
+      <header className="mb-4 flex items-center justify-between">
+        <h1 className="text-xl font-bold flex items-center gap-2">
+          <TableIcon className="w-5 h-5 text-violet-600" />
+          ${name}
+        </h1>
+        <div className="relative">
+          <Search className="w-4 h-4 absolute left-3 top-1/2 -translate-y-1/2 text-gray-400" />
+          <Input
+            className="pl-9 w-64"
+            placeholder="Search..."
+            value={search}
+            onChange={(e) => setSearch(e.target.value)}
+          />
+        </div>
+      </header>
+
+      <div className="bg-white rounded-xl border shadow-sm overflow-hidden">
+        <table className="w-full">
+          <thead className="bg-gray-50 border-b">
+            <tr>
+              <th className="text-left p-3 font-medium text-gray-600">ID</th>
+              <th className="text-left p-3 font-medium text-gray-600">Name</th>
+              <th className="text-left p-3 font-medium text-gray-600">Status</th>
+            </tr>
+          </thead>
+          <tbody>
+            {filtered.map((item, i) => (
+              <tr key={item.id || i} className="border-b hover:bg-gray-50">
+                <td className="p-3">{item.id}</td>
+                <td className="p-3">{item.name || item.nombre || '-'}</td>
+                <td className="p-3">{item.status || '-'}</td>
+              </tr>
+            ))}
+            {filtered.length === 0 && (
+              <tr>
+                <td colSpan={3} className="p-8 text-center text-gray-500">No data found</td>
+              </tr>
+            )}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+}
+`,
+            dataProvider: `import type { FeatureConfig } from '@/sdk';
+
+export const featureConfig: FeatureConfig = {
+  dataSources: {
+    mainTable: {
+      type: 'table',
+      module: 'default',
+      entity: 'items',
+      label: 'Data Table'
+    }
+  },
+  inputs: {},
+  seedData: {
+    description: { es: 'Tabla de datos', en: 'Data table' },
+    data: {
+      items: [
+        { id: 1, name: 'Record 1', status: 'active' },
+        { id: 2, name: 'Record 2', status: 'pending' },
+        { id: 3, name: 'Record 3', status: 'completed' },
+      ]
+    },
+    order: ['items']
+  }
+};
+`,
+        });
+        const getFormTemplate = (name, fnName) => ({
+            index: `// ${name}
+import React, { useState } from 'react';
+import { FileText, Save } from 'lucide-react';
+import { toastSuccess, toastError, type FeatureProps } from '@/sdk';
+import { Button, Input, Label } from '@/sdk';
+
+export { featureConfig } from './core/dataProvider';
+
+export default function ${fnName}View({ id, gufi }: FeatureProps) {
+  const dataProvider = gufi?.dataProvider;
+  const viewSpec = gufi?.context?.viewSpec || {};
+  const CB = gufi?.CB;
+
+  const [formData, setFormData] = useState({ name: '', email: '', notes: '' });
+  const [saving, setSaving] = useState(false);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    if (!dataProvider || !viewSpec.mainTable || !CB) {
+      toastError('Configuration error');
+      return;
+    }
+    setSaving(true);
+    try {
+      await dataProvider.create({
+        resource: viewSpec.mainTable,
+        variables: {
+          name: CB.text(formData.name),
+          email: CB.text(formData.email),
+          notes: CB.text(formData.notes),
+        }
+      });
+      toastSuccess('Saved successfully!');
+      setFormData({ name: '', email: '', notes: '' });
+    } catch (err) {
+      toastError('Error saving');
+    }
+    setSaving(false);
+  };
+
+  return (
+    <div className="flex flex-col min-h-screen bg-gradient-to-br from-violet-50/40 via-white to-purple-50/40 p-6">
+      <header className="mb-6">
+        <h1 className="text-xl font-bold flex items-center gap-2">
+          <FileText className="w-5 h-5 text-violet-600" />
+          ${name}
+        </h1>
+      </header>
+
+      <form onSubmit={handleSubmit} className="bg-white rounded-xl border shadow-sm p-6 max-w-lg space-y-4">
+        <div>
+          <Label htmlFor="name">Name</Label>
+          <Input
+            id="name"
+            value={formData.name}
+            onChange={(e) => setFormData(prev => ({ ...prev, name: e.target.value }))}
+            placeholder="Enter name..."
+            required
+          />
+        </div>
+        <div>
+          <Label htmlFor="email">Email</Label>
+          <Input
+            id="email"
+            type="email"
+            value={formData.email}
+            onChange={(e) => setFormData(prev => ({ ...prev, email: e.target.value }))}
+            placeholder="Enter email..."
+          />
+        </div>
+        <div>
+          <Label htmlFor="notes">Notes</Label>
+          <Input
+            id="notes"
+            value={formData.notes}
+            onChange={(e) => setFormData(prev => ({ ...prev, notes: e.target.value }))}
+            placeholder="Additional notes..."
+          />
+        </div>
+        <Button type="submit" disabled={saving} className="w-full">
+          <Save className="w-4 h-4 mr-2" />
+          {saving ? 'Saving...' : 'Save'}
+        </Button>
+      </form>
+    </div>
+  );
+}
+`,
+            dataProvider: `import type { FeatureConfig } from '@/sdk';
+
+export const featureConfig: FeatureConfig = {
+  dataSources: {
+    mainTable: {
+      type: 'table',
+      module: 'default',
+      entity: 'submissions',
+      label: 'Form Submissions'
+    }
+  },
+  inputs: {},
+  seedData: {
+    description: { es: 'Formulario', en: 'Form' },
+    data: {},
+    order: []
+  }
+};
+`,
+        });
+        // Get the right template
+        let template;
+        switch (params.template) {
+            case "dashboard":
+                template = getDashboardTemplate(params.name, safeName);
+                break;
+            case "table":
+                template = getTableTemplate(params.name, safeName);
+                break;
+            case "form":
+                template = getFormTemplate(params.name, safeName);
+                break;
+            default:
+                template = getBlankTemplate(params.name, safeName);
+        }
+        // Need package_id to create a view
+        if (!params.package_id) {
+            return {
+                error: "package_id is required to create a view",
+                hint: "First create a package with gufi_package_create, then pass its ID",
+                available_templates: ["dashboard", "table", "form", "blank"],
+            };
+        }
+        // Create the view via API
+        const response = await apiRequest(`/api/marketplace/packages/${params.package_id}/views`, {
+            method: "POST",
+            body: JSON.stringify({
+                name: params.name,
+                description: params.description || `${params.template} view created via MCP`,
+                view_type: "custom",
+            }),
+        });
+        const viewId = response.pk_id;
+        // Now update with template files
+        const files = [
+            { file_path: "index.tsx", content: template.index, language: "typescript" },
+            { file_path: "core/dataProvider.ts", content: template.dataProvider, language: "typescript" },
+        ];
+        await saveViewFiles(viewId, files);
+        return {
+            success: true,
+            view_id: viewId,
+            name: params.name,
+            template: params.template,
+            package_id: params.package_id,
+            files_created: files.map(f => f.file_path),
+            next_steps: [
+                `1. Download locally: gufi view:pull ${viewId}`,
+                `2. Edit files in: ~/gufi-dev/view_${viewId}/`,
+                `3. Upload changes: gufi view:push`,
+                `4. Publish: gufi package:sync ${params.package_id}`,
+            ],
+        };
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Packages
     // ─────────────────────────────────────────────────────────────────────────
@@ -1544,6 +2641,31 @@ const toolHandlers = {
         const response = await developerRequest(`/packages/${params.package_id}/entities`);
         return { entities: response.data || [] };
     },
+    async gufi_link_view(params) {
+        const entity = {
+            kind: "marketplace_view",
+            marketplace_view_id: params.view_id,
+            label: params.label,
+            icon: params.icon || "Sparkles",
+        };
+        const response = await developerRequest(`/packages/${params.package_id}/modules/${params.module_id}/add-entity`, {
+            method: "POST",
+            body: JSON.stringify({
+                submodule_name: params.submodule_name,
+                entity,
+            }),
+        });
+        // Invalidate schema cache on main backend
+        try {
+            await apiRequest("/api/company/schema/invalidate", { method: "POST" });
+        }
+        catch { }
+        return {
+            success: true,
+            message: `View "${params.label}" linked to ${params.submodule_name}`,
+            entity: response.data?.entity,
+        };
+    },
 };
 // ════════════════════════════════════════════════════════════════════════════
 // Context Generation Helpers