chels-code 0.0.0-stage → 0.5.0

package/dist/test/intent.test.js

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { classifyRequest } from "../src/engine.js";
+test("routes questions and read-only requests to one AI", () => {
+    for (const request of [
+        "hi",
+        "thanks",
+        "what files are in this project?",
+        "how does the text area work?",
+        "can you explain the build errors?",
+        "list the files",
+        "read package.json",
+        "review this code",
+        "show me the main entry point",
+        "the build failed, why?",
+    ]) {
+        assert.equal(classifyRequest(request), "question", request);
+    }
+});
+test("routes workspace changes and commands to the three-AI team", () => {
+    for (const request of [
+        "create hello.txt",
+        "fix the failing test",
+        "can you build a todo app?",
+        "can you help me build a CLI?",
+        "please update the README",
+        "hey, fix this",
+        "run the tests",
+        "refactor the session store",
+        "add a theme toggle",
+        "commit the changes",
+    ]) {
+        assert.equal(classifyRequest(request), "task", request);
+    }
+});
+test("routes current-info questions to the single AI", () => {
+    for (const request of [
+        "what's the date today?",
+        "what time is it now?",
+        "what's the weather like in Chicago?",
+        "what's the weather in Tokyo?",
+        "what's the news today?",
+        "do you have the latest weather for Paris?",
+        "search the web for the latest AI news",
+    ]) {
+        assert.equal(classifyRequest(request), "question", request);
+    }
+});

package/dist/test/providers.test.js

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createChatCompletion, discoverModels, fetchAvailableCredits, selectReliableModel, } from "../src/providers.js";
+test("discovers models and marks only explicitly zero-priced models free", async (t) => {
+    const originalFetch = globalThis.fetch;
+    t.after(() => { globalThis.fetch = originalFetch; });
+    let requestedUrl;
+    globalThis.fetch = (async (url) => {
+        requestedUrl = String(url);
+        return new Response(JSON.stringify({
+            data: [
+                { id: "paid/model", pricing: { prompt: "0.01", completion: "0.02" } },
+                { id: "free/model:free" },
+                { id: "zero/model", pricing: { prompt: "0", completion: "0" } },
+                { id: "unknown/model", pricing: { prompt: null, completion: "0" } },
+                { name: "missing-id" },
+            ],
+        }));
+    });
+    const models = await discoverModels("openrouter", "test-key");
+    assert.equal(requestedUrl, "https://openrouter.ai/api/v1/models");
+    assert.deepEqual(models.map((model) => [model.id, model.free]), [
+        ["free/model:free", true],
+        ["zero/model", true],
+        ["paid/model", false],
+        ["unknown/model", false],
+    ]);
+});
+test("creates chat completions with tools only when provided", async (t) => {
+    const originalFetch = globalThis.fetch;
+    t.after(() => { globalThis.fetch = originalFetch; });
+    let requestOptions;
+    globalThis.fetch = (async (_url, options) => {
+        requestOptions = options;
+        return new Response(JSON.stringify({
+            choices: [{ message: { content: "ok" } }],
+            usage: { prompt_tokens: 100, completion_tokens: 20, total_tokens: 120, cost: 0.0012 },
+        }));
+    });
+    const result = await createChatCompletion({
+        provider: "groq",
+        apiKey: "test-key",
+        model: "model-id",
+        messages: [{ role: "user", content: "hello" }],
+    });
+    assert.equal(result.message.content, "ok");
+    assert.deepEqual(result.usage, {
+        promptTokens: 100,
+        completionTokens: 20,
+        totalTokens: 120,
+        cost: 0.0012,
+    });
+    const body = JSON.parse(String(requestOptions?.body));
+    assert.equal(body.model, "model-id");
+    assert.equal("tools" in body, false);
+    assert.equal(new Headers(requestOptions?.headers).get("Authorization"), "Bearer test-key");
+});
+test("automatically prefers free models that support tools", () => {
+    const selected = selectReliableModel("openrouter", [
+        { id: "paid/llama-3.3-70b-instruct", name: "paid", free: false, supportsTools: true, contextLength: 128_000 },
+        { id: "free/small-chat:free", name: "small", free: true, supportsTools: false, contextLength: 8_000 },
+        { id: "free/qwen-coder:free", name: "qwen", free: true, supportsTools: true, contextLength: 32_000 },
+    ]);
+    assert.equal(selected.id, "free/qwen-coder:free");
+});
+test("automatically falls back to the strongest stable available chat model", () => {
+    const selected = selectReliableModel("groq", [
+        { id: "audio/whisper-large", name: "whisper", free: false, contextLength: 0 },
+        { id: "llama-3.1-8b-instant", name: "instant", free: false, supportsTools: true, contextLength: 128_000 },
+        { id: "llama-3.3-70b-versatile", name: "versatile", free: false, supportsTools: true, contextLength: 128_000 },
+    ]);
+    assert.equal(selected.id, "llama-3.3-70b-versatile");
+});
+test("reads the available OpenRouter credit balance", async (t) => {
+    const originalFetch = globalThis.fetch;
+    t.after(() => { globalThis.fetch = originalFetch; });
+    let requestedUrl;
+    globalThis.fetch = (async (url) => {
+        requestedUrl = String(url);
+        return new Response(JSON.stringify({
+            data: { limit: 10, limit_remaining: 6.5, usage: 3.5 },
+        }));
+    });
+    const credits = await fetchAvailableCredits("test-key");
+    assert.equal(requestedUrl, "https://openrouter.ai/api/v1/key");
+    assert.deepEqual(credits, { remaining: 6.5, source: "key" });
+});
+test("falls back to account credits when the key has no credit limit", async (t) => {
+    const originalFetch = globalThis.fetch;
+    t.after(() => { globalThis.fetch = originalFetch; });
+    globalThis.fetch = (async (input) => {
+        const url = String(input);
+        if (url.endsWith("/key")) {
+            return new Response(JSON.stringify({
+                data: { limit: null, limit_remaining: null, usage: 2 },
+            }));
+        }
+        return new Response(JSON.stringify({
+            data: { total_credits: 10, total_usage: 2 },
+        }));
+    });
+    const credits = await fetchAvailableCredits("test-key");
+    assert.deepEqual(credits, { remaining: 8, source: "account" });
+});

