gufi-cli 0.1.31 → 0.1.33

package/dist/commands/push.js

@@ -51,6 +51,163 @@ function scanFilesInDirectory(dir, changedFiles) {
     }));
     return scanFilesForXSS(filesToScan);
 }
+/**
+ * Validate view structure before push
+ * REQUIRED files:
+ * - index.tsx (entry point)
+ * - core/dataSources.ts (table mappings)
+ *
+ * RECOMMENDED files:
+ * - core/index.tsx (featureConfig)
+ * - views/page.tsx (main component)
+ */
+function validateViewStructure(dir) {
+    const errors = [];
+    const allFiles = getAllFilesInDir(dir);
+    // 1. REQUIRED: index.tsx (entry point)
+    if (!allFiles.includes("index.tsx")) {
+        errors.push({
+            severity: "error",
+            message: "Falta archivo obligatorio: index.tsx",
+            file: "index.tsx",
+            hint: `Crear con:
+  export { featureConfig } from './core';
+  import Page from './views/page';
+  export default Page;`,
+        });
+    }
+    else {
+        // Validate index.tsx exports featureConfig
+        const indexContent = fs.readFileSync(path.join(dir, "index.tsx"), "utf-8");
+        if (!indexContent.includes("featureConfig")) {
+            errors.push({
+                severity: "error",
+                message: "index.tsx debe exportar featureConfig",
+                file: "index.tsx",
+                hint: "Añadir: export { featureConfig } from './core';",
+            });
+        }
+        if (!indexContent.includes("export default")) {
+            errors.push({
+                severity: "error",
+                message: "index.tsx debe tener un export default (componente)",
+                file: "index.tsx",
+                hint: "Añadir: export default Page; (o importar y re-exportar)",
+            });
+        }
+    }
+    // 2. REQUIRED: core/dataSources.ts (table mappings)
+    const hasDataSources = allFiles.includes("core/dataSources.ts");
+    const hasCoreIndex = allFiles.includes("core/index.tsx");
+    if (!hasDataSources) {
+        // Check if dataSources is in core/index.tsx (also valid)
+        let dataSourcesInCoreIndex = false;
+        if (hasCoreIndex) {
+            const coreIndexContent = fs.readFileSync(path.join(dir, "core/index.tsx"), "utf-8");
+            dataSourcesInCoreIndex = coreIndexContent.includes("dataSources");
+        }
+        if (!dataSourcesInCoreIndex) {
+            errors.push({
+                severity: "error",
+                message: "Falta archivo obligatorio: core/dataSources.ts",
+                file: "core/dataSources.ts",
+                hint: `Crear con:
+  export const dataSources = [
+    { key: 'main', table: 'modulo.entidad' },
+  ] as const;`,
+            });
+        }
+    }
+    else {
+        // Validate dataSources.ts has correct structure
+        const dsContent = fs.readFileSync(path.join(dir, "core/dataSources.ts"), "utf-8");
+        if (!dsContent.includes("dataSources")) {
+            errors.push({
+                severity: "error",
+                message: "core/dataSources.ts debe exportar 'dataSources'",
+                file: "core/dataSources.ts",
+                hint: "export const dataSources = [{ key: '...', table: '...' }] as const;",
+            });
+        }
+    }
+    // 3. RECOMMENDED: core/index.tsx (featureConfig)
+    if (!hasCoreIndex) {
+        errors.push({
+            severity: "warning",
+            message: "Recomendado: crear core/index.tsx con featureConfig",
+            file: "core/index.tsx",
+            hint: `export const featureConfig = {
+  dataSources,
+  meta: { name: 'Mi Vista', version: '1.0.0' }
+};`,
+        });
+    }
+    else {
+        const coreContent = fs.readFileSync(path.join(dir, "core/index.tsx"), "utf-8");
+        if (!coreContent.includes("featureConfig")) {
+            errors.push({
+                severity: "warning",
+                message: "core/index.tsx debería exportar featureConfig",
+                file: "core/index.tsx",
+            });
+        }
+    }
+    // 4. RECOMMENDED: views/page.tsx or similar
+    const hasPageComponent = allFiles.some((f) => f.startsWith("views/") && (f.endsWith(".tsx") || f.endsWith(".jsx")));
+    if (!hasPageComponent) {
+        errors.push({
+            severity: "warning",
+            message: "Recomendado: crear views/page.tsx (componente principal)",
+            file: "views/page.tsx",
+        });
+    }
+    return errors;
+}
+/**
+ * Get all files in directory recursively (relative paths)
+ */
+function getAllFilesInDir(dir) {
+    const files = [];
+    function scan(currentDir, relativePath = "") {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                // Skip hidden dirs and node_modules
+                if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
+                    scan(path.join(currentDir, entry.name), relPath);
+                }
+            }
+            else if (!entry.name.startsWith(".")) {
+                files.push(relPath);
+            }
+        }
+    }
+    scan(dir);
+    return files;
+}
+function showStructureErrors(errors) {
+    const criticalErrors = errors.filter((e) => e.severity === "error");
+    const warnings = errors.filter((e) => e.severity === "warning");
+    if (criticalErrors.length > 0) {
+        console.log(chalk.red("\n  ✗ Errores de estructura (BLOQUEANTES):"));
+        for (const error of criticalErrors) {
+            console.log(chalk.red(`    • ${error.message}`));
+            if (error.hint) {
+                console.log(chalk.gray(`      ${error.hint.split("\n").join("\n      ")}`));
+            }
+        }
+    }
+    if (warnings.length > 0) {
+        console.log(chalk.yellow("\n  ⚠ Advertencias de estructura:"));
+        for (const warning of warnings) {
+            console.log(chalk.yellow(`    • ${warning.message}`));
+            if (warning.hint) {
+                console.log(chalk.gray(`      ${warning.hint.split("\n").join("\n      ")}`));
+            }
+        }
+    }
+}
 export async function pushCommand(viewDir) {
     if (!isLoggedIn()) {
         console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
@@ -87,6 +244,25 @@ export async function pushCommand(viewDir) {
         console.log(chalk.yellow(`    • ${file}`));
     });
     console.log();
+    // 💜 Structure validation (BEFORE pushing)
+    const structureSpinner = ora("Validando estructura...").start();
+    const structureErrors = validateViewStructure(dir);
+    const criticalErrors = structureErrors.filter((e) => e.severity === "error");
+    const structureWarnings = structureErrors.filter((e) => e.severity === "warning");
+    if (criticalErrors.length > 0) {
+        structureSpinner.fail(chalk.red("Estructura inválida"));
+        showStructureErrors(structureErrors);
+        console.log(chalk.red("\n  ✗ Push bloqueado. Corrige los errores primero.\n"));
+        process.exit(1);
+    }
+    else if (structureWarnings.length > 0) {
+        structureSpinner.warn(chalk.yellow("Advertencias de estructura"));
+        showStructureErrors(structureErrors);
+        console.log();
+    }
+    else {
+        structureSpinner.succeed(chalk.green("Estructura válida"));
+    }
     // Security scan
     const securitySpinner = ora("Escaneando seguridad...").start();
     const securityWarnings = scanFilesInDirectory(dir, changedFiles);

package/dist/mcp.js

@@ -49,6 +49,35 @@ function setCachedViewContext(viewId, context) {
     viewContextCache.set(viewId, { data: context, timestamp: Date.now() });
 }
 // ════════════════════════════════════════════════════════════════════════════
+// Analytics - Track MCP tool calls
+// ════════════════════════════════════════════════════════════════════════════
+async function trackAnalytics(data) {
+    try {
+        const token = getToken();
+        if (!token) {
+            console.error("[MCP Analytics] No token, skipping");
+            return;
+        }
+        const url = `${getApiUrl()}/api/cli/mcp-analytics`;
+        console.error(`[MCP Analytics] Tracking ${data.tool_name} to ${url}`);
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Client": "mcp",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify(data),
+        });
+        if (!res.ok) {
+            console.error(`[MCP Analytics] Failed: ${res.status}`);
+        }
+    }
+    catch (err) {
+        console.error(`[MCP Analytics] Error: ${err.message}`);
+    }
+}
+// ════════════════════════════════════════════════════════════════════════════
 // API Client (reused from CLI)
 // ════════════════════════════════════════════════════════════════════════════
 async function autoLogin() {
@@ -235,6 +264,79 @@ function normalizeFileFields(data) {
     return normalized;
 }
 // ════════════════════════════════════════════════════════════════════════════
+// Table Name Resolution (logical → physical)
+// ════════════════════════════════════════════════════════════════════════════
+// Cache for company schemas (to resolve logical table names)
+const schemaCache = new Map();
+const SCHEMA_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+/**
+ * Physical table name regex: m{moduleId}_t{tableId}
+ */
+const PHYSICAL_TABLE_RE = /^m\d+_t\d+$/;
+/**
+ * Get company schema (cached)
+ */
+async function getCompanySchema(companyId) {
+    const cached = schemaCache.get(companyId);
+    if (cached && Date.now() - cached.timestamp < SCHEMA_CACHE_TTL) {
+        return cached.schema;
+    }
+    try {
+        const data = await apiRequest("/api/cli/schema", {}, companyId);
+        schemaCache.set(companyId, { schema: data, timestamp: Date.now() });
+        return data;
+    }
+    catch (err) {
+        console.error(`[MCP] Failed to get schema for company ${companyId}:`, err.message);
+        return null;
+    }
+}
+/**
+ * Resolve a table name: logical (module.entity) → physical (m123_t456)
+ * If already physical, returns as-is
+ * @param tableName - logical name like "taller.clientes" or physical like "m366_t12269"
+ * @param companyId - company ID for schema lookup
+ * @returns physical table name or throws error
+ */
+async function resolveTableName(tableName, companyId) {
+    // If already physical, return as-is
+    if (PHYSICAL_TABLE_RE.test(tableName)) {
+        return tableName;
+    }
+    // Try to resolve logical name (module.entity format)
+    const parts = tableName.split(".");
+    if (parts.length !== 2) {
+        throw new Error(`Invalid table name: "${tableName}". Use physical (m123_t456) or logical (module.entity) format`);
+    }
+    const [moduleName, entityName] = parts;
+    const schema = await getCompanySchema(companyId);
+    if (!schema?.modules) {
+        throw new Error(`Cannot resolve logical table name "${tableName}": schema not available. Use physical name (m123_t456) instead`);
+    }
+    // Find module and entity
+    for (const mod of schema.modules) {
+        const modMatch = mod.name?.toLowerCase() === moduleName.toLowerCase() ||
+            mod.label?.toLowerCase() === moduleName.toLowerCase();
+        if (!modMatch)
+            continue;
+        for (const ent of mod.entities || []) {
+            const entMatch = ent.name?.toLowerCase() === entityName.toLowerCase() ||
+                ent.label?.toLowerCase() === entityName.toLowerCase();
+            if (entMatch) {
+                // Found! Build physical name from entity ID
+                const moduleId = mod.id;
+                const tableId = ent.id;
+                if (moduleId && tableId) {
+                    return `m${moduleId}_t${tableId}`;
+                }
+            }
+        }
+    }
+    throw new Error(`Table "${tableName}" not found in schema. Available modules: ${schema.modules
+        .map((m) => m.name)
+        .join(", ")}`);
+}
+// ════════════════════════════════════════════════════════════════════════════
 // Tool Definitions - Descriptions loaded from docs/mcp/tool-descriptions.json
 // ════════════════════════════════════════════════════════════════════════════
 // Load tool descriptions from centralized documentation
@@ -891,7 +993,9 @@ const toolHandlers = {
     // ─────────────────────────────────────────────────────────────────────────
     async gufi_data(params) {
         // 💜 Unified data tool - all CRUD operations in one
-        const { action, table, company_id } = params;
+        const { action, company_id } = params;
+        // 💜 Resolve logical table names (module.entity) to physical (m123_t456)
+        const table = await resolveTableName(params.table, company_id);
         switch (action) {
             case "list": {
                 const limit = params.limit || 20;
@@ -1623,10 +1727,27 @@ async function handleRequest(request) {
                 const handler = toolHandlers[toolName];
                 if (!handler) {
                     sendError(id, -32601, `Unknown tool: ${toolName}`);
+                    // Track unknown tool
+                    trackAnalytics({
+                        tool_name: toolName || "unknown",
+                        success: false,
+                        error_message: `Unknown tool: ${toolName}`,
+                        duration_ms: 0,
+                        input: toolParams,
+                    });
                     return;
                 }
+                const startTime = Date.now();
                 try {
                     const result = await handler(toolParams);
+                    const duration = Date.now() - startTime;
+                    // Track success
+                    trackAnalytics({
+                        tool_name: toolName,
+                        success: true,
+                        duration_ms: duration,
+                        input: toolParams,
+                    });
                     sendResponse({
                         jsonrpc: "2.0",
                         id,
@@ -1641,6 +1762,15 @@ async function handleRequest(request) {
                     });
                 }
                 catch (err) {
+                    const duration = Date.now() - startTime;
+                    // Track error
+                    trackAnalytics({
+                        tool_name: toolName,
+                        success: false,
+                        error_message: err.message,
+                        duration_ms: duration,
+                        input: toolParams,
+                    });
                     sendResponse({
                         jsonrpc: "2.0",
                         id,

package/package.json

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