gufi-cli 0.1.27 → 0.1.29

package/CLAUDE.md

@@ -62,14 +62,16 @@ El servidor MCP está en `src/mcp.ts` y expone 44 tools para que Claude interact
 
 ### Tools principales
 
-- **`gufi_context`** - Genera contexto inteligente:
-  - `summary`: Resumen ejecutivo
-  - `next_actions`: Pasos sugeridos
+- **`gufi_context`** - 🚨 THE ONE TOOL FOR CONTEXT - Genera contexto inteligente:
+  - `{ company_id }` - Overview de empresa
+  - `{ company_id, detail: "full" }` - Schema completo Claude-optimizado (reemplaza gufi_schema)
+  - `{ company_id, module_id }` - Contexto de módulo específico
+  - `{ company_id, entity_id }` - Contexto de entidad específica
+  - `{ package_id }` - Contexto de package
+  - `{ view_id }` - Contexto de vista
   - Auto-detecta si está en codebase, vista local, o muestra packages
-  - **Usar con**: `{ package_id }`, `{ view_id }`, `{ company_id }`
 
 - **`gufi_docs`** - Lee documentación de `docs/mcp/`
-- **`gufi_schema`** - Schema de BD (módulos, tablas, campos)
 - **`gufi_rows/row/row_create/row_update`** - CRUD de datos
 - **`gufi_module/module_update`** - Gestión de módulos JSON
 - **`gufi_automation/automation_create`** - Gestión de automations

package/README.md

@@ -498,9 +498,8 @@ El MCP expone todas las funcionalidades del CLI como tools que Claude puede usar
 | Tool | Descripción |
 |------|-------------|
 | **Contexto** | |
-| `gufi_context` | Genera contexto del proyecto para Claude |
+| `gufi_context` | THE ONE TOOL - Contexto unificado (schema, módulos, vistas, packages) |
 | `gufi_whoami` | Ver usuario y entorno actual |
-| `gufi_schema` | Ver estructura de tablas |
 | **Companies** | |
 | `gufi_companies` | Listar companies del usuario |
 | `gufi_company_create` | Crear nueva company |

package/dist/commands/doctor.js

