@danieltmn/tamnora 0.9.4 → 0.9.6

package/harness/packages/server/test/advisor.test.js

@@ -0,0 +1,205 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  resolveAdvisor,
+  advisorShouldRun,
+  collectChangedFiles,
+  collectToolSummary,
+  buildAdvisorPrompt,
+  consultAdvisor,
+} from '../src/lib/advisor.js';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+
+const editMessages = () => [
+  {
+    role: 'assistant',
+    content: '',
+    tool_calls: [
+      { id: 'c1', function: { name: 'edit', arguments: JSON.stringify({ path: 'src/a.js' }) } },
+    ],
+  },
+  { role: 'tool', tool_call_id: 'c1', name: 'edit', content: '- const token = "secreto"\n+ const token = process.env.TOKEN' },
+];
+
+test('resolveAdvisor mezcla defaults y sanitiza', () => {
+  assert.equal(resolveAdvisor({}).enabled, false);
+  const saved = resolveAdvisor({ advisor: { enabled: true, notes: 'x', maxWords: 999 } });
+  assert.equal(saved.enabled, true);
+  assert.equal(saved.code, true);
+  assert.equal(saved.maxWords, 120);
+  const off = resolveAdvisor({ advisor: { code: false, explain: false, advice: false, maxWords: 5 } });
+  assert.equal(off.maxWords, 10);
+  assert.equal(off.code, false);
+});
+
+test('advisorShouldRun exige tools o respuesta larga', () => {
+  assert.equal(advisorShouldRun({ toolCalls: 0, answer: 'corto' }), false);
+  assert.equal(advisorShouldRun({ toolCalls: 1, answer: '' }), true);
+  assert.equal(advisorShouldRun({ toolCalls: 0, answer: 'x'.repeat(201) }), true);
+});
+
+test('collectChangedFiles arma path + diff de write/edit', () => {
+  const files = collectChangedFiles(editMessages());
+  assert.equal(files.length, 1);
+  assert.equal(files[0].path, 'src/a.js');
+  assert.match(files[0].diff, /secreto/);
+});
+
+test('collectToolSummary lista las tools del turno', () => {
+  const summary = collectToolSummary(editMessages());
+  assert.equal(summary.length, 1);
+  assert.match(summary[0], /^edit:/);
+});
+
+test('buildAdvisorPrompt respeta los toggles y las notas', () => {
+  const { system, user } = buildAdvisorPrompt({
+    userInput: 'hola',
+    answer: 'listo',
+    toolSummary: ['edit: src/a.js'],
+    changedFiles: [{ path: 'src/a.js', diff: '- x\n+ y' }],
+    options: { code: false, explain: true, advice: true, notes: 'avisame de secretos', maxWords: 20 },
+  });
+  assert.doesNotMatch(system, /problema real en el codigo/);
+  assert.match(system, /explicar un proceso/);
+  assert.match(system, /avisame de secretos/);
+  assert.match(user, /PEDIDO DEL USUARIO/);
+  assert.match(user, /src\/a\.js/);
+});
+
+const fakeProvider = (content) => ({ streamChat: async () => ({ content }) });
+
+test('consultAdvisor interpreta speak:true', async () => {
+  const advice = await consultAdvisor({
+    provider: fakeProvider('{"speak":true,"kind":"code","text":"Ojo con el token en src/a.js."}'),
+    config: {},
+    model: 'x',
+    messages: editMessages(),
+    options: { code: true, explain: true, advice: true, maxWords: 40 },
+  });
+  assert.equal(advice.speak, true);
+  assert.equal(advice.kind, 'code');
+  assert.match(advice.text, /token/);
+});
+
+test('consultAdvisor respeta speak:false, JSON invalido y errores', async () => {
+  const off = await consultAdvisor({
+    provider: fakeProvider('{"speak":false,"text":""}'),
+    config: {},
+    model: 'x',
+    messages: [],
+    options: {},
+  });
+  assert.equal(off.speak, false);
+  assert.equal(
+    await consultAdvisor({ provider: fakeProvider('no json'), config: {}, model: 'x', messages: [], options: {} }),
+    null
+  );
+  const boom = {
+    streamChat: async () => {
+      throw new Error('boom');
+    },
+  };
+  assert.equal(await consultAdvisor({ provider: boom, config: {}, model: 'x', messages: [], options: {} }), null);
+});
+
+test('consultAdvisor recorta a maxWords', async () => {
+  const long = 'palabra '.repeat(50).trim();
+  const advice = await consultAdvisor({
+    provider: fakeProvider(JSON.stringify({ speak: true, kind: 'advice', text: long })),
+    config: {},
+    model: 'x',
+    messages: [],
+    options: { maxWords: 10, code: true, explain: true, advice: true },
+  });
+  assert.ok(advice.text.split(' ').length <= 11);
+  assert.match(advice.text, /…$/);
+});
+
+test('GET/PUT /api/advisor/settings y POST /api/advisor/test con proveedor inyectado', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-advisor-'));
+  setHome(cwd);
+  let reply = '{"speak":true,"kind":"code","text":"Cuidado con el secreto."}';
+  const provider = { streamChat: async () => ({ content: reply }) };
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider, config: {} }),
+  });
+  instance.ctx.store.setSetting('activeProvider', 'fake');
+  instance.ctx.store.setSetting('activeModel', 'test-model');
+  const info = await instance.listen({ port: 0 });
+  const base = info.url;
+  try {
+    const initial = await (await fetch(`${base}/api/advisor/settings`)).json();
+    assert.equal(initial.enabled, false);
+
+    const put = await fetch(`${base}/api/advisor/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: true, code: false, maxWords: 500 }),
+    });
+    const saved = await put.json();
+    assert.equal(saved.enabled, true);
+    assert.equal(saved.code, false);
+    assert.equal(saved.maxWords, 120);
+
+    const on = await (await fetch(`${base}/api/advisor/test`, { method: 'POST' })).json();
+    assert.equal(on.speak, true);
+    assert.match(on.text, /secreto/);
+
+    reply = '{"speak":false,"text":""}';
+    const off = await (await fetch(`${base}/api/advisor/test`, { method: 'POST' })).json();
+    assert.equal(off.speak, false);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('el asesor emite el evento advice al cerrar el turno', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-advice-'));
+  setHome(cwd);
+  let calls = 0;
+  const provider = {
+    id: 'fake',
+    streamChat: async (_config, { onEvent } = {}) => {
+      calls += 1;
+      if (calls === 1) {
+        const text = `Listo. ${'x'.repeat(220)}`;
+        onEvent?.({ type: 'text', delta: text, full: text });
+        return { content: text, reasoning: '', toolCalls: [] };
+      }
+      return { content: '{"speak":true,"kind":"code","text":"Cuidado con el token."}', reasoning: '', toolCalls: [] };
+    },
+  };
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider, config: {} }),
+  });
+  instance.ctx.app = {
+    ...instance.ctx.app,
+    advisor: { enabled: true, code: true, explain: true, advice: true, notes: '', maxWords: 40 },
+  };
+  instance.ctx.store.setSetting('activeProvider', 'fake');
+  instance.ctx.store.setSetting('activeModel', 'test-model');
+  const info = await instance.listen({ port: 0 });
+  try {
+    const res = await fetch(`${info.url}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'quién soy', model: 'test-model', provider: 'fake' }),
+    });
+    const body = await res.text();
+    assert.equal(calls, 2);
+    assert.match(body, /event: advice/);
+    assert.match(body, /Cuidado con el token/);
+  } finally {
+    await instance.close();
+  }
+});