package/dist/test/resume.test.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { render } from "ink-testing-library";
+import { App } from "../src/ui/App.js";
+import { sanitize } from "../src/ui/theme.js";
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const json = (payload) => new Response(JSON.stringify(payload), {
+    headers: { "Content-Type": "application/json" },
+});
+async function waitFor(app, predicate, timeout = 4_000) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeout) {
+        const text = sanitize(app.lastFrame() ?? "");
+        if (predicate(text))
+            return;
+        await delay(20);
+    }
+    throw new Error(`Timed out waiting for the resumed session.\n${sanitize(app.lastFrame() ?? "")}`);
+}
+async function waitForSavedSession(file) {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        try {
+            return JSON.parse(await readFile(file, "utf8"));
+        }
+        catch {
+            await delay(20);
+        }
+    }
+    throw new Error(`The session was not saved to ${file}.`);
+}
+test("resumes a saved session with its transcript, mode, effort, and usage", async (t) => {
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-resume-"));
+    const sessionsDir = await mkdtemp(path.join(os.tmpdir(), "chels-resume-store-"));
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = (async (input) => {
+        const url = new URL(String(input));
+        if (url.pathname.endsWith("/models")) {
+            return json({
+                data: [{
+                        id: "qwen/qwen3-coder:free",
+                        pricing: { prompt: 0, completion: 0 },
+                        supported_parameters: ["tools"],
+                        context_length: 200_000,
+                    }],
+            });
+        }
+        if (url.pathname.endsWith("/key")) {
+            return json({ data: { limit: 5, limit_remaining: 5, usage: 0 } });
+        }
+        throw new Error(`Unexpected request: ${url}`);
+    });
+    const resume = {
+        schema: 1,
+        id: "abc12345",
+        workspace,
+        createdAt: "2026-01-01T00:00:00.000Z",
+        updatedAt: "2026-01-02T00:00:00.000Z",
+        mode: "plan",
+        effort: "ultra",
+        tokensUsed: 1_234,
+        creditsUsed: 0.5,
+        creditsAvailable: 5,
+        entries: [
+            { id: 1, kind: "user", text: "previous request" },
+            {
+                id: 2,
+                kind: "done",
+                text: "previous answer",
+                made: [{ kind: "file", path: "page.html" }],
+            },
+        ],
+    };
+    const app = render(_jsx(App, { apiKeys: { openrouter: "test", nvidia: "test", groq: "test" }, workspace: workspace, version: "0.5.0", sessionId: resume.id, resume: resume, sessionsDir: sessionsDir }));
+    t.after(async () => {
+        globalThis.fetch = originalFetch;
+        app.unmount();
+        await rm(workspace, { recursive: true, force: true });
+        await rm(sessionsDir, { recursive: true, force: true });
+    });
+    await waitFor(app, (text) => text.includes("Ask anything") && !text.includes("Thinking"));
+    const frame = sanitize(app.lastFrame() ?? "");
+    assert.match(frame, /Resumed session abc12345/);
+    assert.match(frame, /> previous request/);
+    assert.match(frame, /previous answer/);
+    assert.match(frame, /Plan · MystBloom V1\.0  Free ChelsCode · ultra/);
+    assert.match(frame, /1\.2K \(10%\)/);
+    const saved = await waitForSavedSession(path.join(sessionsDir, `${resume.id}.json`));
+    assert.equal(saved.mode, "plan");
+    assert.equal(saved.effort, "ultra");
+    assert.equal(saved.tokensUsed, 1_234);
+    assert.deepEqual(saved.entries.map((entry) => entry.kind), ["user", "done"], "the saved transcript should keep prior messages without a duplicate header");
+});

