@danieltmn/tamnora 0.1.0

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

@@ -0,0 +1,237 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { runAgent, parseToolArguments } from '../src/agent/runAgent.js';
+import { createTools } from '../src/tools/index.js';
+
+test('agent executes tool calls then returns the final answer', async () => {
+  const events = [];
+  const provider = {
+    id: 'mock',
+    async streamChat(_config, { messages }) {
+      const toolRounds = messages.filter((m) => m.role === 'tool').length;
+      if (toolRounds === 0) {
+        return {
+          content: 'pensando',
+          reasoning: '',
+          toolCalls: [
+            { id: 'c1', type: 'function', function: { name: 'calculate', arguments: '{"a":1}' } },
+          ],
+        };
+      }
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'mock-model',
+    messages: [
+      { role: 'system', content: 's' },
+      { role: 'user', content: 'u' },
+    ],
+    tools: [{ type: 'function', function: { name: 'calculate', parameters: {} } }],
+    execute: async (name, args) => {
+      assert.equal(name, 'calculate');
+      assert.deepEqual(args, { a: 1 });
+      return 'result';
+    },
+    onEvent: (e) => events.push(e.type),
+  });
+
+  assert.equal(result.content, 'listo');
+  assert.equal(result.rounds, 2);
+  assert.equal(result.stopReason, 'end_turn');
+  assert.ok(events.includes('tool_call'));
+  assert.ok(events.includes('tool_result'));
+  assert.equal(result.messages.at(-2).role, 'tool');
+  assert.equal(result.messages.at(-1).role, 'assistant');
+  assert.equal(result.messages.at(-1).content, 'listo');
+});
+
+test('agent stops at maxRounds when the model keeps calling tools', async () => {
+  const provider = {
+    async streamChat() {
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [{ id: 'x', type: 'function', function: { name: 'noop', arguments: '{}' } }],
+      };
+    },
+  };
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    execute: async () => 'ok',
+    maxRounds: 3,
+  });
+  assert.equal(result.stopReason, 'max_rounds');
+  assert.equal(result.rounds, 3);
+});
+
+test('parseToolArguments handles objects, malformed JSON and garbage', () => {
+  assert.deepEqual(parseToolArguments({ function: { arguments: { a: 1 } } }), { a: 1 });
+  assert.deepEqual(parseToolArguments({ function: { arguments: '{"b":2,}' } }), { b: 2 });
+  assert.deepEqual(parseToolArguments({ function: { arguments: 'nope' } }), {});
+});
+
+test('agent writes a file through the local "write" tool', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-agent-'));
+  const { definitions, execute } = createTools({ root, permissions: { write: 'allow' } });
+
+  let round = 0;
+  const provider = {
+    async streamChat() {
+      round++;
+      if (round === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            {
+              id: 'c1',
+              type: 'function',
+              function: {
+                name: 'write',
+                arguments: JSON.stringify({ path: 'out.txt', content: 'hola' }),
+              },
+            },
+          ],
+        };
+      }
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'creá out.txt' }],
+    tools: definitions,
+    execute,
+  });
+
+  assert.equal(result.content, 'listo');
+  assert.equal(await readFile(path.join(root, 'out.txt'), 'utf8'), 'hola');
+});
+
+test('stall watchdog warns once when the model emits nothing', async () => {
+  const events = [];
+  const provider = {
+    async streamChat() {
+      await new Promise((resolve) => setTimeout(resolve, 120));
+      return { content: 'tarde', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    onEvent: (e) => events.push(e),
+    stallWarnMs: 30,
+  });
+
+  const stalls = events.filter((e) => e.type === 'stall');
+  assert.equal(stalls.length, 1);
+  assert.equal(stalls[0].seconds, 1);
+});
+
+test('stall watchdog stays quiet while the model streams', async () => {
+  const events = [];
+  const provider = {
+    async streamChat(_config, { onEvent }) {
+      for (let i = 0; i < 6; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        onEvent?.({ type: 'text', delta: 'a', full: 'a'.repeat(i + 1) });
+      }
+      return { content: 'aaaaaa', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    onEvent: (e) => events.push(e),
+    // Margen amplio a proposito: el watchdog compara contra Date.now(), asi que un
+    // stallWarnMs pegado al intervalo de 20ms dispara por jitter del event loop.
+    stallWarnMs: 100,
+  });
+
+  assert.equal(events.filter((e) => e.type === 'stall').length, 0);
+});
+
+test('stall watchdog is disabled with stallWarnMs 0', async () => {
+  const events = [];
+  const provider = {
+    async streamChat() {
+      await new Promise((resolve) => setTimeout(resolve, 80));
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    onEvent: (e) => events.push(e),
+    stallWarnMs: 0,
+  });
+
+  assert.equal(events.filter((e) => e.type === 'stall').length, 0);
+});
+
+test('agent aggregates usage and stamps tokens on assistant messages', async () => {
+  let round = 0;
+  const provider = {
+    async streamChat() {
+      round++;
+      if (round === 1) {
+        return {
+          content: 'pensando',
+          reasoning: '',
+          toolCalls: [{ id: 'c1', type: 'function', function: { name: 'noop', arguments: '{}' } }],
+          usage: { prompt_tokens: 10, completion_tokens: 2, total_tokens: 12 },
+        };
+      }
+      return {
+        content: 'listo',
+        reasoning: '',
+        toolCalls: [],
+        usage: { prompt_tokens: 20, completion_tokens: 5, total_tokens: 25 },
+      };
+    },
+  };
+
+  const result = await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    execute: async () => 'ok',
+  });
+
+  assert.deepEqual(result.usage, {
+    prompt_tokens: 30,
+    completion_tokens: 7,
+    total_tokens: 37,
+    last_prompt_tokens: 20,
+    last_completion_tokens: 5,
+  });
+
+  const assistants = result.messages.filter((m) => m.role === 'assistant');
+  assert.equal(assistants[0].tokens_in, 10);
+  assert.equal(assistants[0].tokens_out, 2);
+  assert.equal(assistants[1].tokens_in, 20);
+  assert.equal(assistants[1].tokens_out, 5);
+});

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

