@danieltmn/tamnora 0.24.2 → 0.25.1

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

@@ -0,0 +1,58 @@
+// Esfuerzo de razonamiento: un vocabulario comun que cada adaptador traduce al
+// parametro de su proveedor. `''` significa "sin override" (default del modelo).
+
+export const EFFORT_LEVELS = ['off', 'low', 'medium', 'high', 'max'];
+
+export const EFFORT_LABELS = {
+  off: 'Sin razonamiento',
+  low: 'Bajo',
+  medium: 'Medio',
+  high: 'Alto',
+  max: 'Máximo',
+};
+
+const ALIASES = {
+  none: 'off',
+  minimal: 'low',
+  medium: 'medium',
+  xhigh: 'max',
+  ultra: 'max',
+};
+
+/** Normaliza lo que manda el usuario/proveedor al vocabulario comun. */
+export function normalizeEffort(value) {
+  if (value === null || value === undefined) return '';
+  const raw = String(value).trim().toLowerCase();
+  if (!raw || raw === 'auto' || raw === 'default') return '';
+  const level = ALIASES[raw] ?? raw;
+  return EFFORT_LEVELS.includes(level) ? level : '';
+}
+
+/**
+ * Agrega al body del request el parametro de esfuerzo que entiende el
+ * proveedor. Los adaptadores que no lo soportan (`reasoning: 'none'`) no
+ * reciben nada, asi un modelo sin razonamiento no rompe con un 400.
+ */
+export function applyReasoningEffort(body, effort, provider = {}) {
+  const level = normalizeEffort(effort);
+  if (!level) return body;
+  const mode = provider?.reasoning ?? 'none';
+
+  if (mode === 'think') {
+    // Ollama: `think` acepta boolean o (en versiones nuevas) un nivel.
+    body.think = level === 'off' ? false : level;
+    return body;
+  }
+
+  if (mode === 'effort' || mode === 'openai' || mode === 'deepseek') {
+    // OpenAI solo llega hasta high; DeepSeek y OpenRouter aceptan max.
+    const effortValue = level === 'max' && mode === 'openai' ? 'high' : level === 'off' ? 'none' : level;
+    body.reasoning_effort = effortValue;
+    if (mode === 'deepseek') {
+      body.thinking = { type: level === 'off' ? 'disabled' : 'enabled' };
+    }
+    return body;
+  }
+
+  return body;
+}

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