package/dist/test/safety.test.js

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { isSensitivePath, resolveWorkspacePath } from "../src/safety.js";
+test("blocks paths that escape the workspace", async () => {
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-code-"));
+    try {
+        await assert.rejects(resolveWorkspacePath(workspace, "..\\outside.txt"), /inside the workspace/);
+        await assert.rejects(resolveWorkspacePath(workspace, "C:\\outside.txt"), /Absolute paths/);
+    }
+    finally {
+        await rm(workspace, { recursive: true, force: true });
+    }
+});
+test("blocks secret-like paths but allows the example env file", () => {
+    assert.equal(isSensitivePath(".env"), true);
+    assert.equal(isSensitivePath("config/.env.local"), true);
+    assert.equal(isSensitivePath("keys/private-key.pem"), true);
+    assert.equal(isSensitivePath(".env.example"), false);
+});
+test("blocks symlinks that resolve outside the workspace", async (t) => {
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-code-"));
+    const outside = await mkdtemp(path.join(os.tmpdir(), "chels-outside-"));
+    try {
+        await writeFile(path.join(outside, "data.txt"), "outside the workspace");
+        try {
+            await symlink(outside, path.join(workspace, "linked"), "junction");
+        }
+        catch (error) {
+            if (error.code === "EPERM") {
+                t.skip("Creating symlinks is not permitted in this environment.");
+                return;
+            }
+            throw error;
+        }
+        await assert.rejects(resolveWorkspacePath(workspace, "linked\\data.txt", { mustExist: true }), /outside the workspace/);
+    }
+    finally {
+        await rm(workspace, { recursive: true, force: true });
+        await rm(outside, { recursive: true, force: true });
+    }
+});