@@ -0,0 +1,33 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { loadConfig, loadInstructions, DEFAULT_CONFIG } from '../src/config/index.js';
+import { resolveProviderRuntime, getProvider } from '../src/providers/index.js';
+
+test('loadConfig returns defaults when tamnora.json is absent', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-'));
+  const config = await loadConfig(dir);
+  assert.equal(config.provider, DEFAULT_CONFIG.provider);
+  assert.equal(config.maxRounds, DEFAULT_CONFIG.maxRounds);
+});
+
+test('loadConfig merges tamnora.json and loadInstructions reads AGENTS.md', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-'));
+  await writeFile(path.join(dir, 'tamnora.json'), JSON.stringify({ model: 'x', maxRounds: 3 }));
+  await writeFile(path.join(dir, 'AGENTS.md'), '# Instrucciones\nHacé esto.');
+  const config = await loadConfig(dir);
+  assert.equal(config.model, 'x');
+  assert.equal(config.maxRounds, 3);
+  const instructions = await loadInstructions(dir, config.instructions);
+  assert.match(instructions, /Instrucciones/);
+});
+
+test('provider presets resolve their base URL', () => {
+  assert.equal(getProvider('deepseek').defaultBaseUrl, 'https://api.deepseek.com/v1');
+  const { provider, config } = resolveProviderRuntime({ providerId: 'deepseek', apiKey: 'k' });
+  assert.equal(provider.id, 'deepseek');
+  assert.equal(config.baseUrl, 'https://api.deepseek.com/v1');
+  assert.equal(config.apiKey, 'k');
+});

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

