@danieltmn/tamnora 0.9.1 → 0.9.3

package/CHANGELOG.md

@@ -5,6 +5,19 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.9.3] - 2026-10-07
+
+### Cambios
+
+- feat(telegram): audio solo cuando el usuario lo pide
+- feat: diff lado a lado en TUI, proveedores Anthropic/Gemini y mejoras de consola
+
+## [0.9.2] - 2026-10-07
+
+### Cambios
+
+- feat: perfil del usuario, dictado de voz y Telegram por proyecto
+
 ## [0.9.1] - 2026-10-07
 
 ### Cambios

package/harness/packages/cli/src/tui/app.js

@@ -1,7 +1,8 @@
 // Full-screen terminal console (opencode/codex-like), zero dependencies.
 // Alt-screen + raw input + incremental rendering; reuses the harness engine.
 
-import { createTools } from '../lib/core.js';
+import { readFileSync } from 'node:fs';
+import { createTools, diffRows, resolveInRoot } from '../lib/core.js';
 import { runTurn } from '../lib/runtime.js';
 import { parseKeys } from './keys.js';
 import { render } from './layout.js';
@@ -67,6 +68,15 @@ export function runTui({
     tools: [],
   });
 
+  const readWorkspaceFile = (rel) => {
+    if (!rel) return '';
+    try {
+      return readFileSync(resolveInRoot(toolOptions.root, rel), 'utf8');
+    } catch {
+      return '';
+    }
+  };
+
   const onAsk = (name, args) =>
     new Promise((resolve) => {
       state.pendingAsk = { name, detail: args?.command ?? args?.path ?? '', resolve };
@@ -186,10 +196,19 @@ export function runTui({
           } else if (event.type === 'stall') {
             if (!sawText) assistant.text = `⚠ ${event.seconds} s sin respuesta del modelo (proveedor caído o muy lento). Sigo esperando...`;
           } else if (event.type === 'tool_call') {
-            assistant.tools.push({ name: event.name, args: JSON.stringify(event.args) });
+            const tool = { name: event.name, args: JSON.stringify(event.args), path: event.args?.path };
+            if (event.name === 'write' || event.name === 'edit') {
+              tool.oldContent = readWorkspaceFile(event.args?.path);
+            }
+            assistant.tools.push(tool);
           } else if (event.type === 'tool_result') {
             const tool = assistant.tools[assistant.tools.length - 1];
-            if (tool) tool.result = String(event.result).slice(0, 2000);
+            if (tool) {
+              tool.result = String(event.result).slice(0, 2000);
+              if (tool.oldContent !== undefined) {
+                tool.diff = diffRows(tool.oldContent, readWorkspaceFile(tool.path), { maxRows: 400 });
+              }
+            }
           }
           draw();
         },

package/harness/packages/cli/src/tui/layout.js

@@ -48,6 +48,53 @@ function clip(text, width) {
   return arr.length <= width ? text : arr.slice(0, width).join('');
 }
 
+function sanitize(text) {
+  return String(text ?? '').replace(/\t/g, '    ');
+}
+
+// Una columna del diff: numero de linea dim y contenido rojo (viejo) / verde
+// (nuevo) / normal (contexto). Devuelve texto con ANSI ya resuelto (raw).
+function diffSide(cell, kind, numW, contentW) {
+  if (!cell) return color.dim(' '.repeat(numW + 3 + contentW));
+  const num = String(cell.no).padStart(numW);
+  const text = clip(sanitize(cell.text), contentW);
+  const pad = ' '.repeat(Math.max(0, contentW - chars(text).length));
+  const sign = kind === 'del' ? '-' : kind === 'add' ? '+' : ' ';
+  const paint = kind === 'del' ? color.red : kind === 'add' ? color.green : (t) => t;
+  return color.dim(`${num} `) + paint(`${sign} ${text}`) + pad;
+}
+
+// Arma las lineas del diff lado a lado. Devuelve null si el ancho es muy chico
+// (en ese caso el que llama cae al diff de una sola columna).
+function buildDiff(diff, width) {
+  const indent = 2;
+  const mid = ' │ ';
+  const maxNo = diff.reduce((m, row) => Math.max(m, row.left?.no ?? 0, row.right?.no ?? 0), 1);
+  const numW = Math.max(3, String(maxNo).length);
+  const colW = Math.floor((width - indent - mid.length) / 2);
+  const contentW = colW - numW - 3;
+  if (contentW < 6) return null;
+
+  const out = [];
+  for (const row of diff) {
+    if (row.type === 'skip') {
+      out.push({ text: `${' '.repeat(indent)}${color.dim('…')}`, raw: true });
+      continue;
+    }
+    const leftKind = row.type === 'add' ? 'blank' : row.type === 'ctx' ? 'ctx' : 'del';
+    const rightKind = row.type === 'del' ? 'blank' : row.type === 'ctx' ? 'ctx' : 'add';
+    const line =
+      ' '.repeat(indent) +
+      diffSide(row.left, leftKind, numW, contentW) +
+      color.dim(mid) +
+      diffSide(row.right, rightKind, numW, contentW);
+    out.push({ text: line, raw: true });
+  }
+  return out;
+}
+
+const TOOL_LABELS = { write: 'Write', edit: 'Edit' };
+
 function buildBody(state, width) {
   const out = [];
   for (const message of state.messages) {
@@ -62,6 +109,12 @@ function buildBody(state, width) {
       for (const line of wrapText(message.text, width - 2)) out.push({ text: `  ${line}`, style: 'assistant' });
     }
     for (const tool of message.tools ?? []) {
+      const diff = tool.diff?.length ? buildDiff(tool.diff, width) : null;
+      if (diff) {
+        out.push({ text: `  ✎ ${TOOL_LABELS[tool.name] ?? tool.name} ${tool.path ?? ''}`.trimEnd(), style: 'tool' });
+        out.push(...diff);
+        continue;
+      }
       out.push({ text: `  ⚙ ${tool.name} ${clip(tool.args ?? '', width - 8)}`, style: 'tool' });
       if (tool.result !== undefined) {
         for (const line of wrapText(tool.result, width - 6)) out.push({ text: `    → ${line}`, style: 'dim' });
@@ -121,8 +174,12 @@ export function render(state, { cols = 80, rows = 24 } = {}) {
   const parts = [];
   for (let i = 0; i < rows; i++) {
     const entry = lines[i] ?? { text: '', style: 'dim' };
-    const style = THEME[entry.style] ?? THEME.assistant;
-    parts.push(moveTo(i + 1, 1), '\x1b[2K', style(clip(entry.text, width)));
+    parts.push(moveTo(i + 1, 1), '\x1b[2K');
+    if (entry.raw) parts.push(entry.text);
+    else {
+      const style = THEME[entry.style] ?? THEME.assistant;
+      parts.push(style(clip(entry.text, width)));
+    }
   }
 
   const cursorCol = state.pendingAsk ? 2 : Math.min(width, chars(`  ❯ ${before}`).length + 1);

package/harness/packages/cli/test/tui.test.js

@@ -81,6 +81,36 @@ test('render places the cursor at inputCursor', () => {
   assert.equal(cursor.col, 6);
 });
 
+test('render shows a side-by-side diff for write/edit', () => {
+  const state = {
+    header: { provider: 'p', model: 'm', cwd: '/x' },
+    messages: [
+      {
+        role: 'assistant',
+        text: '',
+        tools: [
+          {
+            name: 'edit',
+            args: '{"path":"a.js"}',
+            path: 'a.js',
+            diff: [
+              { type: 'ctx', left: { no: 1, text: 'const a = 1;' }, right: { no: 1, text: 'const a = 1;' } },
+              { type: 'mod', left: { no: 2, text: 'const b = 2;' }, right: { no: 2, text: 'const b = 3;' } },
+            ],
+          },
+        ],
+      },
+    ],
+    input: '',
+    streaming: false,
+    pendingAsk: null,
+  };
+  const { frame } = render(state, { cols: 80, rows: 20 });
+  assert.match(frame, /Edit a\.js/);
+  assert.match(frame, /const b = 2;/);
+  assert.match(frame, /const b = 3;/);
+});
+
 test('render scrolls the viewport', () => {
   const messages = Array.from({ length: 40 }, (_, i) => ({ role: 'assistant', text: `linea ${i}`, tools: [] }));
   const base = { header: { provider: 'p', model: 'm', cwd: '/x' }, input: '', streaming: false, pendingAsk: null };

package/harness/packages/core/src/config/app.js

@@ -12,6 +12,8 @@ export const DEFAULT_APP = {
   tunnel: { provider: 'tunnelmole', domain: '' },
   authSecret: '',
   user: null,
+  // Datos del usuario para que el agente lo conozca (se inyecta en el prompt).
+  profile: { address: '', name: '', language: '', notes: '', fields: {} },
 };
 
 export function randomToken(bytes = 32) {

package/harness/packages/core/src/index.js

@@ -12,7 +12,7 @@ export { resolveApiKey, resolveEnvMap } from './config/secrets.js';
 export { ensureUtf8Console } from './console.js';
 export { MAX_TOOL_ROUNDS, runAgent, parseToolArguments } from './agent/runAgent.js';
 export { estimateTokens, trimContext } from './agent/context.js';
-export { diffLines } from './tools/diff.js';
+export { diffLines, diffRows } from './tools/diff.js';
 export { isGitRepo, gitStatus, gitDiff } from './git/index.js';
 export { summarizeToolCall, previewToolResult } from './tools/labels.js';
 export { MODES, MODE_IDS, resolveMode } from './agent/modes.js';
@@ -105,6 +105,7 @@ export {
   sintetizar,
   listarVoces,
 } from './tts/edge.js';
+export { reconocerGoogle, wavToPcm } from './stt/google.js';
 export { pidAlive, killPidTree } from './pid.js';
 export { openBrowser, openerFor } from './open.js';
 export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip } from './procs/detect.js';

package/harness/packages/core/src/providers/presets.js

@@ -9,6 +9,10 @@ function preset(id, label, baseUrl) {
 export const OPENAI_COMPATIBLE_PRESETS = [
   preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1'),
   preset('openai', 'OpenAI', 'https://api.openai.com/v1'),
+  // Anthropic y Gemini exponen una capa compatible con OpenAI (chat/completions
+  // + tools) que usa el mismo Bearer; sirven con este adaptador sin cambios.
+  preset('anthropic', 'Anthropic (Claude)', 'https://api.anthropic.com/v1'),
+  preset('gemini', 'Google Gemini', 'https://generativelanguage.googleapis.com/v1beta/openai'),
   preset('groq', 'Groq', 'https://api.groq.com/openai/v1'),
   preset('mistral', 'Mistral AI', 'https://api.mistral.ai/v1'),
   preset('xai', 'xAI (Grok)', 'https://api.x.ai/v1'),

package/harness/packages/core/src/stt/google.js

@@ -0,0 +1,91 @@
+// Reconocimiento de voz con el servicio no oficial de Chromium/Google (el mismo
+// que usa el Web Speech API del navegador). No necesita API key: usa la clave
+// publica que trae Chromium. Analogо al TTS de Edge: gratis, sin dependencias y
+// con el mismo riesgo (si cambia el protocolo/clave hay que actualizarlo).
+
+const GOOGLE_KEY = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw';
+const GOOGLE_URL = 'https://www.google.com/speech-api/v2/recognize';
+
+/**
+ * Extrae el trozo PCM de un WAV y su sample rate. Si no es un WAV conocido,
+ * devuelve el buffer tal cual a 16 kHz.
+ */
+export function wavToPcm(buffer) {
+  const wav = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer ?? []);
+  if (wav.length < 44 || wav.toString('ascii', 0, 4) !== 'RIFF' || wav.toString('ascii', 8, 12) !== 'WAVE') {
+    return { pcm: wav, rate: 16000, channels: 1, bits: 16 };
+  }
+  let rate = 16000;
+  let channels = 1;
+  let bits = 16;
+  let offset = 12;
+  while (offset + 8 <= wav.length) {
+    const id = wav.toString('ascii', offset, offset + 4);
+    const size = wav.readUInt32LE(offset + 4);
+    if (id === 'fmt ' && size >= 16) {
+      channels = wav.readUInt16LE(offset + 10);
+      rate = wav.readUInt32LE(offset + 12);
+      bits = wav.readUInt16LE(offset + 22);
+    } else if (id === 'data') {
+      return { pcm: wav.subarray(offset + 8, offset + 8 + size), rate, channels, bits };
+    }
+    offset += 8 + size + (size % 2);
+  }
+  return { pcm: wav.subarray(44), rate, channels, bits };
+}
+
+/** Convierte PCM multicanal/8-bit a 16-bit mono little-endian. */
+function aMono16(pcm, channels, bits) {
+  if (bits !== 16) return pcm;
+  if (channels <= 1) return pcm;
+  const frames = Math.floor(pcm.length / 2 / channels);
+  const out = Buffer.alloc(frames * 2);
+  for (let i = 0; i < frames; i++) {
+    let sum = 0;
+    for (let c = 0; c < channels; c++) sum += pcm.readInt16LE((i * channels + c) * 2);
+    out.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(sum / channels))), i * 2);
+  }
+  return out;
+}
+
+function parsearRespuesta(texto) {
+  let transcript = '';
+  for (const linea of String(texto ?? '').split('\n')) {
+    const value = linea.trim();
+    if (!value) continue;
+    let data;
+    try {
+      data = JSON.parse(value);
+    } catch {
+      continue;
+    }
+    const results = data?.result ?? data?.results ?? [];
+    for (const r of results) {
+      const alt = r?.alternative?.[0];
+      if (alt?.transcript) transcript += `${transcript ? ' ' : ''}${alt.transcript}`;
+    }
+  }
+  return transcript.trim();
+}
+
+/**
+ * Transcribe un WAV (o PCM crudo) contra el servicio de Google. Devuelve el
+ * texto ('' si no se reconoció nada).
+ */
+export async function reconocerGoogle(audio, { lang = 'es-AR', signal } = {}) {
+  const { pcm, rate, channels, bits } = wavToPcm(audio);
+  const mono = aMono16(pcm, channels, bits);
+  if (!mono.length) return '';
+  const url = `${GOOGLE_URL}?output=json&lang=${encodeURIComponent(lang || 'es-AR')}&key=${GOOGLE_KEY}&client=chromium`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': `audio/l16; rate=${rate || 16000}` },
+    body: mono,
+    signal,
+  });
+  if (!res.ok) {
+    const detail = String((await res.text().catch(() => '')) ?? '').slice(0, 200);
+    throw new Error(`reconocimiento de Google falló (HTTP ${res.status})${detail ? `: ${detail}` : ''}`);
+  }
+  return parsearRespuesta(await res.text());
+}

package/harness/packages/core/src/tools/diff.js

@@ -7,7 +7,9 @@ const MAX_CELLS = 1_500_000;
 
 function splitLines(text) {
   if (text === '' || text == null) return [];
-  return String(text).replace(/\r\n/g, '\n').split('\n');
+  const lines = String(text).replace(/\r\n/g, '\n').split('\n');
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop();
+  return lines;
 }
 
 function computeOps(a, b) {
@@ -88,3 +90,70 @@ export function diffLines(oldText, newText, { context = 3, maxLines = 200 } = {}
   if (truncated) out.push('  … (diff truncado)');
   return out.join('\n');
 }
+
+/**
+ * Diff estructurado para una vista lado a lado (dos columnas): devuelve filas
+ * con la linea vieja (izquierda) y la nueva (derecha) ya numeradas. Las
+ * supresiones y adiciones de un mismo bloque se emparejan en la misma fila.
+ *
+ * @returns {Array<{type:'ctx'|'mod'|'del'|'add'|'skip', left:({no:number,text:string}|null), right:({no:number,text:string}|null)}>}
+ *   [] si no hay cambios.
+ */
+export function diffRows(oldText, newText, { context = 3, maxRows = 400 } = {}) {
+  const ops = computeOps(splitLines(oldText), splitLines(newText));
+  const changes = ops.map((o, idx) => (o.t === 'eq' ? -1 : idx)).filter((idx) => idx >= 0);
+  if (!changes.length) return [];
+
+  const keep = new Array(ops.length).fill(false);
+  for (const idx of changes) {
+    for (let j = Math.max(0, idx - context); j <= Math.min(ops.length - 1, idx + context); j++) keep[j] = true;
+  }
+
+  const rows = [];
+  let oldNo = 1;
+  let newNo = 1;
+  let pending = [];
+  let skipped = false;
+
+  const flush = () => {
+    const dels = pending.filter((p) => p.t === 'del');
+    const adds = pending.filter((p) => p.t === 'add');
+    const total = Math.max(dels.length, adds.length);
+    for (let i = 0; i < total; i++) {
+      const d = dels[i] ?? null;
+      const a = adds[i] ?? null;
+      rows.push({
+        type: d && a ? 'mod' : d ? 'del' : 'add',
+        left: d ? { no: d.no, text: d.line } : null,
+        right: a ? { no: a.no, text: a.line } : null,
+      });
+    }
+    pending = [];
+  };
+
+  for (let idx = 0; idx < ops.length; idx++) {
+    const op = ops[idx];
+    if (op.t === 'eq') {
+      flush();
+      if (keep[idx]) {
+        rows.push({ type: 'ctx', left: { no: oldNo, text: op.line }, right: { no: newNo, text: op.line } });
+        skipped = false;
+      } else if (!skipped) {
+        rows.push({ type: 'skip', left: null, right: null });
+        skipped = true;
+      }
+      oldNo++;
+      newNo++;
+    } else if (op.t === 'del') {
+      pending.push({ t: 'del', line: op.line, no: oldNo++ });
+    } else {
+      pending.push({ t: 'add', line: op.line, no: newNo++ });
+    }
+  }
+  flush();
+
+  if (rows.length > maxRows) {
+    return rows.slice(0, maxRows).concat({ type: 'skip', left: null, right: null });
+  }
+  return rows;
+}

package/harness/packages/core/test/diff.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { diffLines } from '../src/index.js';
+import { diffLines, diffRows } from '../src/index.js';
 
 test('diffLines reports added and removed lines with context', () => {
   const diff = diffLines('a\nb\nc\n', 'a\nB\nc\n');
@@ -18,3 +18,26 @@ test('diffLines marks a new file as additions', () => {
   assert.match(diff, /^\+ l1$/m);
   assert.match(diff, /^\+ l2$/m);
 });
+
+test('diffRows pairs a removed and an added line side by side', () => {
+  const rows = diffRows('a\nb\nc\n', 'a\nB\nc\n');
+  const mod = rows.find((r) => r.type === 'mod');
+  assert.equal(mod.left.text, 'b');
+  assert.equal(mod.left.no, 2);
+  assert.equal(mod.right.text, 'B');
+  assert.equal(mod.right.no, 2);
+  assert.ok(rows.some((r) => r.type === 'ctx' && r.left.no === 1 && r.right.no === 1));
+});
+
+test('diffRows numbers additions for a new file', () => {
+  const rows = diffRows('', 'l1\nl2\n');
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].type, 'add');
+  assert.equal(rows[0].left, null);
+  assert.equal(rows[0].right.text, 'l1');
+  assert.equal(rows[1].right.no, 2);
+});
+
+test('diffRows returns an empty list when there are no changes', () => {
+  assert.deepEqual(diffRows('x\ny\n', 'x\ny\n'), []);
+});