@semalt-ai/code 1.8.5 → 1.19.0

package/test/harness/chat-harness.js

@@ -0,0 +1,142 @@
+'use strict';
+
+// Chat-loop smoke harness for cmdChat (Task 1.5, tests-first). Drives the real
+// createCommands().cmdChat() with a fully mocked UI so the interactive chat
+// closure can be characterized WITHOUT a TTY: the mock inputField captures the
+// onSubmit callback, and submit(text) invokes it exactly as a keypress would.
+//
+// Home-based paths (saved sessions, audit log) are redirected to a temp dir
+// before any lib module loads, so a chat session writes nothing real.
+
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const TMP_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-chat-home-'));
+process.env.HOME = TMP_HOME;
+process.env.USERPROFILE = TMP_HOME;
+
+const { createCommands } = require('../../lib/commands');
+const tools = require('../../lib/tools');
+
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// The mock UI handles returned by createUI().
+function makeChatUI() {
+  const chatHistory = {
+    messages: [],
+    addMessage(m) { this.messages.push(m); },
+    clearMessages() { this.messages = []; },
+    clearStreamingContent() {},
+    collapseById() {}, removeById() {}, rerenderById() {},
+    finalizeLastMessage() {}, streamToken() {}, toggleLastExpand() {},
+    texts() { return this.messages.map((m) => (typeof m.content === 'string' ? m.content : '')); },
+    last() { return this.messages[this.messages.length - 1]; },
+    find(re) { return this.texts().find((t) => re.test(t)); },
+  };
+  const statusBar = {
+    states: [],
+    update(...a) { this.states.push(a); },
+    setModel() {}, setContextLimit() {}, updateMetrics() {}, addPendingTokens() {}, onToken() {},
+  };
+  const inputField = {
+    _submit: null, _handlers: {}, _nav: null,
+    onSubmit(cb) { this._submit = cb; },
+    on(ev, cb) { (this._handlers[ev] = this._handlers[ev] || []).push(cb); },
+    removeListener(ev, cb) { const a = this._handlers[ev] || []; const i = a.indexOf(cb); if (i >= 0) a.splice(i, 1); },
+    captureNavigation(h) { this._nav = h; },
+    releaseNavigation() { this._nav = null; },
+    setDisabled() {}, setSearchItems() {}, captureSelect() { return Promise.resolve(null); },
+    async submit(text) { if (!this._submit) throw new Error('onSubmit not registered'); return this._submit(text); },
+    emit(ev, ...args) { for (const cb of (this._handlers[ev] || [])) cb(...args); },
+  };
+  return { chatHistory, statusBar, inputField, layout: null, destroy: () => {}, redrawFixed: () => {} };
+}
+
+// The `ui` object createCommands destructures (colors + helpers + createUI).
+function makeUI(chatUI) {
+  const ui = { createUI: () => chatUI };
+  for (const k of ['BOLD', 'BG_SELECTED', 'FG_BLUE', 'FG_CYAN', 'FG_DARK', 'FG_GRAY', 'FG_GREEN', 'FG_RED', 'FG_TEAL', 'FG_YELLOW', 'RST', 'DIM']) ui[k] = '';
+  ui.approxTokens = (s) => Math.ceil(((s || '').length) / 4);
+  ui.getCols = () => 80;
+  ui.boxLine = (s) => s;
+  ui.interactiveSelect = async () => null;
+  return ui;
+}
+
+function makeDeps(chatUI, overrides = {}) {
+  const config = {
+    auth_token: '', default_model: 'test-model', dashboard_model_id: null,
+    dashboard_url: 'http://dash', api_base: 'http://api', models: [],
+    system_prompt_mode: 'system_role', temperature: 0.7,
+    ...(overrides.config || {}),
+  };
+  const getConfig = () => config;
+  const setConfig = (c) => Object.assign(config, c);
+
+  const calls = { runAgentLoop: [], chatStream: [], shell: [], permissionClear: 0 };
+
+  const permissionManager = {
+    setUICallbacks() {}, clear() { calls.permissionClear++; }, toggleAll() { return true; },
+    askPermission: async () => true, readonlyBlock: () => null, captureSelect: async () => null, state: {},
+  };
+
+  const apiClient = {
+    chatStream: async (...a) => { calls.chatStream.push(a); return { content: '', usage: null }; },
+    chatSync: async () => '',
+    dashboardCreateChat: async () => ({ chat: { id: 1 } }),
+    dashboardGetChat: async () => ({ chat: { title: 't' }, messages: [] }),
+    dashboardSaveMessages: async () => ({}),
+    dashboardListChats: async () => ({ chats: [] }),
+    dashboardListModels: async () => ({ models: [] }),
+    dashboardGetModelForCli: async () => ({ model: null }),
+    dashboardWhoAmI: async () => ({ user: null }),
+    dashboardLogout: async () => ({}),
+    estimateTokens: (s) => Math.ceil((s || '').length / 4),
+    getCliLoginStatus: async () => ({ status: 'authorized' }),
+    requestCliLogin: async () => ({ id: 1, hash: 'h', token: 'tok', verification_url: 'http://v' }),
+    setActiveModelProfile: () => {},
+    ...(overrides.apiClient || {}),
+  };
+
+  const runAgentLoop = overrides.runAgentLoop
+    || (async (messages, model, maxIter, limit, opts) => {
+      calls.runAgentLoop.push({ messages: messages.map((m) => ({ ...m })), model, opts });
+      return { messages, metrics: { summary: () => 'metrics-summary' } };
+    });
+  const readFileContext = overrides.readFileContext || ((f) => `ctx:${JSON.stringify(f)}`);
+  const agentExecShell = overrides.agentExecShell
+    || (async (cmd, o) => { calls.shell.push({ cmd, o }); return { exit_code: 0, stdout: `out:${cmd}`, stderr: '' }; });
+
+  return {
+    deps: { getConfig, setConfig, permissionManager, ui: makeUI(chatUI), apiClient, runAgentLoop, readFileContext, agentExecShell },
+    config, calls,
+  };
+}
+
+// Start a chat session. Returns once onSubmit is registered. `submit(text)` runs
+// a turn; `submit('exit')` ends the session (await `done` to confirm teardown).
+async function startChat(overrides = {}) {
+  const chatUI = makeChatUI();
+  const { deps, config, calls } = makeDeps(chatUI, overrides);
+  const commands = createCommands(deps);
+  const done = commands.cmdChat({ model: undefined, ...(overrides.opts || {}) });
+
+  // Wait for cmdChat's async setup (ensureDefaultModel + resolveTokenLimit) to
+  // register the submit handler.
+  for (let i = 0; i < 200 && !chatUI.inputField._submit; i++) await delay(2);
+  if (!chatUI.inputField._submit) throw new Error('cmdChat did not register onSubmit');
+
+  return {
+    chatHistory: chatUI.chatHistory,
+    statusBar: chatUI.statusBar,
+    inputField: chatUI.inputField,
+    config,
+    calls,
+    submit: (text) => chatUI.inputField.submit(text),
+    done,
+    cleanup: () => { try { tools.setUIActive(false); } catch {} },
+  };
+}
+
+module.exports = { startChat };