package/harness/packages/server/test/markdown.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { renderMarkdown, highlight } from '../public/markdown.js';
+import { renderMarkdown, highlight, speechText } from '../public/markdown.js';
 
 test('escapes raw HTML from model output', () => {
   const html = renderMarkdown('<script>alert(1)</script>');
@@ -67,3 +67,45 @@ test('a lone pipe line without a delimiter row stays a paragraph', () => {
 test('highlight escapes code content', () => {
   assert.equal(highlight('a < b', 'bash'), 'a &lt; b');
 });
+
+test('speechText saca bloques de codigo y tablas', () => {
+  const md = [
+    'Te dejo el resumen.',
+    '',
+    '```js',
+    'const x = 1;',
+    '```',
+    '',
+    'Y una tabla:',
+    '',
+    '| a | b |',
+    '| - | - |',
+    '| 1 | 2 |',
+    '',
+    'Fin.',
+  ].join('\n');
+  const spoken = speechText(md);
+  assert.doesNotMatch(spoken, /const x/);
+  assert.doesNotMatch(spoken, /1 \| 2/);
+  assert.match(spoken, /Te dejo el resumen\./);
+  assert.match(spoken, /Fin\./);
+});
+
+test('speechText limpia marcas de markdown y aplasta espacios', () => {
+  const spoken = speechText('# Título\n\n**Nombre:** Daniel\n\n- uno\n- dos');
+  assert.equal(spoken, 'Título Nombre: Daniel uno dos');
+});
+
+test('speechText mantiene el texto de inline code', () => {
+  assert.equal(speechText('Corré `npm test` y listo.'), 'Corré npm test y listo.');
+});
+
+test('speechText recorta en un limite con maxChars', () => {
+  const spoken = speechText(`${'hola '.repeat(40)}`, { maxChars: 50 });
+  assert.ok(spoken.length <= 51);
+  assert.match(spoken, /…$/);
+});
+
+test('speechText devuelve vacio si solo hay codigo', () => {
+  assert.equal(speechText('```\nsolo codigo\n```'), '');
+});

package/harness/packages/server/test/update.test.js

@@ -0,0 +1,94 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+import { clearUpdateCache } from '../src/lib/update.js';
+
+async function startServer() {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-update-'));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: { id: 'fake' }, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url };
+}
+
+/** `fetch` que solo intercepta el registro npm; el resto va al server real. */
+function fakeRegistry(version, original) {
+  return async (url, opts) => {
+    if (String(url).includes('registry.npmjs.org')) {
+      return { ok: true, json: async () => ({ 'dist-tags': { latest: version } }) };
+    }
+    return original(url, opts);
+  };
+}
+
+test('GET /api/update informa cuando hay version nueva', async () => {
+  clearUpdateCache();
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  global.fetch = fakeRegistry('99.0.0', original);
+  try {
+    const data = await (await fetch(`${base}/api/update`)).json();
+    assert.equal(data.latest, '99.0.0');
+    assert.equal(data.updateAvailable, true);
+    assert.match(data.current, /^\d+\.\d+\.\d+/);
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});
+
+test('GET /api/update no rompe si no hay red', async () => {
+  clearUpdateCache();
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  global.fetch = async (url, opts) => {
+    if (String(url).includes('registry.npmjs.org')) throw new Error('offline');
+    return original(url, opts);
+  };
+  try {
+    const data = await (await fetch(`${base}/api/update`)).json();
+    assert.equal(data.updateAvailable, false);
+    assert.equal(data.latest, '');
+    assert.ok(data.error);
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});
+
+test('POST /api/update dispara el actualizador y responde 202', async () => {
+  clearUpdateCache();
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  global.fetch = fakeRegistry('99.0.0', original);
+  let called = null;
+  instance.ctx.spawnUpdater = (options) => {
+    called = options;
+    return { ok: true, pid: 1234 };
+  };
+  instance.ctx.shutdown = async () => {};
+  try {
+    const res = await fetch(`${base}/api/update`, { method: 'POST' });
+    assert.equal(res.status, 202);
+    const data = await res.json();
+    assert.equal(data.updating, true);
+    assert.match(data.from, /^\d+\.\d+\.\d+/);
+    assert.equal(data.to, '99.0.0');
+    assert.ok(called);
+    assert.equal(called.target, '99.0.0');
+    assert.equal(called.pid, process.pid);
+    assert.equal(typeof called.cwd, 'string');
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});

package/harness/scripts/self-update.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// Auto-actualizacion disparada desde el server (POST /api/update).
+//
+// Corre detached: espera a que el server viejo muera (en Windows eso libera los
+// archivos que npm necesita reemplazar), instala la ultima version y vuelve a
+// levantar el server con el codigo nuevo. Todo se loguea en el log del server
+// para poder diagnosticar desde Ajustes o `tamnora server --logs`.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+
+const PACKAGE = '@danieltmn/tamnora';
+const IS_WIN = process.platform === 'win32';
+const NPM = IS_WIN ? 'npm.cmd' : 'npm';
+
+function arg(name) {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 ? process.argv[i + 1] : '';
+}
+
+const pid = Number(arg('pid')) || 0;
+const port = arg('port');
+const host = arg('host');
+const cwd = arg('cwd');
+const target = arg('target') || 'latest';
+const home = arg('home') || process.env.TAMNORA_HOME || '';
+
+function defaultHome() {
+  if (process.env.APPDATA) return path.join(process.env.APPDATA, 'tamnora');
+  if (process.platform === 'darwin') {
+    return path.join(process.env.HOME || '', 'Library', 'Application Support', 'tamnora');
+  }
+  return path.join(process.env.HOME || process.env.USERPROFILE || '', '.config', 'tamnora');
+}
+
+function log(line) {
+  const text = `[${new Date().toISOString()}] self-update: ${line}`;
+  try {
+    appendFileSync(path.join(home || defaultHome(), 'logs', 'server.log'), `${text}\n`);
+  } catch {
+    /* sin log seguimos: la instalacion es lo importante */
+  }
+  try {
+    process.stdout.write(`${text}\n`);
+  } catch {
+    /* stdout cerrado */
+  }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function alive(p) {
+  if (!p) return false;
+  try {
+    process.kill(p, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitDead(p, ms = 15000) {
+  const start = Date.now();
+  while (alive(p)) {
+    if (Date.now() - start > ms) {
+      try {
+        process.kill(p);
+      } catch {
+        /* ya murio */
+      }
+      await sleep(1500);
+      return !alive(p);
+    }
+    await sleep(300);
+  }
+  return true;
+}
+
+function runNpm(args) {
+  return spawnSync(NPM, args, { encoding: 'utf8', windowsHide: true, shell: IS_WIN, timeout: 180000 });
+}
+
+async function main() {
+  log(`esperando que muera el server (pid ${pid})`);
+  await waitDead(pid);
+  await sleep(800);
+
+  log(`instalando ${PACKAGE}@${target}`);
+  const install = runNpm(['i', '-g', `${PACKAGE}@${target}`]);
+  if (install.status !== 0) {
+    log(`FALLO la instalacion: ${(install.stderr || install.stdout || '').trim()}`);
+    log('Podes reintentar a mano: npm i -g ' + `${PACKAGE}@${target}`);
+    return;
+  }
+
+  const rootOut = runNpm(['root', '-g']).stdout?.trim();
+  const pkgDir = rootOut ? path.join(rootOut, ...PACKAGE.split('/')) : '';
+  const bin = pkgDir ? path.join(pkgDir, 'harness', 'packages', 'cli', 'bin', 'tamnora.mjs') : '';
+  if (!bin || !existsSync(bin)) {
+    log(`instale pero no encontre el binario nuevo en ${pkgDir || '(npm root -g vacio)'}`);
+    log('Levantalo a mano: tamnora server --start');
+    return;
+  }
+
+  const args = [bin, 'server', '--stream', '--no-open'];
+  if (port) args.push('--port', port);
+  if (host) args.push('--host', host);
+  if (cwd) args.push('--dir', cwd);
+  log(`reiniciando: ${args.join(' ')}`);
+  const env = { ...process.env, TAMNORA_DETACHED: '1' };
+  if (home) env.TAMNORA_HOME = home;
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env,
+  });
+  child.unref();
+  log(`server reiniciado (pid ${child.pid}).`);
+}
+
+main().catch((error) => log(`error: ${error?.stack ?? error}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",