llm-agent-cli 2.0.0

package/dist/agent.js

@@ -0,0 +1,730 @@
+import { TOOL_DEFINITIONS, TOOL_MAP, configureToolRuntime, getToolRuntime, } from "./tools/index.js";
+import { estimateTokens } from "./context.js";
+class RouterHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "RouterHttpError";
+        this.status = status;
+    }
+}
+export class TurnCancelledError extends Error {
+    constructor(message = "Turn cancelled") {
+        super(message);
+        this.name = "TurnCancelledError";
+    }
+}
+const RETRYABLE_STATUS = new Set([429, 500, 503]);
+const MAX_ATTEMPTS = 3;
+function getRouterConfig() {
+    const baseUrl = process.env.LLM_ROUTER_BASE_URL;
+    const apiKey = process.env.LLM_ROUTER_API_KEY;
+    const model = process.env.LLM_ROUTER_MODEL ?? "auto";
+    if (!baseUrl)
+        throw new Error("LLM_ROUTER_BASE_URL is not set in .env");
+    if (!apiKey)
+        throw new Error("LLM_ROUTER_API_KEY is not set in .env");
+    return { baseUrl, apiKey, model };
+}
+async function sleep(ms, signal) {
+    if (signal?.aborted) {
+        throw new TurnCancelledError();
+    }
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            cleanup();
+            reject(new TurnCancelledError());
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function isRetryableError(err) {
+    if (err instanceof TurnCancelledError)
+        return false;
+    if (err instanceof RouterHttpError) {
+        return RETRYABLE_STATUS.has(err.status);
+    }
+    if (err instanceof TypeError) {
+        return true;
+    }
+    return false;
+}
+function buildSystemPrompt(workspaceRoot, runtime, systemContext) {
+    const contextBlock = systemContext
+        ? `\nProject context:\n${systemContext}\n`
+        : "";
+    return `You are a capable terminal-based AI agent.
+
+Available tools:
+- read_file
+- write_to_file
+- apply_diff
+- list_directory
+- create_directory
+- delete_file
+- move_file
+- get_file_info
+- search_files
+- find_files
+- fetch_url
+- run_bash_command
+
+Execution constraints:
+- Workspace root: ${workspaceRoot}
+- Permission mode: ${runtime.permissionMode}
+- Max read size: ${runtime.maxReadBytes} bytes
+- Max tool result passed back to model: ${runtime.maxToolResultChars} chars
+- Use targeted edits (apply_diff) when possible instead of full rewrites.
+- Inspect files before editing.
+- Summarize what changed when complete.${contextBlock}`;
+}
+function buildFullSystemPrompt(base, memory) {
+    if (!memory.trim())
+        return base;
+    return `${base}\n\n# Persistent Memory\n${memory}`;
+}
+function normalizeToolCalls(map) {
+    return Array.from(map.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([, value]) => value)
+        .filter((call) => call.function.name.trim().length > 0);
+}
+async function parseSseResponse(response, signal, onToken) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error("Router response body is empty");
+    }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let role = "assistant";
+    let content = "";
+    let finishReason = "stop";
+    let usage;
+    let model;
+    const toolCalls = new Map();
+    while (true) {
+        if (signal?.aborted) {
+            throw new TurnCancelledError();
+        }
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            const rawLine = buffer.slice(0, newlineIndex);
+            buffer = buffer.slice(newlineIndex + 1);
+            const line = rawLine.trim();
+            if (!line || line.startsWith(":")) {
+                newlineIndex = buffer.indexOf("\n");
+                continue;
+            }
+            if (!line.startsWith("data:")) {
+                newlineIndex = buffer.indexOf("\n");
+                continue;
+            }
+            const payload = line.slice(5).trim();
+            if (!payload || payload === "[DONE]") {
+                newlineIndex = buffer.indexOf("\n");
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                newlineIndex = buffer.indexOf("\n");
+                continue;
+            }
+            if (parsed.model) {
+                model = parsed.model;
+            }
+            if (parsed.usage) {
+                usage = parsed.usage;
+            }
+            const choice = parsed.choices?.[0];
+            if (choice?.finish_reason) {
+                finishReason = choice.finish_reason;
+            }
+            if (choice?.delta?.role) {
+                role = choice.delta.role;
+            }
+            const deltaContent = choice?.delta?.content;
+            if (deltaContent) {
+                content += deltaContent;
+                if (onToken) {
+                    await onToken(deltaContent);
+                }
+            }
+            const deltaToolCalls = choice?.delta?.tool_calls ?? [];
+            for (const deltaToolCall of deltaToolCalls) {
+                const index = deltaToolCall.index ?? 0;
+                const existing = toolCalls.get(index) ?? {
+                    id: deltaToolCall.id ?? `tool_call_${index}`,
+                    type: "function",
+                    function: {
+                        name: "",
+                        arguments: "",
+                    },
+                };
+                if (deltaToolCall.id) {
+                    existing.id = deltaToolCall.id;
+                }
+                const functionName = deltaToolCall.function?.name;
+                if (functionName) {
+                    existing.function.name += functionName;
+                }
+                const functionArgs = deltaToolCall.function?.arguments;
+                if (functionArgs) {
+                    existing.function.arguments += functionArgs;
+                }
+                toolCalls.set(index, existing);
+            }
+            newlineIndex = buffer.indexOf("\n");
+        }
+    }
+    return {
+        message: {
+            role,
+            content: content || null,
+            tool_calls: normalizeToolCalls(toolCalls),
+        },
+        finishReason,
+        usage,
+        model,
+    };
+}
+async function callRouterOnce(messages, options) {
+    const { baseUrl, apiKey, model } = getRouterConfig();
+    const body = {
+        model,
+        messages,
+    };
+    if (options.toolsEnabled) {
+        body.tools = TOOL_DEFINITIONS;
+        body.tool_choice = "auto";
+    }
+    if (options.stream) {
+        body.stream = true;
+        body.stream_options = { include_usage: true };
+    }
+    const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+            "X-Client-Type": "cli-agent",
+            Accept: options.stream ? "text/event-stream, application/json" : "application/json",
+        },
+        signal: options.signal,
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const errorBody = await response.text();
+        throw new RouterHttpError(response.status, `LLM Router error ${response.status}: ${errorBody}`);
+    }
+    if (options.stream) {
+        const contentType = response.headers.get("content-type") ?? "";
+        if (!contentType.includes("application/json")) {
+            return parseSseResponse(response, options.signal, options.onToken);
+        }
+    }
+    const data = (await response.json());
+    const choice = data.choices[0];
+    if (!choice) {
+        throw new Error("No choice returned from router");
+    }
+    return {
+        message: choice.message,
+        finishReason: choice.finish_reason,
+        usage: data.usage,
+        model: data.model,
+    };
+}
+async function callRouterWithRetry(messages, signal, callbacks) {
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+        try {
+            return await callRouterOnce(messages, {
+                signal,
+                toolsEnabled: true,
+                stream: true,
+                onToken: callbacks.onToken,
+            });
+        }
+        catch (err) {
+            if (signal?.aborted) {
+                throw new TurnCancelledError();
+            }
+            if (!isRetryableError(err) || attempt >= MAX_ATTEMPTS) {
+                throw err;
+            }
+            const delayMs = 1000 * 2 ** (attempt - 1);
+            const reason = err instanceof Error ? err.message : String(err);
+            if (callbacks.onRetry) {
+                await callbacks.onRetry(attempt, delayMs, reason);
+            }
+            await sleep(delayMs, signal);
+        }
+    }
+    throw new Error("Router call failed after maximum retries");
+}
+function previewArgs(rawArgs) {
+    const collapsed = rawArgs.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= 120)
+        return collapsed;
+    return `${collapsed.slice(0, 117)}...`;
+}
+function truncateToolResult(rawResult) {
+    const runtime = getToolRuntime();
+    if (rawResult.length <= runtime.maxToolResultChars) {
+        return { output: rawResult, truncated: false };
+    }
+    const trimmed = rawResult.slice(0, runtime.maxToolResultChars);
+    const dropped = rawResult.length - runtime.maxToolResultChars;
+    return {
+        output: `${trimmed}\n\n[Tool output truncated: removed ${dropped} chars before returning to model]`,
+        truncated: true,
+    };
+}
+function isApprovedFromToolResult(toolName, toolResult) {
+    const lower = toolResult.toLowerCase();
+    if (!lower.startsWith("error")) {
+        return true;
+    }
+    if (lower.includes("user denied") ||
+        lower.includes("disabled in safe mode") ||
+        lower.includes("requires confirmation") ||
+        lower.includes("blocked dangerous command pattern")) {
+        return false;
+    }
+    if (toolName === "run_bash_command" && lower.includes("shell commands are disabled")) {
+        return false;
+    }
+    return true;
+}
+function normalizeMessageContent(content) {
+    if (content === undefined)
+        return null;
+    return content;
+}
+export async function checkRouterHealth() {
+    const baseUrl = process.env.LLM_ROUTER_BASE_URL;
+    if (!baseUrl) {
+        return { ok: false, message: "LLM_ROUTER_BASE_URL is not set" };
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2_000);
+    try {
+        const response = await fetch(`${baseUrl}/health`, {
+            method: "GET",
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                message: `Router health check failed with HTTP ${response.status}`,
+            };
+        }
+        return { ok: true, message: "Router reachable" };
+    }
+    catch {
+        return {
+            ok: false,
+            message: `Router unreachable at ${baseUrl}`,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export class Agent {
+    history = [];
+    lastUserInput = null;
+    verboseTools = false;
+    auditLogger;
+    baseSystemPrompt;
+    memory;
+    contextWindowTokens;
+    constructor(options = {}) {
+        configureToolRuntime({
+            workspaceRoot: options.workspaceRoot,
+            permissionMode: options.permissionMode,
+            maxReadBytes: options.maxReadBytes,
+            maxToolResultChars: options.maxToolResultChars,
+            maxCommandOutputChars: options.maxCommandOutputChars,
+            shellTimeoutMs: options.shellTimeoutMs,
+        });
+        const runtime = getToolRuntime();
+        this.baseSystemPrompt = buildSystemPrompt(runtime.workspaceRoot, runtime, options.systemContext);
+        this.memory = options.memory ?? "";
+        this.auditLogger = options.auditLogger;
+        this.contextWindowTokens = options.contextWindowTokens ?? 200_000;
+        this.history.push({
+            role: "system",
+            content: buildFullSystemPrompt(this.baseSystemPrompt, this.memory),
+        });
+    }
+    /**
+     * Hot-update the persistent memory injected into the system prompt.
+     * Safe to call mid-session — patches history[0] in place so the model sees
+     * the new memory on the very next turn.
+     */
+    updateMemory(memory) {
+        this.memory = memory;
+        if (this.history[0]) {
+            this.history[0].content = buildFullSystemPrompt(this.baseSystemPrompt, this.memory);
+        }
+    }
+    getLastUserInput() {
+        return this.lastUserInput;
+    }
+    getPermissionMode() {
+        return getToolRuntime().permissionMode;
+    }
+    getWorkspaceRoot() {
+        return getToolRuntime().workspaceRoot;
+    }
+    isVerboseTools() {
+        return this.verboseTools;
+    }
+    setVerboseTools(enabled) {
+        this.verboseTools = enabled;
+    }
+    reset() {
+        this.history = [
+            {
+                role: "system",
+                content: buildFullSystemPrompt(this.baseSystemPrompt, this.memory),
+            },
+        ];
+        this.lastUserInput = null;
+    }
+    undoLastTurn() {
+        for (let i = this.history.length - 1; i >= 1; i -= 1) {
+            if (this.history[i]?.role === "user") {
+                const removedUser = this.history[i]?.content ?? null;
+                this.history = this.history.slice(0, i);
+                this.lastUserInput = removedUser;
+                return removedUser;
+            }
+        }
+        return null;
+    }
+    exportState(contextState) {
+        return {
+            history: this.history.map((msg) => ({
+                role: msg.role,
+                content: normalizeMessageContent(msg.content),
+                tool_calls: msg.tool_calls,
+                tool_call_id: msg.tool_call_id,
+                name: msg.name,
+            })),
+            lastUserInput: this.lastUserInput,
+            verboseTools: this.verboseTools,
+            cwd: process.cwd(),
+            contextState,
+        };
+    }
+    importState(state) {
+        if (!state.history || state.history.length === 0) {
+            this.reset();
+            return;
+        }
+        this.history = state.history.map((msg) => ({
+            role: msg.role,
+            content: normalizeMessageContent(msg.content),
+            tool_calls: msg.tool_calls,
+            tool_call_id: msg.tool_call_id,
+            name: msg.name,
+        }));
+        this.lastUserInput = state.lastUserInput;
+        this.verboseTools = state.verboseTools;
+    }
+    async run(userInput, options = {}) {
+        if (options.signal?.aborted) {
+            throw new TurnCancelledError();
+        }
+        this.lastUserInput = userInput;
+        const historyStart = this.history.length;
+        this.history.push({ role: "user", content: userInput });
+        // ── Pre-flight context estimation ─────────────────────────────────────────
+        // Estimate token usage before sending so the user sees a warning (or an
+        // auto-compact) instead of an opaque 400 error from the router.
+        const estimatedTokens = estimateTokens(this.history);
+        const compactThreshold = Math.floor(this.contextWindowTokens * 0.9);
+        const warnThreshold = Math.floor(this.contextWindowTokens * 0.7);
+        if (estimatedTokens >= compactThreshold) {
+            if (options.callbacks?.onToken) {
+                await options.callbacks.onToken(`\n[Context ~${estimatedTokens.toLocaleString()} tokens ` +
+                    `(${Math.round((estimatedTokens / this.contextWindowTokens) * 100)}% of window). ` +
+                    `Auto-compacting before sending...]\n`);
+            }
+            await this.compactHistory(options.signal);
+        }
+        else if (estimatedTokens >= warnThreshold) {
+            if (options.callbacks?.onToken) {
+                await options.callbacks.onToken(`\n[Context ~${estimatedTokens.toLocaleString()} tokens ` +
+                    `(${Math.round((estimatedTokens / this.contextWindowTokens) * 100)}% of window). ` +
+                    `Consider /compact to free space.]\n`);
+            }
+        }
+        let finalResponse = "";
+        let finalUsage;
+        let finalModel = getRouterConfig().model;
+        let finishReason = "stop";
+        let toolCallCount = 0;
+        try {
+            let iterations = 0;
+            const maxIterations = 20;
+            while (iterations < maxIterations) {
+                iterations += 1;
+                const streamed = await callRouterWithRetry(this.history, options.signal, {
+                    onToken: options.callbacks?.onToken,
+                    onRetry: options.callbacks?.onRetry,
+                });
+                const assistantMessage = streamed.message;
+                finalModel = streamed.model ?? finalModel;
+                finishReason = streamed.finishReason;
+                this.history.push({
+                    role: "assistant",
+                    content: assistantMessage.content ?? null,
+                    tool_calls: assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0
+                        ? assistantMessage.tool_calls
+                        : undefined,
+                });
+                if (streamed.finishReason === "tool_calls" &&
+                    assistantMessage.tool_calls?.length) {
+                    const total = assistantMessage.tool_calls.length;
+                    for (let index = 0; index < total; index += 1) {
+                        if (options.signal?.aborted) {
+                            throw new TurnCancelledError();
+                        }
+                        const toolCall = assistantMessage.tool_calls[index];
+                        toolCallCount += 1;
+                        const toolName = toolCall.function.name;
+                        const toolFn = TOOL_MAP[toolName];
+                        const argsPreview = previewArgs(toolCall.function.arguments);
+                        if (options.callbacks?.onToolStart) {
+                            await options.callbacks.onToolStart({
+                                toolName,
+                                argsPreview,
+                                index: index + 1,
+                                total,
+                            });
+                        }
+                        let toolResult = "";
+                        let parsedArgs = {};
+                        if (!toolFn) {
+                            toolResult = `Error: unknown tool \"${toolName}\"`;
+                        }
+                        else {
+                            try {
+                                parsedArgs = JSON.parse(toolCall.function.arguments);
+                            }
+                            catch {
+                                parsedArgs = {};
+                                toolResult =
+                                    "Error: could not parse tool arguments as JSON; received raw argument string.";
+                            }
+                            if (!toolResult) {
+                                const toolContext = {
+                                    abortSignal: options.signal,
+                                };
+                                toolResult = await toolFn(parsedArgs, toolContext);
+                            }
+                        }
+                        const truncated = truncateToolResult(toolResult);
+                        if (this.auditLogger) {
+                            await this.auditLogger.logTool(toolName, parsedArgs, truncated.output, isApprovedFromToolResult(toolName, toolResult));
+                        }
+                        if (options.callbacks?.onToolEnd) {
+                            const preview = this.verboseTools
+                                ? truncated.output
+                                : truncated.output.slice(0, 300);
+                            await options.callbacks.onToolEnd({
+                                toolName,
+                                index: index + 1,
+                                total,
+                                truncated: truncated.truncated,
+                                resultPreview: preview,
+                            });
+                        }
+                        this.history.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            name: toolName,
+                            content: truncated.output,
+                        });
+                    }
+                    continue;
+                }
+                finalResponse = assistantMessage.content ?? "";
+                finalUsage = streamed.usage;
+                break;
+            }
+            if (!finalResponse && finishReason !== "tool_calls") {
+                finalResponse = "[Agent produced an empty response]";
+            }
+            if (!finalResponse && finishReason === "tool_calls") {
+                finalResponse =
+                    "[Agent stopped: reached maximum iteration limit of 20 iterations]";
+            }
+            return {
+                response: finalResponse,
+                usage: finalUsage,
+                model: finalModel,
+                finishReason,
+                toolCalls: toolCallCount,
+            };
+        }
+        catch (err) {
+            this.history = this.history.slice(0, historyStart);
+            throw err;
+        }
+    }
+    async compactHistory(signal) {
+        if (this.history.length <= 2) {
+            return "Conversation is already compact.";
+        }
+        // ── Tiered compaction ────────────────────────────────────────────────────
+        // Recent exchanges are preserved verbatim so the model never loses sight
+        // of what was just asked / just returned.  Everything older is compressed
+        // into a structured summary block.
+        //
+        // Structure after compaction:
+        //   [system, assistant(summary), ...last-N-turns-verbatim]
+        //
+        const KEEP_TURNS = 3; // number of complete user→assistant exchanges to keep
+        const keepFromIndex = this._findKeepBoundary(KEEP_TURNS);
+        // Nothing old enough to summarise — all turns fall within the keep window.
+        if (keepFromIndex <= 1) {
+            return "Recent context fits within the keep window — nothing to compact.";
+        }
+        const toSummarize = this.history.slice(1, keepFromIndex);
+        const toKeep = this.history.slice(keepFromIndex);
+        // ── Build transcript of the portion being compressed ────────────────────
+        const rawTranscript = toSummarize
+            .map((msg, i) => {
+            let header = `${i + 1}. [${msg.role}]`;
+            if (msg.role === "assistant" && msg.tool_calls?.length) {
+                const calls = msg.tool_calls.map((tc) => tc.function.name).join(", ");
+                header += ` → calls: ${calls}`;
+            }
+            if (msg.role === "tool" && msg.name) {
+                header += ` result for: ${msg.name}`;
+            }
+            // 5 000 chars per message — enough signal without overwhelming the
+            // summariser for large file reads.
+            const body = (msg.content ?? "").slice(0, 5_000);
+            return `${header}\n${body}`;
+        })
+            .join("\n\n");
+        // Hard cap: 120 k chars ≈ 30 k tokens keeps the summarisation call safely
+        // inside even a 32 k-token context window.
+        const MAX_TRANSCRIPT = 120_000;
+        const transcript = rawTranscript.length > MAX_TRANSCRIPT
+            ? `[... ${(rawTranscript.length - MAX_TRANSCRIPT).toLocaleString()} earlier chars omitted ...]\n\n` +
+                rawTranscript.slice(-MAX_TRANSCRIPT)
+            : rawTranscript;
+        // ── Structured summarisation prompt ──────────────────────────────────────
+        // Sections match what the agent needs to resume work cleanly.  Be explicit
+        // about requiring file paths, line numbers, and exact values so the model
+        // doesn't produce vague prose.
+        const prompt = `Compress the following conversation transcript into a structured summary.
+Use these exact section headers. Be specific: include file paths, line numbers, function names, and exact values where they matter. Omit sections that have no content.
+
+## Objective
+What the user is trying to achieve overall.
+
+## Work Completed
+Bullet list of finished tasks. Include file paths and what changed.
+
+## Files Touched
+For each file: path, what was read/modified, key contents if critical to remember.
+
+## Commands Run
+Shell commands executed and their notable output or outcome.
+
+## Decisions Made
+Architecture, design, or implementation decisions with rationale.
+
+## In Progress
+What was actively being worked on at the point of compaction.
+
+## Remaining Work
+Tasks not yet started, bugs not yet fixed, open questions.
+
+## Key Context
+Constants, API shapes, naming conventions, configuration values, or constraints the agent must remember.
+
+---
+TRANSCRIPT TO COMPRESS:
+
+${transcript}`;
+        const summaryResult = await callRouterOnce([
+            this.history[0],
+            { role: "user", content: prompt },
+        ], { signal, toolsEnabled: false, stream: false });
+        const summary = summaryResult.message.content?.trim() ?? "Conversation summary unavailable.";
+        // ── Rebuild history ───────────────────────────────────────────────────────
+        // [system, assistant(structured summary), ...last-N-turns-verbatim]
+        //
+        // Storing the summary as "assistant" keeps the sequence valid for all
+        // providers (no double system messages).  The verbatim recent turns follow
+        // immediately so the model has full fidelity on the current task.
+        this.history = [
+            this.history[0],
+            {
+                role: "assistant",
+                content: `[Prior context — compacted]\n\n${summary}`,
+            },
+            ...toKeep,
+        ];
+        return summary;
+    }
+    /**
+     * Find the history index of the start of the Nth-from-last complete exchange
+     * (where an exchange begins with a user message).  Returns 1 if there are
+     * fewer than keepTurns user messages — meaning nothing should be compacted.
+     */
+    _findKeepBoundary(keepTurns) {
+        let userCount = 0;
+        for (let i = this.history.length - 1; i >= 1; i -= 1) {
+            if (this.history[i]?.role === "user") {
+                userCount += 1;
+                if (userCount === keepTurns) {
+                    return i;
+                }
+            }
+        }
+        return 1;
+    }
+    async listModels(signal) {
+        const { baseUrl, apiKey } = getRouterConfig();
+        const response = await fetch(`${baseUrl}/v1/models`, {
+            method: "GET",
+            signal,
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "X-Client-Type": "cli-agent",
+            },
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Failed to fetch models (${response.status}): ${body}`);
+        }
+        const payload = (await response.json());
+        return payload.data ?? [];
+    }
+}
+//# sourceMappingURL=agent.js.map