package/dist/test/session.test.js

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { createSessionId, findLatestSession, loadSession, resumeHint, sameWorkspace, saveSession, } from "../src/session.js";
+function snapshot(overrides = {}) {
+    return {
+        schema: 1,
+        id: "abc12345",
+        workspace: process.cwd(),
+        createdAt: "2026-01-01T00:00:00.000Z",
+        updatedAt: "2026-01-01T00:00:00.000Z",
+        mode: "plan",
+        effort: "ultra",
+        tokensUsed: 1_234,
+        creditsUsed: 0.5,
+        creditsAvailable: 5,
+        entries: [
+            { id: 1, kind: "user", text: "make a page" },
+            { id: 2, kind: "done", text: "Made the page.", made: [{ kind: "file", path: "page.html" }] },
+        ],
+        ...overrides,
+    };
+}
+test("saves, replaces, and loads a session", async (t) => {
+    const directory = await mkdtemp(path.join(os.tmpdir(), "chels-session-"));
+    t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+    const first = snapshot();
+    saveSession(first, directory);
+    assert.deepEqual(loadSession(first.id, directory), first);
+    const second = snapshot({ updatedAt: "2026-01-02T00:00:00.000Z" });
+    second.entries = [{ id: 1, kind: "note", text: "updated" }];
+    saveSession(second, directory);
+    assert.deepEqual(loadSession(first.id, directory), second);
+});
+test("finds the latest session for a workspace and skips bad files", async (t) => {
+    const directory = await mkdtemp(path.join(os.tmpdir(), "chels-session-"));
+    t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+    const workspace = process.cwd();
+    saveSession(snapshot({
+        id: "older001",
+        updatedAt: "2026-01-01T00:00:00.000Z",
+    }), directory);
+    saveSession(snapshot({
+        id: "newer002",
+        updatedAt: "2026-02-01T00:00:00.000Z",
+    }), directory);
+    saveSession(snapshot({
+        id: "other003",
+        workspace: path.join(workspace, "elsewhere"),
+        updatedAt: "2026-03-01T00:00:00.000Z",
+    }), directory);
+    await writeFile(path.join(directory, "broken04.json"), "{ nope", "utf8");
+    const latest = findLatestSession(workspace, directory);
+    assert.equal(latest?.id, "newer002");
+    assert.equal(findLatestSession(workspace, path.join(directory, "missing")), null);
+});
+test("rejects missing, malformed, and unsafe sessions", async (t) => {
+    const directory = await mkdtemp(path.join(os.tmpdir(), "chels-session-"));
+    t.after(async () => { await rm(directory, { recursive: true, force: true }); });
+    assert.throws(() => loadSession("../secret", directory), /Invalid session id/);
+    assert.throws(() => loadSession("missing1", directory), /was not found/);
+    await writeFile(path.join(directory, "broken01.json"), "{ nope", "utf8");
+    assert.throws(() => loadSession("broken01", directory), /not valid JSON/);
+    await writeFile(path.join(directory, "future01.json"), JSON.stringify({
+        ...snapshot(),
+        id: "future01",
+        schema: 2,
+    }), "utf8");
+    assert.throws(() => loadSession("future01", directory), /unsupported format/);
+});
+test("creates readable session ids and the resume command", () => {
+    const id = createSessionId();
+    assert.match(id, /^[a-z0-9]{8}$/);
+    assert.notEqual(createSessionId(), id);
+    assert.equal(resumeHint(id), `Resume this session with:\n  chelscode --id ${id}`);
+});
+test("compares workspaces case-insensitively on Windows", () => {
+    const workspace = path.join(process.cwd(), "Example");
+    assert.equal(sameWorkspace(workspace, workspace), true);
+    assert.equal(sameWorkspace(workspace, workspace.toUpperCase()), process.platform === "win32");
+});