@@ -0,0 +1,44 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { estimateTokens, trimContext } from '../src/index.js';
+
+test('estimateTokens approximates by characters', () => {
+  const messages = [{ role: 'user', content: 'x'.repeat(400) }];
+  assert.equal(estimateTokens(messages), 100);
+});
+
+test('trimContext is a no-op under budget', () => {
+  const messages = [{ role: 'user', content: 'hola' }];
+  const result = trimContext(messages, { maxTokens: 1000 });
+  assert.equal(result.messages, messages);
+  assert.equal(result.trimmed, 0);
+  assert.equal(result.dropped, 0);
+});
+
+test('trimContext shrinks old tool results first', () => {
+  const messages = [
+    { role: 'system', content: 'sys' },
+    { role: 'user', content: 'hola' },
+    { role: 'assistant', content: null, tool_calls: [{ id: '1', function: { name: 'read', arguments: '{}' } }] },
+    { role: 'tool', tool_call_id: '1', name: 'read', content: 'y'.repeat(20000) },
+    { role: 'user', content: 'ultima' },
+  ];
+  const result = trimContext(messages, { maxTokens: 500, keepLast: 1 });
+  assert.ok(result.trimmed >= 1);
+  assert.ok(estimateTokens(result.messages) < estimateTokens(messages));
+  // el historial original no se muta
+  assert.equal(messages[3].content.length, 20000);
+});
+
+test('trimContext drops oldest groups but keeps the system and the tail', () => {
+  const messages = [{ role: 'system', content: 's' }];
+  for (let i = 0; i < 20; i++) {
+    messages.push({ role: 'user', content: `u${i} ${'a'.repeat(400)}` });
+    messages.push({ role: 'assistant', content: `a${i} ${'b'.repeat(400)}` });
+  }
+  const result = trimContext(messages, { maxTokens: 300, keepLast: 4 });
+  assert.ok(result.dropped > 0);
+  assert.equal(result.messages[0].content, 's');
+  assert.ok(result.messages.length <= messages.length);
+  assert.ok(result.messages.length > 4);
+});

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

@@ -0,0 +1,20 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { diffLines } from '../src/index.js';
+
+test('diffLines reports added and removed lines with context', () => {
+  const diff = diffLines('a\nb\nc\n', 'a\nB\nc\n');
+  assert.match(diff, /^- b$/m);
+  assert.match(diff, /^\+ B$/m);
+  assert.match(diff, /^ {2}a$/m);
+});
+
+test('diffLines returns empty when there are no changes', () => {
+  assert.equal(diffLines('x\ny\n', 'x\ny\n'), '');
+});
+
+test('diffLines marks a new file as additions', () => {
+  const diff = diffLines('', 'l1\nl2\n');
+  assert.match(diff, /^\+ l1$/m);
+  assert.match(diff, /^\+ l2$/m);
+});

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

