@semalt-ai/code 1.8.5 → 1.20.0

package/test/chat-relogin.test.js

@@ -0,0 +1,207 @@
+'use strict';
+
+// Coverage for the relogin chat-context reset + 404 self-heal on save.
+// Root cause: /logout and /login did NOT reset ctx.currentChatId, so a stale id
+// survived a relogin and suppressed fresh-chat creation; the next save POSTed to
+// a chat the new principal can't see → 404 "Chat not found" → warn-and-drop.
+//
+// The two factories (createChatSession / createSlashHandlers) both take a plain
+// `ctx`; in production cmdChat hands them the SAME ctx. We mirror that by passing
+// one shared ctx, so a slash handler's reset is visible to the session helpers.
+
+const test = require('node:test');
+const assert = require('node:assert');
+
+const { createChatSession } = require('../lib/commands/chat-session');
+const { createSlashHandlers } = require('../lib/commands/chat-slash');
+
+// Build a shared ctx with recording stubs. Only the fields the functions under
+// test touch are real; the rest are inert so the destructures don't throw.
+function makeCtx(overrides = {}) {
+  const warns = [];
+  const saves = [];   // { chatId, count }
+  let createSeq = 0;
+  const created = [];
+
+  const config = {
+    auth_token: 'tok', dashboard_model_id: 'm1', ...(overrides.config || {}),
+  };
+
+  const ctx = {
+    // session state
+    messages: overrides.messages || [],
+    currentChatId: overrides.currentChatId !== undefined ? overrides.currentChatId : null,
+    savedUpTo: overrides.savedUpTo || 0,
+    currentModel: 'test-model',
+    resolvedTokenLimit: 1000,
+
+    // collaborators used by chat-session helpers
+    msgs: { sysWarn: (m) => warns.push(m) },
+    getConfig: () => config,
+    setConfig: (c) => Object.assign(config, c),
+    storage: { list: () => [], save() {}, load: () => null },
+    approxTokens: (s) => Math.ceil((s || '').length / 4),
+    PAGE_SIZE: 10, sessionStart: 0, getCols: () => 80,
+    FG_GRAY: '', RST: '',
+    cleanOrphanedToolMessages: (m) => ({ messages: m, droppedTool: 0, droppedAssistantCalls: 0, droppedAssistantMsgs: 0 }),
+    reconstructLoadedMessage: (m) => m,
+    resolveTokenLimit: async () => 1000,
+
+    dashboardCreateChat: overrides.dashboardCreateChat || (async () => {
+      const id = `chat-${++createSeq}`; created.push(id); return { chat: { id } };
+    }),
+    dashboardSaveMessages: overrides.dashboardSaveMessages || (async (chatId, msgs) => {
+      saves.push({ chatId, count: msgs.length }); return {};
+    }),
+    dashboardGetChat: async () => ({ messages: [] }),
+    dashboardGetModelForCli: async () => ({ model: null }),
+
+    // collaborators used by slash handlers
+    chatHistory: { addMessage() {} },
+    statusBar: { update() {}, setModel() {}, setContextLimit() {} },
+    inputField: { setDisabled() {} },
+    permissionManager: { clear() { ctx._permClears = (ctx._permClears || 0) + 1; } },
+    loginFlow: overrides.loginFlow || (async () => {}),
+    ensureDefaultModel: overrides.ensureDefaultModel || (async () => null),
+    dashboardLogout: overrides.dashboardLogout || (async () => ({})),
+
+    _warns: warns, _saves: saves, _created: created,
+  };
+
+  // Note: createChatIfNeeded reads `created` length via the default stub above.
+  Object.defineProperty(ctx, '_createdCount', { get: () => created.length });
+  return ctx;
+}
+
+// (b) /login resets currentChatId and savedUpTo (and mirrors /new: messages + approvals).
+test('/login resets chat context (currentChatId, savedUpTo, messages)', async () => {
+  const ctx = makeCtx({ currentChatId: 'stale', savedUpTo: 5, messages: [{ role: 'user', content: 'x' }] });
+  const handlers = createSlashHandlers(ctx);
+  await handlers['/login']();
+  assert.strictEqual(ctx.currentChatId, null);
+  assert.strictEqual(ctx.savedUpTo, 0);
+  assert.deepStrictEqual(ctx.messages, []);
+  assert.strictEqual(ctx._permClears, 1, 'approvals cleared on principal change');
+});
+
+// (c) /logout resets them too, even if the dashboardLogout HTTP call failed.
+test('/logout resets chat context even when dashboardLogout HTTP fails', async () => {
+  const err503 = Object.assign(new Error('Service Unavailable'), { statusCode: 503 });
+  const ctx = makeCtx({
+    currentChatId: 'stale', savedUpTo: 5,
+    dashboardLogout: async () => { throw err503; },
+  });
+  const handlers = createSlashHandlers(ctx);
+  await handlers['/logout']();   // early-returns on the 503, but reset must still hold
+  assert.strictEqual(ctx.currentChatId, null);
+  assert.strictEqual(ctx.savedUpTo, 0);
+});
+
+// (a) in-process /logout → /login → next turn creates a NEW chat; save targets it.
+test('logout then login: next turn creates a fresh chat and save targets it', async () => {
+  const ctx = makeCtx({
+    currentChatId: 'chat-old', savedUpTo: 3,
+    loginFlow: async () => { ctx.setConfig({ auth_token: 'newtok' }); },
+  });
+  const session = createChatSession(ctx);
+  const handlers = createSlashHandlers(ctx);
+
+  await handlers['/logout']();
+  assert.strictEqual(ctx.currentChatId, null, 'logout dropped the stale id');
+  await handlers['/login']();
+  assert.strictEqual(ctx.currentChatId, null, 'login left it null for lazy create');
+
+  // Next turn.
+  ctx.messages.push({ role: 'user', content: 'hello' }, { role: 'assistant', content: 'hi' });
+  await session.createChatIfNeeded('hello');
+  await session.saveTurnToDashboard();
+
+  assert.strictEqual(ctx._createdCount, 1, 'exactly one fresh chat created');
+  assert.strictEqual(ctx._saves.length, 1);
+  assert.strictEqual(ctx._saves[0].chatId, 'chat-1', 'save went to the new chat, not chat-old');
+  assert.deepStrictEqual(ctx._warns, [], 'no "Chat not found" warning');
+});
+
+// (d) 404 on save → self-heal: new chat, re-save same slice, advance savedUpTo after success.
+test('saveTurnToDashboard self-heals on 404 (recreate + re-save, once)', async () => {
+  let createSeq = 0;
+  const saves = [];
+  const ctx = makeCtx({
+    currentChatId: 'stale', savedUpTo: 0,
+    messages: [{ role: 'user', content: 'hi' }, { role: 'assistant', content: 'yo' }],
+    dashboardCreateChat: async () => ({ chat: { id: `fresh-${++createSeq}` } }),
+    dashboardSaveMessages: async (chatId, msgs) => {
+      saves.push({ chatId, count: msgs.length });
+      if (chatId === 'stale') throw Object.assign(new Error('Chat not found'), { statusCode: 404 });
+      return {};
+    },
+  });
+  const session = createChatSession(ctx);
+  await session.saveTurnToDashboard();
+
+  assert.strictEqual(createSeq, 1, 'exactly one new chat created (no retry loop)');
+  assert.strictEqual(ctx.currentChatId, 'fresh-1');
+  assert.deepStrictEqual(saves.map((s) => s.chatId), ['stale', 'fresh-1'], 'retried on the fresh chat');
+  assert.strictEqual(saves[1].count, 2, 're-saved the SAME pending slice');
+  assert.strictEqual(ctx.savedUpTo, 2, 'savedUpTo advanced only after re-save succeeded');
+  assert.ok(!ctx._warns.some((w) => /history save failed/.test(w)), 'no failure warning on success');
+});
+
+// (e) non-404 (503) → does NOT recreate; warns; savedUpTo unchanged.
+test('saveTurnToDashboard does not recover on non-404 (503)', async () => {
+  let creates = 0;
+  const ctx = makeCtx({
+    currentChatId: 'stale', savedUpTo: 0,
+    messages: [{ role: 'user', content: 'hi' }, { role: 'assistant', content: 'yo' }],
+    dashboardCreateChat: async () => { creates++; return { chat: { id: 'x' } }; },
+    dashboardSaveMessages: async () => { throw Object.assign(new Error('Service Unavailable'), { statusCode: 503 }); },
+  });
+  const session = createChatSession(ctx);
+  await session.saveTurnToDashboard();
+
+  assert.strictEqual(creates, 0, 'transient error must NOT spawn a new chat');
+  assert.strictEqual(ctx.currentChatId, 'stale', 'chat id untouched');
+  assert.strictEqual(ctx.savedUpTo, 0, 'savedUpTo unadvanced so a later turn retries');
+  assert.ok(ctx._warns.some((w) => /history save failed/.test(w)), 'warned');
+});
+
+// (f) createChatIfNeeded creation failure is surfaced, not swallowed.
+test('createChatIfNeeded surfaces a creation failure (not silent)', async () => {
+  const ctx = makeCtx({
+    currentChatId: null,
+    dashboardCreateChat: async () => { throw new Error('boom'); },
+  });
+  const session = createChatSession(ctx);
+  await session.createChatIfNeeded('hello');
+  assert.strictEqual(ctx.currentChatId, null, 'still no chat (non-fatal)');
+  assert.ok(ctx._warns.some((w) => /could not create dashboard chat/.test(w)), 'failure surfaced');
+});
+
+// (g) regression: normal session and --resume session save to the right chat.
+test('regression: normal session lazily creates and saves; --resume saves to resumed id', async () => {
+  // Normal session: currentChatId starts null → lazy create → save.
+  const a = makeCtx({ currentChatId: null, savedUpTo: 0, messages: [{ role: 'user', content: 'q' }, { role: 'assistant', content: 'a' }] });
+  const sa = createChatSession(a);
+  await sa.createChatIfNeeded('q');
+  await sa.saveTurnToDashboard();
+  assert.strictEqual(a._created.length, 1);
+  assert.strictEqual(a._saves[0].chatId, 'chat-1');
+  assert.strictEqual(a.savedUpTo, 2);
+  assert.deepStrictEqual(a._warns, []);
+
+  // --resume session: currentChatId set, savedUpTo at resumed length; a new turn
+  // saves the incremental slice to the SAME chat (no reset, no new chat).
+  const b = makeCtx({
+    currentChatId: 'resumed-id', savedUpTo: 2,
+    messages: [{ role: 'user', content: 'q1' }, { role: 'assistant', content: 'a1' }],
+  });
+  const sb = createChatSession(b);
+  await sb.createChatIfNeeded('ignored');   // no-op: currentChatId already set
+  b.messages.push({ role: 'user', content: 'q2' }, { role: 'assistant', content: 'a2' });
+  await sb.saveTurnToDashboard();
+  assert.strictEqual(b._created.length, 0, '--resume must not create a new chat');
+  assert.strictEqual(b._saves.length, 1);
+  assert.strictEqual(b._saves[0].chatId, 'resumed-id');
+  assert.strictEqual(b._saves[0].count, 2, 'only the incremental slice saved');
+  assert.strictEqual(b.savedUpTo, 4);
+});