@@ -0,0 +1,111 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  AGENT_FILE,
+  parseAgentMarkdown,
+  loadAgents,
+  mergeAgents,
+  buildAgentsIndex,
+  buildSubagentPrompt,
+  writeAgentFile,
+} from '../src/agents/index.js';
+
+test('parseAgentMarkdown reads frontmatter, lists and the body', () => {
+  const parsed = parseAgentMarkdown(
+    '---\nname: Revisor\ndescription: Busca bugs\nmodel: claude\nprovider: anthropic\nmode: plan\neffort: high\nmaxRounds: 4\ntools: read, grep\nskills: [code-review, tests]\n---\n\n# Rol\nMirá el diff.',
+    'revisor'
+  );
+  assert.equal(parsed.id, 'revisor');
+  assert.equal(parsed.name, 'Revisor');
+  assert.equal(parsed.description, 'Busca bugs');
+  assert.equal(parsed.model, 'claude');
+  assert.equal(parsed.provider, 'anthropic');
+  assert.equal(parsed.mode, 'plan');
+  assert.equal(parsed.effort, 'high');
+  assert.equal(parsed.maxRounds, 4);
+  assert.deepEqual(parsed.tools, ['read', 'grep']);
+  assert.deepEqual(parsed.skills, ['code-review', 'tests']);
+  assert.match(parsed.body, /Mirá el diff/);
+
+  const plain = parseAgentMarkdown('Solo cuerpo.', 'x');
+  assert.equal(plain.name, 'x');
+  assert.equal(plain.tools, null);
+  assert.equal(plain.skills, null);
+  assert.equal(plain.body, 'Solo cuerpo.');
+});
+
+test('loadAgents scans directories and standalone .md files', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-'));
+  await mkdir(path.join(root, 'revisor'));
+  await writeFile(path.join(root, 'revisor', AGENT_FILE), '---\nname: Revisor\n---\nCuerpo.');
+  await writeFile(path.join(root, 'tests.md'), '---\nname: Tests\n---\nCuerpo tests.');
+  await writeFile(path.join(root, 'ignorado.txt'), 'no es un agente');
+
+  const agents = loadAgents(root);
+  assert.deepEqual(
+    agents.map((agent) => agent.id),
+    ['revisor', 'tests']
+  );
+  assert.equal(agents.find((agent) => agent.id === 'revisor').name, 'Revisor');
+  assert.equal(loadAgents(path.join(root, 'nope')).length, 0);
+});
+
+test('mergeAgents lets the workspace override the casa agent', async () => {
+  const home = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-home-'));
+  const workspace = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-ws-'));
+  await mkdir(path.join(home, 'demo'));
+  await writeFile(path.join(home, 'demo', AGENT_FILE), '---\nname: Demo casa\n---\nCasa.');
+  await mkdir(path.join(workspace, 'demo'));
+  await writeFile(path.join(workspace, 'demo', AGENT_FILE), '---\nname: Demo workspace\n---\nWorkspace.');
+
+  const merged = mergeAgents([loadAgents(home), loadAgents(workspace)]);
+  assert.equal(merged.length, 1);
+  assert.equal(merged[0].name, 'Demo workspace');
+});
+
+test('buildAgentsIndex catalogs subagents and buildSubagentPrompt includes instructions', () => {
+  assert.equal(buildAgentsIndex([]), '');
+  const index = buildAgentsIndex([
+    { id: 'revisor', name: 'Revisor', description: 'Busca bugs' },
+    { id: 'docs', name: 'Docs' },
+  ]);
+  assert.match(index, /task\(\{ agent: "<id>"/);
+  assert.match(index, /revisor: Revisor — Busca bugs/);
+  assert.match(index, /docs: Docs/);
+
+  const prompt = buildSubagentPrompt({ id: 'revisor', name: 'Revisor', description: 'Busca bugs', body: 'Mirá el diff.' }, { basePrompt: 'BASE' });
+  assert.match(prompt, /BASE/);
+  assert.match(prompt, /subagente "Revisor"/);
+  assert.match(prompt, /Mirá el diff\./);
+});
+
+test('writeAgentFile round-trips through parseAgentMarkdown', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-agents-write-'));
+  await writeAgentFile(path.join(root, 'revisor'), {
+    id: 'revisor',
+    name: 'Revisor',
+    description: 'Busca bugs',
+    model: 'gpt',
+    provider: 'openai',
+    mode: 'plan',
+    effort: 'low',
+    maxRounds: 3,
+    tools: ['read'],
+    skills: null,
+    body: '# Rol\nMirá el diff.',
+  });
+  const text = await readFile(path.join(root, 'revisor', AGENT_FILE), 'utf8');
+  const parsed = parseAgentMarkdown(text, 'revisor');
+  assert.equal(parsed.name, 'Revisor');
+  assert.equal(parsed.effort, 'low');
+  assert.equal(parsed.maxRounds, 3);
+  assert.deepEqual(parsed.tools, ['read']);
+  assert.equal(parsed.skills, null);
+  assert.match(parsed.body, /Mirá el diff/);
+
+  await assert.rejects(() => writeAgentFile(path.join(root, '..'), { id: '../escape', body: 'x' }), /inválido/);
+});

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

@@ -0,0 +1,43 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { normalizeEffort, applyReasoningEffort, EFFORT_LEVELS } from '../src/providers/reasoning.js';
+
+test('normalizeEffort accepts the common vocabulary and aliases', () => {
+  for (const level of EFFORT_LEVELS) assert.equal(normalizeEffort(level), level);
+  assert.equal(normalizeEffort(' HIGH '), 'high');
+  assert.equal(normalizeEffort('none'), 'off');
+  assert.equal(normalizeEffort('minimal'), 'low');
+  assert.equal(normalizeEffort('xhigh'), 'max');
+  assert.equal(normalizeEffort('ultra'), 'max');
+  assert.equal(normalizeEffort('auto'), '');
+  assert.equal(normalizeEffort(''), '');
+  assert.equal(normalizeEffort(null), '');
+  assert.equal(normalizeEffort('inventado'), '');
+});
+
+test('applyReasoningEffort maps the level to each provider shape', () => {
+  const deepseek = applyReasoningEffort({}, 'high', { reasoning: 'deepseek' });
+  assert.equal(deepseek.reasoning_effort, 'high');
+  assert.deepEqual(deepseek.thinking, { type: 'enabled' });
+
+  const off = applyReasoningEffort({}, 'off', { reasoning: 'deepseek' });
+  assert.equal(off.reasoning_effort, 'none');
+  assert.deepEqual(off.thinking, { type: 'disabled' });
+
+  const openai = applyReasoningEffort({}, 'max', { reasoning: 'openai' });
+  assert.equal(openai.reasoning_effort, 'high', 'OpenAI no llega a max');
+
+  const openrouter = applyReasoningEffort({}, 'max', { reasoning: 'effort' });
+  assert.equal(openrouter.reasoning_effort, 'max');
+
+  const ollama = applyReasoningEffort({}, 'low', { reasoning: 'think' });
+  assert.equal(ollama.think, 'low');
+  const ollamaOff = applyReasoningEffort({}, 'off', { reasoning: 'think' });
+  assert.equal(ollamaOff.think, false);
+});
+
+test('applyReasoningEffort leaves unsupported providers untouched', () => {
+  assert.deepEqual(applyReasoningEffort({ model: 'x' }, 'high', { reasoning: 'none' }), { model: 'x' });
+  assert.deepEqual(applyReasoningEffort({ model: 'x' }, 'high', {}), { model: 'x' });
+  assert.deepEqual(applyReasoningEffort({ model: 'x' }, '', { reasoning: 'effort' }), { model: 'x' });
+});