@@ -0,0 +1,144 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { mkdtemp, writeFile, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { normalizeExpect, createTaskWorkspace } from '../src/eval/task.js';
+import { runScorers, validateSchema } from '../src/eval/scorers.js';
+import { runDataset, extractToolCalls } from '../src/eval/runner.js';
+
+test('normalizeExpect accepts strings, objects and arrays', () => {
+  assert.deepEqual(normalizeExpect('hola'), [{ type: 'contains', value: 'hola' }]);
+  assert.deepEqual(normalizeExpect({ equals: 'x' }), [{ type: 'exact', value: 'x' }]);
+  assert.deepEqual(normalizeExpect([{ regex: 'a+' }, 'b']), [
+    { type: 'regex', pattern: 'a+' },
+    { type: 'contains', value: 'b' },
+  ]);
+  assert.deepEqual(normalizeExpect(undefined), []);
+});
+
+test('validateSchema checks types, required and properties', () => {
+  const schema = {
+    type: 'object',
+    required: ['name'],
+    properties: { name: { type: 'string' }, age: { type: 'integer' } },
+  };
+  assert.equal(validateSchema({ name: 'a', age: 3 }, schema).valid, true);
+  assert.equal(validateSchema({ age: 3 }, schema).valid, false);
+  assert.equal(validateSchema({ name: 'a', age: 'x' }, schema).valid, false);
+});
+
+test('runScorers evaluates text, tool and file scorers', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-score-'));
+  await writeFile(path.join(dir, 'out.txt'), 'contenido hola');
+
+  const task = {
+    expect: [
+      { type: 'contains', value: '4' },
+      { type: 'regex', pattern: '\\d+' },
+      { type: 'toolCalled', name: 'write', argsContains: 'out.txt' },
+      { type: 'fileExists', path: 'out.txt' },
+      { type: 'fileContains', path: 'out.txt', value: 'hola' },
+      { type: 'jsonSchema', schema: { type: 'object', required: ['ok'] } },
+    ],
+  };
+
+  const scoring = await runScorers(task, {
+    output: 'El resultado es 4: {"ok": true}',
+    toolCalls: [{ name: 'write', args: { path: 'out.txt' } }],
+    workspaceDir: dir,
+  });
+
+  assert.equal(scoring.passed, true);
+  assert.equal(scoring.score, 1);
+  assert.equal(scoring.details.length, 6);
+});
+
+test('runScorers fails when a criterion is not met', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-score-'));
+  const scoring = await runScorers(
+    { expect: { contains: 'gato' } },
+    { output: 'perro', workspaceDir: dir }
+  );
+  assert.equal(scoring.passed, false);
+  assert.equal(scoring.details[0].detail.includes('no contiene'), true);
+});
+
+test('createTaskWorkspace copies the fixture', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-fixture-'));
+  await mkdir(path.join(root, 'fixtures', 't1'), { recursive: true });
+  await writeFile(path.join(root, 'fixtures', 't1', 'seed.txt'), 'seed');
+  const ws = await createTaskWorkspace({ fixture: 'fixtures/t1' }, { rootDir: root });
+  const { readFile } = await import('node:fs/promises');
+  assert.equal(await readFile(path.join(ws.dir, 'seed.txt'), 'utf8'), 'seed');
+  await ws.cleanup();
+});
+
+test('extractToolCalls parses tool calls from messages', () => {
+  const calls = extractToolCalls([
+    { role: 'assistant', tool_calls: [{ function: { name: 'write', arguments: '{"a":1}' } }] },
+    { role: 'tool', content: 'ok' },
+  ]);
+  assert.deepEqual(calls, [{ name: 'write', args: { a: 1 } }]);
+});
+
+test('runDataset scores a task end-to-end (mock Ollama server)', async () => {
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (c) => (body += c));
+    req.on('end', () => {
+      const parsed = JSON.parse(body);
+      const hasTool = parsed.messages.some((m) => m.role === 'tool');
+      res.setHeader('Content-Type', 'application/x-ndjson');
+      if (!hasTool) {
+        res.write(
+          `${JSON.stringify({
+            message: {
+              content: '',
+              tool_calls: [{ function: { name: 'write', arguments: { path: 'x.txt', content: 'hi' } } }],
+            },
+            done: false,
+          })}\n`
+        );
+      } else {
+        res.write(`${JSON.stringify({ message: { content: 'listo' }, done: false })}\n`);
+      }
+      res.write(`${JSON.stringify({ done: true })}\n`);
+      res.end();
+    });
+  });
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  const { port } = server.address();
+
+  try {
+    const results = await runDataset({
+      tasks: [
+        {
+          id: 't1',
+          input: 'creá x.txt',
+          expect: [
+            { type: 'toolCalled', name: 'write' },
+            { type: 'fileContains', path: 'x.txt', value: 'hi' },
+            { type: 'contains', value: 'listo' },
+          ],
+        },
+      ],
+      models: ['mock'],
+      providerId: 'ollama',
+      baseUrl: `http://127.0.0.1:${port}`,
+      systemPrompt: 'test',
+      enabledTools: ['write'],
+      yes: true,
+      concurrency: 1,
+      rootDir: process.cwd(),
+    });
+
+    assert.equal(results.length, 1);
+    assert.equal(results[0].passed, true);
+    assert.equal(results[0].error, null);
+    assert.equal(results[0].trace.scorers.length, 3);
+  } finally {
+    server.close();
+  }
+});