package/dist/test/title.test.js

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { cleanTitle, installTerminalTitle, titleSequence, } from "../src/terminal-title.js";
+function recordingOutput(isTTY = true) {
+    const writes = [];
+    return {
+        writes,
+        output: {
+            isTTY,
+            write(chunk) {
+                writes.push(chunk);
+                return true;
+            },
+        },
+    };
+}
+test("builds an OSC title sequence and strips control characters", () => {
+    assert.equal(titleSequence("ChelsCode"), "\u001b]0;ChelsCode\u0007");
+    assert.equal(cleanTitle("Clean\u0007Title\u001b]2;evil"), "CleanTitle]2;evil");
+    assert.equal(titleSequence("Chels\u0007Code"), "\u001b]0;ChelsCode\u0007");
+});
+test("sets ChelsCode as the Windows title and restores the previous one", () => {
+    const { writes, output } = recordingOutput();
+    let current = "Windows PowerShell";
+    const restore = installTerminalTitle("ChelsCode", {
+        output,
+        platform: "win32",
+        readTitle: () => current,
+        writeTitle: (title) => {
+            current = title;
+        },
+    });
+    assert.equal(current, "ChelsCode");
+    assert.deepEqual(writes, ["\u001b]0;ChelsCode\u0007"]);
+    restore();
+    assert.equal(current, "Windows PowerShell");
+    assert.deepEqual(writes, [
+        "\u001b]0;ChelsCode\u0007",
+        "\u001b]0;Windows PowerShell\u0007",
+    ]);
+    restore();
+    assert.equal(writes.length, 2, "restoring twice should not write again");
+});
+test("clears the title on non-Windows terminals", () => {
+    const { writes, output } = recordingOutput();
+    let read = false;
+    const restore = installTerminalTitle("ChelsCode", {
+        output,
+        platform: "linux",
+        readTitle: () => {
+            read = true;
+            return "unused";
+        },
+    });
+    assert.equal(read, false, "non-Windows titles cannot be read back");
+    restore();
+    assert.deepEqual(writes, ["\u001b]0;ChelsCode\u0007", "\u001b]0;\u0007"]);
+});
+test("leaves non-interactive output alone", () => {
+    const { writes, output } = recordingOutput(false);
+    let processTitle = "untouched";
+    const restore = installTerminalTitle("ChelsCode", {
+        output,
+        platform: "win32",
+        readTitle: () => "Windows PowerShell",
+        writeTitle: (title) => {
+            processTitle = title;
+        },
+    });
+    restore();
+    assert.deepEqual(writes, []);
+    assert.equal(processTitle, "untouched");
+});

package/dist/test/tools.test.js

