gufi-cli 0.1.18 → 0.1.21

package/CLAUDE.md

@@ -11,9 +11,13 @@
 ## Quick Reference
 
 ```bash
-# Contexto y diagnóstico
+# Contexto, diagnóstico y documentación
 gufi context              # Genera contexto para Claude
 gufi doctor               # Diagnóstico del sistema
+gufi docs                 # Ver topics disponibles
+gufi docs fields          # Documentación de tipos de campo
+gufi docs errors          # Errores comunes y soluciones
+gufi docs --search "currency"  # Buscar en toda la documentación
 
 # Entornos
 gufi config               # Ver entornos
@@ -68,12 +72,13 @@ El CLI incluye un servidor MCP que permite a Claude interactuar **directamente**
 claude mcp add --transport stdio gufi -- gufi mcp
 ```
 
-### Tools disponibles (42 tools)
+### Tools disponibles (43 tools)
 
 **Contexto e Info (EMPEZAR AQUÍ):**
 - `gufi_context` - **USAR PRIMERO** - Genera contexto inteligente del proyecto
 - `gufi_whoami` - Usuario y entorno actual
 - `gufi_schema` - Estructura de tablas/campos
+- `gufi_docs` - **LEER DOCUMENTACIÓN** - Topics: fields, views, automations, errors, examples
 
 **Companies:**
 - `gufi_companies` - Listar companies
@@ -149,7 +154,7 @@ Claude: [usa gufi_schema para encontrar tabla de clientes]
 Al crear o actualizar datos, usa los formatos correctos:
 
 **Simples:**
-- text, textarea, email, url, barcode: `"string"`
+- text, email, url, barcode: `"string"`
 - number_int: `42` | number_float: `3.14` | percentage: `0.75`
 - boolean: `true/false`
 - date: `"2024-01-15"` | datetime: `"2024-01-15T10:30:00Z"` | time: `"14:30:00"`
@@ -185,6 +190,8 @@ gufi.CB.multiselect('a', 'b') // → ['a', 'b']
 |-----------|---------|
 | **Contexto para Claude** | `gufi context` |
 | **Diagnóstico** | `gufi doctor` |
+| **Leer documentación** | `gufi docs fields` |
+| **Buscar en docs** | `gufi docs --search "currency"` |
 | Ver companies | `gufi companies` |
 | Ver módulos | `gufi modules 146` |
 | Editar módulo | `gufi module 360 --edit` |

package/dist/commands/companies.d.ts

@@ -62,3 +62,9 @@ export declare function automationsExecutionsCommand(options?: {
     limit?: string;
     script?: string;
 }): Promise<void>;
+export declare function automationExecuteCommand(automationIdOrName?: string, options?: {
+    company?: string;
+    input?: string;
+    wait?: boolean;
+    timeout?: string;
+}): Promise<void>;

package/dist/commands/companies.js

@@ -5,30 +5,13 @@
  */
 import chalk from "chalk";
 import { isLoggedIn, getApiUrl, getToken, getRefreshToken, setToken, loadConfig } from "../lib/config.js";
-import { COLUMN_TYPE_NAMES } from "@gufi/column-types";
-// 💜 Valid column types from @gufi/column-types + special types
-const VALID_COLUMN_TYPES = new Set([
-    ...COLUMN_TYPE_NAMES,
-    "gufi_id", // Special auto-generated ID type
-    "user", // Alias for users (singular)
-    "image", // Alias for file with image handling
-]);
-// 💜 Suggestions for common mistakes
-const TYPE_SUGGESTIONS = {
-    "number_decimal": "number_precise", // For financial values
-    "decimal": "number_precise",
-    "float": "number_float",
-    "int": "number_int",
-    "integer": "number_int",
-    "string": "text",
-    "varchar": "text",
-    "bool": "boolean",
-    "timestamp": "datetime",
-    "array": "multiselect",
-};
+import { getValidColumnTypes, getTypeSuggestions } from "../lib/columnTypes.js";
 const API_URL_BASE = "https://gogufi.com";