package/harness/packages/core/test/git-tools.test.js

@@ -0,0 +1,44 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { executors } from '../src/tools/index.js';
+
+const git_tools = executors.EXECUTORS;
+
+function git(cwd, args) {
+  return execFileSync('git', args, { cwd, stdio: 'ignore', windowsHide: true });
+}
+
+test('git tools read status/log and commit', async (t) => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-git-'));
+  try {
+    git(cwd, ['init']);
+  } catch {
+    t.skip('git no disponible');
+    return;
+  }
+  git(cwd, ['config', 'user.email', 'test@tamnora.local']);
+  git(cwd, ['config', 'user.name', 'Tamnora Test']);
+  await writeFile(path.join(cwd, 'a.txt'), 'hola\n');
+
+  const status = await git_tools.git_status(cwd, {});
+  assert.match(status, /a\.txt|\?\?/);
+
+  const commit = await git_tools.git_commit(cwd, { message: 'primer commit', files: ['a.txt'] });
+  assert.match(commit, /primer commit/i);
+
+  const log = await git_tools.git_log(cwd, { limit: 5 });
+  assert.match(log, /primer commit/);
+
+  // El working tree quedo limpio tras commitear.
+  const clean = await git_tools.git_status(cwd, {});
+  assert.match(clean, /##/);
+});
+
+test('git_commit requires a message', async () => {
+  const out = await git_tools.git_commit(process.cwd(), {});
+  assert.match(out, /falta "message"/i);
+});

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

@@ -0,0 +1,62 @@
+import { test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  setHome,
+  homeDir,
+  homePath,
+  databaseFile,
+  ensureApp,
+  readApp,
+  writeApp,
+  migrateLegacyDb,
+} from '../src/index.js';
+
+const prevHome = process.env.TAMNORA_HOME;
+
+afterEach(() => {
+  setHome(null);
+  if (prevHome === undefined) delete process.env.TAMNORA_HOME;
+  else process.env.TAMNORA_HOME = prevHome;
+});
+
+test('homeDir honors TAMNORA_HOME and the setHome override', async () => {
+  const fromEnv = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
+  process.env.TAMNORA_HOME = fromEnv;
+  assert.equal(homeDir(), path.resolve(fromEnv));
+
+  const override = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
+  setHome(override);
+  assert.equal(homeDir(), path.resolve(override));
+});
+
+test('ensureApp creates app.json with a secret and roundtrips', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
+  setHome(dir);
+
+  const app = ensureApp();
+  assert.ok(app.authSecret);
+  assert.equal(app.port, 4517);
+
+  const raw = JSON.parse(await readFile(homePath('app.json'), 'utf8'));
+  assert.equal(raw.authSecret, app.authSecret);
+
+  raw.port = 4599;
+  writeApp(raw);
+  assert.equal(readApp().port, 4599);
+});
+
+test('migrateLegacyDb copies the legacy project database to the global home', async () => {
+  const home = await mkdtemp(path.join(tmpdir(), 'tamnora-home-'));
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-cwd-'));
+  setHome(home);
+
+  await mkdir(path.join(cwd, '.tamnora'), { recursive: true });
+  await writeFile(path.join(cwd, '.tamnora', 'tamnora.db'), 'legacy-db');
+
+  const target = migrateLegacyDb(cwd);
+  assert.equal(target, databaseFile());
+  assert.equal(await readFile(target, 'utf8'), 'legacy-db');
+});