@semalt-ai/code 1.8.5 → 1.19.0

package/test/checkpoints-agent.test.js

@@ -0,0 +1,181 @@
+'use strict';
+
+// Integration tests for checkpoints (Task 4.3) driving the REAL executor +
+// runAgentLoop (and a REAL subagent loop) against the mock-LLM harness. Covers:
+//   * a write through the real loop is checkpointed post-gate/pre-mutation, with
+//     turn linkage, and is rewindable;
+//   * a DENIED tool call produces NO checkpoint;
+//   * a SUBAGENT's mutation is checkpointed into the PARENT session and is
+//     rewindable (subagents reuse the parent's agentExecFile).
+
+const { test, before, after, afterEach } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const ui = require('../lib/ui');
+const { createApiClient } = require('../lib/api');
+const { createToolExecutor, extractToolCalls } = require('../lib/tools');
+const { createPermissionManager } = require('../lib/permissions');
+const { createAgentRunner } = require('../lib/agent');
+const { createCheckpointStore } = require('../lib/checkpoints');
+const toolRegistry = require('../lib/tool_registry');
+const { createSubagentManager, buildSpawnAgentEntry } = require('../lib/subagents');
+const { startMockLLM } = require('./harness/mock-llm');
+
+let prevKey;
+before(() => { prevKey = process.env.SEMALT_API_KEY; process.env.SEMALT_API_KEY = 'test-key'; });
+after(() => {
+  if (prevKey === undefined) delete process.env.SEMALT_API_KEY;
+  else process.env.SEMALT_API_KEY = prevKey;
+});
+afterEach(() => { toolRegistry.clearDynamicTools(); });
+
+function tmpdir(tag = 'work') { return fs.mkdtempSync(path.join(os.tmpdir(), `semalt-cpa-${tag}-`)); }
+
+// Build a full stack (api + permissions + executor wired with a real checkpoint
+// store + agent runner). Optionally wires a subagent manager sharing the SAME
+// executor, so a child's mutations flow through the same checkpoint store.
+function buildStack(base, { skipPermissions = false, withSubagents = false } = {}) {
+  const config = {
+    api_base: base, api_key: 'test-key', default_model: 'test-model',
+    temperature: 0.5, request_timeout_ms: 5000, stream: true, models: [],
+    checkpoints: { enabled: true },
+  };
+  const getConfig = () => config;
+  const api = createApiClient({ getConfig, saveConfig: (c) => Object.assign(config, c), ui });
+  const pm = createPermissionManager(ui, { skipPermissions });
+  pm.setUICallbacks({ onAddMessage: () => {}, onShowModal: () => {}, onCloseModal: () => {}, onCaptureNavigation: () => () => {} });
+
+  const root = tmpdir('cproot');
+  const checkpointStore = createCheckpointStore({
+    getConfig, sessionId: 'agent-sess', rootDir: root, audit: { logCheckpoint: () => {} },
+  });
+
+  const { agentExecShell, agentExecFile, describePermission } = createToolExecutor(pm, ui, getConfig, { checkpointStore });
+  const runner = createAgentRunner({
+    chatStream: api.chatStream, extractToolCalls, agentExecShell, agentExecFile,
+    describePermission, permissionManager: pm, ui, getConfig, checkpoints: checkpointStore,
+  });
+
+  let manager = null;
+  if (withSubagents) {
+    manager = createSubagentManager({
+      chatStream: api.chatStream, extractToolCalls, agentExecShell, agentExecFile,
+      describePermission, permissionManager: pm, ui, getConfig, agentDefs: [],
+    });
+    toolRegistry.registerDynamicTool(buildSpawnAgentEntry(manager));
+  }
+  return { runner, manager, checkpointStore, root, config };
+}
+
+// ---------------------------------------------------------------------------
+// 1. A write through the real loop is checkpointed (post-gate) and rewindable
+// ---------------------------------------------------------------------------
+
+test('a top-level write is checkpointed with turn linkage and is rewindable', async () => {
+  const dir = tmpdir();
+  const file = path.join(dir, 'note.txt');
+  fs.writeFileSync(file, 'ORIGINAL');
+
+  // isPathSafe confines writes to the CWD — point it at the work dir.
+  const cwd0 = process.cwd();
+  process.chdir(dir);
+  const mock = await startMockLLM();
+  mock.replyWith(`<write_file path="${file}">REWRITTEN</write_file>`); // iter 0: the mutation
+  mock.replyWith('Done.');                                            // iter 1: final
+  try {
+    const { runner, checkpointStore } = buildStack(mock.base, { skipPermissions: true });
+    const messages = [{ role: 'user', content: 'rewrite the note' }];
+    await runner.runAgentLoop(messages, 'test-model', 5, null, { callbacks: { onError: () => {} } });
+
+    assert.strictEqual(fs.readFileSync(file, 'utf8'), 'REWRITTEN', 'the write happened');
+
+    const items = checkpointStore.list();
+    assert.strictEqual(items.length, 1, 'one checkpoint captured for the write');
+    const rec = checkpointStore._loadRecord(items[0].seq);
+    assert.strictEqual(rec.action, 'write');
+    assert.strictEqual(rec.targets[0].path, file);
+    // prior state was captured BEFORE the mutation
+    assert.strictEqual(Buffer.from(rec.targets[0].priorContentB64, 'base64').toString('utf8'), 'ORIGINAL');
+    // turn linkage recorded (forward-compat for conversation-rewind, Task 4.3b)
+    assert.strictEqual(rec.turn.turnId, 'turn-1');
+    assert.strictEqual(typeof rec.turn.messageCountAtStart, 'number');
+
+    // and it actually rewinds
+    const res = checkpointStore.rewind('last');
+    assert.ok(res.ok);
+    assert.strictEqual(fs.readFileSync(file, 'utf8'), 'ORIGINAL', 'rewind restored prior content');
+  } finally {
+    await mock.close();
+    process.chdir(cwd0);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 2. A denied tool call produces NO checkpoint
+// ---------------------------------------------------------------------------
+
+test('a denied write (non-TTY, no skip) is NOT checkpointed', async () => {
+  const dir = tmpdir();
+  const file = path.join(dir, 'blocked.txt');
+
+  const mock = await startMockLLM();
+  mock.replyWith(`<write_file path="${file}">SHOULD NOT WRITE</write_file>`); // denied at the gate
+  mock.replyWith('ok');
+  try {
+    // skipPermissions:false in a non-TTY env → the gate REFUSES the write, so
+    // the executor never runs and nothing is checkpointed.
+    const { runner, checkpointStore } = buildStack(mock.base, { skipPermissions: false });
+    const messages = [{ role: 'user', content: 'try to write' }];
+    await runner.runAgentLoop(messages, 'test-model', 5, null, { callbacks: { onError: () => {} } });
+
+    assert.ok(!fs.existsSync(file), 'the write was denied');
+    assert.strictEqual(checkpointStore.list().length, 0, 'no checkpoint for a denied call');
+  } finally {
+    await mock.close();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 3. A subagent's mutation is checkpointed in the PARENT session, rewindable
+// ---------------------------------------------------------------------------
+
+test('a subagent mutation is checkpointed in the parent session and is rewindable', async () => {
+  const dir = tmpdir();
+  const file = path.join(dir, 'child.txt');
+  fs.writeFileSync(file, 'BEFORE');
+
+  const cwd0 = process.cwd();
+  process.chdir(dir);
+  const mock = await startMockLLM();
+  // Parent dispatches spawn_agent; the child performs the write; child + parent
+  // each conclude. The child reuses the parent's agentExecFile, so its mutation
+  // flows through the SAME checkpoint store.
+  mock.replyWithToolCall('spawn_agent', { prompt: 'rewrite child.txt' }); // parent iter 0
+  mock.replyWith(`<write_file path="${file}">AFTER</write_file>`);        // child iter 0 (the mutation)
+  mock.replyWith('child done');                                          // child iter 1 (final)
+  mock.replyWith('parent done');                                         // parent iter 1 (final)
+  try {
+    const { runner, checkpointStore } = buildStack(mock.base, { skipPermissions: true, withSubagents: true });
+    const messages = [{ role: 'user', content: 'delegate a write' }];
+    await runner.runAgentLoop(messages, 'test-model', 6, null, { callbacks: { onError: () => {} } });
+
+    assert.strictEqual(fs.readFileSync(file, 'utf8'), 'AFTER', 'the child performed the write');
+
+    const items = checkpointStore.list();
+    assert.strictEqual(items.length, 1, "the child's write is checkpointed in the parent session");
+    const rec = checkpointStore._loadRecord(items[0].seq);
+    assert.strictEqual(rec.targets[0].path, file);
+    // linked to the parent's turn (the parent never reset turn context for the child)
+    assert.strictEqual(rec.turn.turnId, 'turn-1');
+
+    const res = checkpointStore.rewind('last');
+    assert.ok(res.ok);
+    assert.strictEqual(fs.readFileSync(file, 'utf8'), 'BEFORE', "a subagent's mutation is rewindable from the parent");
+  } finally {
+    await mock.close();
+    process.chdir(cwd0);
+  }
+});