package/test/harness/memwarn-headless-child.js

@@ -0,0 +1,65 @@
+'use strict';
+
+// Child process for the memory-truncation headless test. Runs cmdCode in json
+// mode with an oversized project AGENTS.md so the PARENT can capture this
+// process's stdout (the JSON envelope) and stderr (the truncation warning)
+// cleanly — running in a child avoids swapping the parent's global
+// process.stdout, which would collide with the node:test TAP reporter.
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..'); // project root
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'memwarn-child-home-'));
+process.env.HOME = home;
+process.env.USERPROFILE = home;
+process.env.SEMALT_API_KEY = 'test-key';
+
+const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'memwarn-child-repo-'));
+fs.mkdirSync(path.join(repo, '.git'), { recursive: true });
+const { DEFAULT_MEMORY_MAX_BYTES } = require(path.join(ROOT, 'lib', 'memory'));
+fs.writeFileSync(path.join(repo, 'AGENTS.md'), 'Z'.repeat(DEFAULT_MEMORY_MAX_BYTES + 4000));
+process.chdir(repo);
+
+const ui = require(path.join(ROOT, 'lib', 'ui'));
+const { createApiClient } = require(path.join(ROOT, 'lib', 'api'));
+const { createToolExecutor, extractToolCalls } = require(path.join(ROOT, 'lib', 'tools'));
+const { createPermissionManager } = require(path.join(ROOT, 'lib', 'permissions'));
+const { createAgentRunner } = require(path.join(ROOT, 'lib', 'agent'));
+const { createOneshotCommands } = require(path.join(ROOT, 'lib', 'commands', 'oneshot'));
+const { startMockLLM } = require(path.join(ROOT, 'test', 'harness', 'mock-llm'));
+
+(async () => {
+  const mock = await startMockLLM();
+  mock.replyWith('All done.');
+  const config = {
+    api_base: mock.base, api_key: 'test-key', auth_token: 'tok', default_model: 'test-model',
+    temperature: 0.5, request_timeout_ms: 5000, stream: true, models: [],
+    max_iterations: 10, system_prompt_mode: 'system_role', pricing: {},
+  };
+  const getConfig = () => config;
+  const api = createApiClient({ getConfig, saveConfig() {}, ui });
+  const pm = createPermissionManager(ui, { skipPermissions: true });
+  pm.setUICallbacks({ onAddMessage() {}, onShowModal() {}, onCloseModal() {}, onCaptureNavigation: () => () => {} });
+  const { agentExecShell, agentExecFile, describePermission } = createToolExecutor(pm, ui, getConfig);
+  const runner = createAgentRunner({
+    chatStream: api.chatStream, extractToolCalls, agentExecShell, agentExecFile,
+    describePermission, permissionManager: pm, ui, getConfig,
+  });
+  const shared = {
+    ...ui,
+    writer: { scrollback() {} },
+    getConfig, setConfig() {},
+    runAgentLoop: runner.runAgentLoop,
+    readFileContext: () => '',
+    ensureDefaultModel: async () => {},
+    msgs: require(path.join(ROOT, 'lib', 'ui', 'messages')),
+    dbg: require(path.join(ROOT, 'lib', 'debug')),
+  };
+  const { cmdCode } = createOneshotCommands(shared);
+  await cmdCode({ outputFormat: 'json' }, ['do something']);
+  await mock.close();
+  process.exit(0);
+})().catch((e) => { process.stderr.write('CHILDERR:' + (e && e.stack || e) + '\n'); process.exit(1); });

