chels-code 0.0.0-stage → 0.5.1

package/dist/src/ui/Transcript.js

@@ -0,0 +1,67 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { ASSISTANT_NAME, breakLongWords, limitLines, plural, sanitize, shortenPath, TAGLINE, theme, } from "./theme.js";
+function TextBlock({ text, railColor, color, limit = 160, width, }) {
+    const content = limitLines(text, limit);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderTop: false, borderBottom: false, borderRight: false, borderColor: railColor, paddingLeft: 1, flexShrink: 1, minWidth: 0, children: [_jsx(Text, { color: color, children: breakLongWords(content.text || " ", width) }), content.omitted > 0 ? (_jsxs(Text, { color: theme.faint, children: ["\u2026 ", content.omitted, " more ", plural(content.omitted, "line")] })) : null] }));
+}
+const LOGO = [
+    " ██████╗██╗  ██╗███████╗██╗     ███████╗ ██████╗ ██████╗ ██████╗ ███████╗",
+    "██╔════╝██║  ██║██╔════╝██║     ██╔════╝██╔════╝██╔═══██╗██╔══██╗██╔════╝",
+    "██║     ███████║█████╗  ██║     ███████╗██║     ██║   ██║██║  ██║█████╗  ",
+    "██║     ██╔══██║██╔══╝  ██║     ╚════██║██║     ██║   ██║██║  ██║██╔══╝  ",
+    "╚██████╗██║  ██║███████╗███████╗███████║╚██████╗╚██████╔╝██████╔╝███████╗",
+    " ╚═════╝╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝",
+];
+const LOGO_WIDTH = 73;
+const LOGO_COLORS = [
+    theme.bright,
+    theme.bright,
+    theme.primary,
+    theme.primary,
+    theme.deep,
+    theme.deep,
+];
+function HeaderEntry({ entry, columns }) {
+    const wide = columns >= LOGO_WIDTH + 4;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, marginBottom: 1, children: [wide ? (_jsxs(_Fragment, { children: [LOGO.map((line, index) => (_jsx(Text, { color: LOGO_COLORS[index], children: line }, index))), _jsxs(Box, { width: LOGO_WIDTH, justifyContent: "space-between", children: [_jsx(Text, { color: theme.dim, children: TAGLINE }), _jsx(Text, { color: theme.faint, children: entry.version })] })] })) : (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.primary, children: "\u25C6" }), _jsx(Text, { bold: true, color: theme.bright, children: " ChelsCode" }), _jsxs(Text, { color: theme.faint, children: ["  ", entry.version] })] }), _jsx(Text, { color: theme.dim, children: TAGLINE })] })), _jsx(Text, { color: theme.faint, children: shortenPath(entry.workspace, Math.max(18, columns - 6)) }), entry.resumedFrom ? (_jsxs(Text, { color: theme.faint, children: ["Resumed session ", entry.resumedFrom] })) : null] }));
+}
+function UserEntry({ entry, columns }) {
+    return (_jsxs(Box, { paddingX: 2, marginTop: 1, children: [_jsx(Text, { color: theme.primary, children: "> " }), _jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minWidth: 0, children: _jsx(Text, { color: theme.white, children: breakLongWords(sanitize(entry.text), Math.max(8, columns - 6)) }) })] }));
+}
+function PlanEntry({ entry, columns }) {
+    return (_jsx(Box, { paddingX: 2, marginTop: 1, width: columns, children: _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.primary, paddingX: 1, width: Math.max(16, columns - 4), children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: "Combined plan" }), _jsxs(Text, { color: theme.faint, children: ["  ·  ", entry.tasks.length, " ", plural(entry.tasks.length, "task"), "  ·  "] }), _jsx(Text, { color: theme.primary, children: ASSISTANT_NAME })] }), entry.tasks.map((task, index) => {
+                    const instructions = limitLines(task.instructions, 40);
+                    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [_jsxs(Text, { color: theme.primary, children: [index + 1, ". "] }), _jsx(Text, { bold: true, children: sanitize(task.title) })] }), _jsx(Text, { color: theme.dim, children: breakLongWords(instructions.text, Math.max(8, columns - 8)) }), instructions.omitted > 0 ? (_jsxs(Text, { color: theme.faint, children: ["\u2026 ", instructions.omitted, " more ", plural(instructions.omitted, "line")] })) : null] }, `${index}-${task.title}`));
+                })] }) }));
+}
+function madeText(item) {
+    return item.kind === "file" ? item.path : item.command;
+}
+function DoneEntry({ entry, columns }) {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.green, children: "\u25C6" }), _jsx(Text, { bold: true, color: theme.green, children: " Done" })] }), entry.text ? (_jsx(TextBlock, { text: entry.text, railColor: theme.green, width: columns - 6 })) : null, entry.made.length > 0 ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: theme.dim, children: "Made" }), entry.made.map((item, index) => (_jsxs(Text, { children: [_jsx(Text, { color: item.kind === "file" ? theme.green : theme.yellow, children: item.kind === "file" ? "+ " : "$ " }), _jsx(Text, { color: theme.dim, children: breakLongWords(sanitize(madeText(item)), Math.max(8, columns - 8)) })] }, `${item.kind}-${index}`)))] })) : null] }));
+}
+function NoteEntry({ entry }) {
+    return (_jsx(Box, { paddingX: 2, marginTop: 1, children: _jsxs(Text, { children: [_jsx(Text, { color: theme.primary, children: "\u25C6" }), _jsxs(Text, { color: theme.dim, children: [" ", sanitize(entry.text)] })] }) }));
+}
+function ErrorEntry({ entry, columns }) {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, marginTop: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.red, children: "\u2716" }), _jsxs(Text, { bold: true, color: theme.red, children: [" ", sanitize(entry.title)] })] }), _jsx(TextBlock, { text: entry.message, railColor: theme.red, width: columns - 6 })] }));
+}
+export function TranscriptEntryView({ entry, columns }) {
+    switch (entry.kind) {
+        case "header":
+            return _jsx(HeaderEntry, { entry: entry, columns: columns });
+        case "user":
+            return _jsx(UserEntry, { entry: entry, columns: columns });
+        case "plan":
+            return _jsx(PlanEntry, { entry: entry, columns: columns });
+        case "done":
+            return _jsx(DoneEntry, { entry: entry, columns: columns });
+        case "note":
+            return _jsx(NoteEntry, { entry: entry });
+        case "error":
+            return _jsx(ErrorEntry, { entry: entry, columns: columns });
+        default:
+            return null;
+    }
+}

