@danieltmn/tamnora 0.24.2 → 0.25.1

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

@@ -0,0 +1,90 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { SETTINGS_GROUPS, SETTINGS_SECTIONS, filterSettings, foldText, hasSettingsSection } from '../public/settingsNav.js';
+
+const html = readFileSync(new URL('../public/index.html', import.meta.url), 'utf8');
+
+const ids = (list) => list.map((section) => section.id);
+
+test('foldText ignora mayusculas y acentos', () => {
+  assert.equal(foldText('  Límites  '), 'limites');
+  assert.equal(foldText('Transcripción'), 'transcripcion');
+  assert.equal(foldText(null), '');
+});
+
+test('sin consulta devuelve todas las secciones, en el orden de los grupos', () => {
+  assert.deepEqual(ids(filterSettings('')), ids(SETTINGS_SECTIONS));
+  assert.deepEqual(ids(filterSettings('   ')), ids(SETTINGS_SECTIONS));
+  assert.equal(SETTINGS_SECTIONS.length, 14);
+});
+
+test('busca por nombre sin importar acentos ni mayusculas', () => {
+  assert.deepEqual(ids(filterSettings('limites')), ['limites']);
+  assert.deepEqual(ids(filterSettings('TRANSCRIPCIÓN')), ['transcripcion']);
+  assert.deepEqual(ids(filterSettings('tele')), ['telegram']);
+});
+
+test('el nombre del grupo no tapa a la seccion: "voz" da Voz, no todo "Voz y canales"', () => {
+  assert.deepEqual(ids(filterSettings('voz')), ['voz']);
+  assert.deepEqual(ids(filterSettings('canales')), ['voz', 'transcripcion', 'asesor', 'telegram']);
+});
+
+test('busca por palabra clave y por grupo', () => {
+  assert.ok(ids(filterSettings('tema')).includes('apariencia'));
+  assert.ok(ids(filterSettings('dictado')).includes('transcripcion'));
+  assert.ok(ids(filterSettings('cron')).includes('tareas'));
+  assert.deepEqual(ids(filterSettings('contexto')), ['perfil', 'memoria', 'skills', 'agentes', 'mcp']);
+});
+
+test('todas las palabras de la consulta tienen que coincidir', () => {
+  assert.deepEqual(ids(filterSettings('voz hablar')), ['voz']);
+  assert.deepEqual(ids(filterSettings('voz zzzz')), []);
+  assert.deepEqual(ids(filterSettings('nada que ver')), []);
+});
+
+test('las coincidencias por nombre van antes que las de palabra clave', () => {
+  const result = ids(filterSettings('mcp'));
+  assert.equal(result[0], 'mcp');
+});
+
+test('hasSettingsSection distingue ids reales', () => {
+  assert.ok(hasSettingsSection('voz'));
+  assert.ok(!hasSettingsSection('inexistente'));
+});
+
+test('los ids de las secciones no se repiten', () => {
+  const all = ids(SETTINGS_SECTIONS);
+  assert.equal(new Set(all).size, all.length);
+});
+
+test('index.html tiene un boton y un panel por cada seccion, y ninguno de mas', () => {
+  const tabs = [...html.matchAll(/<button[^>]*class="ajustes-tab[^"]*"[^>]*data-panel="([a-z]+)"/g)].map((m) => m[1]);
+  const panels = [...html.matchAll(/<div class="panel ajustes-panel[^"]*"[^>]*data-panel="([a-z]+)"/g)].map((m) => m[1]);
+  const expected = ids(SETTINGS_SECTIONS).sort();
+  assert.deepEqual([...tabs].sort(), expected, 'botones del menu de ajustes');
+  assert.deepEqual([...panels].sort(), expected, 'paneles de ajustes');
+});
+
+test('el menu de index.html respeta los grupos y el nombre de cada seccion', () => {
+  for (const group of SETTINGS_GROUPS) {
+    const block = html.match(new RegExp(`<div class="ajustes-group" data-group="${group.id}"[^>]*>([\\s\\S]*?)\\n            </div>`));
+    assert.ok(block, `falta el grupo ${group.id}`);
+    assert.ok(block[1].includes(`>${group.label}</span>`), `titulo del grupo ${group.id}`);
+    const inBlock = [...block[1].matchAll(/data-panel="([a-z]+)"[^>]*>([^<]+)<\/button>/g)].map((m) => [m[1], m[2]]);
+    assert.deepEqual(
+      inBlock,
+      group.sections.map((section) => [section.id, section.label]),
+      `secciones del grupo ${group.id}`,
+    );
+  }
+});
+
+test('cada tab apunta a su panel por aria-controls y el panel a su tab', () => {
+  for (const { id } of SETTINGS_SECTIONS) {
+    assert.match(html, new RegExp(`id="ajustes-tab-${id}"[^>]*aria-controls="ajustes-panel-${id}"`), `tab ${id}`);
+    assert.match(html, new RegExp(`id="ajustes-panel-${id}"[^>]*role="tabpanel"[^>]*aria-labelledby="ajustes-tab-${id}"`), `panel ${id}`);
+  }
+  const selected = html.match(/class="ajustes-tab[^"]*"[^>]*aria-selected="true"/g) ?? [];
+  assert.equal(selected.length, 1, 'exactamente una tab seleccionada al cargar');
+});

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

@@ -0,0 +1,110 @@
+// Lee los temas de `public/styles.css` tal como los ve el navegador y calcula
+// contraste WCAG. Sirve a los tests de temas: no hay DOM, se parsea el texto.
+import { readFileSync } from 'node:fs';
+
+const CSS_URL = new URL('../public/styles.css', import.meta.url);
+
+export function readStyles() {
+  return readFileSync(CSS_URL, 'utf8').replace(/\r\n/g, '\n');
+}
+
+function parseVars(body) {
+  const vars = {};
+  for (const m of body.matchAll(/(--[a-z0-9-]+)\s*:\s*([^;]+);/gi)) vars[m[1]] = m[2].trim();
+  return vars;
+}
+
+/** `{ root: {...}, themes: { paper: {...}, ... } }` con las variables declaradas en cada bloque. */
+export function parseThemeBlocks(css = readStyles()) {
+  const root = css.match(/(^|\n):root \{\n([\s\S]*?)\n\}/);
+  if (!root) throw new Error('no encontre :root');
+  const themes = {};
+  for (const m of css.matchAll(/^html\[data-theme='([a-z-]+)'\] \{\n([\s\S]*?)\n\}/gm)) {
+    themes[m[1]] = parseVars(m[2]);
+  }
+  return { root: parseVars(root[2]), themes };
+}
+
+/** Variables resueltas de un tema: las de `:root` pisadas por las del tema. */
+export function resolveTheme(id, blocks = parseThemeBlocks()) {
+  if (id !== 'dark' && !blocks.themes[id]) throw new Error(`tema desconocido: ${id}`);
+  return { ...blocks.root, ...(blocks.themes[id] ?? {}) };
+}
+
+export function parseColor(value) {
+  const text = String(value).trim();
+  let m = text.match(/^#([0-9a-f]{3})$/i);
+  if (m) return { r: parseInt(m[1][0] + m[1][0], 16), g: parseInt(m[1][1] + m[1][1], 16), b: parseInt(m[1][2] + m[1][2], 16), a: 1 };
+  m = text.match(/^#([0-9a-f]{6})$/i);
+  if (m) return { r: parseInt(m[1].slice(0, 2), 16), g: parseInt(m[1].slice(2, 4), 16), b: parseInt(m[1].slice(4, 6), 16), a: 1 };
+  m = text.match(/^#([0-9a-f]{8})$/i);
+  if (m) return { r: parseInt(m[1].slice(0, 2), 16), g: parseInt(m[1].slice(2, 4), 16), b: parseInt(m[1].slice(4, 6), 16), a: parseInt(m[1].slice(6, 8), 16) / 255 };
+  m = text.match(/^rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)$/i);
+  if (m) return { r: Number(m[1]), g: Number(m[2]), b: Number(m[3]), a: m[4] === undefined ? 1 : Number(m[4]) };
+  return null;
+}
+
+/** Pinta `top` (con alfa) sobre `base` opaco. */
+export function composite(top, base) {
+  const a = top.a;
+  return {
+    r: Math.round(top.r * a + base.r * (1 - a)),
+    g: Math.round(top.g * a + base.g * (1 - a)),
+    b: Math.round(top.b * a + base.b * (1 - a)),
+    a: 1,
+  };
+}
+
+function channel(value) {
+  const s = value / 255;
+  return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+}
+
+export function luminance({ r, g, b }) {
+  return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
+}
+
+export const TOKEN_NAMES = ['comment', 'string', 'number', 'keyword', 'tag', 'attr', 'selector', 'punct'];
+
+/**
+ * Pisos de contraste de un tema ya resuelto. Texto de interfaz: AA (4.5). Texto
+ * principal: 7 (AAA). Colores de sintaxis: 3, porque son un apoyo visual sobre un
+ * bloque de codigo y no el texto que se lee.
+ */
+export function contrastChecks(vars) {
+  const color = (name) => {
+    const parsed = parseColor(vars[name]);
+    if (!parsed) throw new Error(`color ilegible en ${name}: ${vars[name]}`);
+    return parsed;
+  };
+  const bg = color('--bg');
+  const panel = composite(color('--panel'), bg);
+  const theirs = color('--theirs');
+  const solid = color('--solid');
+  const checks = [
+    { name: 'text/bg', vars: ['--text', '--bg'], ratio: contrast(color('--text'), bg), min: 7 },
+    { name: 'text/panel', vars: ['--text', '--panel'], ratio: contrast(color('--text'), panel), min: 7 },
+    { name: 'muted/bg', vars: ['--muted', '--bg'], ratio: contrast(color('--muted'), bg), min: 4.5 },
+    { name: 'muted/panel', vars: ['--muted', '--panel'], ratio: contrast(color('--muted'), panel), min: 4.5 },
+    { name: 'muted/theirs', vars: ['--muted', '--theirs'], ratio: contrast(color('--muted'), theirs), min: 4.5 },
+    { name: 'accent/bg', vars: ['--accent', '--bg'], ratio: contrast(color('--accent'), bg), min: 4.5 },
+    { name: 'primary-fg/accent', vars: ['--primary-fg', '--accent'], ratio: contrast(color('--primary-fg'), color('--accent')), min: 4.5 },
+  ];
+  for (const status of ['danger', 'ok', 'warn', 'info']) {
+    checks.push({ name: `${status}/bg`, vars: [`--${status}`, '--bg'], ratio: contrast(color(`--${status}`), bg), min: 4.5 });
+  }
+  // Indicador grafico (mic/manos libres activos): componente de interfaz, 3:1.
+  checks.push({ name: 'live/bg', vars: ['--live', '--bg'], ratio: contrast(color('--live'), bg), min: 3 });
+  for (const token of TOKEN_NAMES) {
+    checks.push({ name: `tok-${token}/solid`, vars: [`--tok-${token}`, '--solid'], ratio: contrast(color(`--tok-${token}`), solid), min: 3 });
+  }
+  return checks;
+}
+
+/** Relacion de contraste WCAG entre dos colores opacos (1 a 21). */
+export function contrast(foreground, background) {
+  const l1 = luminance(foreground);
+  const l2 = luminance(background);
+  const [hi, lo] = l1 >= l2 ? [l1, l2] : [l2, l1];
+  return (hi + 0.05) / (lo + 0.05);
+}

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

@@ -0,0 +1,72 @@
+// Los temas de la consola, verificados sobre el CSS real (sin navegador).
+// Un tema nuevo (o un retoque de colores) no puede dejar texto ilegible ni una
+// variable sin definir: eso se nota en pantalla recien cuando alguien lo usa.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { THEMES } from '../public/appearance.js';
+import { TOKEN_NAMES, contrastChecks, parseColor, parseThemeBlocks, readStyles, resolveTheme } from './themeCss.js';
+
+const blocks = parseThemeBlocks();
+const ids = THEMES.map((theme) => theme.id);
+
+// Variables que no son color: las define :root y los temas no las repiten.
+const NO_COLOR = new Set(['--sans', '--serif', '--mono', '--font', '--chat-font']);
+
+test('cada tema de appearance.js tiene su bloque de CSS, y viceversa', () => {
+  const conBloque = ['dark', ...Object.keys(blocks.themes)];
+  assert.deepEqual([...conBloque].sort(), [...ids].sort());
+});
+
+test('el esquema declarado de cada tema coincide con su color-scheme', () => {
+  const css = readStyles();
+  for (const theme of THEMES) {
+    const open = theme.id === 'dark' ? ':root {' : `html[data-theme='${theme.id}'] {`;
+    const start = css.indexOf(open);
+    const body = css.slice(start, css.indexOf('\n}\n', start));
+    assert.match(body, new RegExp(`color-scheme: ${theme.scheme};`), `${theme.id} deberia ser ${theme.scheme}`);
+  }
+});
+
+test('todos los temas definen las mismas variables de color que :root', () => {
+  const requeridas = Object.keys(blocks.root).filter((name) => !NO_COLOR.has(name));
+  assert.ok(requeridas.length > 25, 'no se leyeron las variables de :root');
+  for (const [id, vars] of Object.entries(blocks.themes)) {
+    const faltan = requeridas.filter((name) => !(name in vars));
+    assert.deepEqual(faltan, [], `el tema "${id}" no define: ${faltan.join(', ')}`);
+  }
+});
+
+test('cada color de cada tema se puede leer', () => {
+  for (const id of ids) {
+    const vars = resolveTheme(id, blocks);
+    for (const [name, value] of Object.entries(vars)) {
+      if (NO_COLOR.has(name)) continue;
+      assert.ok(parseColor(value), `${id}: ${name} = "${value}" no es un color valido`);
+    }
+  }
+});
+
+test('la sintaxis se tematiza con variables, no con reglas copiadas por tema', () => {
+  const css = readStyles();
+  assert.ok(!/data-theme='[a-z-]+'\] \.tok-/.test(css), 'quedaron reglas .tok-* por tema');
+  for (const name of TOKEN_NAMES) {
+    assert.match(css, new RegExp(`\\.tok-${name} \\{ color: var\\(--tok-${name}\\);`), `.tok-${name} no usa su variable`);
+    for (const id of ids) assert.ok(resolveTheme(id, blocks)[`--tok-${name}`], `${id} sin --tok-${name}`);
+  }
+});
+
+for (const id of ids) {
+  test(`contraste del tema "${id}" cumple los pisos (texto AA/AAA, sintaxis 3:1)`, () => {
+    const fallas = contrastChecks(resolveTheme(id, blocks))
+      .filter((check) => check.ratio < check.min)
+      .map((check) => `${check.name} ${check.ratio.toFixed(2)} < ${check.min}`);
+    assert.deepEqual(fallas, [], `${id}: ${fallas.join(' | ')}`);
+  });
+}
+
+test('metaColor (barra del navegador) coincide con el fondo de cada tema', () => {
+  for (const theme of THEMES) {
+    const bg = resolveTheme(theme.id, blocks)['--bg'];
+    assert.equal(theme.metaColor.toLowerCase(), bg.toLowerCase(), `${theme.id}: metaColor ${theme.metaColor} != --bg ${bg}`);
+  }
+});

package/harness/scripts/restart.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+// Reinicio disparado desde la consola (POST /api/server/restart).
+//
+// Corre detached: espera a que el server viejo muera (libera el puerto y, en
+// Windows, los archivos) y lo vuelve a levantar con el mismo comando con que
+// arranco (el argv serializado por el server), sin tocar la instalacion. Todo se
+// loguea en el log del server para diagnosticar desde `tamnora server --logs`.
+
+import { spawn } from 'node:child_process';
+import { appendFileSync } from 'node:fs';
+import path from 'node:path';
+
+function arg(name) {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 ? process.argv[i + 1] : '';
+}
+
+const pid = Number(arg('pid')) || 0;
+const home = arg('home') || process.env.TAMNORA_HOME || '';
+let argv = [];
+try {
+  argv = JSON.parse(arg('argv') || '[]');
+} catch {
+  argv = [];
+}
+
+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()}] restart: ${line}`;
+  try {
+    appendFileSync(path.join(home || defaultHome(), 'logs', 'server.log'), `${text}\n`);
+  } catch {
+    /* sin log seguimos: el reinicio 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;
+}
+
+async function main() {
+  log(`esperando que muera el server (pid ${pid})`);
+  await waitDead(pid);
+  await sleep(800);
+
+  if (!Array.isArray(argv) || !argv.length) {
+    log('no llego el argv que relanzar; levantalo a mano: tamnora server');
+    return;
+  }
+
+  log(`reiniciando: ${process.execPath} ${argv.join(' ')}`);
+  const env = { ...process.env, TAMNORA_DETACHED: '1' };
+  if (home) env.TAMNORA_HOME = home;
+  const child = spawn(process.execPath, argv, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env,
+  });
+  child.unref();
+  log(`server reiniciado (pid ${child.pid}).`);
+}
+
+main().catch((error) => log(`error: ${error?.stack ?? error}`));

package/harness/tamnora.example.json

@@ -7,6 +7,7 @@
   "maxDurationMs": 0,
   "maxOutputTokens": 0,
   "promptCaching": false,
+  "effort": "",
   "skills": { "mode": "lazy" },
   "compact": { "enabled": true, "threshold": 0.75, "keepLast": 8 },
   "rules": [".tamnora/rules/*.md"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.24.2",
+  "version": "0.25.1",
   "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",