@gishubperu/ghp 0.0.1

package/infrastructure/core/orchestrator.js

@@ -0,0 +1,155 @@
+// infrastructure/core/orchestrator.js
+
+import { AgentType, SystemPrompts, DEFAULT_SYSTEM_PROMPT, TaskType } from '../constants/index.js';
+
+export class Orchestrator {
+
+    #queue; #workers; #router; #memory; #toolset;
+
+    constructor({ queue, workerPool, router, memory, toolset }) {
+        this.#queue   = queue;
+        this.#workers = workerPool;
+        this.#router  = router;
+        this.#memory  = memory;
+        this.#toolset = toolset;
+    }
+
+    async run(userInput, { onProgress, agentId = AgentType.AUTO, signal = null } = {}) {
+        const systemPrompt = SystemPrompts[agentId] ?? DEFAULT_SYSTEM_PROMPT;
+        const complexity   = this.#assessComplexity(userInput);
+
+        if (complexity === 'simple')
+            return this.#runSimple(userInput, { onProgress, systemPrompt, signal });
+        return this.#runPlanned(userInput, { onProgress, systemPrompt, signal });
+    }
+
+    // Single agent with conversation history
+    async #runSimple(input, { onProgress, systemPrompt, signal }) {
+        const history  = this.#memory.getBuffer();
+        const messages = [...history, { role: 'user', content: input }];
+
+        this.#memory.pushTurn({ role: 'user', content: input });
+
+        const result = await this.#chatWithTools({
+            taskType: 'fast', messages, systemPrompt, onProgress, signal,
+        });
+
+        this.#memory.pushTurn({ role: 'assistant', content: result.text });
+        await this.#memory.save({ input, output: result.text, type: 'simple' });
+        return result;
+    }
+
+    // Splits into parallel subtasks → synthesizes
+    async #runPlanned(input, { onProgress, systemPrompt, signal }) {
+        onProgress?.({ type: 'planning' });
+
+        const plan    = await this.#buildPlan(input);
+        onProgress?.({ type: 'plan', tasks: plan });
+
+        const taskIds = plan.map(t => this.#queue.enqueue({ ...t, parentInput: input }));
+        const results = await this.#workers.runAll(taskIds, { onProgress, signal });
+
+        onProgress?.({ type: 'synthesizing' });
+
+        const history   = this.#memory.getBuffer();
+        const synthesis = await this.#chatWithTools({
+            taskType: 'fast',
+            systemPrompt: systemPrompt + '\n\nConsolida los resultados en una respuesta clara y directa.',
+            messages: [
+                ...history,
+                {
+                    role: 'user',
+                    content: `Pregunta original: ${input}\n\nResultados de subtareas paralelas:\n${
+                        results.map(t => `[${t.type}${t.error ? ' ✗' : ''}]: ${t.result}`).join('\n\n')
+                    }`,
+                },
+            ],
+            onProgress, signal,
+        });
+
+        this.#memory.pushTurn({ role: 'user',      content: input          });
+        this.#memory.pushTurn({ role: 'assistant', content: synthesis.text });
+        await this.#memory.save({ input, output: synthesis.text, type: 'planned' });
+        return synthesis;
+    }
+
+    // Iterative tool-call loop
+    async #chatWithTools({ taskType, messages, systemPrompt, onProgress, signal }) {
+        const tools    = this.#toolset?.declarations ?? [];
+        let   msgs     = [...messages];
+        let   maxIter  = 8;
+
+        while (maxIter-- > 0) {
+            if (signal?.aborted) throw new DOMException('Cancelled by user', 'AbortError');
+
+            const res = await this.#router.chat({ taskType, messages: msgs, tools, systemPrompt, signal });
+
+            if (!res.toolCalls?.length)
+                return { text: res.text, model: res.model };
+
+            for (const toolCall of res.toolCalls) {
+                onProgress?.({ type: 'tool_start', toolName: toolCall.name, toolArgs: toolCall.arguments });
+
+                let toolResult;
+                try   { toolResult = await this.#toolset.execute(toolCall.name, toolCall.arguments ?? {}); }
+                catch (err) { toolResult = { error: err.message }; }
+
+                onProgress?.({ type: 'tool_done', toolName: toolCall.name, toolResult });
+
+                msgs.push({ role: 'assistant', content: res.rawContent ?? '', toolCalls: res.toolCalls });
+                msgs.push({ role: 'tool', tool_call_id: toolCall.id, content: JSON.stringify(toolResult) });
+            }
+        }
+
+        return { text: 'Límite de iteraciones de herramientas alcanzado.', model: 'system' };
+    }
+
+    // LLM-based task planner
+    async #buildPlan(input) {
+        const res = await this.#router.chat({
+            taskType:     'fast',
+            systemPrompt: PLANNER_PROMPT,
+            messages:     [{ role: 'user', content: input }],
+        });
+        try {
+            const raw  = res.text;
+            const json = raw.match(/```json\n?([\s\S]*?)\n?```/)?.[1]
+                      ?? raw.match(/(\[[\s\S]*\])/)?.[1] ?? raw;
+            return JSON.parse(json);
+        } catch {
+            return [{ id: '1', type: 'general', description: input, priority: 1 }];
+        }
+    }
+
+    // Decides simple vs parallel execution
+    #assessComplexity(input) {
+        if (input.length < 60) return 'simple';
+
+        const multiTaskPatterns = [
+            /compara.+y.+|versus|vs\b/i,
+            /(piura|cajamarca|cusco|lima|junín|ayacucho).+(y|,).+(piura|cajamarca|cusco|lima|junín|ayacucho)/i,
+            /analiz.+y.+(genera|crea|report)/i,
+            /por (cada|todos los) (departamento|region|cultivo)/i,
+            /(informe completo|reporte detallado|análisis nacional|resumen nacional)/i,
+            /(datos|estadísticas).+(reporte|pdf|informe)/i,
+        ];
+
+        if (multiTaskPatterns.some(pattern => pattern.test(input))) return 'complex';
+
+        if (input.length > 120 &&
+            /\b(analiza|genera|crea|compara|investiga|planifica|extrae|procesa|reporte|informe)\b/i.test(input))
+            return 'complex';
+
+        return 'simple';
+    }
+}
+
+const PLANNER_PROMPT = `Eres un planificador de tareas paralelas. Divide la solicitud en subtareas INDEPENDIENTES que puedan ejecutarse en paralelo.
+Responde ÚNICAMENTE con un JSON array, sin texto adicional:
+[
+  {"id":"1","type":"agriculture","description":"consulta específica 1","priority":1},
+  {"id":"2","type":"deforestation","description":"análisis específico 2","priority":1}
+]
+Tipos disponibles: agriculture, minning, deforestation, general.
+Máximo 4 subtareas. Cada subtarea debe ser autónoma y específica.
+Si la tarea no tiene subtareas paralelas claras, devuelve solo 1 tarea de tipo general.`;

