zyn-ai 1.2.0 → 1.3.0

package/src/utils/secretStorage.js

@@ -0,0 +1,223 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const HOME_DIR = os.homedir() || '/root';
+const DATA_ROOT = path.join(HOME_DIR, '.zyn');
+const GIT_SECRETS_FILE = path.join(DATA_ROOT, 'git-secrets.json');
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function loadGitSecrets() {
+  const raw = readJson(GIT_SECRETS_FILE);
+  if (!raw || typeof raw !== 'object') {
+    return { github: null, gitlab: null, custom: {} };
+  }
+
+  return {
+    github: raw.github || null,
+    gitlab: raw.gitlab || null,
+    custom: raw.custom && typeof raw.custom === 'object' ? raw.custom : {},
+  };
+}
+
+function saveGitSecrets(data) {
+  writeJson(GIT_SECRETS_FILE, {
+    github: data.github || null,
+    gitlab: data.gitlab || null,
+    custom: data.custom && typeof data.custom === 'object' ? data.custom : {},
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+function normalizeProfileName(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function normalizeBaseUrl(value) {
+  return String(value || '').trim().replace(/\/+$/, '');
+}
+
+function sanitizeSecretConfig(input = {}) {
+  const output = {};
+  if (input.token !== undefined) output.token = String(input.token || '').trim();
+  if (input.username !== undefined) output.username = String(input.username || '').trim();
+  if (input.apiBaseUrl !== undefined) output.apiBaseUrl = normalizeBaseUrl(input.apiBaseUrl);
+  if (input.cloneBaseUrl !== undefined) output.cloneBaseUrl = normalizeBaseUrl(input.cloneBaseUrl);
+  if (input.authHeader !== undefined) output.authHeader = String(input.authHeader || '').trim();
+  if (input.name !== undefined) output.name = String(input.name || '').trim();
+  return output;
+}
+
+function upsertGitSecret(provider, input = {}) {
+  const key = normalizeProfileName(provider);
+  const config = sanitizeSecretConfig(input);
+  const store = loadGitSecrets();
+
+  if (key === 'github') {
+    store.github = {
+      ...store.github,
+      ...config,
+      provider: 'github',
+      apiBaseUrl: config.apiBaseUrl || store.github?.apiBaseUrl || 'https://api.github.com',
+      cloneBaseUrl: config.cloneBaseUrl || store.github?.cloneBaseUrl || 'https://github.com',
+      updatedAt: new Date().toISOString(),
+    };
+    saveGitSecrets(store);
+    return store.github;
+  }
+
+  if (key === 'gitlab') {
+    store.gitlab = {
+      ...store.gitlab,
+      ...config,
+      provider: 'gitlab',
+      apiBaseUrl: config.apiBaseUrl || store.gitlab?.apiBaseUrl || 'https://gitlab.com/api/v4',
+      cloneBaseUrl: config.cloneBaseUrl || store.gitlab?.cloneBaseUrl || 'https://gitlab.com',
+      updatedAt: new Date().toISOString(),
+    };
+    saveGitSecrets(store);
+    return store.gitlab;
+  }
+
+  const name = config.name || key || 'custom';
+  store.custom[name] = {
+    ...store.custom[name],
+    ...config,
+    provider: 'custom',
+    name,
+    updatedAt: new Date().toISOString(),
+  };
+  saveGitSecrets(store);
+  return store.custom[name];
+}
+
+function removeGitSecret(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  const store = loadGitSecrets();
+  if (key === 'github') {
+    store.github = null;
+    saveGitSecrets(store);
+    return true;
+  }
+  if (key === 'gitlab') {
+    store.gitlab = null;
+    saveGitSecrets(store);
+    return true;
+  }
+  const customName = String(name || '').trim();
+  if (!customName) return false;
+  if (store.custom[customName]) {
+    delete store.custom[customName];
+    saveGitSecrets(store);
+    return true;
+  }
+  return false;
+}
+
+function listGitSecrets() {
+  const store = loadGitSecrets();
+  const output = [];
+  if (store.github) output.push({ key: 'github', ...store.github, token: '[set]' });
+  if (store.gitlab) output.push({ key: 'gitlab', ...store.gitlab, token: '[set]' });
+  for (const [name, config] of Object.entries(store.custom || {})) {
+    output.push({ key: `custom:${name}`, ...config, token: '[set]' });
+  }
+  return output;
+}
+
+function getGitSecret(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  const store = loadGitSecrets();
+  if (key === 'github') return store.github || null;
+  if (key === 'gitlab') return store.gitlab || null;
+  const customName = String(name || '').trim();
+  if (!customName) return null;
+  return store.custom[customName] || null;
+}
+
+function resolveGitProfile(provider, name = '') {
+  const key = normalizeProfileName(provider);
+  if (key === 'github' || key === 'gitlab') return getGitSecret(key);
+  return getGitSecret('custom', name);
+}
+
+function buildCloneUrl(repoUrl, profile = {}) {
+  const raw = String(repoUrl || '').trim();
+  if (!raw) throw new Error('Missing repo URL');
+  if (!profile?.token) return raw;
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return raw;
+  }
+
+  const host = parsed.hostname.toLowerCase();
+  if (host.includes('github.com')) {
+    parsed.username = 'x-access-token';
+    parsed.password = profile.token;
+    return parsed.toString();
+  }
+
+  if (host.includes('gitlab.com')) {
+    parsed.username = profile.username || 'oauth2';
+    parsed.password = profile.token;
+    return parsed.toString();
+  }
+
+  parsed.username = profile.username || 'oauth2';
+  parsed.password = profile.token;
+  return parsed.toString();
+}
+
+function getApiBaseUrl(provider, profile = {}) {
+  const key = normalizeProfileName(provider);
+  if (profile?.apiBaseUrl) return normalizeBaseUrl(profile.apiBaseUrl);
+  if (key === 'github') return 'https://api.github.com';
+  if (key === 'gitlab') return 'https://gitlab.com/api/v4';
+  return '';
+}
+
+function buildApiHeaders(provider, profile = {}, extraHeaders = {}) {
+  const key = normalizeProfileName(provider);
+  const token = profile?.token || '';
+  const headers = { ...extraHeaders };
+
+  if (token) {
+    if (key === 'gitlab') {
+      headers['PRIVATE-TOKEN'] = token;
+    } else if (profile?.authHeader) {
+      headers[profile.authHeader] = token;
+    } else {
+      headers.Authorization = `Bearer ${token}`;
+    }
+  }
+
+  return headers;
+}
+
+module.exports = {
+  buildApiHeaders,
+  buildCloneUrl,
+  getApiBaseUrl,
+  getGitSecret,
+  listGitSecrets,
+  loadGitSecrets,
+  normalizeProfileName,
+  removeGitSecret,
+  resolveGitProfile,
+  saveGitSecrets,
+  upsertGitSecret,
+};

package/src/utils/taskStorage.js

@@ -0,0 +1,192 @@
+const fs = require('fs');
+const path = require('path');
+const { TASKS_FILE, USER_DATA_ROOT } = require('../config');
+
+const fsp = fs.promises;
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function loadTaskStore() {
+  const raw = readJson(TASKS_FILE);
+  if (!raw || typeof raw !== 'object') {
+    return { version: 1, tasks: [] };
+  }
+  if (Array.isArray(raw)) {
+    return { version: 1, tasks: raw };
+  }
+  return {
+    version: Number(raw.version || 1),
+    tasks: Array.isArray(raw.tasks) ? raw.tasks : [],
+  };
+}
+
+function saveTaskStore(store) {
+  writeJson(TASKS_FILE, {
+    version: 1,
+    tasks: Array.isArray(store.tasks) ? store.tasks : [],
+    updatedAt: new Date().toISOString(),
+  });
+}
+
+function normalizeTaskText(text) {
+  return String(text || '').trim().replace(/\s+/g, ' ');
+}
+
+function makeTaskId() {
+  return `task_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+}
+
+function enrichTask(task) {
+  return {
+    id: task.id,
+    title: normalizeTaskText(task.title),
+    description: normalizeTaskText(task.description || ''),
+    status: task.status || 'todo',
+    priority: task.priority || 'medium',
+    createdAt: task.createdAt || new Date().toISOString(),
+    updatedAt: task.updatedAt || task.createdAt || new Date().toISOString(),
+    dueAt: task.dueAt || null,
+    tags: Array.isArray(task.tags) ? task.tags : [],
+    source: task.source || 'manual',
+    sessionId: task.sessionId || null,
+    notes: normalizeTaskText(task.notes || ''),
+  };
+}
+
+function listTasks(options = {}) {
+  const { status, includeDone = true } = options;
+  const store = loadTaskStore();
+  return store.tasks
+    .map(enrichTask)
+    .filter(task => (includeDone ? true : task.status !== 'done'))
+    .filter(task => (status ? task.status === status : true))
+    .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+function createTask(input = {}) {
+  const store = loadTaskStore();
+  const title = normalizeTaskText(input.title || input.text || input.description);
+  if (!title) {
+    throw new Error('task title requerido');
+  }
+
+  const now = new Date().toISOString();
+  const task = enrichTask({
+    id: makeTaskId(),
+    title,
+    description: input.description || '',
+    status: input.status || 'todo',
+    priority: input.priority || 'medium',
+    createdAt: now,
+    updatedAt: now,
+    dueAt: input.dueAt || null,
+    tags: input.tags || [],
+    source: input.source || 'manual',
+    sessionId: input.sessionId || null,
+    notes: input.notes || '',
+  });
+
+  store.tasks.push(task);
+  saveTaskStore(store);
+  return task;
+}
+
+function findTaskIndex(store, idOrTitle) {
+  const needle = normalizeTaskText(idOrTitle).toLowerCase();
+  if (!needle) return -1;
+  return store.tasks.findIndex(task => {
+    const idMatch = String(task.id || '').toLowerCase() === needle;
+    const titleMatch = String(task.title || '').toLowerCase() === needle;
+    return idMatch || titleMatch;
+  });
+}
+
+function updateTask(idOrTitle, updates = {}) {
+  const store = loadTaskStore();
+  const idx = findTaskIndex(store, idOrTitle);
+  if (idx === -1) {
+    throw new Error(`No existe la tarea: ${idOrTitle}`);
+  }
+
+  const current = store.tasks[idx];
+  const next = enrichTask({
+    ...current,
+    ...updates,
+    title: updates.title ?? current.title,
+    description: updates.description ?? current.description,
+    priority: updates.priority ?? current.priority,
+    status: updates.status ?? current.status,
+    dueAt: updates.dueAt === undefined ? current.dueAt : updates.dueAt,
+    tags: updates.tags ?? current.tags,
+    notes: updates.notes ?? current.notes,
+    updatedAt: new Date().toISOString(),
+  });
+
+  store.tasks[idx] = next;
+  saveTaskStore(store);
+  return next;
+}
+
+function completeTask(idOrTitle, notes = '') {
+  return updateTask(idOrTitle, {
+    status: 'done',
+    notes,
+  });
+}
+
+function deleteTask(idOrTitle) {
+  const store = loadTaskStore();
+  const idx = findTaskIndex(store, idOrTitle);
+  if (idx === -1) {
+    throw new Error(`No existe la tarea: ${idOrTitle}`);
+  }
+  const [removed] = store.tasks.splice(idx, 1);
+  saveTaskStore(store);
+  return enrichTask(removed);
+}
+
+function clearTasks() {
+  saveTaskStore({ tasks: [] });
+}
+
+function formatTask(task) {
+  const state = task.status === 'done' ? '✓' : task.status === 'doing' ? '▶' : '·';
+  const due = task.dueAt ? ` · due ${task.dueAt}` : '';
+  const priority = task.priority ? ` · ${task.priority}` : '';
+  const desc = task.description ? `\n    ${task.description}` : '';
+  const notes = task.notes ? `\n    notas: ${task.notes}` : '';
+  return `${state} ${task.id} :: ${task.title}${priority}${due}${desc}${notes}`;
+}
+
+function summarizeTasks(tasks = listTasks()) {
+  const lines = [`Tasks: ${tasks.length}`];
+  for (const task of tasks.slice(0, 20)) {
+    lines.push(formatTask(task));
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  clearTasks,
+  completeTask,
+  createTask,
+  deleteTask,
+  formatTask,
+  listTasks,
+  loadTaskStore,
+  saveTaskStore,
+  summarizeTasks,
+  updateTask,
+  USER_DATA_ROOT,
+};

package/src/web/webAgent.js

@@ -599,7 +599,7 @@ async function executeTool(tool, args, ctx) {
   }
 }
 
-async function runConcuerdo(primaryContent, primaryKey, modelMessages, onEvent, isAborted) {
+async function runConcuerdo(primaryContent, primaryKey, modelMessages, onEvent, isAborted, language = 'en') {
   const otherKeys = Object.keys(MODELS).filter(k => k !== primaryKey);
   if (!otherKeys.length) return null;
 
@@ -1029,7 +1029,7 @@ async function runWebAgent({ chatData, user, onEvent, isAborted }) {
     // ── Final response ──
     if (parsed.type === 'final') {
       if (group) {
-        const synthResult = await runConcuerdo(parsed.content, modelKey, modelMessages, onEvent, isAborted);
+        const synthResult = await runConcuerdo(parsed.content, modelKey, modelMessages, onEvent, isAborted, language);
         if (synthResult) {
           chatData.messages.push({ role: 'assistant', content: synthResult, ts: Date.now() });
           store.saveChat(chatData);

package/.github/workflows/publish.yml

@@ -1,23 +0,0 @@
-name: Publish to npm
-
-on:
-  release:
-    types: [published]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '18'
-          registry-url: 'https://registry.npmjs.org/'
-
-      - run: npm install
-
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/data/models.example.json

@@ -1,15 +0,0 @@
-{
-  "models": {
-    "local-llama": {
-      "label": "Local Llama",
-      "provider": "ollama",
-      "ollamaModel": "llama3.1:8b"
-    },
-    "my-openai-model": {
-      "label": "Mi modelo OpenAI-compatible",
-      "provider": "openai-compatible",
-      "openaiModel": "gpt-4o-mini",
-      "baseUrl": "https://api.example.com/v1"
-    }
-  }
-}

package/data/skills/code-style.md

@@ -1,79 +0,0 @@
-# Estilo de respuestas
-
-## Respuestas finales al usuario
-
-- Usa markdown: **bold**, `code inline`, bloques de codigo con ```, headers ##, listas -.
-- Se conciso pero completo. No repitas informacion que el usuario ya sabe.
-- Si creaste/editaste archivos, menciona que cambiaste y en que archivo.
-- Si ejecutaste comandos, resume el resultado relevante (no copies todo el stdout).
-- Para preguntas simples, responde en 1-3 lineas.
-- Para tareas completadas, da un resumen estructurado de lo que hiciste.
-- Si algo salio mal, explica que paso y que alternativas hay.
-- Usa listas cuando hay multiples items. Usa code blocks para codigo.
-- NUNCA inventes output de comandos o contenido de archivos. Solo reporta lo real.
-
-## Formato de codigo en respuestas
-
-Cuando muestres codigo en content, usa triple backtick con el lenguaje:
-```js
-const x = 42;
-```
-Para paths o comandos inline usa backtick simple: `src/index.js`, `npm install`.
-
-# Generacion de codigo
-
-## Principios generales (cualquier lenguaje)
-
-- Codigo limpio y autoexplicativo. Nombres descriptivos reemplazan comentarios.
-- Solo comenta lo que NO es obvio por el codigo (decisiones de diseno, workarounds, gotchas).
-- Funciones pequenas con una sola responsabilidad.
-- Early return / guard clauses para evitar nesting profundo.
-- Manejo de errores robusto: try/catch en operaciones async, validacion de inputs.
-- No hardcodear valores magicos. Usa constantes con nombre descriptivo.
-- DRY (Don't Repeat Yourself) pero sin abstracciones prematuras.
-- Codigo production-ready: maneja edge cases, inputs invalidos, errores de red.
-
-## JavaScript / Node.js
-
-- const por defecto, let solo si reasigna, NUNCA var.
-- async/await siempre. No callbacks, no .then() chains.
-- Arrow functions para callbacks: arr.map(x => x.id).
-- Template literals para interpolacion: `Hola ${nombre}`.
-- Optional chaining: obj?.prop?.sub.
-- Nullish coalescing: valor ?? 'default'.
-- Destructuring cuando simplifica: const { name, age } = user.
-- Indentacion: 2 espacios.
-- Semicolons: siempre.
-- Strings: comillas simples en JS, dobles en atributos HTML.
-
-## Python
-
-- Type hints en funciones: def process(data: list[str]) -> dict:
-- f-strings para interpolacion: f"Hola {nombre}".
-- List/dict comprehensions cuando son legibles.
-- Context managers (with) para archivos y recursos.
-- pathlib sobre os.path para manejo de paths.
-- Indentacion: 4 espacios.
-- Docstrings solo en funciones publicas complejas.
-
-## Bash / Shell
-
-- set -euo pipefail al inicio de scripts.
-- Comillas dobles en variables: "$variable".
-- Usa [[ ]] en lugar de [ ] para condicionales.
-- Funciones para logica reutilizable.
-- Exit codes significativos.
-
-## HTML / CSS
-
-- HTML semantico: header, main, nav, section, article, footer.
-- Clases descriptivas y consistentes.
-- Mobile-first: disenar para movil, escalar a desktop.
-- Accesibilidad basica: alt en imgs, labels en forms, aria cuando aplique.
-
-## Cuando modificas codigo existente
-
-- Respeta el estilo del archivo existente (indentacion, naming, patron).
-- No refactorices lo que no te pidieron. Cambios minimos y quirurgicos.
-- No agregues imports, types, o abstracciones que no son necesarias para el cambio.
-- Si el archivo tiene un patron (ej: todos los handlers siguen X estructura), siguelo.

package/data/skills/completion.md

@@ -1,20 +0,0 @@
-# Completion discipline
-
-## Operating rule
-- When the user asks for an action, complete the action instead of narrating it.
-- Do not ask the user to choose between options when one clear path exists.
-- If a tool can do the work, use the tool.
-- If a response would be only a plan, replace it with execution or a concrete result.
-- If the model stalls, switch to investigation, then act, then verify.
-
-## Quality bar
-- No fake progress.
-- No pretending to have executed commands.
-- No claiming success without evidence.
-- No giving a tutorial when a direct change is possible.
-
-## Recovery behavior
-- Read the relevant files or state first.
-- Apply the fix.
-- Verify the result.
-- Report the result plainly.

package/data/skills/core.md

@@ -1,35 +0,0 @@
-# Identidad y Rol
-Eres Zyn, un Agente de Terminal Senior y Arquitecto de Software desarrolado por Maycol y Ado.
-
-Dominio: Programacion polyglot, Arquitectura de Sistemas, DevOps, Bases de Datos, APIs, Web Scraping, Automatizacion, Debugging, Servidores, Ciberseguridad.
-
-Nivel: Resolutivo, codigo production-ready. Anticipas edge cases y manejas errores.
-
-Adaptate al idioma que te habla el usuario.
-Tono: Tecnico, directo, conciso.
-
-# Directrices
-- Eficiente: minimas operaciones necesarias. Lee contexto antes de actuar.
-- Honesto: si algo falla, indicalo sin rodeos.
-- Preciso: cambios que funcionan a la primera.
-- Seguro: alerta vulnerabilidades y riesgos.
-
-# Formato de respuesta — CRITICO
-
-Cada respuesta DEBE ser EXACTAMENTE un JSON valido. Sin texto antes ni despues.
-Sin markdown wrapping. Sin bloques de codigo. Solo el JSON puro.
-
-Para invocar una herramienta:
-{"type":"tool","tool":"nombre_herramienta","args":{...}}
-
-Para responder al usuario (soporta markdown dentro de content):
-{"type":"final","content":"tu respuesta aqui"}
-
-Reglas estrictas:
-- UNA sola accion por respuesta (una herramienta O una respuesta final).
-- Si necesitas una herramienta, responde SOLO con el JSON de herramienta.
-- El campo "content" en respuesta final SI acepta markdown.
-- Escapa comillas dobles con \" y saltos de linea con \n dentro del JSON.
-- JAMAS pongas texto plano fuera del JSON.
-- JAMAS anides JSON de herramienta dentro de content.
-- Si la pregunta es conversacional, responde directo con type=final.