zyn-ai 1.2.0 → 1.2.1

package/package.json

@@ -1,18 +1,31 @@
 {
   "name": "zyn-ai",
-  "version": "1.2.0",
-  "description": "Professional local terminal and web agent",
+  "version": "1.2.1",
+  "description": "Production-ready AI agent for CLI and web with real tool execution and automation",
   "author": "Maycol y Ado",
+  "keywords": [
+    "ai-agent",
+    "cli-ai",
+    "terminal-ai",
+    "automation-agent",
+    "developer-tools",
+    "ai-cli",
+    "nodejs-cli",
+    "productivity-tool",
+    "local-ai-agent",
+    "command-line-ai",
+    "web-ai-agent",
+    "zyn"
+  ],
   "bin": {
-    "Zyn": "./zyn.js",
     "zyn": "./zyn.js"
   },
   "type": "commonjs",
   "scripts": {
-    "start": "node ./zyn.js",
-    "web": "node ./src/web/server.js",
-    "test": "node ./zyn.js test",
-    "check": "node --check ./zyn.js && node --check ./src/cli/runtime.js"
+    "start": "node zyn.js",
+    "dev": "node zyn.js",
+    "web": "node src/web/server.js",
+    "check": "node --check zyn.js && node --check src/cli/runtime.js"
   },
   "dependencies": {
     "axios": "^1.7.9",
@@ -25,9 +38,26 @@
     "react": "^19.0.0",
     "session-file-store": "^1.5.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SoyMaycol/Zyn"
+  },
+  "homepage": "https://github.com/SoyMaycol/Zyn#readme",
+  "bugs": {
+    "url": "https://github.com/SoyMaycol/Zyn/issues"
+  },
   "engines": {
     "node": ">=18"
   },
-  "license": "SEE LICENSE IN LICENSE",
+  "license": "MIT",
+  "files": [
+    "zyn.js",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./zyn.js"
+  },
   "preferGlobal": true
 }

package/src/providers/catalog.js