@@ -53,33 +53,39 @@ function countResults(sections) {
 // ════════════════════════════════════════════════════════════════════
 function validateFeatureConfig(content, filePath) {
     const results = [];
-    // Check export default
-    if (!content.includes("export default")) {
-        results.push({
-            status: "error",
-            message: "Falta export default del componente",
-            details: filePath,
-        });
-    }
-    else {
-        results.push({ status: "ok", message: "export default presente" });
-    }
-    // Check featureConfig export
-    if (!content.includes("export { featureConfig }") && !content.includes("export {featureConfig}")) {
-        // Check if it's a re-export
-        if (!content.match(/export\s*{\s*featureConfig\s*}\s*from/)) {
+    // 💜 These checks only apply to the ROOT index.tsx (main entry point)
+    // Paths like /components/index.tsx or /core/index.tsx are NOT the main entry
+    const isIndexFile = filePath === "index.tsx" || filePath === "/index.tsx";
+    if (isIndexFile) {
+        // Check export default (supports both `export default` and `export { default }` re-export)
+        const hasExportDefault = content.includes("export default") || content.match(/export\s*{\s*default\s*}\s*from/);
+        if (!hasExportDefault) {
             results.push({
                 status: "error",
-                message: "Falta export { featureConfig }",
-                details: "Necesario para que Developer Center detecte la configuración",
+                message: "Falta export default del componente",
+                details: filePath,
             });
         }
         else {
-            results.push({ status: "ok", message: "featureConfig re-exportado" });
+            results.push({ status: "ok", message: "export default presente" });
+        }
+        // Check featureConfig export
+        if (!content.includes("export { featureConfig }") && !content.includes("export {featureConfig}")) {
+            // Check if it's a re-export
+            if (!content.match(/export\s*{\s*featureConfig\s*}\s*from/)) {
+                results.push({
+                    status: "error",
+                    message: "Falta export { featureConfig }",
+                    details: "Necesario para que Developer Center detecte la configuración",
+                });
+            }
+            else {
+                results.push({ status: "ok", message: "featureConfig re-exportado" });
+            }
+        }
+        else {
+            results.push({ status: "ok", message: "featureConfig exportado" });
         }
-    }
-    else {
-        results.push({ status: "ok", message: "featureConfig exportado" });
     }
     // Check for hardcoded table IDs
     const hardcodedIds = content.match(/['"](m\d+_t\d+)['"]/g);
@@ -106,6 +112,54 @@ function validateFeatureConfig(content, filePath) {
             details: "Usar gufi.dataProvider en lugar de importar directamente",
         });
     }
+    // 💜 Check for deprecated useCompanySchemaStore
+    if (content.includes("useCompanySchemaStore")) {
+        results.push({
+            status: "error",
+            message: "useCompanySchemaStore está deprecado",
+            details: "Usar useSchemaStore de @/stores/useSchemaStore o gufi.context.schema",
+        });
+    }
+    // 💜 Check for runAnalyticsSpec (not available in marketplace SDK)
+    if (content.includes("runAnalyticsSpec")) {
+        results.push({
+            status: "error",
+            message: "runAnalyticsSpec no disponible en SDK",
+            details: "Reemplazar con dataProvider.getList() + filtros, o usar agregación SQL en backend",
+        });
+    }
+    // 💜 Check for optional chaining on gufi (gufi?.)
+    if (content.match(/gufi\?\./)) {
+        results.push({
+            status: "warning",
+            message: "gufi?. con optional chaining - gufi debe ser REQUIRED",
+            details: "Quitar ?. y usar gufi. directamente. gufi: FullGufiContext en props (no opcional)",
+        });
+    }
+    // 💜 Check for optional gufi prop (gufi?:)
+    if (content.match(/gufi\?: /)) {
+        results.push({
+            status: "error",
+            message: "gufi prop es opcional - debe ser REQUIRED",
+            details: "Cambiar 'gufi?:' a 'gufi:' en la interface. gufi siempre se provee a vistas marketplace",
+        });
+    }
+    // 💜 Check for direct notification import
+    if (content.match(/import.*from\s+['"]@\/shared\/notifications/)) {
+        results.push({
+            status: "warning",
+            message: "Import directo de notifications",
+            details: "Usar gufi.utils.toastSuccess/toastError/toastInfo en su lugar",
+        });
+    }
+    // 💜 Check for direct language import
+    if (content.match(/import.*from\s+['"]@\/shared\/language/)) {
+        results.push({
+            status: "warning",
+            message: "Import directo de language",
+            details: "Usar gufi.context.lang y gufi.utils.tUI en su lugar",
+        });
+    }
     return results;
 }
 function validateDataSources(content) {
@@ -545,13 +599,26 @@ export async function doctorCommand(options) {
                 const files = await getViewFiles(parseInt(options.view, 10));
                 const viewResults = [];
                 viewResults.push({ status: "ok", message: `Vista: ${view.name}` });
-                const indexFile = files.find((f) => f.file_path === "index.tsx");
-                if (indexFile) {
-                    viewResults.push(...validateFeatureConfig(indexFile.content, "index.tsx"));
+                // 💜 Analyze ALL code files, not just index.tsx
+                const codeFiles = files.filter((f) => f.file_path.match(/\.(tsx?|jsx?)$/));
+                viewResults.push({ status: "ok", message: `${codeFiles.length} archivos de código` });
+                for (const file of codeFiles) {
+                    const fileResults = validateFeatureConfig(file.content, file.file_path);
+                    // Only add non-ok results to avoid clutter
+                    const issues = fileResults.filter(r => r.status !== "ok");
+                    if (issues.length > 0) {
+                        viewResults.push({
+                            status: "warning",
+                            message: `Archivo: ${file.file_path}`,
+                        });
+                        viewResults.push(...issues);
+                    }
                 }
                 const dpFile = files.find((f) => f.file_path === "core/dataProvider.ts");
                 if (dpFile) {
-                    viewResults.push(...validateDataSources(dpFile.content));
+                    const dpResults = validateDataSources(dpFile.content);
+                    const dpIssues = dpResults.filter(r => r.status !== "ok");
+                    viewResults.push(...dpIssues);
                 }
                 allSections.push({ title: `Vista ${options.view}`, results: viewResults });
             }

package/dist/commands/push.d.ts

@@ -2,14 +2,10 @@
  * gufi push - Upload local changes to Gufi
  * 💜 Now with featureConfig validation!
  */
-interface PushFlags {
-    force?: boolean;
-}
-export declare function pushCommand(viewDir?: string | object, flags?: PushFlags): Promise<void>;
+export declare function pushCommand(viewDir?: string | object): Promise<void>;
 /**
  * gufi view:errors - Validate view files without pushing
  * 💜 Check for errors BEFORE you push!
  */
 export declare function viewErrorsCommand(viewIdArg?: string | number): Promise<void>;
 export declare function statusCommand(viewDir?: string | object): Promise<void>;
-export {};

package/dist/commands/push.js

@@ -60,17 +60,12 @@ function scanFilesInDirectory(dir, changedFiles) {
     }));
     return scanFilesForXSS(filesToScan);
 }
-export async function pushCommand(viewDir, flags = {}) {
+export async function pushCommand(viewDir) {
     if (!isLoggedIn()) {
         console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
         process.exit(1);
     }
     console.log(chalk.magenta("\n  🟣 Gufi Push\n"));
-    // 💜 Check for --force flag
-    const forceMode = flags.force || false;
-    if (forceMode) {
-        console.log(chalk.yellow("  ⚡ Modo forzado: subiendo todos los archivos\n"));
-    }
     // Determine view directory:
     // 1. Explicit path argument
     // 2. Current directory if it has .gufi-view.json
@@ -129,7 +124,7 @@ export async function pushCommand(viewDir, flags = {}) {
     // 💜 Push changes (simple hash comparison)
     const spinner = ora("Subiendo cambios...").start();
     try {
-        const result = await pushView(dir, { force: forceMode });
+        const result = await pushView(dir);
         spinner.succeed(chalk.green(`${result.pushed} archivo(s) subido(s)`));
     }
     catch (error) {

package/dist/index.js

@@ -337,8 +337,7 @@ program
 program
     .command("view:push [path]")
     .description("Subir cambios locales a Gufi (con validación)")
-    .option("-f, --force", "Forzar push de todos los archivos (ignora detección de cambios)")
-    .action((path, options) => pushCommand(path, { force: options.force }));
+    .action((path) => pushCommand(path));
 program
     .command("view:watch [path]")
     .description("Auto-sync al guardar archivos")

package/dist/lib/security.js

@@ -77,9 +77,10 @@ const SUSPICIOUS_PATTERNS = [
         message: "Location redirect detected - verify this is intentional",
         severity: "warning",
     },
-    // Script injection
+    // Script injection (only real JSX script tags, not strings for print windows)
+    // Note: <script in template literals for print windows is allowed
     {
-        pattern: /<script/gi,
+        pattern: /<script(?![^`]*`)/gi,
         message: "Script tag detected - not allowed in views",
         severity: "error",
     },
@@ -103,6 +104,13 @@ const ALLOWED_PATTERNS = [
     // Common false positives
     /useViewPreferences/, // Our localStorage wrapper
     /@\/shared\/hooks/, // Our hooks that safely use storage
+    // Print window patterns - legitimate use for printing barcodes/labels
+    /printWindow/i,
+    /window\.print/i,
+    /JsBarcode/,
+    // Script tags inside template literals (for print windows)
+    /^\s*<script>\s*$/,
+    /^\s*<\/script>\s*$/,
 ];
 /**
  * Scan a file for suspicious patterns

package/dist/lib/sync.d.ts

@@ -28,9 +28,7 @@ export declare function pullView(viewId: number, viewKey: string, packageId: num
  * Simple logic: compare local content hash with stored hash from last pull/push
  * No server calls, no mtime fallbacks - just hash comparison
  */
-export declare function pushView(viewDir?: string, options?: {
-    force?: boolean;
-}): Promise<{
+export declare function pushView(viewDir?: string): Promise<{
     pushed: number;
 }>;
 /**

package/dist/lib/sync.js

@@ -87,8 +87,7 @@ export async function pullView(viewId, viewKey, packageId) {
  * Simple logic: compare local content hash with stored hash from last pull/push
  * No server calls, no mtime fallbacks - just hash comparison
  */
-export async function pushView(viewDir, options = {}) {
-    const { force = false } = options;
+export async function pushView(viewDir) {
     const dir = viewDir || getCurrentView()?.localPath;
     if (!dir) {
         throw new Error("No hay vista activa. Usa: gufi pull <vista>");
@@ -104,11 +103,9 @@ export async function pushView(viewDir, options = {}) {
         const localHash = hashContent(content);
         const filePath = "/" + file;
         // Simple change detection: hash differs from stored hash?
-        if (!force) {
-            const storedMeta = meta.files[filePath];
-            if (storedMeta && storedMeta.hash === localHash) {
-                continue; // No changes - hash matches what we had
-            }
+        const storedMeta = meta.files[filePath];
+        if (storedMeta && storedMeta.hash === localHash) {
+            continue; // No changes - hash matches what we had
         }
         // Push to Gufi
         await saveViewFile(meta.viewId, {

package/dist/mcp.js

@@ -208,118 +208,6 @@ function normalizeFileFields(data) {
     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
@@ -354,7 +242,9 @@ const TOOLS = [
                 package_id: { type: "string", description: "Package ID to get context for" },
                 view_id: { type: "string", description: "View ID to get context for" },
                 company_id: { type: "string", description: "Company ID to get context for" },
-                full: { type: "boolean", description: "Include detailed explanations of Gufi concepts (viewSpec, dataSources, CB builders, etc.)" },
+                module_id: { type: "string", description: "Module ID to get detailed context for (requires company_id)" },
+                entity_id: { type: "string", description: "Entity ID to get detailed context for (requires company_id)" },
+                detail: { type: "string", description: "Level of detail: 'summary' (default) or 'full' (Claude-optimized complete export with all fields, automations, webhooks, etc.)" },
             },
         },
     },
@@ -363,17 +253,7 @@ const TOOLS = [
         description: getDesc("gufi_whoami"),
         inputSchema: { type: "object", properties: {} },
     },
-    {
-        name: "gufi_schema",
-        description: getDesc("gufi_schema"),
-        inputSchema: {
-            type: "object",
-            properties: {
-                company_id: { type: "string", description: "Company ID (optional if user has only one company)" },
-                format: { type: "string", description: "Output format: 'flat' (text, default) or 'json' (structured)" },
-            },
-        },
-    },
+    // gufi_schema REMOVED - functionality merged into gufi_context with detail: "full"
     {
         name: "gufi_schema_modify",
         description: getDesc("gufi_schema_modify"),
@@ -767,6 +647,18 @@ const TOOLS = [
             required: ["view_id"],
         },
     },
+    {
+        name: "gufi_view_read",
+        description: "📖 Read the full content of view files. Returns actual code, not just metadata.\n\nUse this to:\n- Debug view issues by reading the code\n- Understand view structure before making changes\n- Find bugs or incorrect imports\n\nExample: gufi_view_read({ view_id: 3 }) → Returns all files with content\ngufi_view_read({ view_id: 3, file_path: 'views/page.tsx' }) → Returns specific file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_id: { type: "number", description: "View ID" },
+                file_path: { type: "string", description: "Optional: specific file path to read (e.g., 'views/page.tsx')" },
+            },
+            required: ["view_id"],
+        },
+    },
     {
         name: "gufi_view_create",
         description: getDesc("gufi_view_create"),
@@ -781,6 +673,17 @@ const TOOLS = [
             required: ["name", "template"],
         },
     },
+    {
+        name: "gufi_view_diagnose",
+        description: "🔍 Diagnose common issues in a marketplace view.\n\nAutomatically detects:\n- Deprecated store imports (useCompanySchemaStore)\n- Forbidden @/stores imports\n- Unavailable SDK functions (runAnalyticsSpec)\n- Optional chaining on gufi (gufi?.xxx)\n- Missing gufi prop patterns\n- Hardcoded table names\n\nReturns actionable fixes for each issue found.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                view_id: { type: "number", description: "View ID to diagnose" },
+            },
+            required: ["view_id"],
+        },
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Packages (Marketplace Distribution)
     // ─────────────────────────────────────────────────────────────────────────
@@ -1195,14 +1098,27 @@ const toolHandlers = {
     },
     async gufi_context(params) {
         // Generate intelligent context based on what's requested
+        const wantsFull = params.detail === "full";
+        // Module-specific context (uses export-claude endpoint)
+        if (params.module_id && params.company_id) {
+            return getClaudeOptimizedContext(params.company_id, params.module_id, undefined, wantsFull);
+        }
+        // Entity-specific context (uses export-claude endpoint)
+        if (params.entity_id && params.company_id) {
+            return getClaudeOptimizedContext(params.company_id, undefined, params.entity_id, wantsFull);
+        }
         if (params.view_id) {
-            return generateViewContextMcp(parseInt(params.view_id), params.full);
+            return generateViewContextMcp(parseInt(params.view_id), wantsFull);
         }
         else if (params.package_id) {
-            return generatePackageContextMcp(parseInt(params.package_id), params.full);
+            return generatePackageContextMcp(parseInt(params.package_id), wantsFull);
         }
         else if (params.company_id) {
-            return generateCompanyContextMcp(parseInt(params.company_id), params.full);
+            // Company context - use Claude-optimized export when detail is "full"
+            if (wantsFull) {
+                return getClaudeOptimizedContext(params.company_id, undefined, undefined, true);
+            }
+            return generateCompanyContextMcp(parseInt(params.company_id), false);
         }
         else {
             // Auto-detect context from current directory
@@ -1237,7 +1153,7 @@ const toolHandlers = {
             // 2. Check if we're in a view directory (.gufi-view.json)
             const viewMeta = loadViewMetaFromCwd();
             if (viewMeta) {
-                return generateViewContextMcp(viewMeta.viewId, params.full);
+                return generateViewContextMcp(viewMeta.viewId, wantsFull);
             }
             // 3. Fallback: Return packages overview
             const response = await developerRequest("/my-packages");
@@ -1259,70 +1175,10 @@ const toolHandlers = {
             };
         }
     },
-    async gufi_schema(params) {
-        // 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,
-                            })),
-                        });
-                    }
-                }
-                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 as plain text for maximum readability
-        const schema = await response.text();
-        return { format: "flat", schema };
-    },
+    // gufi_schema REMOVED - functionality merged into gufi_context with detail: "full"
+    // Use: gufi_context({ company_id: "X", detail: "full" })
+    //      gufi_context({ company_id: "X", module_id: "Y", detail: "full" })
+    //      gufi_context({ company_id: "X", entity_id: "Z", detail: "full" })
     async gufi_schema_modify(params) {
         // Use the new /api/schema/operations endpoint for semantic operations
         const result = await apiRequest("/api/schema/operations", {
@@ -1789,11 +1645,6 @@ const toolHandlers = {
             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),
@@ -1805,11 +1656,6 @@ const toolHandlers = {
                     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),
@@ -1869,11 +1715,6 @@ const toolHandlers = {
     async gufi_row_create(params) {
         // 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(normalizedData),
@@ -1888,11 +1729,6 @@ const toolHandlers = {
     async gufi_row_update(params) {
         // 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(normalizedData),
@@ -1979,6 +1815,140 @@ const toolHandlers = {
                 : `❌ ${response.errors?.length || 0} errors, ${response.warnings?.length || 0} warnings`,
         };
     },
+    async gufi_view_read(params) {
+        const files = await getViewFiles(params.view_id);
+        // If specific file requested, return just that file
+        if (params.file_path) {
+            const file = files.find((f) => f.file_path === params.file_path || f.file_path === `/${params.file_path}` || `/${f.file_path}` === params.file_path);
+            if (!file) {
+                return {
+                    error: `File not found: ${params.file_path}`,
+                    available_files: files.map((f) => f.file_path),
+                };
+            }
+            return {
+                view_id: params.view_id,
+                file_path: file.file_path,
+                language: file.language,
+                content: file.content,
+                size: file.content.length,
+            };
+        }
+        // Return all files with content
+        return {
+            view_id: params.view_id,
+            total_files: files.length,
+            files: files.map((f) => ({
+                path: f.file_path,
+                language: f.language,
+                is_entry_point: f.is_entry_point,
+                content: f.content,
+                size: f.content.length,
+            })),
+        };
+    },
+    async gufi_view_diagnose(params) {
+        const files = await getViewFiles(params.view_id);
+        const issues = [];
+        // Patterns to detect
+        const patterns = [
+            {
+                regex: /useCompanySchemaStore/g,
+                issue: "Deprecated store import: useCompanySchemaStore",
+                severity: "error",
+                fix: "Use useSchemaStore from @/stores/useSchemaStore or gufi.context.schema",
+            },
+            {
+                regex: /@\/stores\/(?!useSchemaStore|useAuthStore|usePermissionsStore)/g,
+                issue: "Forbidden store import in marketplace view",
+                severity: "error",
+                fix: "Use gufi.context or gufi.utils instead of direct store imports",
+            },
+            {
+                regex: /runAnalyticsSpec/g,
+                issue: "runAnalyticsSpec is not available in marketplace SDK",
+                severity: "error",
+                fix: "Replace with dataProvider.getList() with filters, or use SQL aggregation on backend",
+            },
+            {
+                regex: /gufi\?\./g,
+                issue: "Optional chaining on gufi - gufi should be REQUIRED",
+                severity: "warning",
+                fix: "Remove ?. and use gufi. directly. Ensure gufi: FullGufiContext in props (not optional)",
+            },
+            {
+                regex: /gufi\?: /g,
+                issue: "gufi prop is optional - should be REQUIRED",
+                severity: "error",
+                fix: "Change 'gufi?:' to 'gufi:' in interface. gufi is always provided to marketplace views",
+            },
+            {
+                regex: /['"]m\d+_t\d+['"]/g,
+                issue: "Hardcoded physical table ID",
+                severity: "warning",
+                fix: "Use logical table names like 'module.entity' instead of physical IDs",
+            },
+            {
+                regex: /import.*from\s+['"]@\/shared\/notifications/g,
+                issue: "Direct notification import - use gufi.utils instead",
+                severity: "warning",
+                fix: "Use gufi.utils.toastSuccess/toastError/toastInfo instead",
+            },
+            {
+                regex: /import.*from\s+['"]@\/shared\/language/g,
+                issue: "Direct language import - use gufi.context instead",
+                severity: "warning",
+                fix: "Use gufi.context.lang and gufi.utils.tUI instead",
+            },
+        ];
+        for (const file of files) {
+            if (!file.file_path.match(/\.(tsx?|jsx?)$/))
+                continue;
+            const lines = file.content.split("\n");
+            for (const pattern of patterns) {
+                // Reset regex
+                pattern.regex.lastIndex = 0;
+                let match;
+                while ((match = pattern.regex.exec(file.content)) !== null) {
+                    // Find line number
+                    const beforeMatch = file.content.slice(0, match.index);
+                    const lineNumber = beforeMatch.split("\n").length;
+                    // 💜 Skip if line is a comment (ignore false positives from documentation)
+                    const line = lines[lineNumber - 1] || "";
+                    const trimmedLine = line.trim();
+                    if (trimmedLine.startsWith("//") || trimmedLine.startsWith("*") || trimmedLine.startsWith("/*")) {
+                        continue;
+                    }
+                    issues.push({
+                        file: file.file_path,
+                        line: lineNumber,
+                        issue: pattern.issue,
+                        severity: pattern.severity,
+                        fix: pattern.fix,
+                    });
+                }
+            }
+        }
+        // Group issues by severity
+        const errors = issues.filter(i => i.severity === "error");
+        const warnings = issues.filter(i => i.severity === "warning");
+        return {
+            view_id: params.view_id,
+            total_issues: issues.length,
+            errors: errors.length,
+            warnings: warnings.length,
+            status: errors.length > 0 ? "❌ Has blocking issues" : warnings.length > 0 ? "⚠️ Has warnings" : "✅ No issues found",
+            issues: issues.map(i => ({
+                ...i,
+                location: `${i.file}:${i.line}`,
+            })),
+            summary: errors.length > 0
+                ? `Found ${errors.length} error(s) that will cause runtime failures`
+                : warnings.length > 0
+                    ? `Found ${warnings.length} warning(s) that should be reviewed`
+                    : "View follows marketplace best practices",
+        };
+    },
     async gufi_view_create(params) {
         // Generate safe function name
         const safeName = params.name.replace(/[^a-zA-Z0-9]/g, "");
@@ -2670,6 +2640,63 @@ export const featureConfig: FeatureConfig = {
 // ════════════════════════════════════════════════════════════════════════════
 // Context Generation Helpers
 // ════════════════════════════════════════════════════════════════════════════
+/**
+ * Get Claude-optimized context using the export-claude backend endpoint.
+ * This returns the full schema in a format designed for Claude's comprehension.
+ *
+ * @param companyId - Company ID (required)
+ * @param moduleId - Optional module ID to filter by
+ * @param entityId - Optional entity ID to filter by
+ * @param fullText - If true, return as plain text. Otherwise return structured.
+ */
+async function getClaudeOptimizedContext(companyId, moduleId, entityId, fullText = true) {
+    // Build query params
+    const params = new URLSearchParams();
+    if (moduleId)
+        params.set("module_id", moduleId);
+    if (entityId)
+        params.set("entity_id", entityId);
+    const queryString = params.toString();
+    const url = `${getApiUrl()}/api/schema/export-claude${queryString ? "?" + queryString : ""}`;
+    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",
+        "X-Company-ID": companyId,
+    };
+    const response = await fetch(url, { headers });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`API Error ${response.status}: ${text}`);
+    }
+    // Return as plain text for maximum readability
+    const schema = await response.text();
+    if (fullText) {
+        return {
+            type: entityId ? "entity_context" : moduleId ? "module_context" : "company_context",
+            format: "claude_optimized",
+            company_id: companyId,
+            module_id: moduleId || null,
+            entity_id: entityId || null,
+            schema,
+            hint: "This is the complete schema in Claude-optimized format. Use it to understand the data structure.",
+        };
+    }
+    // Parse and return structured (for summary mode)
+    return {
+        type: entityId ? "entity_context" : moduleId ? "module_context" : "company_context",
+        format: "claude_optimized",
+        company_id: companyId,
+        module_id: moduleId || null,
+        entity_id: entityId || null,
+        schema,
+    };
+}
 async function generateViewContextMcp(viewId, includeConcepts) {
     // Use apiRequest for view details
     const viewResponse = await apiRequest(`/api/marketplace/views/${viewId}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gufi-cli",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "CLI for developing Gufi Marketplace views locally with Claude Code",
   "bin": {
     "gufi": "./bin/gufi.js"