package/test/chat.test.js

@@ -0,0 +1,114 @@
+'use strict';
+
+// Characterization tests for cmdChat (Task 1.5, tests-first). These lock in the
+// chat loop's observable behavior — slash dispatch, the agent path, session
+// reset, and teardown — BEFORE cmdChat is decomposed into lib/commands/ modules,
+// so the split can be proven behavior-preserving.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { helpText } = require('../lib/commands/registry');
+const { startChat } = require('./harness/chat-harness');
+
+test('startup shows the welcome banner message', async () => {
+  const c = await startChat();
+  try {
+    assert.ok(c.chatHistory.find(/Semalt\.AI/), 'welcome message present');
+    assert.ok(c.chatHistory.find(/Type \/help for commands/), 'help hint present');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('/help renders the registry help text', async () => {
+  const c = await startChat();
+  try {
+    await c.submit('/help');
+    assert.ok(c.chatHistory.texts().includes(helpText()), 'help text emitted verbatim');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('a normal message is blocked when not logged in', async () => {
+  const c = await startChat({ config: { auth_token: '' } });
+  try {
+    await c.submit('hello there');
+    assert.ok(c.chatHistory.find(/Not logged in/), 'unauthenticated message refused');
+    assert.strictEqual(c.calls.runAgentLoop.length, 0, 'agent not invoked');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('a normal message runs the agent loop when authenticated', async () => {
+  const c = await startChat({ config: { auth_token: 'tok' } });
+  try {
+    await c.submit('do the thing');
+    assert.strictEqual(c.calls.runAgentLoop.length, 1, 'agent invoked once');
+    const turn = c.calls.runAgentLoop[0];
+    assert.ok(turn.messages.some((m) => m.role === 'user' && m.content === 'do the thing'), 'user message threaded into the loop');
+    assert.ok(c.chatHistory.messages.some((m) => m.role === 'user' && m.content === 'do the thing'), 'user message shown in history');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('/new resets the conversation so the next turn starts fresh', async () => {
+  const c = await startChat({ config: { auth_token: 'tok' } });
+  try {
+    await c.submit('first message');
+    await c.submit('/new');
+    assert.ok(c.chatHistory.find(/Started new conversation/));
+    await c.submit('second message');
+    const lastTurn = c.calls.runAgentLoop[c.calls.runAgentLoop.length - 1];
+    const userMsgs = lastTurn.messages.filter((m) => m.role === 'user').map((m) => m.content);
+    assert.deepStrictEqual(userMsgs, ['second message'], 'history reset — only the post-/new message remains');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('/clear resets conversation and clears approvals', async () => {
+  const c = await startChat({ config: { auth_token: 'tok' } });
+  try {
+    await c.submit('a message');
+    const before = c.calls.permissionClear;
+    await c.submit('/clear');
+    assert.ok(c.chatHistory.find(/cleared/i));
+    assert.strictEqual(c.calls.permissionClear, before + 1, 'permission approvals cleared');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('/model with no arg shows the current model; with an arg switches it', async () => {
+  const c = await startChat({ config: { auth_token: 'tok', default_model: 'm-one' } });
+  try {
+    await c.submit('/model');
+    assert.ok(c.chatHistory.find(/Current model: m-one/));
+    await c.submit('/model m-two');
+    assert.ok(c.chatHistory.find(/Model → m-two/));
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('an unknown slash-looking message falls through to the agent (authed)', async () => {
+  const c = await startChat({ config: { auth_token: 'tok' } });
+  try {
+    await c.submit('/notacommand please');
+    assert.strictEqual(c.calls.runAgentLoop.length, 1, 'non-command text reaches the agent');
+  } finally {
+    await c.submit('exit'); await c.done; c.cleanup();
+  }
+});
+
+test('exit ends the chat session (the cmdChat promise resolves)', async () => {
+  const c = await startChat();
+  await c.submit('exit');
+  await c.done; // resolves only if the exit handler ran resolveExit
+  c.cleanup();
+  assert.ok(true);
+});

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);
+  }
+});