package/infrastructure/core/queue.js

@@ -0,0 +1,53 @@
+// infrastructure/core/queue.js
+// Priority task queue — min-heap by priority
+
+export class TaskQueue {
+
+    #heap = [];
+
+    enqueue(task) {
+        const item = { ...task, enqueuedAt: Date.now() };
+        this.#heap.push(item);
+        this.#bubbleUp(this.#heap.length - 1);
+        return item;
+    }
+
+    dequeue() {
+        if (this.#heap.length === 0) return null;
+        const top  = this.#heap[0];
+        const last = this.#heap.pop();
+        if (this.#heap.length > 0) {
+            this.#heap[0] = last;
+            this.#sinkDown(0);
+        }
+        return top;
+    }
+
+    peek()    { return this.#heap[0] ?? null; }
+    size()    { return this.#heap.length; }
+    isEmpty() { return this.#heap.length === 0; }
+
+    // Lower priority number = execute first (1 > 2 > 3)
+    #bubbleUp(i) {
+        while (i > 0) {
+            const parent = Math.floor((i - 1) / 2);
+            if (this.#heap[parent].priority <= this.#heap[i].priority) break;
+            [this.#heap[parent], this.#heap[i]] = [this.#heap[i], this.#heap[parent]];
+            i = parent;
+        }
+    }
+
+    #sinkDown(i) {
+        const n = this.#heap.length;
+        while (true) {
+            let smallest = i;
+            const left   = 2 * i + 1;
+            const right  = 2 * i + 2;
+            if (left  < n && this.#heap[left].priority  < this.#heap[smallest].priority) smallest = left;
+            if (right < n && this.#heap[right].priority < this.#heap[smallest].priority) smallest = right;
+            if (smallest === i) break;
+            [this.#heap[smallest], this.#heap[i]] = [this.#heap[i], this.#heap[smallest]];
+            i = smallest;
+        }
+    }
+}

package/infrastructure/core/workers.js

@@ -0,0 +1,67 @@
+// infrastructure/core/workers.js
+// Worker pool — runs subtasks in parallel with concurrency limit
+
+import { AgentFactory } from '../agents/agent-factory.js';
+import { AgentType } from '../constants/index.js';
+
+const AGENT_REGISTRY = Object.freeze({
+    [AgentType.AGRICULTURE]:   AgentType.AGRICULTURE,
+    [AgentType.MINNING]:       AgentType.MINNING,
+    [AgentType.DEFORESTATION]: AgentType.DEFORESTATION,
+    [AgentType.GENERAL]:       AgentType.GENERAL,
+});
+
+export class WorkerPool {
+
+    #maxConcurrent;
+    #router;
+    #memory;
+    #agents;
+
+    constructor({ workers = 4, router, memory, toolset }) {
+        this.#maxConcurrent = workers;
+        this.#router        = router;
+        this.#memory        = memory;
+        this.#agents        = {};
+        for (const type of Object.values(AGENT_REGISTRY)) {
+            this.#agents[type] = AgentFactory.create(type, { router, memory, toolset });
+        }
+    }
+
+    async runAll(tasks, { onProgress, signal } = {}) {
+        const results = [];
+        for (let i = 0; i < tasks.length; i += this.#maxConcurrent) {
+            const batch         = tasks.slice(i, i + this.#maxConcurrent);
+            const batchOutcomes = await Promise.allSettled(
+                batch.map(task => this.#executeTask(task, { onProgress, signal }))
+            );
+            for (const [j, outcome] of batchOutcomes.entries()) {
+                if (outcome.status === 'fulfilled') {
+                    results.push(outcome.value);
+                } else {
+                    results.push({
+                        ...batch[j],
+                        result: `Error: ${outcome.reason?.message ?? 'unknown'}`,
+                        error:  true,
+                    });
+                }
+            }
+        }
+        return results;
+    }
+
+    async #executeTask(task, { onProgress, signal }) {
+        onProgress?.({ type: 'task_start', task: task.id, taskType: task.type });
+        const agent  = this.#agents[task.type] ?? this.#agents[AgentType.GENERAL];
+        const result = await agent.run(task.description, { signal });
+        onProgress?.({ type: 'task_done', task: task.id, taskType: task.type });
+        return {
+            id:       task.id,
+            type:     task.type,
+            input:    task.description,
+            result:   result.text,
+            model:    result.model,
+            priority: task.priority,
+        };
+    }
+}

package/infrastructure/memory/store.js

@@ -0,0 +1,115 @@
+// infrastructure/memory/store.js
+// Two-layer memory:
+// 1. conversationBuffer — last N turns in RAM (immediate context, always included)
+// 2. entries (JSON file) — persistent history, keyword search
+
+import fs   from 'fs/promises';
+import path from 'path';
+
+const MEMORY_FILE   = path.resolve(process.cwd(), '.agent_memory.json');
+const MAX_ENTRIES   = 500;
+const BUFFER_LIMIT  = 12; // last 12 turns (~6 exchanges)
+
+export class MemoryStore {
+
+    #data   = { entries: [], sessions: [] };
+    #buffer = [];
+
+    async init() {
+        try {
+            const raw  = await fs.readFile(MEMORY_FILE, 'utf8');
+            this.#data = JSON.parse(raw);
+        } catch {
+            this.#data = { entries: [], sessions: [] };
+            await this.#flush();
+        }
+    }
+
+    // Add a turn to the active conversation buffer
+    pushTurn({ role, content }) {
+        this.#buffer.push({ role, content });
+        // Remove oldest pair (user+assistant) to keep structure valid
+        if (this.#buffer.length > BUFFER_LIMIT)
+            this.#buffer.splice(0, 2);
+    }
+
+    // Returns full buffer — pass to model as conversation history
+    getBuffer() {
+        return [...this.#buffer];
+    }
+
+    // Clear buffer (new session / /clear command)
+    clearBuffer() {
+        this.#buffer = [];
+    }
+
+    // Persist interaction at end of each turn
+    async save({ input, output, type = 'general', tasks = [] }) {
+        const entry = {
+            id:        Date.now().toString(36),
+            timestamp: new Date().toISOString(),
+            input,
+            output,
+            type,
+            tasks,
+            keywords:  this.#extractKeywords(input + ' ' + output),
+        };
+        this.#data.entries.unshift(entry);
+        if (this.#data.entries.length > MAX_ENTRIES)
+            this.#data.entries = this.#data.entries.slice(0, MAX_ENTRIES);
+        await this.#flush();
+        return entry;
+    }
+
+    // Keyword similarity search — for relevant context from past sessions
+    async recall(query, { limit = 3 } = {}) {
+        const queryWords = this.#extractKeywords(query);
+        return this.#data.entries
+            .map(e => ({ ...e, score: this.#similarity(queryWords, e.keywords) }))
+            .filter(e => e.score > 0.15)
+            .sort((a, b) => b.score - a.score || new Date(b.timestamp) - new Date(a.timestamp))
+            .slice(0, limit)
+            .map(({ score, keywords, ...e }) => e);
+    }
+
+    async recent(limit = 10) { return this.#data.entries.slice(0, limit); }
+
+    async clear() {
+        this.#data  = { entries: [], sessions: [] };
+        this.#buffer = [];
+        await this.#flush();
+    }
+
+    stats() {
+        return {
+            total:   this.#data.entries.length,
+            buffer:  this.#buffer.length,
+            oldest:  this.#data.entries.at(-1)?.timestamp ?? null,
+            newest:  this.#data.entries.at(0)?.timestamp  ?? null,
+        };
+    }
+
+    async #flush() {
+        await fs.writeFile(MEMORY_FILE, JSON.stringify(this.#data, null, 2), 'utf8');
+    }
+
+    #extractKeywords(text) {
+        const stopWords = new Set([
+            'de','la','el','en','y','a','que','the','of','and','to','is',
+            'los','las','con','por','para','del','un','una','este','esta',
+            'eso','ello','hay','son','está','estoy','tiene','tengo','puedo','puede','sería',
+        ]);
+        return [...new Set(
+            text.toLowerCase()
+                .replace(/[^\w\sáéíóúñü]/g, ' ')
+                .split(/\s+/)
+                .filter(w => w.length > 3 && !stopWords.has(w))
+        )];
+    }
+
+    #similarity(a, b) {
+        const setB    = new Set(b);
+        const matches = a.filter(w => setB.has(w)).length;
+        return matches / Math.max(a.length, b.length, 1);
+    }
+}

package/infrastructure/providers/anthropic.js

@@ -0,0 +1,59 @@
+// models/providers/anthropic.js
+// Anthropic Claude provider implementation
+
+import Anthropic from '@anthropic-ai/sdk';
+
+export class AnthropicProvider {
+
+    #client;
+    #available = false;
+
+    async init() {
+        if (!process.env.ANTHROPIC_API_KEY) return;
+        this.#client    = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+        this.#available = true;
+    }
+
+    async isAvailable() { return this.#available; }
+
+    models() { return ['claude-sonnet-4-5', 'claude-haiku-4-5-20251001']; }
+
+    async chat({ model = 'claude-sonnet-4-5', messages, tools = [], systemPrompt = '' }) {
+        const params = {
+            model,
+            max_tokens: 4096,
+            messages:   messages.map(m => ({ role: m.role, content: m.content })),
+            ...(systemPrompt ? { system: systemPrompt } : {}),
+            ...(tools.length  ? { tools: this.#formatTools(tools) } : {}),
+        };
+
+        const response = await this.#client.messages.create(params);
+        
+        const textBlock = response.content.find(b => b.type === 'text');
+        const toolBlock = response.content.find(b => b.type === 'tool_use');
+        
+        const toolCalls = [];
+        if (toolBlock) {
+            toolCalls.push({
+                id:        toolBlock.id,
+                name:      toolBlock.name,
+                arguments: toolBlock.input ?? {},
+            });
+        }
+
+        return {
+            text:       textBlock?.text ?? '',
+            rawContent: '',
+            toolCalls,
+            model:      `anthropic/${model}`,
+        };
+    }
+
+    #formatTools(tools) {
+        return tools.map(t => ({
+            name:        t.name,
+            description: t.description,
+            input_schema: t.parameters ?? { type: 'object', properties: {} },
+        }));
+    }
+}

package/infrastructure/providers/gateway.js

@@ -0,0 +1,140 @@
+// models/providers/gateway.js
+// GHP Gateway — Kilo AI Gateway (OpenAI-compatible)
+// Modelos :free funcionan SIN API key (200 req/hora anónimo)
+
+import { KNOWN_FREE_MODELS } from '../constants/index.js';
+
+const BASE_URL = 'https://api.kilo.ai/api/gateway';
+
+export class GatewayProvider {
+
+    #apiKey    = null;
+    #available = false;
+    #modelList = [];
+
+    async init() {
+        this.#apiKey = process.env.GH_PPA_KEY ?? process.env.KILO_API_KEY ?? null;
+        try {
+            const res = await fetch(`${BASE_URL}/models`, { signal: AbortSignal.timeout(6_000) });
+            if (res.ok) {
+                const data = await res.json();
+                const raw  = Array.isArray(data) ? data : (data.data ?? []);
+                this.#modelList = raw
+                    .map(m => ({
+                        id:       m.id,
+                        name:     m.name ?? m.id,
+                        provider: m.id.split('/')[0] ?? 'unknown',
+                        free:     m.id.endsWith(':free') || !m.pricing?.prompt || m.pricing?.prompt === '0',
+                        context:  m.context_length ?? null,
+                        gateway:  true,
+                    }))
+                    .sort((a, b) => (b.free - a.free) || a.name.localeCompare(b.name));
+            } else {
+                this.#modelList = KNOWN_FREE_MODELS;
+            }
+        } catch {
+            this.#modelList = KNOWN_FREE_MODELS;
+        }
+        this.#available = true;
+    }
+
+    async isAvailable() { return this.#available; }
+    getModelList()      { return this.#modelList; }
+    models()            { return this.#modelList.map(m => m.id); }
+
+    async chat({ model, messages, tools = [], systemPrompt = '', signal = null }) {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.#apiKey) headers['Authorization'] = `Bearer ${this.#apiKey}`;
+
+        // Convertir messages con tool results al formato OpenAI
+        const formattedMessages = [
+            ...(systemPrompt ? [{ role: 'system', content: systemPrompt }] : []),
+            ...messages.map(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 };
+            }),
+        ];
+
+        const body = { model, messages: formattedMessages };
+
+        // Solo agregar tools si hay declaraciones
+        if (tools.length > 0) {
+            body.tools = tools.map(t => ({
+                type:     'function',
+                function: {
+                    name:        t.name,
+                    description: t.description,
+                    parameters:  t.parameters ?? { type: 'object', properties: {} },
+                },
+            }));
+            body.tool_choice = 'auto';
+        }
+
+        const res = await fetch(`${BASE_URL}/chat/completions`, {
+            method:  'POST',
+            headers,
+            body:    JSON.stringify(body),
+            signal:  signal ?? AbortSignal.timeout(60_000),
+        });
+
+        if (!res.ok) {
+            const text = await res.text().catch(() => String(res.status));
+            const err  = new Error(`GHP Gateway [${model}] → ${res.status}: ${text}`);
+            err.retryable = true;
+            throw err;
+        }
+
+        const data = await res.json();
+
+        if (data.error) {
+            const err = new Error(`GHP Gateway: ${data.error.message ?? JSON.stringify(data.error)}`);
+            err.retryable = true;
+            throw err;
+        }
+
+        const choice  = data.choices?.[0];
+        const message = choice?.message;
+
+        if (!message) {
+            const err = new Error(`GHP Gateway [${model}] no retornó contenido`);
+            err.retryable = true;
+            throw err;
+        }
+
+        // Si el modelo quiere usar tools
+        if (message.tool_calls?.length > 0) {
+            return {
+                text:       message.content ?? '',
+                model:      `gateway/${model}`,
+                rawContent: message.content,
+                toolCalls:  message.tool_calls.map(tc => ({
+                    id:        tc.id,
+                    name:      tc.function.name,
+                    arguments: JSON.parse(tc.function.arguments || '{}'),
+                })),
+            };
+        }
+
+        const text = message.content;
+        if (!text) {
+            const err = new Error(`GHP Gateway [${model}] respuesta vacía`);
+            err.retryable = true;
+            throw err;
+        }
+
+        return { text, model: `gateway/${model}` };
+    }
+}

package/infrastructure/providers/gemini.js

@@ -0,0 +1,50 @@
+// models/providers/gemini.js
+// Google Gemini provider implementation
+
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+export class GeminiProvider {
+
+    #client;
+    #available = false;
+
+    async init() {
+        if (!process.env.GEMINI_API_KEY) return;
+        this.#client    = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
+        this.#available = true;
+    }
+
+    async isAvailable() { return this.#available; }
+
+    models() { return ['gemini-2.5-flash', 'gemini-2.5-pro']; }
+
+    async chat({ model = 'gemini-2.5-flash', messages, tools = [], systemPrompt = '' }) {
+        const geminiModel = this.#client.getGenerativeModel({
+            model,
+            ...(systemPrompt ? { systemInstruction: systemPrompt } : {}),
+            ...(tools.length  ? { tools: [{ functionDeclarations: tools }] } : {}),
+        });
+
+        const history = messages.slice(0, -1).map(m => ({
+            role:  m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }],
+        }));
+
+        const chat   = geminiModel.startChat({ history });
+        const last   = messages.at(-1);
+        const result = await chat.sendMessage(last.content);
+
+        const functionCalls = result.response.functionCalls?.() ?? [];
+        
+        return {
+            text:       result.response.text(),
+            rawContent: '',
+            toolCalls:  functionCalls.length > 0 ? functionCalls.map(fc => ({
+                id:        `gemini-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+                name:      fc.name,
+                arguments: fc.args ?? {},
+            })) : [],
+            model:      `gemini/${model}`,
+        };
+    }
+}