@danieltmn/tamnora 0.1.0

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

@@ -0,0 +1,277 @@
+import { readFile, writeFile, mkdir, stat, readdir } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { resolveInRoot, toRel } from './paths.js';
+import { globToRegExp, walkFiles } from './glob.js';
+import { diffLines } from './diff.js';
+
+const MAX_READ_LINES = 2000;
+const MAX_LIST = 500;
+const MAX_GLOB = 500;
+const MAX_GREP = 300;
+const MAX_GREP_FILE_BYTES = 2_000_000;
+const MAX_BASH_OUTPUT = 100_000;
+
+export async function readTool(root, { path: p, offset, limit } = {}) {
+  const abs = resolveInRoot(root, p);
+  let text;
+  try {
+    text = await readFile(abs, 'utf8');
+  } catch (err) {
+    return `Error leyendo ${toRel(root, abs)}: ${err.message}`;
+  }
+  const lines = text.split('\n');
+  const start = Math.max(0, (Number(offset) || 1) - 1);
+  const count = Number.isFinite(Number(limit)) ? Number(limit) : MAX_READ_LINES;
+  const slice = lines.slice(start, start + count);
+  const numbered = slice
+    .map((line, i) => `${String(start + i + 1).padStart(5)}| ${line}`)
+    .join('\n');
+  const truncated = start + count < lines.length;
+  return (
+    `${toRel(root, abs)} (${lines.length} líneas)\n${numbered}` +
+    (truncated ? `\n[... truncado en ${start + count} de ${lines.length} líneas]` : '')
+  );
+}
+
+export async function writeTool(root, { path: p, content } = {}) {
+  const abs = resolveInRoot(root, p);
+  let previous = null;
+  try {
+    previous = await readFile(abs, 'utf8');
+  } catch {
+    previous = null;
+  }
+  try {
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeFile(abs, content ?? '', 'utf8');
+  } catch (err) {
+    return `Error escribiendo ${toRel(root, abs)}: ${err.message}`;
+  }
+  const rel = toRel(root, abs);
+  const head = previous === null
+    ? `Creado ${rel} (${Buffer.byteLength(content ?? '')} bytes)`
+    : `Escrito ${rel} (${Buffer.byteLength(content ?? '')} bytes)`;
+  const diff = diffLines(previous ?? '', content ?? '');
+  return diff ? `${head}\n${diff}` : head;
+}
+
+function countOccurrences(text, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let index = text.indexOf(needle);
+  while (index !== -1) {
+    count++;
+    index = text.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+
+export async function editTool(root, { path: p, oldString, newString, replaceAll } = {}) {
+  const abs = resolveInRoot(root, p);
+  if (!oldString) return 'Error: falta "oldString".';
+  let text;
+  try {
+    text = await readFile(abs, 'utf8');
+  } catch (err) {
+    return `Error leyendo ${toRel(root, abs)}: ${err.message}`;
+  }
+  const count = countOccurrences(text, oldString);
+  if (count === 0) return `Error: no se encontró "oldString" en ${toRel(root, abs)}.`;
+  if (count > 1 && !replaceAll) {
+    return `Error: "oldString" aparece ${count} veces en ${toRel(root, abs)}; agregá más contexto o usá replaceAll.`;
+  }
+  const updated = replaceAll
+    ? text.split(oldString).join(newString ?? '')
+    : text.replace(oldString, newString ?? '');
+  await writeFile(abs, updated, 'utf8');
+  const head = `Editado ${toRel(root, abs)}${replaceAll ? ` (${count} reemplazos)` : ''}`;
+  const diff = diffLines(text, updated);
+  return diff ? `${head}\n${diff}` : head;
+}
+
+export async function listTool(root, { path: p } = {}) {
+  const abs = resolveInRoot(root, p ?? '.');
+  let entries;
+  try {
+    entries = await readdir(abs, { withFileTypes: true });
+  } catch (err) {
+    return `Error listando ${toRel(root, abs)}: ${err.message}`;
+  }
+  const lines = entries
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .slice(0, MAX_LIST)
+    .map((e) => (e.isDirectory() ? `${e.name}/` : e.name));
+  return `Contenido de ${toRel(root, abs)}:\n${lines.join('\n') || '(vacío)'}`;
+}
+
+export async function globTool(root, { pattern, path: p } = {}) {
+  if (!pattern) return 'Error: falta "pattern".';
+  const base = resolveInRoot(root, p ?? '.');
+  const re = globToRegExp(pattern);
+  const results = [];
+  for await (const file of walkFiles(base)) {
+    const relToBase = path.relative(base, file).split(path.sep).join('/');
+    const relToRoot = toRel(root, file);
+    if (re.test(relToBase) || re.test(relToRoot)) results.push(relToRoot);
+    if (results.length >= MAX_GLOB) break;
+  }
+  results.sort((a, b) => a.localeCompare(b));
+  return results.length ? results.join('\n') : 'Sin coincidencias';
+}
+
+export async function grepTool(root, { pattern, include, path: p } = {}) {
+  if (!pattern) return 'Error: falta "pattern".';
+  let re;
+  try {
+    re = new RegExp(pattern, 'i');
+  } catch (err) {
+    return `Error: regex inválida (${err.message}).`;
+  }
+  const base = resolveInRoot(root, p ?? '.');
+  const includeRe = include ? globToRegExp(include) : null;
+  const results = [];
+
+  for await (const file of walkFiles(base)) {
+    const relToBase = path.relative(base, file).split(path.sep).join('/');
+    if (includeRe && !includeRe.test(relToBase) && !includeRe.test(path.basename(file))) continue;
+    let text;
+    try {
+      const info = await stat(file);
+      if (info.size > MAX_GREP_FILE_BYTES) continue;
+      text = await readFile(file, 'utf8');
+    } catch {
+      continue;
+    }
+    if (text.includes('\u0000')) continue;
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        results.push(`${toRel(root, file)}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+      }
+      if (results.length >= MAX_GREP) break;
+    }
+    if (results.length >= MAX_GREP) break;
+  }
+
+  return results.length ? results.join('\n') : 'Sin coincidencias';
+}
+
+export function bashTool(root, { command, timeout } = {}) {
+  return new Promise((resolve) => {
+    if (!command || typeof command !== 'string') {
+      resolve('Error: falta "command".');
+      return;
+    }
+    const seconds = Math.min(Math.max(Number(timeout) || 30, 1), 300);
+    let child;
+    try {
+      child = spawn(command, { cwd: root, shell: true, windowsHide: true });
+    } catch (err) {
+      resolve(`Error ejecutando el comando: ${err.message}`);
+      return;
+    }
+
+    let output = '';
+    let settled = false;
+    const append = (chunk) => {
+      if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
+    };
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill('SIGKILL');
+      resolve(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
+    }, seconds * 1000);
+
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(`Error ejecutando el comando: ${err.message}`);
+    });
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const truncated = output.length >= MAX_BASH_OUTPUT ? '\n[output truncado]' : '';
+      resolve(`${output}${truncated}\n[exit ${code}]`);
+    });
+  });
+}
+
+function runGit(root, args) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn('git', args, { cwd: root, windowsHide: true });
+    } catch (err) {
+      resolve(`Error ejecutando git: ${err.message}`);
+      return;
+    }
+    let output = '';
+    let settled = false;
+    const append = (chunk) => {
+      if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
+    };
+    child.stdout?.on('data', append);
+    child.stderr?.on('data', append);
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      resolve(`Error ejecutando git: ${err.message}`);
+    });
+    child.on('close', (code) => {
+      if (settled) return;
+      settled = true;
+      const text = output.trim() || '(sin salida)';
+      resolve(code === 0 ? text : `${text}\n[exit ${code}]`);
+    });
+  });
+}
+
+export function gitStatusTool(root) {
+  return runGit(root, ['status', '--short', '--branch']);
+}
+
+export function gitDiffTool(root, { path: p, staged, ref } = {}) {
+  const args = ['diff', '--no-color'];
+  if (staged) args.push('--staged');
+  if (ref) args.push(String(ref));
+  if (p) args.push('--', String(p));
+  return runGit(root, args);
+}
+
+export function gitLogTool(root, { limit } = {}) {
+  const count = Math.min(Math.max(Number(limit) || 20, 1), 200);
+  return runGit(root, ['log', `-n${count}`, '--oneline', '--decorate']);
+}
+
+export async function gitCommitTool(root, { message, files } = {}) {
+  if (!message || typeof message !== 'string') return 'Error: falta "message".';
+  if (files) {
+    const list = Array.isArray(files) ? files : String(files).split(/\s+/).filter(Boolean);
+    if (list.length) {
+      const added = await runGit(root, ['add', '--', ...list]);
+      if (/\[exit [1-9]/.test(added)) return added;
+    }
+  }
+  return runGit(root, ['commit', '-m', message]);
+}
+
+export const EXECUTORS = {
+  read: readTool,
+  write: writeTool,
+  edit: editTool,
+  list: listTool,
+  glob: globTool,
+  grep: grepTool,
+  bash: bashTool,
+  git_status: gitStatusTool,
+  git_diff: gitDiffTool,
+  git_log: gitLogTool,
+  git_commit: gitCommitTool,
+};

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

@@ -0,0 +1,67 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+
+export const DEFAULT_IGNORES = new Set([
+  'node_modules',
+  '.git',
+  '.tamnora',
+  'dist',
+  'build',
+  '.cache',
+  '.next',
+  '.venv',
+  'venv',
+]);
+
+/**
+ * Convert a glob pattern to a RegExp. Supports `**`, `*`, `?` and escapes
+ * regex metacharacters. `/` is the separator in patterns.
+ */
+export function globToRegExp(glob) {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === '*') {
+      if (glob[i + 1] === '*') {
+        re += '.*';
+        i++;
+        if (glob[i + 1] === '/') i++;
+      } else {
+        re += '[^/]*';
+      }
+    } else if (c === '?') {
+      re += '[^/]';
+    } else if ('+.^$(){}|[]\\'.includes(c)) {
+      re += `\\${c}`;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+
+/**
+ * Recursively yield file paths under `root`, skipping common heavy dirs.
+ * @param {string} root
+ * @param {{ignores?: Set<string>}} [opts]
+ */
+export async function* walkFiles(root, { ignores = DEFAULT_IGNORES } = {}) {
+  const stack = [root];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!ignores.has(entry.name)) stack.push(full);
+      } else if (entry.isFile()) {
+        yield full;
+      }
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+import { createToolRegistry } from './registry.js';
+
+export { createToolRegistry } from './registry.js';
+export { TOOL_DEFINITIONS, TOOL_NAMES } from './schema.js';
+export { DEFAULT_PERMISSIONS, evaluatePermission } from './permissions.js';
+export { resolveInRoot, toRel } from './paths.js';
+export { globToRegExp, walkFiles, DEFAULT_IGNORES } from './glob.js';
+export * as executors from './executors.js';
+
+/**
+ * Combine local tools with an optional MCP registry into a single
+ * `{ definitions, execute }` pair for the agent loop.
+ *
+ * @param {object} opts - same options as createToolRegistry, plus:
+ * @param {{definitions:object[], handles:(n:string)=>boolean, call:Function}} [opts.mcp]
+ */
+export function createTools({ mcp, ...registryOptions } = {}) {
+  const registry = createToolRegistry(registryOptions);
+  const definitions = [...registry.definitions, ...(mcp?.definitions ?? [])];
+
+  async function execute(name, args) {
+    if (registry.handles(name)) return registry.execute(name, args);
+    if (mcp?.handles?.(name)) return mcp.call(name, args);
+    return `Error: herramienta desconocida "${name}".`;
+  }
+
+  return { definitions, execute, registry };
+}

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

@@ -0,0 +1,29 @@
+import path from 'node:path';
+
+/**
+ * Resolve a user-supplied path against the workspace root, refusing to escape
+ * it. This is a lexical guard: `..`, absolute paths outside the root and
+ * drive changes are rejected.
+ *
+ * @param {string} root - absolute workspace root
+ * @param {string} input - relative (or absolute-inside-root) path
+ * @returns {string} absolute path inside the root
+ */
+export function resolveInRoot(root, input) {
+  const base = path.resolve(root);
+  const raw = String(input ?? '.').trim() || '.';
+  const target = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(base, raw);
+
+  const rel = path.relative(base, target);
+  const escapes = rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel);
+  if (escapes) {
+    throw new Error(`Ruta fuera del workspace: "${input}"`);
+  }
+  return target;
+}
+
+/** Path relative to the root, using forward slashes, or '.' for the root. */
+export function toRel(root, absolute) {
+  const rel = path.relative(path.resolve(root), absolute);
+  return rel ? rel.split(path.sep).join('/') : '.';
+}

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

@@ -0,0 +1,69 @@
+// Permission policy for tools: 'allow' | 'ask' | 'deny'.
+//
+// A tool's policy is either a single decision or an object mapping patterns to
+// decisions (useful for `bash`, matching the command). The special key '*'
+// provides the fallback.
+
+export const DEFAULT_PERMISSIONS = {
+  read: 'allow',
+  list: 'allow',
+  glob: 'allow',
+  grep: 'allow',
+  git_status: 'allow',
+  git_diff: 'allow',
+  git_log: 'allow',
+  write: 'ask',
+  edit: 'ask',
+  bash: 'ask',
+  git_commit: 'ask',
+};
+
+function patternToRegExp(pattern) {
+  let re = '';
+  for (const c of String(pattern)) {
+    if (c === '*') re += '.*';
+    else if (c === '?') re += '.';
+    else if ('+.^$(){}|[]\\'.includes(c)) re += `\\${c}`;
+    else re += c;
+  }
+  return new RegExp(`^${re}$`);
+}
+
+function matchPattern(pattern, subject) {
+  try {
+    return patternToRegExp(pattern).test(subject);
+  } catch {
+    return false;
+  }
+}
+
+function subjectFor(name, args) {
+  if (name === 'bash') return args?.command ?? '';
+  if (name === 'git_commit') return args?.message ?? '';
+  return args?.path ?? '';
+}
+
+/**
+ * Decide the permission for a tool call.
+ * @returns {'allow'|'ask'|'deny'}
+ */
+export function evaluatePermission(name, args = {}, permissions = {}) {
+  const value = permissions[name] ?? DEFAULT_PERMISSIONS[name] ?? 'ask';
+
+  if (typeof value === 'string') return value;
+
+  if (value && typeof value === 'object') {
+    const subject = subjectFor(name, args);
+    let fallback = 'ask';
+    for (const [pattern, decision] of Object.entries(value)) {
+      if (pattern === '*') {
+        fallback = decision;
+        continue;
+      }
+      if (matchPattern(pattern, subject)) return decision;
+    }
+    return fallback;
+  }
+
+  return 'ask';
+}

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

@@ -0,0 +1,44 @@
+import { TOOL_DEFINITIONS, TOOL_NAMES } from './schema.js';
+import { EXECUTORS } from './executors.js';
+import { evaluatePermission } from './permissions.js';
+
+/**
+ * Build the local tool registry.
+ *
+ * @param {object} opts
+ * @param {string} opts.root - workspace root (all paths are confined here)
+ * @param {string[]} [opts.enabled] - tool names to expose (default: all)
+ * @param {object} [opts.permissions] - policy per tool ('allow'|'ask'|'deny' or pattern map)
+ * @param {(name:string, args:object)=>Promise<boolean>} [opts.onAsk] - interactive approval
+ * @param {boolean} [opts.yes] - auto-approve 'ask' (non-interactive)
+ */
+export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes = false } = {}) {
+  const names = new Set(enabled?.length ? enabled : TOOL_NAMES);
+  const definitions = TOOL_DEFINITIONS.filter((d) => names.has(d.function.name));
+
+  async function execute(name, args = {}) {
+    if (!names.has(name) || !(name in EXECUTORS)) {
+      return `Error: herramienta desconocida "${name}".`;
+    }
+
+    let decision = evaluatePermission(name, args, permissions);
+    if (decision === 'ask') {
+      if (onAsk) decision = (await onAsk(name, args)) ? 'allow' : 'deny';
+      else decision = yes ? 'allow' : 'deny';
+    }
+    if (decision === 'deny') {
+      const detail = args?.command ?? args?.path ?? '';
+      return `Permiso denegado para "${name}"${detail ? ` (${detail})` : ''}.`;
+    }
+
+    return EXECUTORS[name](root, args);
+  }
+
+  return {
+    root,
+    definitions,
+    names: [...names],
+    handles: (name) => names.has(name) && name in EXECUTORS,
+    execute,
+  };
+}

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

@@ -0,0 +1,177 @@
+// OpenAI-schema definitions for the local, workspace-scoped tools.
+// These are shared by the CLI and the harness runner and sent to the model.
+
+export const TOOL_DEFINITIONS = [
+  {
+    type: 'function',
+    function: {
+      name: 'read',
+      description:
+        'Read a text file from the workspace. Returns the file content with line numbers. Optionally read a slice with offset/limit.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path relative to the workspace root' },
+          offset: { type: 'integer', description: '1-based first line to read' },
+          limit: { type: 'integer', description: 'Maximum number of lines' },
+        },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write',
+      description:
+        'Create or overwrite a file in the workspace. Missing parent directories are created.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path relative to the workspace root' },
+          content: { type: 'string', description: 'Full file content' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'edit',
+      description:
+        'Replace an exact string in a file. By default oldString must be unique. Use replaceAll to replace every occurrence.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Path relative to the workspace root' },
+          oldString: { type: 'string', description: 'Exact text to replace' },
+          newString: { type: 'string', description: 'Replacement text' },
+          replaceAll: { type: 'boolean', description: 'Replace all occurrences' },
+        },
+        required: ['path', 'oldString', 'newString'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list',
+      description: 'List files and folders in a workspace directory.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory relative to the workspace root (default: root)' },
+        },
+        required: [],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'glob',
+      description:
+        'Find files by glob pattern (supports **, * and ?). Returns paths relative to the workspace root.',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Glob pattern, e.g. "src/**/*.js"' },
+          path: { type: 'string', description: 'Base directory (default: root)' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'grep',
+      description:
+        'Search file contents with a regular expression. Returns file:line matches (case-insensitive).',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Regular expression' },
+          include: { type: 'string', description: 'Only search files matching this glob, e.g. "*.js"' },
+          path: { type: 'string', description: 'Base directory (default: root)' },
+        },
+        required: ['pattern'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'bash',
+      description:
+        'Run a shell command in the workspace root. Use for tests, builds and git. Output is truncated.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Shell command to execute' },
+          timeout: { type: 'integer', description: 'Timeout in seconds (default 30, max 300)' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'git_status',
+      description: 'Show the git working-tree status (short) and current branch.',
+      parameters: { type: 'object', properties: {}, required: [] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'git_diff',
+      description: 'Show a git diff. Default: unstaged changes. Use staged or a ref (e.g. HEAD~1).',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Limit the diff to this path' },
+          staged: { type: 'boolean', description: 'Diff staged (--staged) changes' },
+          ref: { type: 'string', description: 'Compare against a ref, e.g. HEAD~1 or a branch' },
+        },
+        required: [],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'git_log',
+      description: 'Show recent commits (one line each).',
+      parameters: {
+        type: 'object',
+        properties: { limit: { type: 'integer', description: 'Number of commits (default 20)' } },
+        required: [],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'git_commit',
+      description:
+        'Commit changes. Optionally stage the given files first. Requires a message. Does not push.',
+      parameters: {
+        type: 'object',
+        properties: {
+          message: { type: 'string', description: 'Commit message' },
+          files: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Files to stage before committing (optional)',
+          },
+        },
+        required: ['message'],
+      },
+    },
+  },
+];
+
+export const TOOL_NAMES = TOOL_DEFINITIONS.map((d) => d.function.name);