@gishubperu/ghp 0.0.1

package/infrastructure/providers/ollama.js

@@ -0,0 +1,92 @@
+// models/providers/ollama.js
+// Ollama local provider implementation
+
+const OLLAMA_BASE = process.env.OLLAMA_HOST ?? 'http://localhost:11434';
+
+export class OllamaProvider {
+
+    #available = false;
+    #models    = [];
+
+    async init() {
+        try {
+            const res = await fetch(`${OLLAMA_BASE}/api/tags`, { signal: AbortSignal.timeout(2000) });
+            if (!res.ok) return;
+            const data    = await res.json();
+            this.#models  = data.models?.map(m => m.name) ?? [];
+            this.#available = this.#models.length > 0;
+        } catch {
+            this.#available = false;
+        }
+    }
+
+    async isAvailable() { return this.#available; }
+
+    models() { return this.#models; }
+
+    async chat({ model = 'llama3.2', messages, tools = [], systemPrompt = '' }) {
+        const body = {
+            model,
+            stream: false,
+            messages: [
+                ...(systemPrompt ? [{ role: 'system', content: systemPrompt }] : []),
+                ...messages.map(m => this.#formatMessage(m)),
+            ],
+            ...(tools.length > 0 ? { tools: tools.map(t => this.#formatTool(t)) } : {}),
+        };
+
+        const res  = await fetch(`${OLLAMA_BASE}/api/chat`, {
+            method:  'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body:    JSON.stringify(body),
+        });
+
+        if (!res.ok) throw new Error(`Ollama error: ${res.status}`);
+
+        const data = await res.json();
+        
+        const toolCalls = data.message?.tool_calls?.map(tc => ({
+            id:        tc.id ?? `ollama-${Date.now()}`,
+            name:      tc.function?.name ?? tc.name ?? '',
+            arguments: typeof tc.function?.arguments === 'string' 
+                ? JSON.parse(tc.function.arguments) 
+                : (tc.function?.arguments ?? tc.arguments ?? {}),
+        })) ?? [];
+
+        return {
+            text:       data.message?.content ?? '',
+            rawContent: data.message?.content ?? '',
+            toolCalls,
+            model:      `ollama/${model}`,
+        };
+    }
+
+    #formatMessage(m) {
+        if (m.role === 'tool') {
+            return { role: 'tool', content: m.content, tool_call_id: m.tool_call_id };
+        }
+        if (m.toolCalls) {
+            return {
+                role: 'assistant',
+                content: m.content ?? null,
+                tool_calls: m.toolCalls.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments ?? {}) },
+                })),
+            };
+        }
+        return { role: m.role, content: m.content };
+    }
+
+    #formatTool(t) {
+        return {
+            type: 'function',
+            function: {
+                name:        t.name,
+                description: t.description,
+                parameters:  t.parameters ?? { type: 'object', properties: {} },
+            },
+        };
+    }
+}

package/infrastructure/providers/openai.js