@@ -0,0 +1,302 @@
+const fs = require('fs');
+const path = require('path');
+const { MODELS_FILE, PROVIDERS_FILE, REQUEST_TIMEOUT_MS } = require('../config');
+
+const DEFAULT_HEADERS = {
+  'Content-Type': 'application/json',
+  'Accept': 'application/json',
+  'User-Agent': 'Zyn/1.0',
+};
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function normalizeBaseUrl(input) {
+  return String(input || '').trim().replace(/\/$/, '');
+}
+
+function slugify(text) {
+  return String(text || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'model';
+}
+
+function titleize(text) {
+  return String(text || '')
+    .replace(/[-_]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/\b\w/g, ch => ch.toUpperCase());
+}
+
+async function fetchJson(url, options = {}) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs || REQUEST_TIMEOUT_MS);
+  const signal = options.signal;
+  const onExternalAbort = () => controller.abort();
+  if (signal) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener('abort', onExternalAbort, { once: true });
+  }
+
+  try {
+    const res = await fetch(url, {
+      method: options.method || 'GET',
+      headers: {
+        ...DEFAULT_HEADERS,
+        ...(options.headers || {}),
+      },
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: controller.signal,
+    });
+
+    const text = await res.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      data = { raw: text };
+    }
+
+    if (!res.ok) {
+      const detail = typeof data === 'string'
+        ? data
+        : data?.message || data?.error || text;
+      const err = new Error(`HTTP ${res.status}: ${String(detail || '').slice(0, 300)}`);
+      err.status = res.status;
+      err.body = data;
+      throw err;
+    }
+
+    return data;
+  } finally {
+    clearTimeout(timeout);
+    if (signal) signal.removeEventListener('abort', onExternalAbort);
+  }
+}
+
+function loadProviderRegistry() {
+  const raw = readJsonFile(PROVIDERS_FILE);
+  if (!raw || typeof raw !== 'object') {
+    return { providers: {} };
+  }
+  if (raw.providers && typeof raw.providers === 'object') {
+    return { providers: raw.providers };
+  }
+  return { providers: raw };
+}
+
+function saveProviderRegistry(registry) {
+  writeJsonFile(PROVIDERS_FILE, registry);
+}
+
+function loadExternalModels() {
+  const raw = readJsonFile(MODELS_FILE);
+  if (!raw) return {};
+  if (Array.isArray(raw)) {
+    const output = {};
+    for (const item of raw) {
+      if (!item?.key) continue;
+      output[item.key] = item;
+    }
+    return output;
+  }
+  if (raw.models && typeof raw.models === 'object') return raw.models;
+  return raw && typeof raw === 'object' ? raw : {};
+}
+
+function saveExternalModels(models) {
+  writeJsonFile(MODELS_FILE, models);
+}
+
+function upsertProviderConfig(providerKey, config) {
+  const registry = loadProviderRegistry();
+  registry.providers[providerKey] = {
+    ...registry.providers[providerKey],
+    ...config,
+    provider: providerKey,
+    updatedAt: new Date().toISOString(),
+  };
+  saveProviderRegistry(registry);
+  return registry.providers[providerKey];
+}
+
+function removeProviderConfig(providerKey) {
+  const registry = loadProviderRegistry();
+  delete registry.providers[providerKey];
+  saveProviderRegistry(registry);
+}
+
+function listConfiguredProviders() {
+  const registry = loadProviderRegistry();
+  return Object.entries(registry.providers).map(([key, value]) => ({ key, ...value }));
+}
+
+function sanitizeModelKey(providerKey, modelId) {
+  return `${slugify(providerKey)}-${slugify(modelId)}`;
+}
+
+function buildModelRecord(providerKey, config, modelId, label, extra = {}) {
+  const key = sanitizeModelKey(providerKey, modelId);
+  const record = {
+    key,
+    label: label || titleize(modelId),
+    provider: providerKey,
+    modelId,
+    ...extra,
+  };
+
+  if (config?.baseUrl) record.baseUrl = config.baseUrl;
+  if (config?.apiKey) record.apiKey = config.apiKey;
+  if (config?.modelEndpoint) record.modelEndpoint = config.modelEndpoint;
+  if (config?.chatEndpoint) record.chatEndpoint = config.chatEndpoint;
+  return record;
+}
+
+async function fetchOllamaModels(config) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl || 'http://127.0.0.1:11434');
+  const data = await fetchJson(`${baseUrl}/api/tags`, {
+    headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+  });
+  const models = Array.isArray(data?.models) ? data.models : [];
+  return models.map(model => buildModelRecord(
+    'ollama',
+    { ...config, baseUrl },
+    model.name || model.model || model.id,
+    model.name || model.model || model.id,
+    {
+      ollamaModel: model.name || model.model || model.id,
+      raw: model,
+    },
+  )).filter(item => item.modelId);
+}
+
+async function fetchOpenAICompatibleModels(config) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl);
+  if (!baseUrl) throw new Error('Falta baseUrl para openai-compatible');
+  const data = await fetchJson(`${baseUrl}/v1/models`, {
+    headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+  });
+  const models = Array.isArray(data?.data) ? data.data : Array.isArray(data?.models) ? data.models : [];
+  return models.map(model => buildModelRecord(
+    'openai-compatible',
+    { ...config, baseUrl },
+    model.id || model.name,
+    model.id || model.name,
+    {
+      openaiModel: model.id || model.name,
+      raw: model,
+    },
+  )).filter(item => item.modelId);
+}
+
+async function fetchZenModels(config) {
+  const baseUrl = normalizeBaseUrl(config.baseUrl || 'https://opencode.ai/zen');
+  const data = await fetchJson(`${baseUrl}/v1/models`, {
+    headers: config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {},
+  });
+  const models = Array.isArray(data?.data) ? data.data : Array.isArray(data?.models) ? data.models : [];
+  return models.map(model => buildModelRecord(
+    'zen',
+    { ...config, baseUrl },
+    model.id || model.name,
+    model.name || titleize(model.id || model.name),
+    {
+      zenModel: model.id || model.name,
+      raw: model,
+    },
+  )).filter(item => item.modelId);
+}
+
+async function fetchQwenModels(config) {
+  const models = [
+    { id: 'qwen3.6-plus', label: 'Qwen 3.6 Plus' },
+    { id: 'qwen3.5-plus', label: 'Qwen 3.5 Plus' },
+    { id: 'qwen-coder-plus', label: 'Qwen Coder Plus' },
+  ];
+  return models.map(model => buildModelRecord(
+    'qwen',
+    config,
+    model.id,
+    model.label,
+    {
+      qwenModel: model.id,
+      static: true,
+    },
+  ));
+}
+
+async function fetchProviderModels(providerKey, config = {}) {
+  const key = String(providerKey || '').trim();
+  if (key === 'ollama') return fetchOllamaModels(config);
+  if (key === 'openai-compatible') return fetchOpenAICompatibleModels(config);
+  if (key === 'zen') return fetchZenModels(config);
+  if (key === 'qwen') return fetchQwenModels(config);
+  throw new Error(`Proveedor no soportado: ${key}`);
+}
+
+function mergeProviderModels(providerKey, models) {
+  const current = loadExternalModels();
+  const next = {};
+
+  for (const [key, model] of Object.entries(current)) {
+    if (model.provider !== providerKey) {
+      next[key] = model;
+    }
+  }
+
+  for (const model of models) {
+    next[model.key] = model;
+  }
+
+  saveExternalModels(next);
+  return next;
+}
+
+async function syncProvider(providerKey) {
+  const registry = loadProviderRegistry();
+  const config = registry.providers[providerKey];
+  if (!config) {
+    throw new Error(`Proveedor no configurado: ${providerKey}`);
+  }
+  const models = await fetchProviderModels(providerKey, config);
+  registry.providers[providerKey] = {
+    ...config,
+    provider: providerKey,
+    updatedAt: new Date().toISOString(),
+    modelCount: models.length,
+  };
+  saveProviderRegistry(registry);
+  mergeProviderModels(providerKey, models);
+  return models;
+}
+
+function describeProviderConfig(providerKey) {
+  const registry = loadProviderRegistry();
+  return registry.providers[providerKey] || null;
+}
+
+module.exports = {
+  describeProviderConfig,
+  fetchProviderModels,
+  listConfiguredProviders,
+  loadProviderRegistry,
+  mergeProviderModels,
+  normalizeBaseUrl,
+  removeProviderConfig,
+  saveProviderRegistry,
+  syncProvider,
+  upsertProviderConfig,
+};

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.