gufi-cli 0.1.27 → 0.1.31

package/CLAUDE.md

@@ -10,12 +10,11 @@
 tools/cli/
 ├── src/
 │   ├── index.ts          # Entry point CLI
-│   ├── mcp.ts            # MCP Server (44 tools)
+│   ├── mcp.ts            # MCP Server (12 tools)
 │   ├── commands/         # Comandos CLI
 │   │   ├── context.ts    # gufi context
 │   │   ├── pull.ts       # gufi view:pull
 │   │   ├── push.ts       # gufi view:push
-│   │   ├── watch.ts      # gufi view:watch
 │   │   └── ...
 │   └── lib/
 │       ├── api.ts        # Cliente API
@@ -42,7 +41,7 @@ gufi config:prod
 
 **IMPORTANTE**:
 - Todos los tools MCP (`gufi_*`) respetan el entorno configurado
-- `gufi_whoami()` muestra el entorno actual (`environment: "local"` o `"prod"`)
+- `gufi_whoami()` muestra el entorno actual y empresas disponibles
 - Antes de hacer cambios, verifica que estás en el entorno correcto
 
 ### Config file (~/.gufi/config.json)
@@ -56,27 +55,30 @@ gufi config:prod
 }
 ```
 
-## MCP Server
+## MCP Server - 12 Tools
 
-El servidor MCP está en `src/mcp.ts` y expone 44 tools para que Claude interactúe con Gufi.
+El servidor MCP está en `src/mcp.ts` y expone **12 tools** para que Claude interactúe con Gufi.
 
-### Tools principales
+### Tools organizados por categoría
 
-- **`gufi_context`** - Genera contexto inteligente:
-  - `summary`: Resumen ejecutivo
-  - `next_actions`: Pasos sugeridos
-  - 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
+| Categoría | Tool | Descripción |
+|-----------|------|-------------|
+| **Context** | `gufi_context` | Schema completo (company, view, package) |
+| | `gufi_whoami` | Usuario, entorno, empresas |
+| | `gufi_docs` | Documentación (`docs/mcp/`) |
+| **Schema** | `gufi_schema_modify` | Operaciones atomicas (add/update/remove) |
+| **Automations** | `gufi_automation` | Scripts: list, get, create |
+| | `gufi_triggers` | Ver/configurar triggers |
+| | `gufi_executions` | Historial de ejecuciones |
+| **Data** | `gufi_data` | CRUD: list, get, create, update, delete |
+| **Env** | `gufi_env` | Variables: list, set, delete |
+| **Views** | `gufi_view_pull` | Descargar vista a local |
+| | `gufi_view_push` | Subir cambios a draft |
+| **Packages** | `gufi_package` | list, get, create, delete, add_module, remove_module, publish |
 
 ### Añadir un nuevo tool MCP
 
-1. **Definir tool** en array `TOOLS` (~línea 200):
+1. **Definir tool** en array `TOOLS` (~línea 340):
 ```typescript
 {
   name: "gufi_nuevo_tool",
@@ -91,7 +93,7 @@ El servidor MCP está en `src/mcp.ts` y expone 44 tools para que Claude interact
 },
 ```
 
-2. **Añadir handler** en `toolHandlers` (~línea 870):
+2. **Añadir handler** en `toolHandlers` (~línea 700):
 ```typescript
 async gufi_nuevo_tool(params: { param1: string }) {
   // Implementación
@@ -117,16 +119,16 @@ Los endpoints del backend están montados así:
 /api/marketplace/*    - Marketplace público
 /api/automation-scripts - Scripts de automatización
 /api/cli/*            - Endpoints específicos del CLI
+/api/schema/operations - Operaciones de schema
 ```
 
-**CRÍTICO**: Los módulos usan `/api/company/modules/`, NO `/api/modules/`
-
 ### Funciones helper importantes
 
 - `detectIfInGufiCodebase()` - Detecta si está en el repo gogufi
 - `loadViewMetaFromCwd()` - Carga `.gufi-view.json` del directorio actual
 - `generateViewContextMcp()` - Genera contexto de una vista
 - `generatePackageContextMcp()` - Genera contexto de un package
+- `getClaudeOptimizedContext()` - Exporta schema en formato optimizado para Claude
 - `apiRequest(endpoint, options, companyId)` - Peticiones a API con auth
 - `developerRequest(path, options)` - Peticiones a /api/developer/
 
@@ -153,24 +155,20 @@ export async function miComando(args: string[], flags: Flags) {
 | `gufi config:prod` | Cambiar a producción |
 | `gufi context` | Generar contexto para Claude |
 | `gufi view:pull <id>` | Descargar vista a local |
-| `gufi view:push` | Subir cambios de vista (a **draft**) |
-| `gufi view:watch` | Auto-sync de cambios |
-| `gufi view:errors <id>` | Ver errores de compilación |
-| `gufi package:sync <id>` | Publicar draft → producción |
+| `gufi view:push` | Sync completo (sube todo, servidor borra lo que no esté) |
+| `gufi package:publish <id>` | Publicar draft → producción |
 | `gufi docs <topic>` | Ver documentación |
 
-### Draft vs Published (IMPORTANTE)
-
-Las vistas marketplace tienen **dos tablas**:
+### Views: Solo Pull/Push
 
-- `marketplace.view_files` → **Draft** (desarrollo)
-- `marketplace.published_view_files` → **Publicado** (producción)
-
-**Flujo**:
-1. `view:push` sube a **draft** (visible en Dev Center)
-2. `package:sync <id>` copia draft → published (visible en vistas instaladas)
+```
+gufi view:pull <id>       → ~/gufi-dev/view_<id>/
+# Editar archivos locales
+gufi view:push            → Sync completo
+gufi package:publish <id> → Publicar
+```
 
-**Regla**: Los cambios de `view:push` NO afectan a vistas ya instaladas hasta hacer `package:sync`.
+**Push = sync completo**: Sube TODOS los archivos, servidor borra los que no vengan.
 
 ## Config (~/.gufi/)
 

package/README.md

@@ -301,8 +301,7 @@ gufi package <id>           # Ver detalles
 gufi package:create "Nombre"
 gufi package:add-module <packageId>
 gufi package:add-view <packageId> <viewId>
-gufi package:publish <id>
-gufi package:sync <id>      # Sincronizar versión
+gufi package:publish <id>   # Publicar cambios a producción
 ```
 
 ### Migraciones de Package
@@ -498,9 +497,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/claude.d.ts

@@ -0,0 +1,17 @@
+/**
+ * gufi claude - Setup completo de Claude Code para Gufi
+ *
+ * 1. Configura workspace y MCP
+ * 2. Instala como servicio del sistema (arranca automáticamente)
+ * 3. Inicia el bridge
+ *
+ * Funciona igual en Mac, Linux y Windows.
+ */
+/**
+ * 💜 gufi claude - Setup + Install + Run
+ */
+export declare function claudeCommand(options: {
+    port?: number;
+    service?: boolean;
+    uninstall?: boolean;
+}): Promise<void>;

package/dist/commands/claude.js

@@ -0,0 +1,422 @@
+/**
+ * gufi claude - Setup completo de Claude Code para Gufi
+ *
+ * 1. Configura workspace y MCP
+ * 2. Instala como servicio del sistema (arranca automáticamente)
+ * 3. Inicia el bridge
+ *
+ * Funciona igual en Mac, Linux y Windows.
+ */
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { spawn, execSync } from "child_process";
+import { WebSocketServer, WebSocket } from "ws";
+import { isLoggedIn } from "../lib/config.js";
+const DEFAULT_PORT = 9876;
+const WORKSPACE_DIR = path.join(os.homedir(), "gufi-workspace");
+const GLOBAL_CLAUDE_JSON = path.join(os.homedir(), ".claude.json");
+const GUFI_DIR = path.join(os.homedir(), ".gufi");
+const SERVICE_NAME = "com.gufi.claude";
+const WINDOWS_TASK_NAME = "GufiClaude";
+/**
+ * Check if service is already installed
+ */
+function isServiceInstalled() {
+    const platform = os.platform();
+    if (platform === "darwin") {
+        const plistPath = path.join(os.homedir(), "Library/LaunchAgents", `${SERVICE_NAME}.plist`);
+        return fs.existsSync(plistPath);
+    }
+    else if (platform === "linux") {
+        const servicePath = path.join(os.homedir(), ".config/systemd/user/gufi-claude.service");
+        return fs.existsSync(servicePath);
+    }
+    else if (platform === "win32") {
+        try {
+            execSync(`schtasks /query /tn "${WINDOWS_TASK_NAME}"`, { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Check if bridge is already running on port
+ */
+function isPortInUse(port) {
+    try {
+        if (os.platform() === "win32") {
+            const result = execSync(`netstat -ano | findstr :${port}`, { encoding: "utf8" });
+            return result.includes("LISTENING");
+        }
+        else {
+            const result = execSync(`lsof -i:${port} -t`, { encoding: "utf8" });
+            return result.trim().length > 0;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure workspace exists and MCP is configured
+ */
+function ensureWorkspace() {
+    // Create workspace if needed
+    if (!fs.existsSync(WORKSPACE_DIR)) {
+        fs.mkdirSync(WORKSPACE_DIR, { recursive: true });
+    }
+    // Create .gufi dir if needed
+    if (!fs.existsSync(GUFI_DIR)) {
+        fs.mkdirSync(GUFI_DIR, { recursive: true });
+    }
+    // Create CLAUDE.md if needed
+    const claudeMdPath = path.join(WORKSPACE_DIR, "CLAUDE.md");
+    if (!fs.existsSync(claudeMdPath)) {
+        fs.writeFileSync(claudeMdPath, `# Gufi Workspace
+
+Este es tu espacio de trabajo para Gufi ERP.
+
+## MCP Tools Disponibles
+
+Usa las herramientas de Gufi:
+- \`gufi_context\` - Contexto de empresa/módulos
+- \`gufi_companies\` - Ver empresas
+- \`gufi_rows\` - Consultar datos
+- \`gufi_docs\` - Documentación
+
+## Quick Start
+
+Pregúntame sobre tus empresas, módulos o datos.
+Tengo acceso completo a Gufi via MCP.
+`);
+    }
+    // Configure MCP in global ~/.claude.json
+    if (fs.existsSync(GLOBAL_CLAUDE_JSON)) {
+        try {
+            const claudeConfig = JSON.parse(fs.readFileSync(GLOBAL_CLAUDE_JSON, "utf8"));
+            if (!claudeConfig.projects)
+                claudeConfig.projects = {};
+            const workspaceProject = claudeConfig.projects[WORKSPACE_DIR];
+            if (!workspaceProject?.mcpServers?.gufi) {
+                claudeConfig.projects[WORKSPACE_DIR] = {
+                    ...workspaceProject,
+                    mcpServers: {
+                        ...(workspaceProject?.mcpServers || {}),
+                        gufi: { type: "stdio", command: "gufi", args: ["mcp"], env: {} },
+                    },
+                    hasTrustDialogAccepted: true,
+                };
+                fs.writeFileSync(GLOBAL_CLAUDE_JSON, JSON.stringify(claudeConfig, null, 2));
+            }
+        }
+        catch { }
+    }
+}
+/**
+ * Find gufi executable path
+ */
+async function findGufiPath() {
+    return new Promise((resolve) => {
+        const cmd = os.platform() === "win32" ? "where" : "which";
+        const proc = spawn(cmd, ["gufi"], { shell: true });
+        let output = "";
+        proc.stdout.on("data", (data) => { output += data.toString(); });
+        proc.on("close", (code) => {
+            if (code === 0 && output.trim()) {
+                resolve(output.trim().split("\n")[0]); // First result
+            }
+            else {
+                resolve("gufi"); // Fallback
+            }
+        });
+    });
+}
+/**
+ * Install as system service
+ */
+async function installService(gufiPath, port) {
+    const platform = os.platform();
+    if (platform === "darwin") {
+        await installMac(gufiPath, port);
+    }
+    else if (platform === "linux") {
+        await installLinux(gufiPath, port);
+    }
+    else if (platform === "win32") {
+        await installWindows(gufiPath, port);
+    }
+}
+async function installMac(gufiPath, port) {
+    const plistPath = path.join(os.homedir(), "Library/LaunchAgents", `${SERVICE_NAME}.plist`);
+    const plistDir = path.dirname(plistPath);
+    if (!fs.existsSync(plistDir)) {
+        fs.mkdirSync(plistDir, { recursive: true });
+    }
+    // Stop existing if running
+    try {
+        execSync(`launchctl unload "${plistPath}"`, { stdio: "ignore" });
+    }
+    catch { }
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${SERVICE_NAME}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${gufiPath}</string>
+        <string>claude</string>
+        <string>--service</string>
+        <string>--port</string>
+        <string>${port}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${GUFI_DIR}/claude.log</string>
+    <key>StandardErrorPath</key>
+    <string>${GUFI_DIR}/claude.error.log</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${process.env.PATH}</string>
+    </dict>
+</dict>
+</plist>`;
+    fs.writeFileSync(plistPath, plist);
+    execSync(`launchctl load "${plistPath}"`, { stdio: "ignore" });
+    console.log(chalk.green("  ✓ Servicio instalado (arranca con el sistema)"));
+}
+async function installLinux(gufiPath, port) {
+    const serviceDir = path.join(os.homedir(), ".config/systemd/user");
+    const servicePath = path.join(serviceDir, "gufi-claude.service");
+    if (!fs.existsSync(serviceDir)) {
+        fs.mkdirSync(serviceDir, { recursive: true });
+    }
+    const service = `[Unit]
+Description=Gufi Claude Code Bridge
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${gufiPath} claude --service --port ${port}
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=default.target
+`;
+    fs.writeFileSync(servicePath, service);
+    execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+    execSync("systemctl --user enable gufi-claude", { stdio: "ignore" });
+    execSync("systemctl --user start gufi-claude", { stdio: "ignore" });
+    console.log(chalk.green("  ✓ Servicio instalado (arranca con el sistema)"));
+}
+async function installWindows(gufiPath, port) {
+    // VBS script to run hidden
+    const vbsPath = path.join(GUFI_DIR, "gufi-claude.vbs");
+    const vbs = `Set WshShell = CreateObject("WScript.Shell")
+WshShell.Run """${gufiPath}"" claude --service --port ${port}", 0, False`;
+    fs.writeFileSync(vbsPath, vbs);
+    // Delete existing task
+    try {
+        execSync(`schtasks /delete /tn "${WINDOWS_TASK_NAME}" /f`, { stdio: "ignore" });
+    }
+    catch { }
+    // Create task
+    try {
+        execSync(`schtasks /create /tn "${WINDOWS_TASK_NAME}" /tr "wscript.exe \\"${vbsPath}\\"" /sc onlogon /rl highest /f`, { stdio: "ignore" });
+        // Start now
+        spawn("wscript.exe", [vbsPath], { detached: true, stdio: "ignore" }).unref();
+        console.log(chalk.green("  ✓ Servicio instalado (arranca con Windows)"));
+    }
+    catch {
+        console.log(chalk.yellow("  ⚠️  Ejecuta como administrador para instalar servicio"));
+    }
+}
+/**
+ * 💜 gufi claude - Setup + Install + Run
+ */
+export async function claudeCommand(options) {
+    const port = options.port || DEFAULT_PORT;
+    // Handle uninstall
+    if (options.uninstall) {
+        await uninstallService();
+        return;
+    }
+    // If running as service (called by launchd/systemd), just start server
+    if (options.service) {
+        await startBridgeServer(port);
+        return;
+    }
+    // Interactive mode - show UI
+    console.log(chalk.magenta(`
+  ╭──────────────────────────────────────────────────────╮
+  │  🐿️  Gufi Claude Code                                │
+  ╰──────────────────────────────────────────────────────╯
+`));
+    // Check login
+    if (!isLoggedIn()) {
+        console.log(chalk.yellow("  ⚠️  No estás logueado. Ejecuta: gufi login\n"));
+    }
+    // Check Claude Code installed
+    const claudeOk = await checkClaudeInstalled();
+    if (!claudeOk) {
+        console.log(chalk.red("  ✗ Claude Code no encontrado."));
+        console.log(chalk.gray("  Instala: npm install -g @anthropic-ai/claude-code\n"));
+        process.exit(1);
+    }
+    console.log(chalk.green("  ✓ Claude Code detectado"));
+    // Setup workspace
+    ensureWorkspace();
+    console.log(chalk.green("  ✓ Workspace configurado"));
+    console.log(chalk.gray(`    📁 ${WORKSPACE_DIR}`));
+    // Check if already running
+    if (isPortInUse(port)) {
+        console.log(chalk.green(`  ✓ Bridge ya está corriendo en puerto ${port}`));
+        console.log(chalk.cyan(`
+  ¡Todo listo! Abre Gufi en tu navegador.
+  El botón de Claude Code conectará automáticamente.
+`));
+        return;
+    }
+    // Install service if not installed
+    if (!isServiceInstalled()) {
+        console.log(chalk.gray("  📦 Instalando servicio..."));
+        const gufiPath = await findGufiPath();
+        await installService(gufiPath, port);
+    }
+    else {
+        console.log(chalk.green("  ✓ Servicio instalado"));
+    }
+    // Wait a moment for service to start
+    await new Promise((r) => setTimeout(r, 2000));
+    if (isPortInUse(port)) {
+        console.log(chalk.green(`  ✓ Bridge corriendo en puerto ${port}`));
+    }
+    else {
+        console.log(chalk.yellow(`  ⚠️  Iniciando bridge manualmente...`));
+        await startBridgeServer(port);
+        return;
+    }
+    console.log(chalk.cyan(`
+  ¡Todo listo!
+
+  El bridge de Claude Code:
+  • Arranca automáticamente con tu sistema
+  • Corre en segundo plano en puerto ${port}
+
+  Abre Gufi → Click en el botón Claude Code
+
+  Comandos:
+  • gufi claude --uninstall  - Desinstalar servicio
+  • cat ~/.gufi/claude.log   - Ver logs
+`));
+}
+async function uninstallService() {
+    const platform = os.platform();
+    console.log(chalk.magenta(`
+  ╭──────────────────────────────────────────────────────╮
+  │  🐿️  Desinstalando Gufi Claude                       │
+  ╰──────────────────────────────────────────────────────╯
+`));
+    if (platform === "darwin") {
+        const plistPath = path.join(os.homedir(), "Library/LaunchAgents", `${SERVICE_NAME}.plist`);
+        try {
+            execSync(`launchctl unload "${plistPath}"`, { stdio: "ignore" });
+        }
+        catch { }
+        if (fs.existsSync(plistPath))
+            fs.unlinkSync(plistPath);
+    }
+    else if (platform === "linux") {
+        try {
+            execSync("systemctl --user stop gufi-claude", { stdio: "ignore" });
+            execSync("systemctl --user disable gufi-claude", { stdio: "ignore" });
+        }
+        catch { }
+        const servicePath = path.join(os.homedir(), ".config/systemd/user/gufi-claude.service");
+        if (fs.existsSync(servicePath))
+            fs.unlinkSync(servicePath);
+    }
+    else if (platform === "win32") {
+        try {
+            execSync(`schtasks /delete /tn "${WINDOWS_TASK_NAME}" /f`, { stdio: "ignore" });
+        }
+        catch { }
+        const vbsPath = path.join(GUFI_DIR, "gufi-claude.vbs");
+        if (fs.existsSync(vbsPath))
+            fs.unlinkSync(vbsPath);
+    }
+    console.log(chalk.green("  ✓ Servicio desinstalado\n"));
+}
+async function startBridgeServer(port) {
+    // Dynamically import PTY
+    let pty;
+    try {
+        pty = await import("@homebridge/node-pty-prebuilt-multiarch");
+    }
+    catch {
+        console.error("Error loading PTY");
+        process.exit(1);
+    }
+    const wss = new WebSocketServer({ port });
+    console.log(`Servidor en ws://localhost:${port}`);
+    wss.on("connection", (ws) => {
+        const shellCmd = os.platform() === "win32" ? "cmd.exe" : "/bin/zsh";
+        const shellArgs = os.platform() === "win32" ? ["/c", "claude"] : ["-l", "-c", "claude"];
+        const shell = pty.spawn(shellCmd, shellArgs, {
+            name: "xterm-256color",
+            cols: 120,
+            rows: 40,
+            cwd: WORKSPACE_DIR,
+            env: { ...process.env, TERM: "xterm-256color" },
+        });
+        shell.onData((data) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "output", content: data }));
+            }
+        });
+        shell.onExit(({ exitCode }) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "exit", code: exitCode }));
+            }
+        });
+        ws.on("message", (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                if (msg.type === "input")
+                    shell.write(msg.content);
+                else if (msg.type === "resize")
+                    shell.resize(msg.cols || 120, msg.rows || 40);
+            }
+            catch { }
+        });
+        ws.on("close", () => shell.kill());
+        ws.on("error", () => shell.kill());
+    });
+    wss.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`Puerto ${port} en uso`);
+            process.exit(1);
+        }
+    });
+    process.on("SIGINT", () => { wss.close(); process.exit(0); });
+    process.on("SIGTERM", () => { wss.close(); process.exit(0); });
+}
+async function checkClaudeInstalled() {
+    return new Promise((resolve) => {
+        const proc = spawn("claude", ["--version"], { stdio: ["ignore", "pipe", "pipe"], shell: true });
+        proc.on("close", (code) => resolve(code === 0));
+        proc.on("error", () => resolve(false));
+        setTimeout(() => { proc.kill(); resolve(false); }, 5000);
+    });
+}

package/dist/commands/context.js

@@ -265,8 +265,7 @@ async function generatePackageContext(packageId, includeConcepts) {
     md += `## Comandos\n`;
     md += "```bash\n";
     md += `gufi package ${packageId}      # Ver detalles\n`;
-    md += `gufi package:sync ${packageId} # Sincronizar cambios\n`;
-    md += `gufi package:publish ${packageId} # Publicar\n`;
+    md += `gufi package:publish ${packageId} # Publicar cambios\n`;
     if (pkg.views?.[0]) {
         md += `gufi view:pull ${pkg.views[0].view_id || pkg.views[0].pk_id}  # Descargar primera vista\n`;
     }