@danieltmn/tamnora 0.9.4 → 0.9.6

package/harness/packages/server/src/lib/advisor.js

@@ -0,0 +1,177 @@
+// Asesor tipo Jarvis: una capa de comentario sobre el run activo. Mira lo que
+// el agente hizo (pedido, respuesta, herramientas y diffs), lo interpreta con
+// una llamada corta al modelo y decide si vale la pena decir algo. NO lee la
+// respuesta del agente: solo agrega alertas de codigo, explicaciones o consejos.
+//
+// La salida es JSON estricto para poder decidir el silencio: si el modelo no
+// tiene nada que aportar, no habla ni deja tarjeta.
+
+import { summarizeToolCall, extractJson } from './core.js';
+
+export const DEFAULT_ADVISOR = {
+  enabled: false,
+  code: true,
+  explain: true,
+  advice: true,
+  notes: '',
+  maxWords: 40,
+};
+
+const KINDS = new Set(['code', 'explain', 'advice']);
+const MAX_PROMPT_CHARS = 8000;
+const MAX_DIFF_CHARS = 2500;
+
+/** Config efectiva: lo guardado en app.json (la casa) sobre los defaults. */
+export function resolveAdvisor(app) {
+  const saved = app?.advisor && typeof app.advisor === 'object' ? app.advisor : {};
+  const maxWords = Number(saved.maxWords);
+  return {
+    enabled: saved.enabled === true,
+    code: saved.code !== false,
+    explain: saved.explain !== false,
+    advice: saved.advice !== false,
+    notes: typeof saved.notes === 'string' ? saved.notes.slice(0, 2000) : '',
+    maxWords: Number.isFinite(maxWords)
+      ? Math.min(Math.max(Math.round(maxWords), 10), 120)
+      : DEFAULT_ADVISOR.maxWords,
+  };
+}
+
+/** Gate barato: sin herramientas ni una respuesta larga no hay nada que mirar. */
+export function advisorShouldRun({ toolCalls = 0, answer = '' } = {}) {
+  return Number(toolCalls) > 0 || String(answer ?? '').length > 200;
+}
+
+function parseArgs(call) {
+  try {
+    return JSON.parse(call?.function?.arguments ?? call?.arguments ?? '{}') ?? {};
+  } catch {
+    return {};
+  }
+}
+
+/** Tool-calls de los mensajes del turno como `nombre: resumen` (deduplicado, acotado). */
+export function collectToolSummary(messages = [], limit = 40) {
+  const out = [];
+  const seen = new Set();
+  for (const message of messages) {
+    if (message.role !== 'assistant') continue;
+    for (const call of message.tool_calls ?? []) {
+      const name = call.function?.name ?? call.name ?? '';
+      if (!name) continue;
+      const line = `${name}: ${summarizeToolCall(name, parseArgs(call))}`;
+      if (seen.has(line)) continue;
+      seen.add(line);
+      out.push(line);
+      if (out.length >= limit) return out;
+    }
+  }
+  return out;
+}
+
+/** Archivos tocados por write/edit con su diff, tal como lo devolvio la tool. */
+export function collectChangedFiles(messages = []) {
+  const calls = new Map();
+  for (const message of messages) {
+    if (message.role !== 'assistant') continue;
+    for (const call of message.tool_calls ?? []) {
+      const name = call.function?.name ?? call.name;
+      if (name !== 'write' && name !== 'edit') continue;
+      const id = call.id ?? call.tool_call_id;
+      if (id) calls.set(id, { name, path: parseArgs(call).path ?? '' });
+    }
+  }
+  const files = [];
+  for (const message of messages) {
+    if (message.role !== 'tool') continue;
+    const call = calls.get(message.tool_call_id);
+    if (!call) continue;
+    const content = typeof message.content === 'string' ? message.content : '';
+    files.push({ path: call.path || 'archivo', diff: content.slice(0, MAX_DIFF_CHARS) });
+  }
+  return files;
+}
+
+function focusLines(options) {
+  const lines = [];
+  if (options.code) lines.push('- alertar de un problema real en el codigo (bug, riesgo, secreto expuesto, inconsistencia)');
+  if (options.explain) lines.push('- explicar un proceso o decision que quedo poco clara');
+  if (options.advice) lines.push('- dar un consejo concreto y accionable');
+  if (!lines.length) lines.push('- aportar algo util que el agente no haya dicho');
+  return lines.join('\n');
+}
+
+/** System + user para la consulta al asesor (expuestos para test). */
+export function buildAdvisorPrompt({ userInput = '', answer = '', toolSummary = [], changedFiles = [], options = {} } = {}) {
+  const maxWords = options.maxWords ?? DEFAULT_ADVISOR.maxWords;
+  const system =
+    'Sos el asesor personal del usuario dentro de Tamnora, al estilo de Jarvis.\n' +
+    'Recibis lo que el agente hizo en el ultimo turno: el pedido del usuario, su respuesta\n' +
+    'final, las herramientas que uso y los diffs de los archivos que toco.\n\n' +
+    'Tu trabajo NO es resumir ni repetir la respuesta del agente: el usuario ya la esta\n' +
+    'viendo. Solo aportas algo que el agente no dijo. Enfocate en:\n' +
+    `${focusLines(options)}\n\n` +
+    'Hablale al usuario en segunda persona, breve (' +
+    `${maxWords} palabras como maximo), en espanol, sin markdown ni listas. Si no hay nada\n` +
+    'que valga la pena decir, no hables.\n' +
+    (options.notes ? `\nInstrucciones del usuario: ${options.notes}\n` : '') +
+    '\nResponde SOLO con JSON: {"speak": true|false, "kind": "code|explain|advice", "text": "..."}';
+
+  const parts = [`PEDIDO DEL USUARIO:\n${userInput || '(sin texto)'}`];
+  parts.push(`RESPUESTA FINAL DEL AGENTE:\n${answer || '(sin respuesta)'}`);
+  if (toolSummary.length) parts.push(`HERRAMIENTAS USADAS:\n${toolSummary.map((t) => `- ${t}`).join('\n')}`);
+  if (changedFiles.length) {
+    const files = changedFiles.map((f) => `### ${f.path}\n${f.diff}`).join('\n\n');
+    parts.push(`ARCHIVOS MODIFICADOS (diffs):\n${files}`);
+  }
+
+  return { system, user: parts.join('\n\n').slice(0, MAX_PROMPT_CHARS) };
+}
+
+function truncateWords(text, maxWords) {
+  const words = String(text ?? '').replace(/\s+/g, ' ').trim().split(' ').filter(Boolean);
+  if (words.length <= maxWords) return words.join(' ');
+  return `${words.slice(0, maxWords).join(' ')}…`;
+}
+
+/**
+ * Consulta unica al modelo (mismo patron que el juez de eval). Devuelve
+ * `{ speak, kind, text }` o `null` si no se pudo interpretar. Nunca tira: un
+ * asesor roto no debe romper el run.
+ */
+export async function consultAdvisor({
+  provider,
+  config,
+  model,
+  signal,
+  userInput,
+  answer,
+  messages = [],
+  options = {},
+} = {}) {
+  const todo = collectToolSummary(messages);
+  const changedFiles = collectChangedFiles(messages);
+  const { system, user } = buildAdvisorPrompt({ userInput, answer, toolSummary: todo, changedFiles, options });
+  const maxWords = options.maxWords ?? DEFAULT_ADVISOR.maxWords;
+
+  try {
+    const result = await provider.streamChat(config, {
+      model,
+      messages: [
+        { role: 'system', content: system },
+        { role: 'user', content: user },
+      ],
+      tools: [],
+      signal,
+      onEvent: () => {},
+    });
+    const { value, error } = extractJson(result?.content ?? '');
+    if (error || !value || typeof value !== 'object') return null;
+    const kind = KINDS.has(value.kind) ? value.kind : 'advice';
+    const text = truncateWords(value.text, maxWords);
+    if (value.speak !== true || !text) return { speak: false, kind, text: '' };
+    return { speak: true, kind, text };
+  } catch {
+    return null;
+  }
+}