@@ -0,0 +1,168 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { executeTool, READ_ONLY_TOOL_DEFINITIONS, TOOL_DEFINITIONS } from "../src/workspace-tools.js";
+const makeContext = (workspace, made = []) => ({
+    workspace,
+    confirm: async () => true,
+    onMade: (item) => made.push(item),
+});
+function jsonResponse(payload) {
+    return new Response(JSON.stringify(payload), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function textResponse(body) {
+    return new Response(body, {
+        status: 200,
+        headers: { "Content-Type": "text/html" },
+    });
+}
+test("tracks files that were actually written and ignores declined writes", async () => {
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-tools-"));
+    const made = [];
+    const context = {
+        workspace,
+        confirm: async () => true,
+        onMade: (item) => made.push(item),
+    };
+    try {
+        await executeTool("write_file", JSON.stringify({ path: "notes.txt", content: "hello\n" }), context);
+        assert.equal(await readFile(path.join(workspace, "notes.txt"), "utf8"), "hello\n");
+        assert.deepEqual(made, [{ kind: "file", path: "notes.txt" }]);
+        await executeTool("list_files", JSON.stringify({ path: "." }), context);
+        assert.deepEqual(made, [{ kind: "file", path: "notes.txt" }], "read-only tools should not count");
+        const declined = [];
+        await executeTool("write_file", JSON.stringify({ path: "skipped.txt", content: "nope" }), {
+            ...context,
+            confirm: async () => false,
+            onMade: (item) => declined.push(item),
+        });
+        assert.deepEqual(declined, [], "a declined write should not count as made");
+    }
+    finally {
+        await rm(workspace, { recursive: true, force: true });
+    }
+});
+test("answers the current date and time with the datetime tool", async () => {
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-tools-"));
+    try {
+        const raw = await executeTool("get_current_datetime", JSON.stringify({}), {
+            workspace,
+            confirm: async () => true,
+            onMade: () => { },
+        });
+        const result = JSON.parse(raw);
+        assert.equal(typeof result.iso, "string");
+        assert.equal(typeof result.epochMs, "number");
+        assert.ok(!Number.isNaN(Date.parse(result.iso)));
+        assert.ok(result.timezone.length > 0);
+        assert.ok(result.dayOfWeek.length > 0);
+        assert.ok(result.date.length > 0);
+        assert.ok(result.time.length > 0);
+    }
+    finally {
+        await rm(workspace, { recursive: true, force: true });
+    }
+});
+test("answers weather questions with the weather tool", async () => {
+    const originalFetch = globalThis.fetch;
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-tools-"));
+    const urls = [];
+    globalThis.fetch = (async (input) => {
+        const url = String(input);
+        urls.push(url);
+        if (url.includes("geocoding-api.open-meteo.com")) {
+            return jsonResponse({
+                results: [{
+                        name: "Testville",
+                        latitude: 12.34,
+                        longitude: 56.78,
+                        country: "Testland",
+                        admin1: "Testshire",
+                    }],
+            });
+        }
+        return jsonResponse({
+            current: {
+                temperature_2m: 21.5,
+                apparent_temperature: 20,
+                relative_humidity_2m: 60,
+                wind_speed_50m: 5,
+                precipitation: 0,
+                is_day: 1,
+                weather_code: 2,
+            },
+        });
+    });
+    try {
+        const raw = await executeTool("get_weather", JSON.stringify({ location: "Testville" }), makeContext(workspace));
+        const result = JSON.parse(raw);
+        assert.equal(result.location, "Testville");
+        assert.equal(result.temperatureC, 21.5);
+        assert.equal(result.condition, "Partly cloudy");
+        assert.equal(urls[0]?.includes("geocoding-api.open-meteo.com"), true);
+        assert.equal(urls[1]?.includes("api.open-meteo.com"), true);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        await rm(workspace, { recursive: true, force: true });
+    }
+});
+test("answers news questions with the news tool", async () => {
+    const originalFetch = globalThis.fetch;
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-tools-"));
+    globalThis.fetch = (async () => textResponse(`<?xml version="1.0"?>
+<rss version="2.0"><channel><title>Top stories</title>
+<item><title>Headline one</title><link>https://example.com/one</link><pubDate>2026-01-01</pubDate><source>Example News</source></item>
+<item><title>Headline two</title><link>https://example.com/two</link><pubDate>2026-01-02</pubDate><source>Example News</source></item>
+</channel></rss>`));
+    try {
+        const raw = await executeTool("get_news", JSON.stringify({}), makeContext(workspace));
+        const result = JSON.parse(raw);
+        assert.equal(result.query, "top news");
+        assert.equal(result.items.length, 2);
+        assert.equal(result.items[0]?.title, "Headline one");
+        assert.equal(result.items[0]?.source, "Example News");
+        assert.equal(result.items[1]?.url, "https://example.com/two");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        await rm(workspace, { recursive: true, force: true });
+    }
+});
+test("answers web search questions with the web search tool", async () => {
+    const originalFetch = globalThis.fetch;
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-tools-"));
+    const searchHtml = `<html><body>
+<div class="result results_links"><div class="result"><a class="result__a" href="https://example.com/one">First result</a><div class="result__snippet">Snippet one text.</div></div></div>
+<div class="result results_links"><div class="result"><a class="result__a" href="https://example.com/two">Second result</a><div class="result__snippet">Snippet two text.</div></div></div>
+</body></html>`;
+    globalThis.fetch = (async () => textResponse(searchHtml));
+    try {
+        const raw = await executeTool("web_search", JSON.stringify({ query: "latest ai news" }), makeContext(workspace));
+        const result = JSON.parse(raw);
+        assert.equal(result.query, "latest ai news");
+        assert.equal(result.results.length, 2);
+        assert.equal(result.results[0]?.title, "First result");
+        assert.equal(result.results[0]?.url, "https://example.com/one");
+        assert.equal(result.results[0]?.snippet, "Snippet one text.");
+        assert.equal(result.results[1]?.snippet, "Snippet two text.");
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        await rm(workspace, { recursive: true, force: true });
+    }
+});
+test("exposes the current-info tools to question mode", () => {
+    assert.deepEqual(READ_ONLY_TOOL_DEFINITIONS.map((tool) => tool.function.name), ["list_files", "read_file", "get_current_datetime", "get_weather", "web_search", "get_news"]);
+    assert.ok(TOOL_DEFINITIONS.some((tool) => tool.function.name === "run_command"));
+});
+test("rejects unknown tools", async () => {
+    const workspace = await mkdtemp(path.join(os.tmpdir(), "chels-tools-"));
+    await assert.rejects(executeTool("not_a_tool", JSON.stringify({}), makeContext(workspace)), /Unknown tool/);
+    await rm(workspace, { recursive: true, force: true });
+});