package/test/harness/mock-llm.js

@@ -0,0 +1,120 @@
+'use strict';
+
+// Scriptable mock LLM server for agent-loop integration tests (Task 1.2).
+// Built on the SSE primitives in ./sse-server. A single server instance serves
+// a FIFO queue of scripted responses — one per inbound POST — so a multi-turn
+// agent loop (or a retry sequence) is driven deterministically with no real
+// network and no real model.
+//
+// Each queued response is either:
+//   * a streamed 200 SSE reply (assistant content and/or native tool_calls), or
+//   * an error (non-200) with an optional JSON body and headers (e.g.
+//     Retry-After) — used to exercise the retry/backoff and 400/413 paths.
+//
+// See ./README.md for the full contract and examples.
+
+const http = require('http');
+const { sse, DONE } = require('./sse-server');
+
+// Build the SSE chunk list for a plain assistant message that streams `content`.
+// `content` may be a string (sent as one delta) or an array of strings (sent as
+// successive deltas, to exercise token-by-token handling and mid-stream abort).
+function contentChunks(content, { finish = 'stop', usage = null } = {}) {
+  const parts = Array.isArray(content) ? content : (content ? [content] : []);
+  const chunks = parts.map((p) => sse({ choices: [{ delta: { content: p } }] }));
+  chunks.push(sse({ choices: [{ finish_reason: finish, delta: {} }] }));
+  if (usage) chunks.push(sse({ usage }));
+  chunks.push(DONE);
+  return chunks;
+}
+
+// Build the SSE chunk list for a native OpenAI tool_calls response.
+function toolCallChunks(name, args, { id = 'call_1' } = {}) {
+  return [
+    sse({ choices: [{ delta: { tool_calls: [{ index: 0, id, type: 'function', function: { name, arguments: JSON.stringify(args) } }] } }] }),
+    sse({ choices: [{ finish_reason: 'tool_calls', delta: {} }] }),
+    DONE,
+  ];
+}
+
+function startMockLLM() {
+  const queue = [];
+  const requests = [];
+
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.setEncoding('utf8');
+    req.on('data', (c) => { body += c; });
+    req.on('end', () => {
+      requests.push({ url: req.url, body, headers: req.headers });
+      const spec = queue.shift();
+      if (!spec) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end('{"error":"mock-llm: response queue empty"}');
+        return;
+      }
+      serve(res, spec);
+    });
+  });
+
+  function serve(res, spec) {
+    const status = spec.status || 200;
+    const isSse = status === 200;
+    res.writeHead(status, {
+      'Content-Type': isSse ? 'text/event-stream' : 'application/json',
+      ...(spec.headers || {}),
+    });
+    if (!isSse) {
+      res.end(spec.body != null ? spec.body : '{}');
+      return;
+    }
+    const chunks = spec.chunks || [];
+    const gap = spec.gapMs == null ? 2 : spec.gapMs;
+    let i = 0;
+    const next = () => {
+      if (res.writableEnded) return;
+      if (i >= chunks.length) { res.end(); return; }
+      res.write(chunks[i++]);
+      if (gap > 0) setTimeout(next, gap); else next();
+    };
+    next();
+  }
+
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      resolve({
+        base: `http://127.0.0.1:${port}`,
+        port,
+        requests,
+
+        // Enqueue a streamed assistant message (string or string[] of deltas).
+        replyWith(content, opts = {}) {
+          queue.push({ status: 200, chunks: contentChunks(content, opts), gapMs: opts.gapMs });
+          return this;
+        },
+        // Enqueue a native tool_calls response.
+        replyWithToolCall(name, args, opts = {}) {
+          queue.push({ status: 200, chunks: toolCallChunks(name, args, opts), gapMs: opts.gapMs });
+          return this;
+        },
+        // Enqueue raw SSE chunks (full control).
+        streamChunks(chunks, opts = {}) {
+          queue.push({ status: 200, chunks, gapMs: opts.gapMs });
+          return this;
+        },
+        // Enqueue an error (non-200) response.
+        failWith(status, { body, headers } = {}) {
+          queue.push({ status, body, headers });
+          return this;
+        },
+
+        pending() { return queue.length; },
+        requestCount() { return requests.length; },
+        close() { return new Promise((r) => server.close(r)); },
+      });
+    });
+  });
+}
+
+module.exports = { startMockLLM, contentChunks, toolCallChunks };