package/harness/packages/server/src/lib/agentRun.js

@@ -71,7 +71,8 @@ export async function composeAgentMessages({ ctx, cwd, mode, history = [], userM
     { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
     ...(goal ? [{ role: 'system', content: `Objetivo de la sesión: ${goal}` }] : []),
     ...(summary ? [{ role: 'system', content: `Resumen de la conversación anterior:\n${summary}` }] : []),
-    ...history,
+    // El asesor no contamina el contexto del modelo: es una capa de comentario.
+    ...history.filter((message) => message.name !== 'advisor'),
     userMessage,
   ];
 }

package/harness/packages/server/src/lib/ttsSettings.js

@@ -8,14 +8,14 @@ export const DEFAULT_TTS = {
   enabled: false,
   voice: VOZ_POR_DEFECTO,
   rate: '+0%',
-  announce: { start: true, tools: true, end: true },
+  announce: { start: true, tools: true, end: true, advice: true, answer: false },
 };
 
 /** Merge de defaults + lo guardado (con `announce` aplanado a booleans). */
 export function resolveTts(app) {
   const saved = app?.tts && typeof app.tts === 'object' ? app.tts : {};
   const announce = { ...DEFAULT_TTS.announce, ...(saved.announce ?? {}) };
-  for (const key of ['start', 'tools', 'end']) announce[key] = announce[key] === true;
+  for (const key of ['start', 'tools', 'end', 'advice', 'answer']) announce[key] = announce[key] === true;
   return {
     ...DEFAULT_TTS,
     ...saved,

package/harness/packages/server/src/lib/update.js

@@ -0,0 +1,82 @@
+// Chequeo de version nueva contra el registro npm. Cacheado a proposito: el
+// banner de la consola pregunta seguido y no queremos pegarle a npm en cada
+// request. Un fallo de red no rompe: se devuelve `updateAvailable:false`.
+
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import {
+  ROOT_PACKAGE_NAME,
+  readPackageVersion,
+  compareVersions,
+  fetchLatestVersion,
+  packageRoot,
+  homeDir,
+} from './core.js';
+
+const CACHE_MS = 10 * 60 * 1000;
+
+let cache = { at: 0, latest: '' };
+
+/** Limpia la cache (tests). */
+export function clearUpdateCache() {
+  cache = { at: 0, latest: '' };
+}
+
+/**
+ * @returns {{current:string, latest:string, updateAvailable:boolean, checkedAt:string|null, error?:string}}
+ */
+export async function checkUpdate({ force = false, current = readPackageVersion(), fetchImpl } = {}) {
+  const now = Date.now();
+  const fresh = cache.latest && now - cache.at < CACHE_MS;
+  if (!force && fresh) {
+    return {
+      current,
+      latest: cache.latest,
+      updateAvailable: compareVersions(cache.latest, current) > 0,
+      checkedAt: new Date(cache.at).toISOString(),
+    };
+  }
+
+  try {
+    const latest = await fetchLatestVersion({ pkg: ROOT_PACKAGE_NAME, ...(fetchImpl ? { fetchImpl } : {}) });
+    cache = { at: now, latest };
+    return {
+      current,
+      latest,
+      updateAvailable: compareVersions(latest, current) > 0,
+      checkedAt: new Date(now).toISOString(),
+    };
+  } catch (error) {
+    return {
+      current,
+      latest: '',
+      updateAvailable: false,
+      checkedAt: null,
+      error: String(error?.message ?? error),
+    };
+  }
+}
+
+/**
+ * Lanza el script detached que espera la muerte de este server, instala la
+ * version nueva y lo vuelve a levantar. Devolver rapido es el punto: el server
+ * tiene que soltar los archivos (Windows) antes de que npm los reemplace.
+ */
+export function spawnSelfUpdate({ pid = process.pid, port, host, cwd, target, home } = {}) {
+  const root = packageRoot();
+  if (!root) return { ok: false, error: 'no encontre el paquete del harness' };
+  const script = path.join(root, 'harness', 'scripts', 'self-update.mjs');
+  const args = [script, '--pid', String(pid)];
+  if (port) args.push('--port', String(port));
+  if (host) args.push('--host', String(host));
+  if (cwd) args.push('--cwd', String(cwd));
+  if (target) args.push('--target', String(target));
+  args.push('--home', home || homeDir());
+  try {
+    const child = spawn(process.execPath, args, { detached: true, stdio: 'ignore', windowsHide: true });
+    child.unref();
+    return { ok: true, pid: child.pid };
+  } catch (error) {
+    return { ok: false, error: String(error?.message ?? error) };
+  }
+}

package/harness/packages/server/src/routes/advisor.js

@@ -0,0 +1,76 @@
+// Ajustes del asesor (app.json -> advisor) y una prueba manual que corre una
+// consulta real para ver que devuelve el modelo.
+
+import { resolveAdvisor, consultAdvisor } from '../lib/advisor.js';
+import { readApp, writeApp } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+export function registerAdvisor(route, ctx) {
+  route('GET', '/api/advisor/settings', ({ res }) => {
+    sendJson(res, 200, resolveAdvisor(ctx.app));
+  });
+
+  route('PUT', '/api/advisor/settings', async ({ req, res }) => {
+    const body = await readJson(req);
+    const app = readApp();
+    const current = resolveAdvisor(ctx.app);
+    const next = { ...current };
+    if ('enabled' in body) next.enabled = body.enabled === true;
+    if ('code' in body) next.code = body.code !== false;
+    if ('explain' in body) next.explain = body.explain !== false;
+    if ('advice' in body) next.advice = body.advice !== false;
+    if ('notes' in body) next.notes = String(body.notes ?? '').slice(0, 2000);
+    if ('maxWords' in body) {
+      const value = Number(body.maxWords);
+      next.maxWords = Number.isFinite(value)
+        ? Math.min(Math.max(Math.round(value), 10), 120)
+        : current.maxWords;
+    }
+    app.advisor = next;
+    writeApp(app);
+    ctx.app = app;
+    sendJson(res, 200, resolveAdvisor(app));
+  });
+
+  route('POST', '/api/advisor/test', async ({ res }) => {
+    const options = resolveAdvisor(ctx.app);
+    const providerId = ctx.effectiveProviderId();
+    const model = ctx.effectiveModel();
+    if (!model) return sendError(res, 400, 'Elegí un proveedor y un modelo primero.');
+    const { provider, config } = ctx.resolveProvider({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    });
+    // Turno de ejemplo con una edicion: alcanza para ver si el asesor aporta algo.
+    const messages = [
+      {
+        role: 'assistant',
+        content: '',
+        tool_calls: [
+          {
+            id: 'test-1',
+            type: 'function',
+            function: { name: 'edit', arguments: JSON.stringify({ path: 'src/auth.js' }) },
+          },
+        ],
+      },
+      {
+        role: 'tool',
+        tool_call_id: 'test-1',
+        name: 'edit',
+        content: 'Editado src/auth.js\n- const token = "secreto123"\n+ const token = process.env.TOKEN',
+      },
+    ];
+    const advice = await consultAdvisor({
+      provider,
+      config,
+      model,
+      userInput: 'Revisá el manejo del token de sesión.',
+      answer: 'Listo, ajusté el archivo.',
+      messages,
+      options,
+    });
+    if (!advice) return sendError(res, 502, 'El asesor no devolvió una respuesta interpretable.');
+    sendJson(res, 200, advice);
+  });
+}

package/harness/packages/server/src/routes/chat.js

@@ -17,6 +17,7 @@ import {
   toolResultPayload,
 } from '../lib/agentRun.js';
 import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/announcer.js';
+import { resolveAdvisor, advisorShouldRun, consultAdvisor } from '../lib/advisor.js';
 
 /**
  * Emit streaming partials at most once per `ms` window, keeping only the
@@ -318,6 +319,35 @@ export function registerChat(route, ctx) {
             durationMs,
             say: fraseFin({ stopReason: result.stopReason, rounds: result.rounds, toolCalls, durationMs }),
           });
+
+        // El asesor va despues del `done` pero antes del `finally`, asi el run
+        // sigue vivo y el evento llega/persiste. Puede quedarse callado.
+        const advisorOptions = resolveAdvisor(ctx.app);
+        if (
+          result.stopReason !== 'aborted' &&
+          advisorOptions.enabled &&
+          advisorShouldRun({ toolCalls, answer: result.content })
+        ) {
+          const advice = await consultAdvisor({
+            provider,
+            config,
+            model,
+            signal: ctx.runs.signal(sessionId),
+            userInput: input,
+            answer: result.content,
+            messages: newMessages,
+            options: advisorOptions,
+          });
+          if (advice?.speak) {
+            ctx.store.addMessage(sessionId, {
+              role: 'assistant',
+              name: 'advisor',
+              content: advice.text,
+              mode: advice.kind,
+            });
+            ctx.runs.emit(sessionId, 'advice', { text: advice.text, kind: advice.kind, say: advice.text });
+          }
+        }
       } catch (error) {
         partials.flush();
         if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', { say: fraseFin({ stopReason: 'aborted' }) });

package/harness/packages/server/src/routes/tts.js

@@ -39,7 +39,7 @@ export function registerTts(route, ctx) {
     if ('rate' in body) next.rate = sanearRate(body.rate, actual.rate);
     if (body.announce && typeof body.announce === 'object') {
       const announce = { ...actual.announce };
-      for (const key of ['start', 'tools', 'end']) {
+      for (const key of ['start', 'tools', 'end', 'advice', 'answer']) {
         if (key in body.announce) announce[key] = body.announce[key] === true;
       }
       next.announce = announce;

package/harness/packages/server/src/routes/update.js

@@ -0,0 +1,43 @@
+// Alerta de version nueva y actualizacion con un click desde la consola.
+//
+// `GET /api/update` es solo informacion (cacheada). `POST /api/update` es
+// privilegiado: **solo loopback y sin tunel** (`requireLocal`), igual que
+// shell/git/carpetas. El server responde y se apaga; un script detached espera
+// su muerte, instala la version nueva y lo vuelve a levantar.
+
+import { sendJson, sendError } from '../lib/http.js';
+import { requireLocal } from '../lib/workspace.js';
+import { checkUpdate, spawnSelfUpdate } from '../lib/update.js';
+
+export function registerUpdate(route, ctx) {
+  route('GET', '/api/update', async ({ res, query }) => {
+    const force = query.get('force') === '1';
+    sendJson(res, 200, await checkUpdate({ force }));
+  });
+
+  route('POST', '/api/update', async ({ req, res }) => {
+    if (!requireLocal(req, res, 'Actualizar solo esta permitido en la conexion local.')) return;
+
+    const info = await checkUpdate({ force: true });
+    if (!info.latest) return sendError(res, 502, info.error || 'No pude consultar la ultima version.');
+    if (!info.updateAvailable) {
+      return sendJson(res, 200, { ok: true, upToDate: true, current: info.current, latest: info.latest });
+    }
+
+    const spawnUpdater = ctx.spawnUpdater ?? spawnSelfUpdate;
+    const started = spawnUpdater({
+      pid: process.pid,
+      port: ctx.serverInfo?.port,
+      host: ctx.serverInfo?.host,
+      cwd: ctx.cwd,
+      target: info.latest,
+    });
+    if (!started.ok) return sendError(res, 500, started.error);
+
+    sendJson(res, 202, { ok: true, updating: true, from: info.current, to: info.latest });
+    // Soltar los archivos antes de que npm los reemplace.
+    setTimeout(() => {
+      Promise.resolve(ctx.shutdown?.()).catch(() => process.exit(0));
+    }, 800);
+  });
+}

package/harness/packages/server/src/server.js

@@ -39,6 +39,8 @@ import { registerChannels } from './routes/channels.js';
 import { registerProfile } from './routes/profile.js';
 import { registerTts } from './routes/tts.js';
 import { registerTranscribe } from './routes/transcribe.js';
+import { registerUpdate } from './routes/update.js';
+import { registerAdvisor } from './routes/advisor.js';
 import { registerProcs } from './routes/procs.js';
 import { registerShell } from './routes/shell.js';
 import { registerPreview } from './routes/preview.js';
@@ -186,6 +188,13 @@ export async function createTamnoraServer({
     mergedMcpServers,
     procs,
     procsEnabled,
+    // Se completa en `listen()` con el puerto/host reales (util para reiniciar
+    // el server tras una actualizacion).
+    serverInfo: {
+      port: port ?? config.server?.port ?? 4517,
+      host: host ?? config.server?.host ?? '127.0.0.1',
+      url: '',
+    },
   };
 
   ctx.systemPromptFor = createPromptBuilder({
@@ -234,6 +243,8 @@ export async function createTamnoraServer({
   registerProfile(route, ctx);
   registerTts(route, ctx);
   registerTranscribe(route, ctx);
+  registerAdvisor(route, ctx);
+  registerUpdate(route, ctx);
   registerProcs(route, ctx);
   registerShell(route, ctx);
   const preview = registerPreview(route, ctx);
@@ -320,11 +331,13 @@ export async function createTamnoraServer({
         options.host ?? host ?? config.server?.host ?? '127.0.0.1',
         () => {
           const address = server.address();
-          resolve({
+          const info = {
             host: address.address,
             port: address.port,
             url: `http://${address.address === '::' ? '127.0.0.1' : address.address}:${address.port}`,
-          });
+          };
+          ctx.serverInfo = info;
+          resolve(info);
         }
       );
     });
@@ -354,5 +367,16 @@ export async function createTamnoraServer({
     }
   };
 
+  // Apagado ordenado pedido desde una ruta (actualizacion con un click): cierra
+  // el server y termina el proceso para que npm pueda reemplazar los archivos.
+  ctx.shutdown = async () => {
+    try {
+      await close();
+    } catch {
+      /* ya cerrado */
+    }
+    process.exit(0);
+  };
+
   return { server, config, store, ctx, listen, close, staticDir: staticDir ?? DEFAULT_PUBLIC_DIR };
 }

package/harness/packages/server/src/static.js

@@ -11,6 +11,7 @@ const MIME = {
   '.mjs': 'text/javascript; charset=utf-8',
   '.css': 'text/css; charset=utf-8',
   '.json': 'application/json; charset=utf-8',
+  '.webmanifest': 'application/manifest+json; charset=utf-8',
   '.svg': 'image/svg+xml',
   '.png': 'image/png',
   '.jpg': 'image/jpeg',