@semalt-ai/code 1.8.5 → 1.19.0

package/test/subagents.test.js

@@ -0,0 +1,222 @@
+'use strict';
+
+// Unit tests for subagents (Task 3.6) — the pure / injectable surface:
+//   * agent-definition discovery + frontmatter (name / model / tools / prompt)
+//   * allowed-tool resolution (constrains tools; never includes spawn_agent)
+//   * resolveSpec applies a named definition's model / prompt / tools
+//   * bounded-concurrency pool (injected runChild records peak concurrency)
+//   * spawn single vs. parallel `tasks`
+//   * the spawn_agent dynamic-tool entry (permission gate, fromParams, parseXml)
+//
+// The real isolated-child-loop behavior is covered by subagents-agent.test.js.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  parseAgentFrontmatter,
+  discoverAgentDefs,
+  loadAgentDefsFromDir,
+  resolveAllowedActions,
+  createSubagentManager,
+  buildSpawnAgentEntry,
+  SPAWN_AGENT_TOOL,
+} = require('../lib/subagents');
+
+function tmpdir() { return fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-subagents-')); }
+
+// ---------------------------------------------------------------------------
+// 1. Frontmatter parsing
+// ---------------------------------------------------------------------------
+
+test('parseAgentFrontmatter reads name/model/tools and returns the body as the system prompt', () => {
+  const text = [
+    '---',
+    'name: Code Reviewer',
+    'model: gpt-mini',
+    'tools: read_file, grep glob',
+    'description: reviews diffs',
+    '---',
+    'You are a meticulous reviewer.',
+    'Focus on correctness.',
+  ].join('\n');
+  const { meta, body } = parseAgentFrontmatter(text);
+  assert.equal(meta.name, 'Code Reviewer');
+  assert.equal(meta.model, 'gpt-mini');
+  assert.deepEqual(meta.tools, ['read_file', 'grep', 'glob']);
+  assert.equal(meta.description, 'reviews diffs');
+  assert.match(body, /meticulous reviewer/);
+  assert.doesNotMatch(body, /---/);
+});
+
+test('parseAgentFrontmatter with no frontmatter treats the whole text as the body', () => {
+  const { meta, body } = parseAgentFrontmatter('just a prompt');
+  assert.equal(meta.name, '');
+  assert.deepEqual(meta.tools, []);
+  assert.equal(body, 'just a prompt');
+});
+
+// ---------------------------------------------------------------------------
+// 2. Definition discovery
+// ---------------------------------------------------------------------------
+
+test('discoverAgentDefs loads .semalt/agents/*.md and project overrides global', () => {
+  const home = tmpdir();
+  const repo = tmpdir();
+  fs.mkdirSync(path.join(repo, '.git'));
+  fs.mkdirSync(path.join(home, '.semalt-ai', 'agents'), { recursive: true });
+  fs.mkdirSync(path.join(repo, '.semalt', 'agents'), { recursive: true });
+
+  // A global-only def, plus a `reader` def that exists in both (project wins).
+  fs.writeFileSync(path.join(home, '.semalt-ai', 'agents', 'global-only.md'), '---\nname: global-only\n---\nglobal body');
+  fs.writeFileSync(path.join(home, '.semalt-ai', 'agents', 'reader.md'), '---\nname: reader\nmodel: global-model\n---\nGLOBAL reader');
+  fs.writeFileSync(path.join(repo, '.semalt', 'agents', 'reader.md'), '---\nname: reader\nmodel: project-model\ntools: read_file\n---\nPROJECT reader');
+
+  const defs = discoverAgentDefs({ home, cwd: repo });
+  const bySlug = Object.fromEntries(defs.map((d) => [d.slug, d]));
+  assert.ok(bySlug['global-only'], 'global-only def is discovered');
+  assert.ok(bySlug['reader'], 'reader def is discovered');
+  assert.equal(bySlug['reader'].model, 'project-model', 'project def wins over global');
+  assert.equal(bySlug['reader'].systemPrompt, 'PROJECT reader');
+  assert.deepEqual(bySlug['reader'].tools, ['read_file']);
+});
+
+test('loadAgentDefsFromDir ignores non-.md files and unreadable dirs', () => {
+  const dir = tmpdir();
+  fs.writeFileSync(path.join(dir, 'a.md'), '---\nname: a\n---\nbody');
+  fs.writeFileSync(path.join(dir, 'notes.txt'), 'ignore me');
+  const defs = loadAgentDefsFromDir(dir, 'project');
+  assert.equal(defs.length, 1);
+  assert.equal(defs[0].name, 'a');
+  assert.deepEqual(loadAgentDefsFromDir(path.join(dir, 'nope'), 'project'), []);
+});
+
+// ---------------------------------------------------------------------------
+// 3. Allowed-tool resolution (the no-escalation tool constraint)
+// ---------------------------------------------------------------------------
+
+test('resolveAllowedActions maps tags to canonical actions and never includes spawn_agent', () => {
+  const set = resolveAllowedActions(['read_file', 'grep', 'spawn_agent']);
+  assert.ok(set.has('read'), 'read_file → read action');
+  assert.ok(set.has('grep'));
+  assert.ok(!set.has(SPAWN_AGENT_TOOL), 'spawn_agent is always dropped (no recursion)');
+});
+
+test('resolveAllowedActions returns null for empty / wildcard (inherit-all, still permission-bounded)', () => {
+  assert.equal(resolveAllowedActions(null), null);
+  assert.equal(resolveAllowedActions([]), null);
+  assert.equal(resolveAllowedActions(['*']), null);
+  assert.equal(resolveAllowedActions(['all']), null);
+});
+
+// ---------------------------------------------------------------------------
+// 4. resolveSpec applies a named definition
+// ---------------------------------------------------------------------------
+
+test('resolveSpec applies a named agent definition (model, system prompt, tools) with inline overrides', () => {
+  const agentDefs = [{
+    name: 'reader', slug: 'reader', model: 'def-model',
+    tools: ['read_file'], description: '', systemPrompt: 'You read files.', source: 'project',
+  }];
+  const mgr = createSubagentManager({ agentDefs, getConfig: () => ({ default_model: 'fallback' }) });
+
+  const spec = mgr.resolveSpec({ agent: 'reader', prompt: 'read foo' });
+  assert.equal(spec.model, 'def-model');
+  assert.equal(spec.systemPrompt, 'You read files.');
+  assert.equal(spec.prompt, 'read foo');
+  assert.ok(spec.allowedActions.has('read'));
+  assert.ok(!spec.allowedActions.has('write'), 'a constrained agent cannot write');
+
+  // Inline model overrides the definition's model.
+  assert.equal(mgr.resolveSpec({ agent: 'reader', model: 'override', prompt: 'x' }).model, 'override');
+  // A bare string is treated as the prompt; unknown agent falls back to config model.
+  const bare = mgr.resolveSpec('just do it');
+  assert.equal(bare.prompt, 'just do it');
+  assert.equal(bare.model, 'fallback');
+  assert.equal(bare.allowedActions, null, 'no tool list → inherit-all');
+});
+
+// ---------------------------------------------------------------------------
+// 5. Bounded-concurrency pool
+// ---------------------------------------------------------------------------
+
+test('runMany respects the concurrency bound (injected runChild records peak)', async () => {
+  let active = 0;
+  let peak = 0;
+  const runChild = (spec) => new Promise((resolve) => {
+    active++;
+    peak = Math.max(peak, active);
+    setTimeout(() => { active--; resolve(`done:${spec.prompt}`); }, 15);
+  });
+  const mgr = createSubagentManager({ runChild, maxConcurrency: 2, getConfig: () => ({ default_model: 'm' }) });
+
+  const specs = [1, 2, 3, 4, 5].map((i) => ({ prompt: `task${i}` }));
+  const results = await mgr.runMany(specs);
+  assert.equal(results.length, 5);
+  assert.ok(peak <= 2, `peak concurrency ${peak} must not exceed the bound of 2`);
+  assert.ok(peak >= 2, `pool should actually run in parallel up to the bound (peak=${peak})`);
+  assert.equal(results[0].output, 'done:task1');
+});
+
+test('spawn runs a single task, and `tasks` runs them in (bounded) parallel', async () => {
+  const runChild = (spec) => Promise.resolve(`R:${spec.prompt}`);
+  const mgr = createSubagentManager({ runChild, maxConcurrency: 3, getConfig: () => ({ default_model: 'm' }) });
+
+  const single = await mgr.spawn({ prompt: 'solo' });
+  assert.equal(single.subagent, true);
+  assert.equal(single.count, 1);
+  assert.equal(single.content, 'R:solo');
+
+  const many = await mgr.spawn({ tasks: [{ prompt: 'a' }, { prompt: 'b' }] });
+  assert.equal(many.count, 2);
+  assert.match(many.content, /Subagent 1/);
+  assert.match(many.content, /R:a/);
+  assert.match(many.content, /R:b/);
+});
+
+test('runOne captures a child error instead of throwing', async () => {
+  const runChild = () => { throw new Error('kaboom'); };
+  const mgr = createSubagentManager({ runChild, getConfig: () => ({ default_model: 'm' }) });
+  const res = await mgr.runOne({ prompt: 'x' });
+  assert.equal(res.error, 'kaboom');
+  assert.equal(res.output, '');
+});
+
+// ---------------------------------------------------------------------------
+// 6. spawn_agent dynamic-tool entry
+// ---------------------------------------------------------------------------
+
+test('buildSpawnAgentEntry exposes a registry entry that REQUIRES approval by default', () => {
+  const mgr = createSubagentManager({ runChild: () => Promise.resolve('ok'), getConfig: () => ({}) });
+  const entry = buildSpawnAgentEntry(mgr);
+  assert.equal(entry.tool, SPAWN_AGENT_TOOL);
+  assert.ok(entry.spec && entry.spec.parameters, 'advertises a native function schema');
+
+  // permission() must return a non-null descriptor → it is never auto-allowed by
+  // an --allow-* tier (no privilege escalation by simply spawning).
+  const desc = entry.permission(null, [{ prompt: 'go' }]);
+  assert.ok(desc && desc.tag === SPAWN_AGENT_TOOL, 'gated, not read-only');
+  assert.equal(desc.actionType, 'agent');
+});
+
+test('spawn_agent fromParams + parseXml produce the [name, params] tuple', () => {
+  const mgr = createSubagentManager({ runChild: () => Promise.resolve('ok'), getConfig: () => ({}) });
+  const entry = buildSpawnAgentEntry(mgr);
+
+  assert.deepEqual(entry.fromParams({ prompt: 'p', agent: 'r' }), [SPAWN_AGENT_TOOL, { prompt: 'p', agent: 'r' }]);
+
+  // Plain-text body form with an agent attribute.
+  const xml = entry.parseXml('<spawn_agent agent="reader">summarize the repo</spawn_agent>');
+  assert.equal(xml.length, 1);
+  assert.equal(xml[0][0], SPAWN_AGENT_TOOL);
+  assert.equal(xml[0][1].prompt, 'summarize the repo');
+  assert.equal(xml[0][1].agent, 'reader');
+
+  // JSON body form.
+  const xmlJson = entry.parseXml('<spawn_agent>{"prompt":"do x","model":"m2"}</spawn_agent>');
+  assert.equal(xmlJson[0][1].prompt, 'do x');
+  assert.equal(xmlJson[0][1].model, 'm2');
+});

package/test/tool-registry.test.js

@@ -0,0 +1,85 @@
+'use strict';
+
+// Tests for the runtime tool registry (Task 1.4). The exhaustive per-tag XML
+// and native parsing behavior is already pinned by test/extract-tool-calls.test
+// (which now runs through the registry); this file asserts the registry's own
+// invariants: completeness vs TOOL_SPECS, and that the XML and native transports
+// resolve to the SAME registry entry / tuple.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { TOOL_REGISTRY, fromInvoke, registryToolNames } = require('../lib/tool_registry');
+const { TOOL_SPECS } = require('../lib/tool_specs');
+const { extractToolCalls } = require('../lib/tools');
+
+// ---------------------------------------------------------------------------
+// Completeness — the registry resolves exactly the callable (non-wrapper) specs.
+// ---------------------------------------------------------------------------
+
+test('registry resolves exactly the non-wrapper TOOL_SPECS', () => {
+  const callableSpecs = Object.entries(TOOL_SPECS).filter(([, v]) => !v.wrapper).map(([k]) => k).sort();
+  assert.deepStrictEqual(registryToolNames().slice().sort(), callableSpecs);
+});
+
+test('every registry entry carries name, parse, native, execute, and permission (Task 1.4b)', () => {
+  for (const e of TOOL_REGISTRY) {
+    assert.ok(typeof e.tool === 'string' && e.tool, 'tool name present');
+    assert.strictEqual(typeof e.fromParams, 'function', `${e.tool} has fromParams`);
+    assert.strictEqual(typeof e.execute, 'function', `${e.tool} has execute`);
+    assert.strictEqual(typeof e.permission, 'function', `${e.tool} has permission`);
+    assert.ok(Array.isArray(e.specNames) && e.specNames.length > 0, `${e.tool} has specNames`);
+  }
+});
+
+test('specNames are globally unique (no two tools claim the same name)', () => {
+  const all = TOOL_REGISTRY.flatMap((e) => e.specNames);
+  assert.strictEqual(new Set(all).size, all.length);
+});
+
+// ---------------------------------------------------------------------------
+// XML and native paths resolve to the same tuple via the shared registry.
+// ---------------------------------------------------------------------------
+
+const EQUIVALENCE = [
+  { xml: '<write_file path="a.txt">hi</write_file>', name: 'write_file', params: { path: 'a.txt', content: 'hi' }, tuple: ['write', 'a.txt', 'hi'] },
+  { xml: '<create_file path="a.txt">hi</create_file>', name: 'create_file', params: { path: 'a.txt', content: 'hi' }, tuple: ['write', 'a.txt', 'hi'] },
+  { xml: '<read_file path="a.txt"/>', name: 'read_file', params: { path: 'a.txt' }, tuple: ['read', 'a.txt', null, null, false] },
+  { xml: '<append_file path="a.txt">x</append_file>', name: 'append_file', params: { path: 'a.txt', content: 'x' }, tuple: ['append', 'a.txt', 'x'] },
+  { xml: '<exec>ls -la</exec>', name: 'exec', params: { command: 'ls -la' }, tuple: ['shell', 'ls -la'] },
+  { xml: '<shell>ls -la</shell>', name: 'shell', params: { command: 'ls -la' }, tuple: ['shell', 'ls -la'] },
+  { xml: '<move_file src="a" dst="b"/>', name: 'move_file', params: { src: 'a', dst: 'b' }, tuple: ['move_file', 'a', 'b'] },
+  { xml: '<edit_file path="a.js" line="3">x = 1</edit_file>', name: 'edit_file', params: { path: 'a.js', line: 3, content: 'x = 1' }, tuple: ['edit_file', 'a.js', 3, 'x = 1'] },
+  { xml: '<http_get url="http://x"/>', name: 'http_get', params: { url: 'http://x' }, tuple: ['http_get', 'http://x', {}] },
+  { xml: '<list_memories/>', name: 'list_memories', params: {}, tuple: ['list_memories'] },
+  { xml: '<system_info/>', name: 'system_info', params: {}, tuple: ['system_info'] },
+];
+
+for (const c of EQUIVALENCE) {
+  test(`XML and native resolve to the same tuple: ${c.name}`, () => {
+    const viaXml = extractToolCalls(c.xml);
+    assert.deepStrictEqual(viaXml, [c.tuple], 'XML path');
+    assert.deepStrictEqual(fromInvoke(c.name, c.params), c.tuple, 'native path');
+    assert.deepStrictEqual(viaXml[0], fromInvoke(c.name, c.params), 'both paths agree');
+  });
+}
+
+test('fromInvoke returns null for an unknown tool', () => {
+  assert.strictEqual(fromInvoke('frobnicate', { x: 1 }), null);
+});
+
+test('fromInvoke enforces required params (returns null when missing)', () => {
+  assert.strictEqual(fromInvoke('write_file', { content: 'no path' }), null);
+  assert.strictEqual(fromInvoke('move_file', { src: 'a' }), null);
+});
+
+// ---------------------------------------------------------------------------
+// QUIRK #1.1 preserved through the registry: attribute content is NOT trimmed.
+// ---------------------------------------------------------------------------
+
+test('QUIRK preserved: write_file attribute content is captured raw (un-trimmed)', () => {
+  assert.deepStrictEqual(
+    extractToolCalls('<write_file path="a.txt">\n  spaced  \n</write_file>'),
+    [['write', 'a.txt', '\n  spaced  \n']],
+  );
+});

package/test/trim-budget.test.js

@@ -0,0 +1,101 @@
+'use strict';
+
+// Characterization tests for trimToTokenBudget (Task 1.1).
+// Budgets are derived from the function's own chars/4 estimate so the number of
+// dropped messages is deterministic rather than tuned by hand.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { trimToTokenBudget } = require('../lib/api');
+
+// Mirror of the internal estimate: floor(JSON.stringify(msgs).length / 4).
+const est = (msgs) => Math.floor(JSON.stringify(msgs).length / 4);
+
+const sys = { role: 'system', content: 'SYSTEM PROMPT' };
+const task = { role: 'user', content: 'the original task' };
+const mk = (tag, n) => ({ role: 'user', content: `${tag}:` + 'x'.repeat(n) });
+
+test('under budget: messages returned unchanged', () => {
+  const msgs = [sys, task, mk('a', 100)];
+  const out = trimToTokenBudget(msgs, est(msgs) + 1000);
+  assert.deepStrictEqual(out, msgs);
+});
+
+test('no non-system messages: returns a copy of the system messages only', () => {
+  const sys2 = { role: 'system', content: 'second system' };
+  const msgs = [sys, sys2];
+  const out = trimToTokenBudget(msgs, 1);
+  assert.deepStrictEqual(out, [sys, sys2]);
+  assert.notStrictEqual(out, msgs, 'returns a new array');
+});
+
+test('drops intermediate messages oldest-first, keeping system + pinned + newest', () => {
+  const f1 = mk('f1', 4000);
+  const f2 = mk('f2', 4000);
+  const f3 = mk('f3', 4000);
+  const msgs = [sys, task, f1, f2, f3];
+  // Budget that fits [sys, task, f3] but not [sys, task, f2, f3].
+  const budget = est([sys, task, f3]) + 50;
+  assert.ok(budget < est([sys, task, f2, f3]), 'precondition: budget forces drops');
+
+  const out = trimToTokenBudget(msgs, budget);
+  assert.deepStrictEqual(out, [sys, task, f3]);
+});
+
+test('pinned (first non-system) is never dropped even under heavy pressure', () => {
+  const big = mk('tail', 8000);
+  const msgs = [sys, task, big];
+  const out = trimToTokenBudget(msgs, est([sys, task]) + 10);
+  assert.strictEqual(out[0], sys);
+  assert.strictEqual(out[1], task);
+});
+
+test('truncates the last remaining tail message when still over budget', () => {
+  const huge = mk('tail', 40000);
+  const msgs = [sys, task, huge];
+  // Down to one tail message, but estimate still exceeds budget AND there is
+  // positive room (budget*4 - other - 200 > 0) so truncation engages.
+  const budget = est([sys, task]) + 1500; // ~6000 chars of room for the tail
+  const out = trimToTokenBudget(msgs, budget);
+
+  assert.strictEqual(out.length, 3);
+  assert.strictEqual(out[0], sys);
+  assert.strictEqual(out[1], task);
+  assert.match(out[2].content, /^\[…content truncated to fit model limit…\]\n/);
+  assert.ok(out[2].content.length < huge.content.length, 'tail was shortened');
+  assert.ok(out[2].content.endsWith('x'.repeat(50)), 'keeps the END of the content');
+});
+
+test('truncates the pinned message when there is no tail and it overflows', () => {
+  const hugePinned = mk('pinned', 40000);
+  const msgs = [sys, hugePinned];
+  const budget = est([sys]) + 1500;
+  const out = trimToTokenBudget(msgs, budget);
+
+  assert.strictEqual(out.length, 2);
+  assert.strictEqual(out[0], sys);
+  assert.match(out[1].content, /^\[…content truncated to fit model limit…\]\n/);
+  assert.ok(out[1].content.length < hugePinned.content.length);
+});
+
+test('QUIRK: when there is no room (budget too small) the last message is left intact', () => {
+  // available = budget*4 - other - 200 <= 0, so the truncation branch is skipped
+  // and the (oversized) message is returned unchanged rather than emptied.
+  const huge = mk('tail', 40000);
+  const msgs = [sys, task, huge];
+  const out = trimToTokenBudget(msgs, 1); // 4 chars of budget
+  assert.deepStrictEqual(out, [sys, task, huge]);
+});
+
+test('multiple system messages are all preserved and kept ahead of content', () => {
+  const sys2 = { role: 'system', content: 'second system rule' };
+  const f1 = mk('f1', 4000);
+  const f2 = mk('f2', 4000);
+  const msgs = [sys, sys2, task, f1, f2];
+  const out = trimToTokenBudget(msgs, est([sys, sys2, task, f2]) + 50);
+  assert.strictEqual(out[0], sys);
+  assert.strictEqual(out[1], sys2);
+  assert.strictEqual(out[2], task);
+  assert.ok(!out.includes(f1), 'oldest filler dropped');
+});