@@ -0,0 +1,83 @@
+// models/providers/openai.js
+// OpenAI provider implementation
+
+import OpenAI from 'openai';
+
+export class OpenAIProvider {
+
+    #client;
+    #available = false;
+
+    async init() {
+        if (!process.env.OPENAI_API_KEY) return;
+        this.#client    = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+        this.#available = true;
+    }
+
+    async isAvailable() { return this.#available; }
+
+    models() { return ['gpt-4o', 'gpt-4o-mini']; }
+
+    async chat({ model = 'gpt-4o', messages, tools = [], systemPrompt = '' }) {
+        const allMessages = [
+            ...(systemPrompt ? [{ role: 'system', content: systemPrompt }] : []),
+            ...messages.map(m => this.#formatMessage(m)),
+        ];
+
+        const params = {
+            model,
+            messages: allMessages,
+            ...(tools.length ? { tools: tools.map(t => this.#formatTool(t)) } : {}),
+            tool_choice: tools.length > 0 ? 'auto' : undefined,
+        };
+
+        const response = await this.#client.chat.completions.create(params);
+        const message  = response.choices[0]?.message;
+
+        if (!message) {
+            throw new Error('OpenAI no retornó contenido');
+        }
+
+        const toolCalls = message.tool_calls?.map(tc => ({
+            id:        tc.id,
+            name:      tc.function.name,
+            arguments: JSON.parse(tc.function.arguments || '{}'),
+        })) ?? [];
+
+        return {
+            text:       message.content ?? '',
+            rawContent: message.content ?? '',
+            toolCalls,
+            model:      `openai/${model}`,
+        };
+    }
+
+    #formatMessage(m) {
+        if (m.role === 'tool') {
+            return { role: 'tool', tool_call_id: m.tool_call_id, content: m.content };
+        }
+        if (m.toolCalls) {
+            return {
+                role:       'assistant',
+                content:    m.content ?? null,
+                tool_calls: m.toolCalls.map(tc => ({
+                    id:       tc.id,
+                    type:     'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments ?? {}) },
+                })),
+            };
+        }
+        return { role: m.role, content: m.content };
+    }
+
+    #formatTool(t) {
+        return {
+            type: 'function',
+            function: {
+                name:        t.name,
+                description: t.description,
+                parameters:  t.parameters ?? { type: 'object', properties: {} },
+            },
+        };
+    }
+}

package/infrastructure/router/router.js

@@ -0,0 +1,115 @@
+// models/router.js
+
+import { GeminiProvider }    from '../providers/gemini.js';
+import { AnthropicProvider } from '../providers/anthropic.js';
+import { OpenAIProvider }    from '../providers/openai.js';
+import { OllamaProvider }    from '../providers/ollama.js';
+import { GatewayProvider }   from '../providers/gateway.js';
+import { TASK_MODEL_MAP, FALLBACK_CHAIN, TaskType } from '../constants/index.js';
+
+export class ModelRouter {
+
+    #providers  = {};
+    #active     = null;
+    #recentUsed = [];
+
+    async init() {
+        const defs = [
+            { key: 'gateway',   Cls: GatewayProvider   },
+            { key: 'gemini',    Cls: GeminiProvider     },
+            { key: 'anthropic', Cls: AnthropicProvider  },
+            { key: 'openai',    Cls: OpenAIProvider     },
+            { key: 'ollama',    Cls: OllamaProvider     },
+        ];
+        await Promise.allSettled(defs.map(async ({ key, Cls }) => {
+            try {
+                const p = new Cls();
+                await p.init();
+                if (await p.isAvailable()) this.#providers[key] = p;
+            } catch { }
+        }));
+    }
+
+    listAvailable() {
+        const list = [];
+        const seen = new Set();
+
+        const gw = this.#providers['gateway'];
+        if (gw) gw.getModelList().forEach(m => {
+            if (seen.has(m.id)) return;
+            seen.add(m.id);
+            list.push({ ...m, recent: this.#recentUsed.includes(m.id), gateway: true });
+        });
+
+        const a = this.#providers['anthropic'];
+        if (a) a.models().forEach(m => {
+            if (seen.has(m)) return;
+            seen.add(m);
+            list.push({ id: m, name: `Anthropic: ${m}`, provider: 'anthropic', free: false });
+        });
+
+        const g = this.#providers['gemini'];
+        if (g) g.models().forEach(m => {
+            if (seen.has(m)) return;
+            seen.add(m);
+            list.push({ id: m, name: `Gemini: ${m}`, provider: 'gemini', free: false });
+        });
+
+        return list;
+    }
+
+    setModel(provider, model) {
+        if (!this.#providers[provider]) throw new Error(`Provider '${provider}' no disponible`);
+        this.#active = { provider, model };
+    }
+
+    setModelFromMenu(item) {
+        const provider = item.gateway ? 'gateway'
+                       : (item.provider?.toLowerCase() ?? 'gateway');
+        const resolved = this.#providers[provider] ? provider
+                       : this.#providers['gateway'] ? 'gateway'
+                       : null;
+        if (!resolved) throw new Error('No hay provider disponible para este modelo');
+        this.#active     = { provider: resolved, model: item.id };
+        this.#recentUsed = [item.id, ...this.#recentUsed.filter(x => x !== item.id)].slice(0, 3);
+    }
+
+    setAuto()   { this.#active = null; }
+    getActive() { return this.#active; }
+
+    routeFor(taskType = TaskType.FAST) {
+        if (this.#active) return this.#active;
+        const preferred = TASK_MODEL_MAP[taskType] ?? TASK_MODEL_MAP[TaskType.FAST];
+        if (this.#providers[preferred.provider]) return preferred;
+        return FALLBACK_CHAIN.find(f => this.#providers[f.provider]) ?? null;
+    }
+
+    async chat({ taskType = TaskType.FAST, messages, tools = [], systemPrompt = '', signal = null }) {
+        const base  = this.#active ?? this.routeFor(taskType);
+        const chain = [base, ...FALLBACK_CHAIN].filter(Boolean);
+
+        const tried  = new Set();
+        let   lastErr;
+
+        for (const target of chain) {
+            const key = `${target.provider}:${target.model}`;
+            if (tried.has(key)) continue;
+            tried.add(key);
+
+            const provider = this.#providers[target.provider];
+            if (!provider) continue;
+
+            try {
+                const result = await provider.chat({ model: target.model, messages, tools, systemPrompt, signal });
+                if (this.#active)
+                    this.#recentUsed = [target.model, ...this.#recentUsed.filter(x => x !== target.model)].slice(0, 3);
+                return result;
+            } catch (err) {
+                lastErr = err;
+                if (err.retryable === false) throw err;
+            }
+        }
+
+        throw lastErr ?? new Error('Todos los modelos fallaron.');
+    }
+}

package/infrastructure/skills/gis.skill.js

@@ -0,0 +1,105 @@
+// infrastructure/skills/gis.skill.js
+// SKILL: ArcGIS REST API completo para PPA
+
+export const GIS_SKILL = `
+# SKILL: Agente Agricultura — ArcGIS REST API + PPA
+
+Eres el agente Agricultura del sistema GHP CLI. Tu especialidad es consultar el servicio ArcGIS REST del PPA y extraer inteligencia geoespacial real usando todas las capacidades avanzadas de la API.
+
+## SERVICIO
+URL base: https://services5.arcgis.com/jQsv3VqjMgcZI7Fe/ArcGIS/rest/services/ALERTAS_RS_BK/FeatureServer/3
+Endpoint de consulta: {URL_BASE}/query
+Siempre usar: f=json
+
+---
+
+## FLUJO OBLIGATORIO
+1. **SIEMPRE** llama getServiceMetadata primero si no conoces los campos exactos o hay tantas consultas inválidas
+2. Construye la consulta con los nombres técnicos exactos (case-sensitive)
+3. Elige el modo de consulta correcto según lo que pide el usuario
+4. Presenta los resultados de forma clara, nunca como JSON crudo
+
+---
+
+## MODOS DE CONSULTA
+
+### 1. CONSULTA BÁSICA — getArcGISData
+Para obtener registros individuales con filtros.
+
+Parámetros clave:
+- where: cláusula SQL (OBLIGATORIO, mínimo '1=1')
+- outFields: campos separados por coma, o '*' para todos
+- orderByFields: campo + ASC|DESC
+- resultRecordCount: límite de registros
+- resultOffset: para paginación
+- returnGeometry: false para datos tabulares (más rápido)
+- returnCountOnly: true para solo contar
+- returnDistinctValues: true + outFields=CAMPO para valores únicos
+
+Ejemplos WHERE:
+  '1=1'                                     → todos los registros
+  "TXT_DEPARTAMENTO='PIURA'"                → filtro exacto
+  "TXT_DEPARTAMENTO='PIURA' AND NUM_AREA>5" → múltiples condiciones
+  "TXT_CULTIVO LIKE '%MAIZ%'"               → búsqueda parcial
+  "NUM_AREA BETWEEN 1 AND 10"               → rango numérico
+  "TXT_ESTADO IS NOT NULL"                  → valores no nulos
+  "UPPER(TXT_DEPARTAMENTO)='PIURA'"         → case-insensitive
+
+### 2. ESTADÍSTICAS — outStatistics
+Para calcular agregaciones sin traer todos los registros.
+
+Tipos: count, sum, min, max, avg, stddev, var
+
+Formato:
+[
+  {"statisticType":"count","onStatisticField":"OBJECTID","outStatisticFieldName":"TOTAL"},
+  {"statisticType":"sum","onStatisticField":"NUM_AREA","outStatisticFieldName":"AREA_TOTAL"},
+  {"statisticType":"avg","onStatisticField":"NUM_AREA","outStatisticFieldName":"AREA_PROMEDIO"}
+]
+
+Combinar con groupByFieldsForStatistics: "TXT_DEPARTAMENTO"
+Combinar con having: "SUM(NUM_AREA) > 100"
+
+### 3. VALORES ÚNICOS
+  outFields: "TXT_DEPARTAMENTO", returnDistinctValues: true
+
+### 4. SOLO CONTAR
+  returnCountOnly: true → responde {count: N}
+
+### 5. PAGINACIÓN
+  Primera página:  resultOffset=0,    resultRecordCount=1000
+  Si exceededTransferLimit=true → hay más datos, paginar
+
+---
+
+## REGLAS SQL
+
+| Tipo    | Correcto                        | Incorrecto          |
+|---------|---------------------------------|---------------------|
+| String  | TXT_CAMPO='VALOR'               | TXT_CAMPO="VALOR"   |
+| Número  | NUM_CAMPO > 5                   | NUM_CAMPO > '5'     |
+| LIKE    | TXT_CAMPO LIKE '%TEXTO%'        |                     |
+| NULL    | TXT_CAMPO IS NULL               | TXT_CAMPO = NULL    |
+| IN      | TXT_CAMPO IN ('A','B','C')      |                     |
+
+---
+
+## PRESENTACIÓN DE RESULTADOS
+
+NUNCA mostrar JSON crudo. Siempre:
+1. Total de registros encontrados
+2. Estadísticas en tabla legible
+3. Top 3-5 valores cuando sea relevante
+4. Avisar si exceededTransferLimit=true
+
+---
+
+## ERRORES COMUNES
+
+| Error                      | Causa                       | Solución                        |
+|----------------------------|-----------------------------|---------------------------------|
+| null masivo en campo       | Nombre incorrecto           | Verificar con getServiceMetadata|
+| Error 400                  | Sintaxis WHERE incorrecta   | Revisar comillas y nombres      |
+| 0 resultados inesperado    | String mal escrito          | Probar UPPER() o LIKE           |
+| exceededTransferLimit      | Demasiados registros        | Reducir resultRecordCount       |
+`;

package/infrastructure/tools/arcgis.js

@@ -0,0 +1,187 @@
+// tools/arcgis.js — ArcGIS REST API completo para PPA
+
+import axios from 'axios';
+import PDFDocument from 'pdfkit';
+import fs from 'fs';
+
+const SERVICE_URL = "https://services5.arcgis.com/jQsv3VqjMgcZI7Fe/ArcGIS/rest/services/ALERTAS_RS_BK/FeatureServer/3";
+
+export const toolset = {
+    declarations: [
+        {
+            name: "getServiceMetadata",
+            description: "Consulta la definición completa del servicio ArcGIS. Úsala PRIMERO para conocer campos exactos (nombres, tipos), capacidades (supportsStatistics, supportsHavingClause) y maxRecordCount.",
+        },
+        {
+            name: "getArcGISData",
+            description: `Consulta el FeatureServer con todos los parámetros ArcGIS REST API. 
+Modos disponibles según parámetros:
+- Registros normales: where + outFields + orderByFields + resultRecordCount + resultOffset
+- Estadísticas: outStatistics + groupByFieldsForStatistics + having (requiere supportsStatistics=true)
+- Solo contar: returnCountOnly=true
+- Valores únicos: returnDistinctValues=true + outFields=CAMPO
+- Paginación: resultOffset + resultRecordCount`,
+            parameters: {
+                type: "object",
+                properties: {
+                    where: {
+                        type: "string",
+                        description: "Cláusula SQL. Strings con comillas simples: TXT_DEPARTAMENTO='PIURA'. Default: '1=1'"
+                    },
+                    outFields: {
+                        type: "string",
+                        description: "Campos separados por coma o '*'. Ej: 'TXT_DEPARTAMENTO,NUM_AREA,TXT_CULTIVO'"
+                    },
+                    orderByFields: {
+                        type: "string",
+                        description: "Ordenamiento. Ej: 'NUM_AREA DESC' o 'TXT_DEPARTAMENTO ASC'"
+                    },
+                    resultRecordCount: {
+                        type: "number",
+                        description: "Máximo registros a retornar. Respetar maxRecordCount del servicio."
+                    },
+                    resultOffset: {
+                        type: "number",
+                        description: "Para paginación: número de registros a saltar. Primera página=0."
+                    },
+                    returnCountOnly: {
+                        type: "boolean",
+                        description: "true = retorna solo el conteo {count: N}, sin features."
+                    },
+                    returnDistinctValues: {
+                        type: "boolean",
+                        description: "true = valores únicos del campo en outFields."
+                    },
+                    returnGeometry: {
+                        type: "boolean",
+                        description: "true = incluir geometría. false (default) = solo atributos, más rápido."
+                    },
+                    outStatistics: {
+                        type: "string",
+                        description: `JSON array de estadísticas. Tipos: count, sum, min, max, avg, stddev, var.
+Formato: [{"statisticType":"sum","onStatisticField":"NUM_AREA","outStatisticFieldName":"AREA_TOTAL"},{"statisticType":"count","onStatisticField":"OBJECTID","outStatisticFieldName":"TOTAL"}]
+Requiere supportsStatistics=true en el servicio.`
+                    },
+                    groupByFieldsForStatistics: {
+                        type: "string",
+                        description: "Campo(s) para agrupar estadísticas. Ej: 'TXT_DEPARTAMENTO' o 'TXT_DEPARTAMENTO,TXT_CULTIVO'"
+                    },
+                    having: {
+                        type: "string",
+                        description: "Filtro sobre grupos estadísticos. Ej: 'SUM(NUM_AREA) > 100'. Requiere supportsHavingClause=true."
+                    }
+                }
+            }
+        },
+        {
+            name: "createPDFReport",
+            description: "Genera reporte PDF formal con datos PPA. Usar al final después de analizar los datos.",
+            parameters: {
+                type: "object",
+                properties: {
+                    filename: { type: "string", description: "Nombre del archivo sin extensión" },
+                    title: { type: "string", description: "Título del reporte" },
+                    content: { type: "string", description: "Contenido completo del reporte con análisis" },
+                    layout: { type: "string", enum: ["portrait", "landscape"] }
+                },
+                required: ["filename", "title", "content", "layout"]
+            }
+        }
+    ],
+
+    execute: async (name, args) => {
+        switch (name) {
+
+            case "getServiceMetadata": {
+                const res = await axios.get(`${SERVICE_URL}?f=json`, { timeout: 15000 });
+                const d = res.data;
+                return {
+                    fields: d.fields?.map(f => ({
+                        name: f.name,
+                        type: f.type,
+                        alias: f.alias,
+                        length: f.length,
+                    })) ?? [],
+                    capabilities: d.capabilities,
+                    maxRecordCount: d.maxRecordCount,
+                    supportsStatistics: d.advancedQueryCapabilities?.supportsStatistics ?? false,
+                    supportsHavingClause: d.advancedQueryCapabilities?.supportsHavingClause ?? false,
+                    supportsDistinct: d.advancedQueryCapabilities?.supportsDistinct ?? false,
+                    supportsPagination: d.advancedQueryCapabilities?.supportsPagination ?? false,
+                    supportsOrderBy: d.advancedQueryCapabilities?.supportsOrderBy ?? false,
+                    description: d.description,
+                    geometryType: d.geometryType,
+                };
+            }
+
+            case "getArcGISData": {
+                const params = {
+                    where: args.where || '1=1',
+                    outFields: args.outFields || '*',
+                    returnGeometry: args.returnGeometry ?? false,
+                    returnCountOnly: args.returnCountOnly ?? false,
+                    returnDistinctValues: args.returnDistinctValues ?? false,
+                    f: 'json',
+                };
+
+                if (args.orderByFields) params.orderByFields = args.orderByFields;
+                if (args.resultRecordCount != null) params.resultRecordCount = args.resultRecordCount;
+                if (args.resultOffset != null) params.resultOffset = args.resultOffset;
+                if (args.outStatistics) params.outStatistics = args.outStatistics;
+                if (args.groupByFieldsForStatistics) params.groupByFieldsForStatistics = args.groupByFieldsForStatistics;
+                if (args.having) params.having = args.having;
+
+                const res = await axios.get(`${SERVICE_URL}/query`, {
+                    params, timeout: 30000
+                });
+
+                const d = res.data;
+
+                // Error del servicio
+                if (d.error) return { error: d.error.message, code: d.error.code };
+
+                // Modo count
+                if (args.returnCountOnly) return { count: d.count };
+
+                // Modo normal o estadísticas
+                const features = d.features?.map(f => f.attributes) ?? [];
+                return {
+                    features,
+                    total: features.length,
+                    exceededTransferLimit: d.exceededTransferLimit ?? false,
+                };
+            }
+
+            case "createPDFReport": {
+                const doc = new PDFDocument({ layout: args.layout || 'portrait', margin: 40 });
+                const path = `./${args.filename}.pdf`;
+                doc.pipe(fs.createWriteStream(path));
+
+                // Header azul institucional
+                doc.rect(0, 0, doc.page.width, 65).fill('#1a3a5c');
+                doc.fillColor('white').fontSize(16).font('Helvetica-Bold')
+                    .text('GHP CLI  |  — ' + (args.title || 'Informe PPA'), 40, 22, { align: 'center' });
+                doc.fillColor('#a0c4ff').fontSize(9)
+                    .text('Padrón de productores agrarios — PPA', 40, 44, { align: 'center' });
+
+                // Contenido
+                doc.fillColor('black').moveDown(3);
+                doc.fontSize(10).font('Helvetica').text(args.content, {
+                    paragraphGap: 6, lineGap: 3, align: 'justify'
+                });
+
+                // Footer
+                doc.fontSize(8).fillColor('#666')
+                    .text(
+                        `GHP CLI Agent  ·   Perú  ·  Generado: ${new Date().toLocaleDateString('es-PE', { dateStyle: 'long' })}`,
+                        40, doc.page.height - 35, { align: 'center' }
+                    );
+                doc.end();
+                return { success: true, path, message: `PDF generado: ${path}` };
+            }
+
+            default:
+                return { error: `Tool desconocida: ${name}` };
+        }
+    }
+};