package/dist/src/ui/theme.js

@@ -0,0 +1,130 @@
+import os from "node:os";
+export const TAGLINE = "I like cats";
+export const ASSISTANT_NAME = "MystBloom V1.0";
+export const MODE_LABELS = {
+    build: "Build",
+    plan: "Plan",
+};
+export const PLAN_NAME = "Free ChelsCode";
+export const theme = {
+    primary: "#a78bfa",
+    bright: "#d8b4fe",
+    deep: "#7c3aed",
+    dim: "#9ca3af",
+    faint: "#6b7280",
+    green: "#34d399",
+    yellow: "#fbbf24",
+    red: "#f87171",
+    orange: "#fb923c",
+    white: "#f5f3ff",
+    blue: "#60a5fa",
+    cyan: "#22d3ee",
+    pink: "#f472b6",
+};
+export const EFFORT_COLORS = {
+    low: theme.green,
+    medium: theme.cyan,
+    high: theme.yellow,
+    max: theme.orange,
+    ultra: theme.pink,
+};
+export const PROVIDER_UI = {
+    openrouter: { label: "OpenRouter", color: theme.primary },
+    nvidia: { label: "NVIDIA", color: theme.green },
+    groq: { label: "Groq", color: theme.orange },
+};
+export function providerLabel(provider) {
+    return PROVIDER_UI[provider]?.label ?? provider;
+}
+export function providerColor(provider) {
+    return PROVIDER_UI[provider]?.color ?? theme.primary;
+}
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+const OSC = /\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
+export function sanitize(text) {
+    return String(text)
+        .replace(OSC, "")
+        .replace(ANSI, "")
+        .replace(/\r\n?/g, "\n")
+        .replace(/\t/g, "    ")
+        .replace(CONTROL, "");
+}
+export function truncate(text, max) {
+    if (max <= 0)
+        return "";
+    const plain = sanitize(text);
+    const chars = [...plain];
+    if (chars.length <= max)
+        return plain;
+    return `${chars.slice(0, Math.max(0, max - 1)).join("")}…`;
+}
+export function limitLines(text, limit = 160) {
+    const lines = sanitize(text).split("\n");
+    if (lines.length <= limit)
+        return { text: lines.join("\n"), omitted: 0 };
+    return { text: lines.slice(0, limit).join("\n"), omitted: lines.length - limit };
+}
+export function breakLongWords(text, width) {
+    if (!Number.isFinite(width) || width < 2)
+        return text;
+    return text
+        .split("\n")
+        .map((line) => {
+        if (line.length <= width)
+            return line;
+        return line.replace(/\S+/g, (word) => {
+            const chars = [...word];
+            if (chars.length <= width)
+                return word;
+            const pieces = [];
+            for (let index = 0; index < chars.length; index += width) {
+                pieces.push(chars.slice(index, index + width).join(""));
+            }
+            return pieces.join("\n");
+        });
+    })
+        .join("\n");
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${Math.max(0, Math.round(ms))}ms`;
+    const seconds = ms / 1000;
+    if (seconds < 60)
+        return `${seconds.toFixed(1)}s`;
+    const minutes = Math.floor(seconds / 60);
+    return `${minutes}m ${Math.round(seconds % 60)}s`;
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+export function formatTokenCount(tokens) {
+    if (!Number.isFinite(tokens) || tokens <= 0)
+        return "0";
+    const trim = (value) => value.toFixed(1).replace(/\.0$/, "");
+    if (tokens >= 1_000_000)
+        return `${trim(tokens / 1_000_000)}M`;
+    if (tokens >= 1_000)
+        return `${trim(tokens / 1_000)}K`;
+    return String(Math.round(tokens));
+}
+export function shortenPath(value, max) {
+    const home = os.homedir();
+    let text = value;
+    if (home && (value === home || value.startsWith(`${home}\\`) || value.startsWith(`${home}/`))) {
+        text = `~${value.slice(home.length)}`;
+    }
+    return truncate(text, max);
+}
+export function shortModelName(model, max = 36) {
+    const value = sanitize(model);
+    const tail = value.split("/").pop() ?? value;
+    return truncate(tail.length >= 8 ? tail : value, max);
+}
+export function plural(count, singular, pluralForm = `${singular}s`) {
+    return count === 1 ? singular : pluralForm;
+}

package/dist/src/ui/useTerminalSize.js

@@ -0,0 +1,22 @@
+import { useEffect, useState } from "react";
+import { useStdout } from "ink";
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const stream = stdout;
+    const [size, setSize] = useState(() => ({
+        columns: stream.columns ?? 80,
+        rows: stream.rows ?? 24,
+    }));
+    useEffect(() => {
+        const update = () => setSize({
+            columns: stream.columns ?? 80,
+            rows: stream.rows ?? 24,
+        });
+        update();
+        stream.on("resize", update);
+        return () => {
+            stream.off("resize", update);
+        };
+    }, [stream]);
+    return size;
+}

package/dist/src/version.js

@@ -0,0 +1 @@
+export const VERSION = "0.5.0";

package/dist/src/workspace-tools.js

@@ -0,0 +1,405 @@
+import { spawn } from "node:child_process";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWorkspacePath } from "./safety.js";
+const MAX_FILE_BYTES = 200_000;
+const MAX_COMMAND_OUTPUT = 20_000;
+const PREVIEW_LINES = 12;
+const PREVIEW_CHARS = 1_200;
+const IGNORED_ENTRIES = new Set([".git", "node_modules"]);
+const WEB_TIMEOUT_MS = 10_000;
+const MAX_WEB_RESULTS = 8;
+const NEWS_ITEM_LIMIT = 10;
+export const TOOL_DEFINITIONS = [
+    {
+        type: "function",
+        function: {
+            name: "list_files",
+            description: "List files and folders in a workspace directory. Use '.' for the workspace root.",
+            parameters: {
+                type: "object",
+                properties: { path: { type: "string" } },
+                required: ["path"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read a UTF-8 text file inside the workspace. Secret-like files are blocked.",
+            parameters: {
+                type: "object",
+                properties: { path: { type: "string" } },
+                required: ["path"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Create or replace a UTF-8 text file inside the workspace. Requires user confirmation.",
+            parameters: {
+                type: "object",
+                properties: { path: { type: "string" }, content: { type: "string" } },
+                required: ["path", "content"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "run_command",
+            description: "Run a PowerShell command in the workspace. Requires user confirmation.",
+            parameters: {
+                type: "object",
+                properties: { command: { type: "string" } },
+                required: ["command"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "get_current_datetime",
+            description: "Get the current date and time. Use this when the user asks what the date, day of the week, or current time is.",
+            parameters: {
+                type: "object",
+                properties: {},
+                required: [],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "get_weather",
+            description: "Get the current weather for a location. Use it when the user asks about the weather, temperature, or conditions for a place.",
+            parameters: {
+                type: "object",
+                properties: { location: { type: "string" } },
+                required: ["location"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_search",
+            description: "Search the web for current information. Use it when the user asks about recent events, news, facts that change over time, or anything that needs up-to-date search results.",
+            parameters: {
+                type: "object",
+                properties: { query: { type: "string" } },
+                required: ["query"],
+                additionalProperties: false,
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "get_news",
+            description: "Get the latest news headlines for a topic or general headlines. Use it when the user asks for the news or current events.",
+            parameters: {
+                type: "object",
+                properties: { query: { type: "string" } },
+                required: [],
+                additionalProperties: false,
+            },
+        },
+    },
+];
+const READ_ONLY_TOOL_NAMES = new Set([
+    "list_files",
+    "read_file",
+    "get_current_datetime",
+    "get_weather",
+    "web_search",
+    "get_news",
+]);
+export const READ_ONLY_TOOL_DEFINITIONS = TOOL_DEFINITIONS
+    .filter((tool) => READ_ONLY_TOOL_NAMES.has(tool.function.name));
+function requireString(value, name) {
+    if (typeof value !== "string")
+        throw new Error(`${name} must be a string.`);
+    return value;
+}
+function toPosix(value) {
+    return value.replaceAll(path.sep, "/");
+}
+function previewContent(content) {
+    const lines = content.split("\n");
+    let preview = lines.slice(0, PREVIEW_LINES).join("\n");
+    let truncated = lines.length > PREVIEW_LINES;
+    if (preview.length > PREVIEW_CHARS) {
+        preview = preview.slice(0, PREVIEW_CHARS);
+        truncated = true;
+    }
+    return { preview, truncated };
+}
+function runPowerShell(command, workspace) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+            cwd: workspace,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const append = (current, chunk) => (`${current}${chunk.toString()}`.slice(-MAX_COMMAND_OUTPUT));
+        const timeout = setTimeout(() => child.kill(), 30_000);
+        child.stdout.on("data", (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr.on("data", (chunk) => { stderr = append(stderr, chunk); });
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            resolve(JSON.stringify({
+                exitCode: code,
+                stdout,
+                stderr,
+                truncated: stdout.length >= MAX_COMMAND_OUTPUT || stderr.length >= MAX_COMMAND_OUTPUT,
+            }));
+        });
+    });
+}
+async function fetchJson(url) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(WEB_TIMEOUT_MS) });
+    if (!response.ok) {
+        throw new Error(`The web service returned HTTP ${response.status} for ${url}.`);
+    }
+    return response.json();
+}
+function stripHtml(value) {
+    return value
+        .replace(/<[^>]*>/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function decodeText(value) {
+    return value
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, "&")
+        .trim();
+}
+const WEATHER_DESCRIPTIONS = {
+    0: "Clear sky",
+    1: "Mainly clear sky",
+    2: "Partly cloudy",
+    3: "Overcast",
+    45: "Fog",
+    48: "Depositing rime fog",
+    51: "Light drizzle",
+    53: "Drizzle",
+    55: "Dense drizzle",
+    56: "Freezing drizzle",
+    57: "Freezing drizzle",
+    61: "Light rain",
+    63: "Rain",
+    65: "Heavy rain",
+    66: "Freezing rain",
+    67: "Heavy freezing rain",
+    71: "Light snow",
+    73: "Snow",
+    75: "Heavy snow",
+    77: "Snow grains",
+    80: "Light showers",
+    81: "Rain showers",
+    82: "Violent showers",
+    85: "Snow showers",
+    86: "Snow showers",
+    95: "Thunderstorm",
+    96: "Thunderstorm with hail",
+    99: "Thunderstorm with hail",
+};
+function describeWeatherCode(code) {
+    if (Number.isFinite(code) && code in WEATHER_DESCRIPTIONS) {
+        return WEATHER_DESCRIPTIONS[code];
+    }
+    return `Unknown weather condition (${code}).`;
+}
+function parseWebResults(html) {
+    const pattern = /<a\b[^>]*class="result__a"[^>]*>([\s\S]*?)<\/a>/gi;
+    const matches = [...html.matchAll(pattern)];
+    const results = [];
+    for (let index = 0; index < matches.length && results.length < MAX_WEB_RESULTS; index += 1) {
+        const match = matches[index];
+        const hrefMatch = /href="([^"]*)"/i.exec(match[0]);
+        const title = decodeText(stripHtml(match[1] ?? ""));
+        if (!hrefMatch || !title)
+            continue;
+        const start = (match.index ?? 0) + match[0].length;
+        const end = index + 1 < matches.length ? (matches[index + 1].index ?? html.length) : html.length;
+        const chunk = html.slice(start, end);
+        const snippetMatch = /class="result__snippet"[^>]*>([\s\S]*?)<\/(?:a|div)>/i.exec(chunk);
+        const snippet = snippetMatch ? decodeText(stripHtml(snippetMatch[1] ?? "")) : "";
+        results.push({ title, url: hrefMatch[1], snippet });
+    }
+    return results;
+}
+function parseNewsItems(xml) {
+    const items = [];
+    const pattern = /<item>([\s\S]*?)<\/item>/gi;
+    for (const match of xml.matchAll(pattern)) {
+        const block = match[1] ?? "";
+        const title = decodeText(/<title>([\s\S]*?)<\/title>/i.exec(block)?.[1] ?? "");
+        const url = /<link>([\s\S]*?)<\/link>/i.exec(block)?.[1] ?? "";
+        const publishedAt = /<pubDate>([\s\S]*?)<\/pubDate>/i.exec(block)?.[1] ?? "";
+        const source = decodeText(/<source[^>]*>([\s\S]*?)<\/source>/i.exec(block)?.[1] ?? "");
+        if (!title)
+            continue;
+        items.push({ title, url, publishedAt, source });
+        if (items.length >= NEWS_ITEM_LIMIT)
+            break;
+    }
+    return items;
+}
+export async function executeTool(name, rawArguments, { workspace, confirm, onMade }) {
+    const args = typeof rawArguments === "string" ? JSON.parse(rawArguments) : rawArguments;
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        throw new Error("Tool arguments must be a JSON object.");
+    }
+    const values = args;
+    if (name === "list_files") {
+        const requested = requireString(values.path, "path");
+        const directory = await resolveWorkspacePath(workspace, requested, { mustExist: true });
+        const entries = await readdir(directory, { withFileTypes: true });
+        return JSON.stringify(entries
+            .filter((entry) => !IGNORED_ENTRIES.has(entry.name))
+            .map((entry) => ({ name: entry.name, type: entry.isDirectory() ? "directory" : "file" })));
+    }
+    if (name === "read_file") {
+        const requested = requireString(values.path, "path");
+        const file = await resolveWorkspacePath(workspace, requested, { mustExist: true });
+        const content = await readFile(file);
+        if (content.byteLength > MAX_FILE_BYTES) {
+            throw new Error(`File exceeds the ${MAX_FILE_BYTES}-byte read limit.`);
+        }
+        return content.toString("utf8");
+    }
+    if (name === "write_file") {
+        const requested = requireString(values.path, "path");
+        const content = requireString(values.content, "content");
+        const file = await resolveWorkspacePath(workspace, requested);
+        const relative = toPosix(path.relative(workspace, file));
+        const { preview, truncated } = previewContent(content);
+        const approved = await confirm({
+            kind: "write",
+            path: relative,
+            lines: content.split("\n").length,
+            bytes: Buffer.byteLength(content, "utf8"),
+            preview,
+            truncated,
+        });
+        if (!approved) {
+            return "User declined the file write.";
+        }
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, content, { encoding: "utf8", flag: "w" });
+        onMade({ kind: "file", path: relative });
+        return `Wrote ${relative}.`;
+    }
+    if (name === "run_command") {
+        const command = requireString(values.command, "command").trim();
+        if (!command)
+            throw new Error("Command cannot be empty.");
+        const approved = await confirm({ kind: "command", command });
+        if (!approved) {
+            return "User declined the command.";
+        }
+        const result = await runPowerShell(command, workspace);
+        onMade({ kind: "command", command });
+        return result;
+    }
+    if (name === "get_current_datetime") {
+        const now = new Date();
+        return JSON.stringify({
+            iso: now.toISOString(),
+            epochMs: now.getTime(),
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            dayOfWeek: new Intl.DateTimeFormat("en-US", { weekday: "long" }).format(now),
+            date: new Intl.DateTimeFormat("en-US", { dateStyle: "full" }).format(now),
+            time: new Intl.DateTimeFormat("en-US", { timeStyle: "long" }).format(now),
+        });
+    }
+    if (name === "get_weather") {
+        const location = requireString(values.location, "location").trim();
+        if (!location)
+            throw new Error("location cannot be empty.");
+        const geoUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1&language=en&format=json`;
+        const geo = (await fetchJson(geoUrl));
+        const place = Array.isArray(geo?.results) ? geo.results[0] : undefined;
+        if (!place || typeof place.latitude !== "number" || typeof place.longitude !== "number") {
+            throw new Error(`No weather location was found for "${location}".`);
+        }
+        const forecastUrl = `https://api.open-meteo.com/v1/forecast?latitude=${place.latitude}&longitude=${place.longitude}&current=temperature_2m,relative_humidity_2m,apparent_temperature,is_day,precipitation,weather_code,wind_speed_50m&timezone=auto`;
+        const forecast = (await fetchJson(forecastUrl));
+        const current = forecast?.current ?? {};
+        const rawWeatherCode = typeof current?.weather_code === "number"
+            ? current.weather_code
+            : Number(current?.weather_code ?? -1);
+        const weatherCode = Number.isFinite(rawWeatherCode) ? rawWeatherCode : -1;
+        return JSON.stringify({
+            location: typeof place.name === "string" && place.name ? place.name : location,
+            region: typeof place.admin1 === "string" ? place.admin1 : null,
+            country: typeof place.country === "string" ? place.country : null,
+            temperatureC: typeof current?.temperature_2m === "number" ? current.temperature_2m : null,
+            apparentTemperatureC: typeof current?.apparent_temperature === "number" ? current.apparent_temperature : null,
+            humidityPercent: typeof current?.relative_humidity_2m === "number" ? current.relative_humidity_2m : null,
+            windKph: typeof current?.wind_speed_50m === "number" ? current.wind_speed_50m : null,
+            precipitationMm: typeof current?.precipitation === "number" ? current.precipitation : null,
+            isDay: typeof current?.is_day === "number" ? current.is_day : null,
+            conditionCode: weatherCode,
+            condition: describeWeatherCode(weatherCode),
+        });
+    }
+    if (name === "web_search") {
+        const query = requireString(values.query, "query").trim();
+        if (!query)
+            throw new Error("query cannot be empty.");
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        const response = await fetch(url, { signal: AbortSignal.timeout(WEB_TIMEOUT_MS) });
+        if (!response.ok) {
+            throw new Error(`The web search service returned HTTP ${response.status} for ${url}.`);
+        }
+        const html = await response.text();
+        const results = parseWebResults(html);
+        if (results.length === 0) {
+            throw new Error(`The web search returned no results for "${query}".`);
+        }
+        return JSON.stringify({ query, results });
+    }
+    if (name === "get_news") {
+        const query = typeof values.query === "string" && values.query.trim() ? values.query.trim() : "top news";
+        const url = `https://news.google.com/rss/search?q=${encodeURIComponent(query)}&hl=en-US&gl=US&ceid=US:en`;
+        const response = await fetch(url, { signal: AbortSignal.timeout(WEB_TIMEOUT_MS) });
+        if (!response.ok) {
+            throw new Error(`The news service returned HTTP ${response.status} for ${url}.`);
+        }
+        const xml = await response.text();
+        const items = parseNewsItems(xml);
+        if (items.length === 0) {
+            throw new Error(`The news service returned no headlines for "${query}".`);
+        }
+        return JSON.stringify({ query, items });
+    }
+    throw new Error(`Unknown tool: ${name}`);
+}

package/dist/test/cli-options.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseOptions } from "../src/cli-options.js";
+test("parses help and version flags", () => {
+    assert.deepEqual(parseOptions([]), {});
+    assert.deepEqual(parseOptions(["--help"]), { help: true });
+    assert.deepEqual(parseOptions(["-h"]), { help: true });
+    assert.deepEqual(parseOptions(["--version"]), { version: true });
+    assert.deepEqual(parseOptions(["-v"]), { version: true });
+});
+test("parses an explicit session id", () => {
+    assert.deepEqual(parseOptions(["--id", "abc12345"]), { id: "abc12345" });
+    assert.deepEqual(parseOptions(["--id=abc12345"]), { id: "abc12345" });
+});
+test("allows --id without a value to resume the latest session", () => {
+    assert.deepEqual(parseOptions(["--id"]), { id: true });
+    assert.deepEqual(parseOptions(["--id="]), { id: true });
+    assert.deepEqual(parseOptions(["--id", "--help"]), { id: true, help: true });
+});
+test("rejects unknown options", () => {
+    assert.throws(() => parseOptions(["--wat"]), /Unknown option: --wat/);
+});