package/test/harness/mock-mcp-server.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+'use strict';
+
+// Mock MCP server over stdio (Task 3.3).
+// ----------------------------------------------------------------------------
+// A tiny, dependency-free, spec-correct MCP server the tests spawn as a local
+// subprocess (no network). It speaks newline-delimited JSON-RPC 2.0 on
+// stdin/stdout — exactly the framing `StdioClientTransport` reads — so the REAL
+// MCP SDK client connects to it and the whole discovery/dispatch path is
+// exercised against a deterministic peer.
+//
+// Implemented methods: `initialize`, `notifications/initialized` (ignored),
+// `tools/list`, `tools/call`, `ping`. It deliberately does NOT depend on the
+// SDK server classes (which require zod schemas) — the raw protocol is ~60
+// lines and keeps the test self-contained and reproducible.
+//
+// Behavior knobs (env vars, so a test can script edge cases):
+//   MOCK_MCP_NAME           server name advertised in initialize (default "mock")
+//   MOCK_MCP_EXIT_ON_START  if set, exit(1) immediately — simulates a server
+//                           that dies on launch (graceful-degradation test).
+//
+// Tools exposed:
+//   echo  { text }       → returns the text back (untrusted-content payloads
+//                          can be injected here to test the delimiter).
+//   add   { a, b }       → returns a+b.
+//   boom  {}             → returns an MCP tool-level error (isError: true).
+
+const SERVER_NAME = process.env.MOCK_MCP_NAME || 'mock';
+
+const TOOLS = [
+  {
+    name: 'echo',
+    description: 'Echo the provided text back verbatim.',
+    inputSchema: {
+      type: 'object',
+      properties: { text: { type: 'string', description: 'Text to echo' } },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'add',
+    description: 'Add two numbers and return the sum.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        a: { type: 'number', description: 'First addend' },
+        b: { type: 'number', description: 'Second addend' },
+      },
+      required: ['a', 'b'],
+    },
+  },
+  {
+    name: 'boom',
+    description: 'Always reports a tool-level error.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+];
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function ok(id, result) {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function err(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+function callTool(name, args) {
+  if (name === 'echo') {
+    return { content: [{ type: 'text', text: String((args && args.text) ?? '') }] };
+  }
+  if (name === 'add') {
+    const sum = Number((args && args.a) || 0) + Number((args && args.b) || 0);
+    return { content: [{ type: 'text', text: String(sum) }] };
+  }
+  if (name === 'boom') {
+    return { content: [{ type: 'text', text: 'the boom tool failed as designed' }], isError: true };
+  }
+  return null; // unknown tool
+}
+
+function handle(msg) {
+  const { id, method, params } = msg;
+  if (method === 'initialize') {
+    // Echo the client's requested protocol version — by definition one the
+    // client supports — and advertise the tools capability.
+    ok(id, {
+      protocolVersion: (params && params.protocolVersion) || '2025-06-18',
+      capabilities: { tools: {} },
+      serverInfo: { name: SERVER_NAME, version: '1.0.0' },
+    });
+    return;
+  }
+  if (method === 'notifications/initialized') return; // notification, no reply
+  if (method === 'ping') { ok(id, {}); return; }
+  if (method === 'tools/list') { ok(id, { tools: TOOLS }); return; }
+  if (method === 'tools/call') {
+    const name = params && params.name;
+    const result = callTool(name, params && params.arguments);
+    if (!result) { err(id, -32602, `Unknown tool: ${name}`); return; }
+    ok(id, result);
+    return;
+  }
+  if (id !== undefined) err(id, -32601, `Method not found: ${method}`);
+}
+
+function run() {
+  // Behavior knob: simulate a server that dies on launch (degradation test).
+  if (process.env.MOCK_MCP_EXIT_ON_START) {
+    process.stderr.write('mock-mcp-server: simulated startup failure\n');
+    process.exit(1);
+  }
+  let buffer = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', (chunk) => {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!line) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }
+      try { handle(msg); } catch (e) {
+        if (msg && msg.id !== undefined) err(msg.id, -32603, e.message);
+      }
+    }
+  });
+  process.stdin.on('end', () => process.exit(0));
+}
+
+// Only attach the stdin server loop when spawned directly (as the MCP client
+// does). The Node test runner discovers and EXECUTES every file under test/ —
+// including this one — each in a child process where `require.main === module`
+// is also true. It sets NODE_TEST_CONTEXT in that child, so we use its ABSENCE
+// (plus require.main) to mean "spawned as a real MCP server"; otherwise this
+// stdin loop would hang the test runner forever waiting on input.
+if (require.main === module && !process.env.NODE_TEST_CONTEXT) run();
+