-function validateModuleColumnTypes(moduleJson) {
+async function validateModuleColumnTypes(moduleJson) {
     const errors = [];
+    // Fetch valid types and suggestions from API
+    const validTypes = await getValidColumnTypes();
+    const suggestions = await getTypeSuggestions();
     // Iterate through submodules
     for (const submodule of moduleJson.submodules || []) {
         // Iterate through entities
@@ -40,12 +23,12 @@ function validateModuleColumnTypes(moduleJson) {
             for (const field of entity.fields) {
                 if (!field.type)
                     continue;
-                if (!VALID_COLUMN_TYPES.has(field.type)) {
+                if (!validTypes.has(field.type)) {
                     errors.push({
                         entity: entity.name || entity.label,
                         field: field.name,
                         invalidType: field.type,
-                        suggestion: TYPE_SUGGESTIONS[field.type],
+                        suggestion: suggestions[field.type],
                     });
                 }
             }
@@ -646,14 +629,14 @@ async function editModuleJson(moduleId, currentJson, companyId) {
         console.log(chalk.red("\n  ✗ JSON inválido. Cambios no guardados.\n"));
         return;
     }
-    // 💜 Validate column types before saving
-    const typeErrors = validateModuleColumnTypes(newJson);
+    // 💜 Validate column types before saving (fetches from API)
+    const typeErrors = await validateModuleColumnTypes(newJson);
     if (typeErrors.length > 0) {
         console.log(chalk.red("\n  ✗ Tipos de columna inválidos:\n"));
         for (const err of typeErrors) {
             const suggestion = err.suggestion
                 ? chalk.cyan(` → Usa "${err.suggestion}" en su lugar`)
-                : chalk.gray(` (tipos válidos: text, number_int, number_float, number_precise, currency, select...)`);
+                : chalk.gray(` (tipos válidos: text, number_int, number_float, currency, select...)`);
             console.log(chalk.yellow(`    • ${err.entity}.${err.field}: "${err.invalidType}" no existe${suggestion}`));
         }
         console.log(chalk.gray(`\n  💡 Ver todos los tipos: https://github.com/juanbp23/gogufi/blob/main/libs/column-types/CLAUDE.md`));
@@ -743,15 +726,15 @@ export async function moduleUpdateCommand(moduleId, jsonFile, options) {
             process.exit(1);
         }
         console.log(chalk.green("  ✓ JSON válido"));
-        // 💜 Validate column types
+        // 💜 Validate column types (fetches from API)
         console.log(chalk.gray("  Validando tipos de columna..."));
-        const typeErrors = validateModuleColumnTypes(newJson);
+        const typeErrors = await validateModuleColumnTypes(newJson);
         if (typeErrors.length > 0) {
             console.log(chalk.red("\n  ✗ Tipos de columna inválidos:\n"));
             for (const err of typeErrors) {
                 const suggestion = err.suggestion
                     ? chalk.cyan(` → Usa "${err.suggestion}" en su lugar`)
-                    : chalk.gray(` (tipos válidos: text, number_int, number_float, number_precise, currency, select...)`);
+                    : chalk.gray(` (tipos válidos: text, number_int, number_float, currency, select...)`);
                 console.log(chalk.yellow(`    • ${err.entity}.${err.field}: "${err.invalidType}" no existe${suggestion}`));
             }
             console.log(chalk.gray(`\n  💡 Ver todos los tipos: https://github.com/juanbp23/gogufi/blob/main/libs/column-types/CLAUDE.md\n`));
@@ -1372,6 +1355,204 @@ export async function automationsExecutionsCommand(options) {
         console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
     }
 }
+// ════════════════════════════════════════════════════════════════════
+// gufi automation:execute <id_or_name> - Execute an automation script
+// 💜 Runs via pg-boss queue, returns jobId and polls for result
+// ════════════════════════════════════════════════════════════════════
+export async function automationExecuteCommand(automationIdOrName, options) {
+    if (!isLoggedIn()) {
+        console.log(chalk.red("\n  ✗ No estás logueado. Usa: gufi login\n"));
+        process.exit(1);
+    }
+    if (!automationIdOrName) {
+        console.log(chalk.red("\n  ✗ Uso: gufi automation:execute <id_or_name> [--input '{...}'] [--wait]\n"));
+        console.log(chalk.gray("  Ejemplos:"));
+        console.log(chalk.gray("    gufi automation:execute 26"));
+        console.log(chalk.gray("    gufi automation:execute nayax_sync_machine_products --wait"));
+        console.log(chalk.gray("    gufi automation:execute 26 --input '{\"foo\": \"bar\"}'\n"));
+        process.exit(1);
+    }
+    console.log(chalk.magenta(`\n  🟣 Ejecutando automation: ${automationIdOrName}\n`));
+    try {
+        // 💜 Detect company and get automation info
+        console.log(chalk.gray("  Buscando automation..."));
+        let companyId = options?.company;
+        let automation;
+        let entityId;
+        let moduleId;
+        // 💜 If company specified, search only in that company
+        if (companyId) {
+            const data = await apiRequest("/api/automation-scripts", {
+                headers: { "X-Company-ID": companyId },
+            });
+            const automations = Array.isArray(data) ? data : data.data || [];
+            const isNumericId = /^\d+$/.test(automationIdOrName);
+            automation = automations.find((a) => isNumericId ? a.id === parseInt(automationIdOrName) : a.name === automationIdOrName);
+        }
+        else {
+            // First try by ID (auto-detect company)
+            const isNumericId = /^\d+$/.test(automationIdOrName);
+            if (isNumericId) {
+                const result = await detectCompanyFromAutomation(automationIdOrName);
+                if (result) {
+                    automation = result.automation;
+                    companyId = result.companyId;
+                }
+            }
+            // If not found by ID, search by name across companies
+            if (!automation) {
+                const companiesData = await apiRequest("/api/companies");
+                const companies = companiesData.items || companiesData.data || companiesData || [];
+                for (const company of companies) {
+                    try {
+                        const data = await apiRequest("/api/automation-scripts", {
+                            headers: { "X-Company-ID": String(company.id) },
+                        });
+                        const automations = Array.isArray(data) ? data : data.data || [];
+                        const found = automations.find((a) => a.name === automationIdOrName);
+                        if (found) {
+                            automation = found;
+                            companyId = String(company.id);
+                            break;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        if (!automation || !companyId) {
+            console.log(chalk.red(`  ✗ Automation '${automationIdOrName}' no encontrada\n`));
+            console.log(chalk.gray("  💡 Usa: gufi automations para ver la lista\n"));
+            process.exit(1);
+        }
+        console.log(chalk.gray(`  Company: ${companyId}`));
+        console.log(chalk.white(`  Script: ${automation.name}`));
+        // 💜 Find entity where this automation is configured (for module_id and entity_id)
+        const metaData = await apiRequest("/api/automation-meta", {
+            headers: { "X-Company-ID": companyId },
+        });
+        const metas = Array.isArray(metaData) ? metaData : metaData.data || [];
+        const meta = metas.find((m) => m.function_name === automation.name);
+        if (meta) {
+            entityId = meta.entity_id;
+            // Get module_id from entity
+            const schemaData = await apiRequest("/api/company/schema", {
+                headers: { "X-Company-ID": companyId },
+            });
+            const modules = schemaData.modules || schemaData.data?.modules || [];
+            for (const mod of modules) {
+                for (const sub of mod.submodules || []) {
+                    for (const ent of sub.entities || []) {
+                        if (ent.id === entityId && ent.ui?.moduleId) {
+                            moduleId = ent.ui.moduleId;
+                            break;
+                        }
+                    }
+                    if (moduleId)
+                        break;
+                }
+                if (moduleId)
+                    break;
+            }
+        }
+        // 💜 Fallback: use first module if not found
+        if (!moduleId) {
+            const schemaData = await apiRequest("/api/company/schema", {
+                headers: { "X-Company-ID": companyId },
+            });
+            const modules = schemaData.modules || schemaData.data?.modules || [];
+            for (const mod of modules) {
+                for (const sub of mod.submodules || []) {
+                    for (const ent of sub.entities || []) {
+                        if (ent.ui?.moduleId) {
+                            moduleId = ent.ui.moduleId;
+                            if (!entityId)
+                                entityId = ent.id;
+                            break;
+                        }
+                    }
+                    if (moduleId)
+                        break;
+                }
+                if (moduleId)
+                    break;
+            }
+        }
+        if (!moduleId || !entityId) {
+            console.log(chalk.red("  ✗ No se pudo determinar module_id o entity_id\n"));
+            process.exit(1);
+        }
+        console.log(chalk.gray(`  Module: ${moduleId}, Entity: ${entityId}`));
+        // Parse input if provided
+        let input = {};
+        if (options?.input) {
+            try {
+                input = JSON.parse(options.input);
+            }
+            catch (e) {
+                console.log(chalk.red("  ✗ Input JSON inválido\n"));
+                process.exit(1);
+            }
+        }
+        // 💜 Execute automation via triggerClick endpoint
+        console.log(chalk.yellow("\n  ⏳ Ejecutando..."));
+        const result = await apiRequest("/api/automation-scripts/triggerClick", {
+            method: "POST",
+            headers: { "X-Company-ID": companyId },
+            body: JSON.stringify({
+                company_id: parseInt(companyId),
+                module_id: moduleId,
+                entity_id: entityId,
+                function_name: automation.name,
+                input,
+            }),
+        });
+        const jobId = result.jobId;
+        console.log(chalk.green(`\n  ✓ Automation encolada!`));
+        console.log(chalk.white(`  Job ID: ${jobId}`));
+        // 💜 If --wait flag, poll for result
+        if (options?.wait) {
+            const timeoutMs = parseInt(options?.timeout || "60000");
+            console.log(chalk.gray(`\n  Esperando resultado (timeout: ${timeoutMs / 1000}s)...`));
+            const startTime = Date.now();
+            let jobStatus;
+            while (Date.now() - startTime < timeoutMs) {
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                jobStatus = await apiRequest(`/api/automation-jobs/${jobId}`, {
+                    headers: { "X-Company-ID": companyId },
+                });
+                if (jobStatus.isCompleted) {
+                    console.log(chalk.green("\n  ✓ Completado exitosamente!"));
+                    if (jobStatus.result) {
+                        console.log(chalk.gray("  Resultado:"));
+                        console.log(JSON.stringify(jobStatus.result, null, 2));
+                    }
+                    console.log();
+                    return;
+                }
+                if (jobStatus.isFailed) {
+                    console.log(chalk.red("\n  ✗ Falló!"));
+                    console.log(chalk.red(`  Error: ${jobStatus.error || "Unknown error"}`));
+                    console.log();
+                    process.exit(1);
+                }
+                process.stdout.write(".");
+            }
+            console.log(chalk.yellow("\n\n  ⏱ Timeout alcanzado. El job sigue ejecutándose en background."));
+            console.log(chalk.gray(`  Verifica estado: gufi automation-jobs ${jobId}\n`));
+        }
+        else {
+            console.log(chalk.gray("\n  💡 Usa --wait para esperar el resultado"));
+            console.log(chalk.gray(`  💡 O consulta: gufi automations:executions -s ${automation.name}\n`));
+        }
+    }
+    catch (err) {
+        console.log(chalk.red(`\n  ✗ Error: ${err.message}\n`));
+        process.exit(1);
+    }
+}
 async function editEntityAutomations(entityId, currentAutomations, availableScripts, companyId) {
     const fs = await import("fs");
     const os = await import("os");

package/dist/commands/docs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * gufi docs - Read Gufi documentation
+ *
+ * Usage:
+ *   gufi docs                    # List available topics
+ *   gufi docs fields             # Read about field types
+ *   gufi docs errors             # Read common errors
+ *   gufi docs --search currency  # Search across all docs
+ */
+export declare function docsCommand(args: string[]): Promise<void>;

package/dist/commands/docs.js

@@ -0,0 +1,141 @@
+/**
+ * gufi docs - Read Gufi documentation
+ *
+ * Usage:
+ *   gufi docs                    # List available topics
+ *   gufi docs fields             # Read about field types
+ *   gufi docs errors             # Read common errors
+ *   gufi docs --search currency  # Search across all docs
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// docs/mcp path relative to CLI
+const DOCS_MCP_PATH = path.resolve(__dirname, "../../../../docs/mcp");
+// Topic to file mapping
+const TOPIC_FILES = {
+    overview: { file: "00-overview.md", description: "Overview and workflow" },
+    architecture: { file: "01-architecture.md", description: "Technical architecture" },
+    modules: { file: "02-modules.md", description: "Module system and entities" },
+    fields: { file: "03-fields.md", description: "Field types and CB builders" },
+    views: { file: "04-views.md", description: "View system and SDK" },
+    automations: { file: "05-automations.md", description: "Automations and worker" },
+    api: { file: "06-api.md", description: "API endpoints reference" },
+    packages: { file: "07-packages.md", description: "Packages and marketplace" },
+    errors: { file: "08-common-errors.md", description: "Common errors and solutions" },
+    examples: { file: "09-examples.md", description: "Practical code examples" },
+};
+export async function docsCommand(args) {
+    const searchIndex = args.indexOf("--search");
+    const jsonFlag = args.includes("--json");
+    // Search mode
+    if (searchIndex !== -1) {
+        const searchTerm = args[searchIndex + 1];
+        if (!searchTerm) {
+            console.error(chalk.red("Error: --search requires a search term"));
+            process.exit(1);
+        }
+        await searchDocs(searchTerm, jsonFlag);
+        return;
+    }
+    // Topic mode
+    const topic = args.find((a) => !a.startsWith("--"));
+    if (!topic) {
+        // List available topics
+        if (jsonFlag) {
+            console.log(JSON.stringify({ topics: Object.keys(TOPIC_FILES) }));
+        }
+        else {
+            console.log(chalk.bold.magenta("\n📚 Gufi Documentation\n"));
+            console.log("Available topics:\n");
+            for (const [name, { description }] of Object.entries(TOPIC_FILES)) {
+                console.log(`  ${chalk.cyan(name.padEnd(14))} ${chalk.gray(description)}`);
+            }
+            console.log(chalk.gray("\nUsage:"));
+            console.log(chalk.gray("  gufi docs <topic>           Read a topic"));
+            console.log(chalk.gray("  gufi docs --search <term>   Search across all docs"));
+            console.log(chalk.gray("\nExamples:"));
+            console.log(chalk.gray("  gufi docs fields"));
+            console.log(chalk.gray("  gufi docs errors"));
+            console.log(chalk.gray('  gufi docs --search "currency"'));
+        }
+        return;
+    }
+    // Read specific topic
+    const topicInfo = TOPIC_FILES[topic.toLowerCase()];
+    if (!topicInfo) {
+        console.error(chalk.red(`Unknown topic: ${topic}`));
+        console.error(chalk.gray(`Available topics: ${Object.keys(TOPIC_FILES).join(", ")}`));
+        process.exit(1);
+    }
+    const filePath = path.join(DOCS_MCP_PATH, topicInfo.file);
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        if (jsonFlag) {
+            console.log(JSON.stringify({ topic, content }));
+        }
+        else {
+            console.log(chalk.bold.magenta(`\n📖 ${topic.charAt(0).toUpperCase() + topic.slice(1)}\n`));
+            console.log(content);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(`Failed to read documentation: ${err.message}`));
+        console.error(chalk.gray("Make sure docs/mcp/ exists in the project root."));
+        process.exit(1);
+    }
+}
+async function searchDocs(searchTerm, jsonFlag) {
+    const term = searchTerm.toLowerCase();
+    const results = [];
+    for (const [topic, { file }] of Object.entries(TOPIC_FILES)) {
+        const filePath = path.join(DOCS_MCP_PATH, file);
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split("\n");
+            const matches = [];
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].toLowerCase().includes(term)) {
+                    const start = Math.max(0, i - 1);
+                    const end = Math.min(lines.length - 1, i + 1);
+                    const context = lines.slice(start, end + 1).join("\n");
+                    matches.push({ line: i + 1, context });
+                }
+            }
+            if (matches.length > 0) {
+                results.push({ topic, matches: matches.slice(0, 3) });
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    if (jsonFlag) {
+        console.log(JSON.stringify({ search: searchTerm, results }));
+        return;
+    }
+    if (results.length === 0) {
+        console.log(chalk.yellow(`\nNo matches found for "${searchTerm}"`));
+        console.log(chalk.gray("Try a different search term or read a specific topic."));
+        return;
+    }
+    console.log(chalk.bold.magenta(`\n🔍 Search results for "${searchTerm}"\n`));
+    for (const { topic, matches } of results) {
+        console.log(chalk.cyan.bold(`  ${topic}`));
+        for (const { line, context } of matches) {
+            console.log(chalk.gray(`    Line ${line}:`));
+            // Highlight search term
+            const highlighted = context.replace(new RegExp(`(${searchTerm})`, "gi"), chalk.yellow.bold("$1"));
+            console.log(highlighted
+                .split("\n")
+                .map((l) => `      ${l}`)
+                .join("\n"));
+            console.log();
+        }
+    }
+    console.log(chalk.gray(`\nFound matches in ${results.length} topics.`));
+    console.log(chalk.gray('Use "gufi docs <topic>" to read the full content.'));
+}

package/dist/commands/doctor.js

@@ -145,7 +145,7 @@ function validateDataSources(content) {
 function validateInputs(content) {
     const results = [];
     // Check for valid input types
-    const validTypes = ["text", "number", "boolean", "select", "email", "multiselect", "textarea"];
+    const validTypes = ["text", "number", "boolean", "select", "email", "multiselect"];
     const typeMatches = content.matchAll(/type:\s*['"](\w+)['"]/g);
     const invalidTypes = [];
     for (const match of typeMatches) {

package/dist/index.js

@@ -74,7 +74,7 @@ import { pushCommand, statusCommand } from "./commands/push.js";
 import { watchCommand } from "./commands/watch.js";
 // listCommand removed - use 'gufi packages' instead
 import { logsCommand } from "./commands/logs.js";
-import { companiesCommand, modulesCommand, moduleCommand, moduleUpdateCommand, moduleCreateCommand, companyCreateCommand, automationsCommand, automationCommand, automationCreateCommand, entityAutomationsCommand, entityAutomationsUpdateCommand, automationsMetaCommand, automationsExecutionsCommand, } from "./commands/companies.js";
+import { companiesCommand, modulesCommand, moduleCommand, moduleUpdateCommand, moduleCreateCommand, companyCreateCommand, automationsCommand, automationCommand, automationCreateCommand, automationExecuteCommand, entityAutomationsCommand, entityAutomationsUpdateCommand, automationsMetaCommand, automationsExecutionsCommand, } from "./commands/companies.js";
 import { rowsListCommand, rowGetCommand, rowCreateCommand, rowUpdateCommand, rowDeleteCommand, rowDuplicateCommand, rowsBulkCreateCommand, } from "./commands/rows.js";
 import { envListCommand, envSetCommand, envDeleteCommand, schemaCommand, } from "./commands/env.js";
 import { packagesCommand, packageCommand, packageCreateCommand, packageDeleteCommand, packageAddModuleCommand, packageRemoveModuleCommand, packagePublishCommand, packageUnpublishCommand, packageSyncCommand, packageCheckCommand, 
@@ -86,6 +86,7 @@ import { configCommand, configLocalCommand, configProdCommand, configSetCommand,
 import { templatesCommand, viewCreateCommand, } from "./commands/templates.js";
 import { contextCommand } from "./commands/context.js";
 import { doctorCommand } from "./commands/doctor.js";
+import { docsCommand } from "./commands/docs.js";
 import { startMcpServer } from "./mcp.js";
 const program = new Command();
 program
@@ -149,6 +150,21 @@ program
     .option("-c, --company <id>", "Diagnosticar company específica")
     .option("--verbose", "Mostrar más detalles")
     .action(doctorCommand);
+program
+    .command("docs [topic]")
+    .description("Leer documentación de Gufi (topics: fields, views, automations, errors...)")
+    .option("--search <term>", "Buscar término en toda la documentación")
+    .option("--json", "Output JSON (for Claude/scripts)")
+    .action((topic, options) => {
+    const args = [];
+    if (topic)
+        args.push(topic);
+    if (options.search)
+        args.push("--search", options.search);
+    if (options.json)
+        args.push("--json");
+    docsCommand(args);
+});
 // ════════════════════════════════════════════════════════════════════
 // 🏢 Companies & Modules
 // ════════════════════════════════════════════════════════════════════
@@ -210,6 +226,14 @@ program
     .description("Crear/actualizar automation desde archivo JS")
     .option("-c, --company <id>", "ID de company (requerido)")
     .action(automationCreateCommand);
+program
+    .command("automation:execute <id_or_name>")
+    .description("Ejecutar automation script")
+    .option("-c, --company <id>", "ID de company")
+    .option("-i, --input <json>", "Input JSON para el script")
+    .option("-w, --wait", "Esperar resultado (polling)")
+    .option("-t, --timeout <ms>", "Timeout en ms (default: 60000)")
+    .action(automationExecuteCommand);
 program
     .command("automations:meta")
     .description("Ver índice del worker (debugging)")

package/dist/lib/columnTypes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 💜 Column Types - Single source of truth from API
+ *
+ * Types are fetched from /api/cli/column-types at runtime.
+ * NO FALLBACK - forces API to be the only source.
+ */
+/**
+ * Get valid column types (fetches from API with cache)
+ */
+export declare function getValidColumnTypes(): Promise<Set<string>>;
+/**
+ * Get type suggestions (fetches from API with cache)
+ */
+export declare function getTypeSuggestions(): Promise<Record<string, string>>;
+/**
+ * Check if a type is valid (async - fetches from API)
+ */
+export declare function isValidColumnType(type: string): Promise<boolean>;
+/**
+ * Get suggestion for an invalid type (async - fetches from API)
+ */
+export declare function getTypeSuggestion(type: string): Promise<string | undefined>;

package/dist/lib/columnTypes.js

@@ -0,0 +1,74 @@
+/**
+ * 💜 Column Types - Single source of truth from API
+ *
+ * Types are fetched from /api/cli/column-types at runtime.
+ * NO FALLBACK - forces API to be the only source.
+ */
+import { getApiUrl } from "./config.js";
+// Cache for column types (fetched from API)
+let cachedTypes = null;
+let cachedSuggestions = null;
+let cacheTimestamp = 0;
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+/**
+ * Fetch column types from API
+ */
+async function fetchColumnTypes() {
+    const apiUrl = getApiUrl();
+    const url = `${apiUrl}/api/cli/column-types`;
+    const response = await fetch(url, {
+        headers: { "X-Client": "cli" },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch column types: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+        types: new Set(data.type_names || []),
+        suggestions: data.suggestions || {},
+    };
+}
+/**
+ * Get valid column types (fetches from API with cache)
+ */
+export async function getValidColumnTypes() {
+    const now = Date.now();
+    // Return cached if still valid
+    if (cachedTypes && now - cacheTimestamp < CACHE_TTL) {
+        return cachedTypes;
+    }
+    const { types, suggestions } = await fetchColumnTypes();
+    cachedTypes = types;
+    cachedSuggestions = suggestions;
+    cacheTimestamp = now;
+    return types;
+}
+/**
+ * Get type suggestions (fetches from API with cache)
+ */
+export async function getTypeSuggestions() {
+    const now = Date.now();
+    // Return cached if still valid
+    if (cachedSuggestions && now - cacheTimestamp < CACHE_TTL) {
+        return cachedSuggestions;
+    }
+    const { types, suggestions } = await fetchColumnTypes();
+    cachedTypes = types;
+    cachedSuggestions = suggestions;
+    cacheTimestamp = now;
+    return suggestions;
+}
+/**
+ * Check if a type is valid (async - fetches from API)
+ */
+export async function isValidColumnType(type) {
+    const types = await getValidColumnTypes();
+    return types.has(type);
+}
+/**
+ * Get suggestion for an invalid type (async - fetches from API)
+ */
+export async function getTypeSuggestion(type) {
+    const suggestions = await getTypeSuggestions();
+    return suggestions[type.toLowerCase()];
+}

package/dist/mcp.js

@@ -11,8 +11,16 @@
  * The MCP server exposes all CLI functionality as tools that Claude can call.
  */
 import * as readline from "readline";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
 import { getToken, getApiUrl, getRefreshToken, setToken, loadConfig, isLoggedIn, getCurrentEnv } from "./lib/config.js";
 import { getViewFiles, saveViewFiles, } from "./lib/api.js";
+// For ES modules __dirname equivalent
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// docs/mcp path relative to CLI
+const DOCS_MCP_PATH = path.resolve(__dirname, "../../../docs/mcp");
 // ════════════════════════════════════════════════════════════════════════════
 // API Client (reused from CLI)
 // ════════════════════════════════════════════════════════════════════════════
@@ -172,6 +180,36 @@ Use this to understand the data structure before creating queries or modificatio
             },
         },
     },
+    {
+        name: "gufi_docs",
+        description: `Read documentation about Gufi. Use this when you need detailed information about specific topics.
+
+Available topics:
+- "overview" - Overview and workflow (start here)
+- "architecture" - Technical architecture
+- "modules" - Module system and entities
+- "fields" - Field types and CB builders (IMPORTANT for data operations)
+- "views" - View system, SDK, and React components
+- "automations" - Automations and worker
+- "api" - API endpoints reference
+- "packages" - Packages and marketplace
+- "errors" - Common errors and solutions
+- "examples" - Practical code examples
+
+You can also search across all docs with the search parameter.
+
+Examples:
+- gufi_docs({ topic: "fields" }) - Read about field types
+- gufi_docs({ topic: "errors" }) - Common errors and fixes
+- gufi_docs({ search: "currency" }) - Search for currency info`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: { type: "string", description: "Topic to read: overview, architecture, modules, fields, views, automations, api, packages, errors, examples" },
+                search: { type: "string", description: "Search term to find across all documentation" },
+            },
+        },
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Companies
     // ─────────────────────────────────────────────────────────────────────────
@@ -217,7 +255,7 @@ Returns the complete module structure:
     - fields[]: Array of fields with type, label, required, options, etc.
 
 Field types (from @gufi/column-types):
-- Text: text, textarea, email, url, barcode
+- Text: text, email, url, barcode
 - Numbers: number_int, number_float, percentage
 - Date/Time: date, datetime, time
 - Boolean: boolean
@@ -472,7 +510,7 @@ Supports:
 Field formats (from @gufi/column-types):
 
 SIMPLE TYPES:
-- text/textarea/email/url/barcode: "string value"
+- text/email/url/barcode: "string value"
 - number_int: 42 (integer)
 - number_float: 3.14 (decimal)
 - percentage: 0.75 (decimal, displayed as 75%)
@@ -980,6 +1018,90 @@ const toolHandlers = {
         }
         return { modules };
     },
+    async gufi_docs(params) {
+        // Map topics to file names
+        const topicFiles = {
+            overview: "00-overview.md",
+            architecture: "01-architecture.md",
+            modules: "02-modules.md",
+            fields: "03-fields.md",
+            views: "04-views.md",
+            automations: "05-automations.md",
+            api: "06-api.md",
+            packages: "07-packages.md",
+            errors: "08-common-errors.md",
+            examples: "09-examples.md",
+        };
+        // Read a specific topic
+        if (params.topic) {
+            const fileName = topicFiles[params.topic.toLowerCase()];
+            if (!fileName) {
+                return {
+                    error: `Unknown topic: ${params.topic}`,
+                    available_topics: Object.keys(topicFiles),
+                };
+            }
+            const filePath = path.join(DOCS_MCP_PATH, fileName);
+            try {
+                const content = fs.readFileSync(filePath, "utf-8");
+                return {
+                    topic: params.topic,
+                    content,
+                };
+            }
+            catch (err) {
+                return {
+                    error: `Failed to read documentation: ${err.message}`,
+                    hint: "Documentation may not be installed. Check docs/mcp/ folder.",
+                };
+            }
+        }
+        // Search across all docs
+        if (params.search) {
+            const searchTerm = params.search.toLowerCase();
+            const results = [];
+            for (const [topic, fileName] of Object.entries(topicFiles)) {
+                const filePath = path.join(DOCS_MCP_PATH, fileName);
+                try {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    const lines = content.split("\n");
+                    const matches = [];
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].toLowerCase().includes(searchTerm)) {
+                            // Include context (line before and after)
+                            const start = Math.max(0, i - 1);
+                            const end = Math.min(lines.length - 1, i + 1);
+                            const context = lines.slice(start, end + 1).join("\n");
+                            matches.push(`Line ${i + 1}:\n${context}`);
+                        }
+                    }
+                    if (matches.length > 0) {
+                        results.push({ topic, matches: matches.slice(0, 3) }); // Max 3 matches per file
+                    }
+                }
+                catch {
+                    // Skip files that can't be read
+                }
+            }
+            if (results.length === 0) {
+                return {
+                    search: params.search,
+                    results: [],
+                    hint: "No matches found. Try a different search term or read a specific topic.",
+                };
+            }
+            return {
+                search: params.search,
+                results,
+                hint: `Found matches in ${results.length} topics. Use gufi_docs({ topic: "..." }) to read the full content.`,
+            };
+        }
+        // No params - return available topics
+        return {
+            available_topics: Object.keys(topicFiles),
+            hint: "Use gufi_docs({ topic: 'fields' }) to read about field types, or gufi_docs({ search: 'currency' }) to search.",
+        };
+    },
     // ─────────────────────────────────────────────────────────────────────────
     // Companies
     // ─────────────────────────────────────────────────────────────────────────
@@ -1673,7 +1795,6 @@ function getGufiConcepts() {
         },
         fieldTypes: {
             text: "string",
-            textarea: "string (multiline)",
             email: "string (validated)",
             url: "string (URL)",
             barcode: "string",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gufi-cli",
-  "version": "0.1.18",
+  "version": "0.1.21",
   "description": "CLI for developing Gufi Marketplace views locally with Claude Code",
   "bin": {
     "gufi": "./bin/gufi.js"
@@ -22,7 +22,6 @@
     "start": "node bin/gufi.js"
   },
   "dependencies": {
-    "@gufi/column-types": "file:../../libs/column-types",
     "@types/prompts": "^2.4.9",
     "@types/ws": "^8.18.1",
     "chalk": "^5.3.0",