@danieltmn/tamnora 0.1.0

package/harness/packages/core/src/storage/sqlite.js

@@ -0,0 +1,453 @@
+import { DatabaseSync } from 'node:sqlite';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+
+function likePattern(query) {
+  return `%${String(query).replace(/[\\%_]/g, (ch) => `\\${ch}`)}%`;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  title TEXT,
+  provider TEXT,
+  model TEXT,
+  cwd TEXT,
+  created_at INTEGER,
+  updated_at INTEGER,
+  meta TEXT
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT,
+  tool_calls TEXT,
+  tool_call_id TEXT,
+  name TEXT,
+  tokens_in INTEGER,
+  tokens_out INTEGER,
+  created_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id, created_at);
+
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY,
+  dataset TEXT,
+  config TEXT,
+  status TEXT,
+  created_at INTEGER,
+  finished_at INTEGER,
+  summary TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_runs_created ON runs(created_at);
+
+CREATE TABLE IF NOT EXISTS run_results (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  task_id TEXT,
+  model TEXT,
+  trial INTEGER,
+  output TEXT,
+  score REAL,
+  passed INTEGER,
+  trace TEXT,
+  duration_ms INTEGER,
+  tokens_in INTEGER,
+  tokens_out INTEGER,
+  cost REAL,
+  artifacts_dir TEXT,
+  created_at INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_results_run ON run_results(run_id);
+
+CREATE TABLE IF NOT EXISTS mcp_servers (
+  id TEXT PRIMARY KEY,
+  name TEXT,
+  transport TEXT,
+  command TEXT,
+  url TEXT,
+  enabled INTEGER,
+  config TEXT
+);
+
+CREATE TABLE IF NOT EXISTS providers (
+  id TEXT PRIMARY KEY,
+  label TEXT,
+  base_url TEXT,
+  api_key TEXT,
+  models TEXT,
+  requires_key INTEGER,
+  custom INTEGER,
+  enabled INTEGER,
+  updated_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT
+);
+`;
+
+/** Open (creating if needed) a SQLite database with the harness schema. */
+export function openDatabase(file) {
+  if (file && file !== ':memory:') {
+    mkdirSync(path.dirname(file), { recursive: true });
+  }
+  const db = new DatabaseSync(file ?? ':memory:');
+  db.exec('PRAGMA journal_mode = WAL;');
+  db.exec(SCHEMA);
+  return db;
+}
+
+const now = () => Date.now();
+const json = (value) => (value === undefined || value === null ? null : JSON.stringify(value));
+const parseJson = (value) => {
+  if (value === null || value === undefined) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+};
+
+/** Thin data-access layer over the SQLite database. */
+export class Store {
+  constructor(file) {
+    this.db = openDatabase(file);
+  }
+
+  close() {
+    this.db.close();
+  }
+
+  // --- Sessions -----------------------------------------------------------
+
+  createSession({ title = 'Nueva sesión', provider, model, cwd, meta } = {}) {
+    const id = randomUUID();
+    const ts = now();
+    this.db
+      .prepare(
+        `INSERT INTO sessions (id, title, provider, model, cwd, created_at, updated_at, meta)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, title, provider ?? null, model ?? null, cwd ?? null, ts, ts, json(meta));
+    return id;
+  }
+
+  touchSession(id, { provider, model, title, meta } = {}) {
+    const session = this.getSession(id);
+    if (!session) return;
+    const mergedMeta = meta === undefined ? session.meta : { ...(session.meta ?? {}), ...meta };
+    this.db
+      .prepare(`UPDATE sessions SET updated_at = ?, provider = ?, model = ?, title = ?, meta = ? WHERE id = ?`)
+      .run(
+        now(),
+        provider ?? session.provider,
+        model ?? session.model,
+        title ?? session.title,
+        json(mergedMeta),
+        id
+      );
+  }
+
+  clearMessages(sessionId) {
+    this.db.prepare(`DELETE FROM messages WHERE session_id = ?`).run(sessionId);
+  }
+
+  /** Borra desde `messageId` (incluido) hasta el final. Devuelve cuantos borro. */
+  deleteMessagesFrom(sessionId, messageId) {
+    const row = this.db
+      .prepare(`SELECT rowid FROM messages WHERE id = ? AND session_id = ?`)
+      .get(messageId, sessionId);
+    if (!row) return 0;
+    const info = this.db.prepare(`DELETE FROM messages WHERE session_id = ? AND rowid >= ?`).run(sessionId, row.rowid);
+    return info.changes;
+  }
+
+  sessionTokens(sessionId) {
+    const row = this.db
+      .prepare(
+        `SELECT COALESCE(SUM(tokens_in), 0) AS input_tokens, COALESCE(SUM(tokens_out), 0) AS output_tokens
+         FROM messages WHERE session_id = ?`
+      )
+      .get(sessionId);
+    return { in: row.input_tokens, out: row.output_tokens };
+  }
+
+  getSession(id) {
+    const row = this.db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
+    if (!row) return null;
+    return { ...row, meta: parseJson(row.meta) };
+  }
+
+  listSessions(limit = 20) {
+    return this.db
+      .prepare(`SELECT * FROM sessions ORDER BY updated_at DESC LIMIT ?`)
+      .all(limit)
+      .map((row) => ({ ...row, meta: parseJson(row.meta) }));
+  }
+
+  latestSession() {
+    return this.listSessions(1)[0] ?? null;
+  }
+
+  searchSessions(query, limit = 20) {
+    const like = likePattern(query);
+    return this.db
+      .prepare(`SELECT * FROM sessions WHERE title LIKE ? ESCAPE '\\' ORDER BY updated_at DESC LIMIT ?`)
+      .all(like, limit)
+      .map((row) => ({ ...row, meta: parseJson(row.meta) }));
+  }
+
+  searchMessages(query, limit = 30) {
+    const like = likePattern(query);
+    return this.db
+      .prepare(
+        `SELECT m.id, m.session_id, m.role, m.content, m.created_at, s.title, s.cwd
+         FROM messages m JOIN sessions s ON s.id = m.session_id
+         WHERE m.content LIKE ? ESCAPE '\\'
+         ORDER BY m.created_at DESC LIMIT ?`
+      )
+      .all(like, limit)
+      .map((row) => ({
+        id: row.id,
+        sessionId: row.session_id,
+        role: row.role,
+        content: parseJson(row.content),
+        title: row.title,
+        cwd: row.cwd,
+      }));
+  }
+
+  deleteSession(id) {
+    this.db.prepare(`DELETE FROM messages WHERE session_id = ?`).run(id);
+    this.db.prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
+  }
+
+  // --- Messages -----------------------------------------------------------
+
+  addMessage(sessionId, message) {
+    const id = randomUUID();
+    this.db
+      .prepare(
+        `INSERT INTO messages (id, session_id, role, content, tool_calls, tool_call_id, name, tokens_in, tokens_out, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        sessionId,
+        message.role,
+        json(message.content),
+        json(message.tool_calls),
+        message.tool_call_id ?? null,
+        message.name ?? null,
+        message.tokens_in ?? null,
+        message.tokens_out ?? null,
+        now()
+      );
+    return id;
+  }
+
+  addMessages(sessionId, messages) {
+    for (const message of messages) this.addMessage(sessionId, message);
+  }
+
+  getMessages(sessionId) {
+    return this.db
+      .prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC`)
+      .all(sessionId)
+      .map((row) => {
+        const message = {
+          id: row.id,
+          role: row.role,
+          content: parseJson(row.content),
+        };
+        if (row.tool_calls) message.tool_calls = parseJson(row.tool_calls);
+        if (row.tool_call_id) message.tool_call_id = row.tool_call_id;
+        if (row.name) message.name = row.name;
+        return message;
+      });
+  }
+
+  // --- Runs (evaluation) --------------------------------------------------
+
+  createRun({ dataset, config } = {}) {
+    const id = randomUUID();
+    this.db
+      .prepare(`INSERT INTO runs (id, dataset, config, status, created_at) VALUES (?, ?, ?, ?, ?)`)
+      .run(id, dataset ?? null, json(config), 'running', now());
+    return id;
+  }
+
+  finishRun(id, { status = 'done', summary } = {}) {
+    this.db
+      .prepare(`UPDATE runs SET status = ?, finished_at = ?, summary = ? WHERE id = ?`)
+      .run(status, now(), json(summary), id);
+  }
+
+  getRun(id) {
+    const row = this.db.prepare(`SELECT * FROM runs WHERE id = ?`).get(id);
+    if (!row) return null;
+    return { ...row, config: parseJson(row.config), summary: parseJson(row.summary) };
+  }
+
+  listRuns(limit = 20) {
+    return this.db
+      .prepare(`SELECT * FROM runs ORDER BY created_at DESC LIMIT ?`)
+      .all(limit)
+      .map((row) => ({ ...row, config: parseJson(row.config), summary: parseJson(row.summary) }));
+  }
+
+  addRunResult(result) {
+    const id = randomUUID();
+    this.db
+      .prepare(
+        `INSERT INTO run_results
+         (id, run_id, task_id, model, trial, output, score, passed, trace, duration_ms,
+          tokens_in, tokens_out, cost, artifacts_dir, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        result.runId,
+        result.taskId ?? null,
+        result.model ?? null,
+        result.trial ?? 0,
+        result.output ?? null,
+        result.score ?? null,
+        result.passed ? 1 : 0,
+        json(result.trace),
+        result.durationMs ?? null,
+        result.tokensIn ?? null,
+        result.tokensOut ?? null,
+        result.cost ?? null,
+        result.artifactsDir ?? null,
+        now()
+      );
+    return id;
+  }
+
+  getRunResults(runId) {
+    return this.db
+      .prepare(`SELECT * FROM run_results WHERE run_id = ? ORDER BY created_at ASC`)
+      .all(runId)
+      .map((row) => ({ ...row, trace: parseJson(row.trace) }));
+  }
+
+  // --- MCP servers --------------------------------------------------------
+
+  listMcpServers() {
+    return this.db
+      .prepare(`SELECT * FROM mcp_servers ORDER BY name ASC`)
+      .all()
+      .map((row) => ({ ...row, enabled: Boolean(row.enabled), config: parseJson(row.config) }));
+  }
+
+  saveMcpServer(server) {
+    this.db
+      .prepare(
+        `INSERT INTO mcp_servers (id, name, transport, command, url, enabled, config)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name, transport = excluded.transport, command = excluded.command,
+           url = excluded.url, enabled = excluded.enabled, config = excluded.config`
+      )
+      .run(
+        server.id,
+        server.name ?? server.id,
+        server.transport ?? 'http',
+        server.command ?? null,
+        server.url ?? null,
+        server.enabled === false ? 0 : 1,
+        json(server.config)
+      );
+  }
+
+  deleteMcpServer(id) {
+    this.db.prepare(`DELETE FROM mcp_servers WHERE id = ?`).run(id);
+  }
+
+  // --- Providers ----------------------------------------------------------
+
+  listProviders() {
+    return this.db
+      .prepare(`SELECT * FROM providers ORDER BY id ASC`)
+      .all()
+      .map(toProvider);
+  }
+
+  getProvider(id) {
+    const row = this.db.prepare(`SELECT * FROM providers WHERE id = ?`).get(id);
+    return row ? toProvider(row) : null;
+  }
+
+  saveProvider(provider) {
+    this.db
+      .prepare(
+        `INSERT INTO providers (id, label, base_url, api_key, models, requires_key, custom, enabled, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           label = excluded.label, base_url = excluded.base_url, api_key = excluded.api_key,
+           models = excluded.models, requires_key = excluded.requires_key,
+           custom = excluded.custom, enabled = excluded.enabled, updated_at = excluded.updated_at`
+      )
+      .run(
+        provider.id,
+        provider.label ?? provider.id,
+        provider.baseUrl ?? null,
+        provider.apiKey ?? null,
+        json(provider.models ?? []),
+        provider.requiresKey === undefined ? null : provider.requiresKey ? 1 : 0,
+        provider.custom ? 1 : 0,
+        provider.enabled === false ? 0 : 1,
+        now()
+      );
+    return this.getProvider(provider.id);
+  }
+
+  deleteProvider(id) {
+    this.db.prepare(`DELETE FROM providers WHERE id = ?`).run(id);
+  }
+
+  // --- Settings (key/value) ----------------------------------------------
+
+  getSetting(key, fallback = null) {
+    const row = this.db.prepare(`SELECT value FROM settings WHERE key = ?`).get(key);
+    return row ? parseJson(row.value) : fallback;
+  }
+
+  setSetting(key, value) {
+    this.db
+      .prepare(
+        `INSERT INTO settings (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+      )
+      .run(key, json(value));
+    return value;
+  }
+
+  allSettings() {
+    const out = {};
+    for (const row of this.db.prepare(`SELECT key, value FROM settings`).all()) {
+      out[row.key] = parseJson(row.value);
+    }
+    return out;
+  }
+}
+
+function toProvider(row) {
+  return {
+    id: row.id,
+    label: row.label ?? row.id,
+    baseUrl: row.base_url ?? '',
+    apiKey: row.api_key ?? '',
+    models: parseJson(row.models) ?? [],
+    requiresKey: row.requires_key === null ? undefined : Boolean(row.requires_key),
+    custom: Boolean(row.custom),
+    enabled: row.enabled === 0 ? false : true,
+    updatedAt: row.updated_at ?? null,
+  };
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Diff de lineas minimo (sin dependencias) para mostrar que cambio write/edit.
+ * Produce lineas con prefijo ' ' / '-' / '+', con contexto y truncado.
+ */
+
+const MAX_CELLS = 1_500_000;
+
+function splitLines(text) {
+  if (text === '' || text == null) return [];
+  return String(text).replace(/\r\n/g, '\n').split('\n');
+}
+
+function computeOps(a, b) {
+  const n = a.length;
+  const m = b.length;
+  if (n === 0) return b.map((line) => ({ t: 'add', line }));
+  if (m === 0) return a.map((line) => ({ t: 'del', line }));
+  if (n * m > MAX_CELLS) {
+    return [
+      ...a.map((line) => ({ t: 'del', line })),
+      ...b.map((line) => ({ t: 'add', line })),
+    ];
+  }
+
+  const dp = new Uint32Array((n + 1) * (m + 1));
+  const at = (i, j) => i * (m + 1) + j;
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[at(i, j)] =
+        a[i] === b[j] ? dp[at(i + 1, j + 1)] + 1 : Math.max(dp[at(i + 1, j)], dp[at(i, j + 1)]);
+    }
+  }
+
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ t: 'eq', line: a[i] });
+      i++;
+      j++;
+    } else if (dp[at(i + 1, j)] >= dp[at(i, j + 1)]) {
+      ops.push({ t: 'del', line: a[i] });
+      i++;
+    } else {
+      ops.push({ t: 'add', line: b[j] });
+      j++;
+    }
+  }
+  while (i < n) ops.push({ t: 'del', line: a[i++] });
+  while (j < m) ops.push({ t: 'add', line: b[j++] });
+  return ops;
+}
+
+/**
+ * @returns {string} diff con prefijos, o '' si no hay cambios; '(diff truncado)'
+ *   al final si se corto por tamano.
+ */
+export function diffLines(oldText, newText, { context = 3, maxLines = 200 } = {}) {
+  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 out = [];
+  let skipped = false;
+  let truncated = false;
+  for (let idx = 0; idx < ops.length; idx++) {
+    if (!keep[idx]) {
+      skipped = true;
+      continue;
+    }
+    if (skipped) {
+      out.push('  …');
+      skipped = false;
+    }
+    const prefix = ops[idx].t === 'add' ? '+' : ops[idx].t === 'del' ? '-' : ' ';
+    out.push(`${prefix} ${ops[idx].line}`);
+    if (out.length >= maxLines) {
+      truncated = true;
+      break;
+    }
+  }
+  if (truncated) out.push('  … (diff truncado)');
+  return out.join('\n');
+}