package/test/harness/sse-server.js

@@ -0,0 +1,69 @@
+'use strict';
+
+// Minimal scriptable SSE server for streaming-parser tests (Task 1.1).
+// Task 1.2 extends this into the full mock-LLM harness (queues, status codes,
+// Retry-After, delays); for now it serves one scripted response per request.
+//
+// Usage:
+//   const srv = await startSseServer({ chunks: ['data: {...}\n', 'data: [DONE]\n'] });
+//   // point config.api_base at srv.base, make the request, then:
+//   await srv.close();
+
+const http = require('http');
+
+// opts:
+//   chunks   string[] — written sequentially (with a tiny gap) so the client's
+//            cross-chunk line buffering is genuinely exercised. A single string
+//            is also accepted and sent as one chunk.
+//   status   HTTP status code (default 200).
+//   headers  extra response headers (merged over the SSE defaults).
+//   gapMs    delay between chunks (default 4ms).
+function startSseServer(opts = {}) {
+  const status = opts.status || 200;
+  const gapMs = opts.gapMs == null ? 4 : opts.gapMs;
+  const chunks = Array.isArray(opts.chunks)
+    ? opts.chunks
+    : [opts.body != null ? opts.body : ''];
+
+  const server = http.createServer((req, res) => {
+    // Drain the request body before responding.
+    req.resume();
+    req.on('end', () => {
+      res.writeHead(status, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        ...(opts.headers || {}),
+      });
+      let i = 0;
+      const writeNext = () => {
+        if (i >= chunks.length) { res.end(); return; }
+        res.write(chunks[i++]);
+        if (gapMs > 0) setTimeout(writeNext, gapMs);
+        else writeNext();
+      };
+      writeNext();
+    });
+  });
+
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => {
+      const { port } = server.address();
+      resolve({
+        server,
+        port,
+        base: `http://127.0.0.1:${port}`,
+        close: () => new Promise((r) => server.close(r)),
+      });
+    });
+  });
+}
+
+// Build a `data: {json}\n` SSE line.
+function sse(obj) {
+  return `data: ${JSON.stringify(obj)}\n`;
+}
+
+const DONE = 'data: [DONE]\n';
+
+module.exports = { startSseServer, sse, DONE };