s-app-scoder-agent 0.0.0-stage → 0.3.0

package/dist/agent.js

@@ -0,0 +1,478 @@
+import { loadPermissionLists } from "./config.js";
+import { LlmClient, LlmError } from "./llm.js";
+import { AnthropicClient } from "./provider-anthropic.js";
+import { AGENT_TOOLS, getTool } from "./tools.js";
+import { detectBuildCommand, runBuild } from "./build.js";
+import { trimHistory, summariseOutput, claimsCompletion } from "./context.js";
+import { PermissionChecker } from "./permissions.js";
+import { SessionStore } from "./session.js";
+import { JsonlLogger } from "./logger.js";
+import { McpManager } from "./mcp.js";
+import * as ui from "./ui.js";
+const SYSTEM_PROMPT = `You are Scoder, an autonomous coding agent running in a terminal.
+You complete coding tasks by using tools: reading/writing/editing files, listing
+files, and running shell commands.
+
+RULES:
+1. Work autonomously. Do NOT ask the user questions mid-task; make reasonable
+   decisions and proceed.
+2. When you believe the task is done, call run_command with the project's build
+   command (or the one the user specified). The loop ends only when the build
+   succeeds.
+3. If the build fails, read the error output carefully, fix the code, and build
+   again. Iterate until it passes.
+4. Prefer small, focused edits. Read a file before editing it.
+5. If an external/environmental problem (missing dependency, wrong environment)
+   makes the task impossible, stop editing and report it clearly in your final
+   message.
+6. Never invent requirements beyond the given task.
+7. IMPORTANT: if a run_command is denied by permission policy, you will receive
+   an error message. Use this as a signal to find a safer alternative or to
+   communicate the limitation to the user.`;
+export class Agent {
+    config;
+    client;
+    messages = [];
+    tools = AGENT_TOOLS.map((t) => t.spec);
+    ctx;
+    permissions;
+    session;
+    logger;
+    aborted = false;
+    streamFallbackWarned = false;
+    sessionCreatedAt;
+    currentTask = "";
+    lastBuildResult = null;
+    mcp = null;
+    /** Aborted when abort() is called — cancels in-flight LLM requests (SIGINT). */
+    runSignal = new AbortController();
+    constructor(config) {
+        this.config = config;
+        const commonOpts = {
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
+            model: config.model,
+            maxTokens: config.maxTokens,
+            temperature: config.temperature,
+        };
+        this.client =
+            config.provider === "anthropic"
+                ? new AnthropicClient(commonOpts)
+                : new LlmClient({ ...commonOpts, stream: config.stream });
+        const permLists = loadPermissionLists(config.workdir);
+        this.permissions = new PermissionChecker({
+            mode: config.permissionMode,
+            allowCommands: permLists.allowCommands,
+            denyCommands: permLists.denyCommands,
+            nonInteractive: config.yes,
+        });
+        this.ctx = {
+            workdir: config.workdir,
+            permissions: this.permissions,
+            permissionMode: config.permissionMode,
+        };
+        this.session = new SessionStore(config.workdir, config.noSave !== true);
+        this.logger = JsonlLogger.forSession(config.workdir, this.session.id, config.logFile);
+    }
+    /**
+     * Handle SIGINT: abort gracefully after current tool finishes.
+     * Also kills any in-flight run_command child process via the context signal.
+     */
+    abort() {
+        this.aborted = true;
+        this.runSignal.abort(new DOMException("interrupted by user", "AbortError"));
+    }
+    /** Reset the run-signal so a new run() can use a fresh controller. */
+    resetRunSignal() {
+        this.runSignal = new AbortController();
+        this.aborted = false;
+        // Keep the tool context in sync so run_command can observe SIGINT and
+        // terminate its child process immediately (long builds must be interruptible).
+        this.ctx.signal = this.runSignal.signal;
+    }
+    /**
+     * One LLM turn: streaming if enabled (renders deltas live), with automatic
+     * fallback to non-streaming when the provider/stream fails.
+     */
+    async chatWithStream() {
+        const signal = this.runSignal.signal;
+        if (!this.config.stream) {
+            return this.client.chat(this.messages, this.tools, { signal });
+        }
+        try {
+            let streamedText = "";
+            let final;
+            let started = false;
+            for await (const chunk of this.client.streamChat(this.messages, this.tools, { signal })) {
+                if (chunk.contentDelta) {
+                    if (!started) {
+                        ui.llmStreamStart("assistant");
+                        started = true;
+                    }
+                    ui.llmStreamChunk(chunk.contentDelta);
+                    streamedText += chunk.contentDelta;
+                }
+                if (chunk.final)
+                    final = chunk.final;
+            }
+            if (started)
+                ui.llmStreamEnd();
+            if (final) {
+                if ((final.message.content == null || final.message.content === "") && streamedText) {
+                    final.message.content = streamedText;
+                }
+                return final;
+            }
+            // No finish_reason seen — fall through to non-streaming
+            return this.client.chat(this.messages, this.tools);
+        }
+        catch (err) {
+            if (err instanceof LlmError && !this.streamFallbackWarned) {
+                this.streamFallbackWarned = true;
+                ui.warn(`streaming unavailable (${err.message.slice(0, 120)}) — falling back to non-streaming`);
+            }
+            return this.client.chat(this.messages, this.tools);
+        }
+    }
+    get buildCmd() {
+        return this.config.buildCmd ?? detectBuildCommand(this.config.workdir) ?? "echo BUILD";
+    }
+    /** Connect configured MCP stdio servers (if any) and merge their tools. */
+    async connectMcp() {
+        const servers = this.config.mcpServers ?? {};
+        if (Object.keys(servers).length === 0)
+            return;
+        if (this.config.permissionMode === "readonly") {
+            ui.warn("readonly mode: MCP tools are disabled (they bypass the permission system)");
+        }
+        this.mcp = new McpManager(servers);
+        await this.mcp.connectAll();
+        const mcpSpecs = this.mcp.toToolSpecs();
+        if (mcpSpecs.length > 0) {
+            this.tools = [...AGENT_TOOLS.map((t) => t.spec), ...mcpSpecs];
+        }
+    }
+    /** Disconnect MCP servers at the end of a run. */
+    shutdownMcp() {
+        this.mcp?.killAll();
+        this.mcp = null;
+    }
+    /**
+     * Autonomous closed loop:
+     * task -> LLM plans -> tool calls -> build -> on failure: read error, patch, retry.
+     */
+    async run(task) {
+        if (!this.config.apiKey) {
+            throw new Error("No API key configured. Set SCODER_API_KEY or OPENAI_API_KEY (or put apiKey in .scoderrc.json).");
+        }
+        const buildCmd = this.buildCmd;
+        ui.header("TASK");
+        ui.info(task);
+        ui.info(`model=${this.client.model}  workdir=${this.config.workdir}  build="${buildCmd}"  maxSteps=${this.config.maxSteps}`);
+        this.currentTask = task;
+        this.resetRunSignal();
+        this.messages = [
+            {
+                role: "system",
+                content: SYSTEM_PROMPT +
+                    `\n\nWorking directory: ${this.config.workdir}\nBuild command (stop condition): ${buildCmd}`,
+            },
+            { role: "user", content: task },
+        ];
+        try {
+            await this.connectMcp();
+            return await this.runLoop(0, buildCmd, null);
+        }
+        finally {
+            this.shutdownMcp();
+        }
+    }
+    /**
+     * One conversational turn in an ongoing session (used by the REPL):
+     * appends the task to the existing message history instead of resetting it,
+     * then runs the autonomous loop. First call behaves like run().
+     */
+    async runTurn(task) {
+        if (this.messages.length === 0) {
+            return this.run(task);
+        }
+        const buildCmd = this.buildCmd;
+        this.currentTask = `${this.currentTask}\n${task}`.trim();
+        this.resetRunSignal();
+        this.messages.push({ role: "user", content: task });
+        try {
+            await this.connectMcp();
+            return await this.runLoop(0, buildCmd, null);
+        }
+        finally {
+            this.shutdownMcp();
+        }
+    }
+    /**
+     * Resume a previous session: restore messages/step count and continue the loop.
+     * An optional follow-up task is appended as a new user message.
+     */
+    async resume(session, followUp) {
+        const buildCmd = this.buildCmd;
+        this.sessionCreatedAt = session.createdAt;
+        this.currentTask = session.task;
+        this.resetRunSignal();
+        this.messages = session.messages ?? [];
+        ui.header(`RESUME ${session.id}`);
+        ui.info(`previous task: ${session.task} (${session.steps} step(s) done)`);
+        if (followUp) {
+            this.messages.push({ role: "user", content: followUp });
+        }
+        else {
+            this.messages.push({
+                role: "user",
+                content: "Continue working on the original task. Build must pass before you finish.",
+            });
+        }
+        const lastBuild = session.lastBuild
+            ? { success: session.lastBuild.success, command: session.lastBuild.command, output: session.lastBuild.output }
+            : null;
+        try {
+            await this.connectMcp();
+            return await this.runLoop(session.steps ?? 0, buildCmd, lastBuild);
+        }
+        finally {
+            this.shutdownMcp();
+        }
+    }
+    /**
+     * The shared autonomous loop:
+     * LLM plans -> tool calls -> build -> on failure: read error, patch, retry.
+     */
+    async runLoop(startSteps, buildCmd, initialBuild = null) {
+        let steps = startSteps;
+        let lastBuild = initialBuild;
+        while (steps < this.config.maxSteps && !this.aborted) {
+            steps++;
+            ui.step(steps, this.config.maxSteps, "thinking...");
+            const { message, usage } = await this.chatWithStream().catch((err) => {
+                // SIGINT during the LLM call — stop gracefully instead of crashing
+                if (this.aborted) {
+                    return {
+                        message: { role: "assistant", content: null, tool_calls: undefined },
+                        usage: undefined,
+                    };
+                }
+                throw err;
+            });
+            if (this.aborted)
+                break;
+            if (usage) {
+                ui.info(`tokens: in=${usage.prompt_tokens ?? "?"} out=${usage.completion_tokens ?? "?"}`);
+                this.logger.log({ type: "step", step: steps, usage });
+            }
+            else {
+                this.logger.log({ type: "step", step: steps });
+            }
+            // No tool calls => assistant produced a text answer
+            if (!message.tool_calls || message.tool_calls.length === 0) {
+                const text = message.content ?? "";
+                this.messages.push({ role: "assistant", content: text });
+                // If the assistant says it's done without building, force a build check.
+                // If the assistant says it's done without building, force a build check.
+                if (claimsCompletion(text) && steps < this.config.maxSteps) {
+                    ui.info("agent claims completion -> verifying with build");
+                    lastBuild = await this.checkBuild(buildCmd);
+                    if (lastBuild.success) {
+                        return this.finish(true, steps, buildCmd, text);
+                    }
+                    this.messages.push({
+                        role: "user",
+                        content: `Build still FAILED after your claimed completion. Output:\n${summariseOutput(lastBuild.output)}\nFix and continue.`,
+                    });
+                    continue;
+                }
+                ui.llm("agent", text);
+                // Treat a plain text answer with no build as interim commentary; nudge loop.
+                this.messages.push({
+                    role: "user",
+                    content: "Continue working on the task. Use tools. Build must pass before you finish.",
+                });
+                continue;
+            }
+            this.messages.push({
+                role: "assistant",
+                content: message.content ?? null,
+                tool_calls: message.tool_calls,
+            });
+            // Execute each tool call (validate args before running)
+            const stepToolResults = new Map();
+            for (const tc of message.tool_calls) {
+                if (this.aborted)
+                    break;
+                const tool = getTool(tc.name);
+                let args;
+                try {
+                    args = tc.arguments ? JSON.parse(tc.arguments) : {};
+                }
+                catch {
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: tc.id,
+                        name: tc.name,
+                        content: `ERROR: invalid JSON arguments: ${tc.arguments.slice(0, 200)}`,
+                    });
+                    continue;
+                }
+                ui.toolCall(tc.name, args);
+                if (!tool && !(this.mcp?.hasTool(tc.name))) {
+                    ui.toolResult(tc.name, false, "unknown tool");
+                    this.logger.log({ type: "tool", step: steps, tool: tc.name, ok: false, error: "unknown tool" });
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: tc.id,
+                        name: tc.name,
+                        content: `ERROR: unknown tool "${tc.name}". Available: ${AGENT_TOOLS.map((t) => t.spec.function.name).join(", ")}${this.mcp ? " + MCP tools (mcp__<server>__<tool>)" : ""}`,
+                    });
+                    continue;
+                }
+                let result;
+                try {
+                    // Permission gate for shell commands
+                    if (tc.name === "run_command" && typeof args.command === "string") {
+                        const decision = this.permissions.classify(args.command);
+                        if (decision.decision === "deny") {
+                            result = {
+                                ok: false,
+                                output: `ERROR: command denied by permission policy (${decision.reason}): ${String(args.command).slice(0, 200)}`,
+                            };
+                            ui.toolResult(tc.name, false, result.output);
+                            this.logger.log({ type: "tool", step: steps, tool: tc.name, args, ok: false, denied: decision.reason });
+                            this.messages.push({
+                                role: "tool",
+                                tool_call_id: tc.id,
+                                name: tc.name,
+                                content: result.output,
+                            });
+                            continue;
+                        }
+                        if (decision.decision === "ask") {
+                            const allowed = await this.permissions.confirm(args.command);
+                            if (!allowed) {
+                                result = {
+                                    ok: false,
+                                    output: `ERROR: user denied permission to run: ${String(args.command).slice(0, 200)}`,
+                                };
+                                ui.toolResult(tc.name, false, result.output);
+                                this.logger.log({ type: "tool", step: steps, tool: tc.name, args, ok: false, denied: "user" });
+                                this.messages.push({
+                                    role: "tool",
+                                    tool_call_id: tc.id,
+                                    name: tc.name,
+                                    content: result.output,
+                                });
+                                continue;
+                            }
+                        }
+                    }
+                    const t0 = Date.now();
+                    // Route MCP tools first (they carry the mcp__ prefix, not in AGENT_TOOLS)
+                    if (tool) {
+                        result = await tool.run(this.ctx, args);
+                    }
+                    else if (this.config.permissionMode === "readonly") {
+                        // MCP tools are not covered by the permission system (no command
+                        // classification, no diff preview) — deny them entirely in readonly.
+                        result = {
+                            ok: false,
+                            output: `ERROR: readonly mode — MCP tool "${tc.name}" is disabled. MCP tools bypass the built-in permission policy, so they cannot run in readonly mode.`,
+                        };
+                    }
+                    else {
+                        const reg = this.mcp?.getTool(tc.name);
+                        if (!reg) {
+                            result = { ok: false, output: `ERROR: unknown tool "${tc.name}"` };
+                        }
+                        else {
+                            const r = await reg.conn.callTool(reg.toolName, args);
+                            result = { ok: r.ok, output: r.output.length > 20_000 ? r.output.slice(0, 20_000) + "\n... [truncated]" : r.output };
+                        }
+                    }
+                    this.logger.log({ type: "tool", step: steps, tool: tc.name, args, ok: result.ok, elapsedMs: Date.now() - t0 });
+                }
+                catch (err) {
+                    result = { ok: false, output: `ERROR: ${err.message}` };
+                    this.logger.log({ type: "tool", step: steps, tool: tc.name, args, ok: false, error: err.message });
+                }
+                // User pressed [q]uit in an edit-confirmation prompt — stop the whole run.
+                if (this.permissions.abortRequested) {
+                    this.aborted = true;
+                    ui.warn("edit confirmation aborted by user ([q]uit) — stopping the run");
+                }
+                ui.toolResult(tc.name, result.ok, result.output);
+                stepToolResults.set(tc.id, { ok: result.ok, output: result.output });
+                this.messages.push({
+                    role: "tool",
+                    tool_call_id: tc.id,
+                    name: tc.name,
+                    content: summariseOutput(result.output),
+                });
+            }
+            // After a build-command run, treat success as the terminal condition.
+            // Match the FULL build command (not just its first word): matching "npm"
+            // would falsely trigger on "npm install" mid-task and end the agent.
+            const buildCall = message.tool_calls.find((tc) => tc.name === "run_command" && tc.arguments.includes(buildCmd));
+            if (buildCall) {
+                // Reuse the tool result when the agent ran the exact build command —
+                // avoids executing the build a second time just to verify.
+                const result = stepToolResults.get(buildCall.id);
+                if (result && result.ok) {
+                    return this.finish(true, steps, buildCmd, message.content ?? "Build passed.");
+                }
+                lastBuild = await this.checkBuild(buildCmd);
+                if (lastBuild.success) {
+                    return this.finish(true, steps, buildCmd, message.content ?? "Build passed.");
+                }
+                this.messages.push({
+                    role: "user",
+                    content: `Build FAILED (stop condition not met). Error output:\n${summariseOutput(lastBuild.output)}\nAnalyze the errors, fix the code, and rebuild.`,
+                });
+            }
+            this.messages = trimHistory(this.messages);
+            // Persist session state after every step (enables resume after crash/SIGINT)
+            this.saveSession(steps, buildCmd, lastBuild);
+        }
+        // Max steps reached or aborted
+        const reason = this.aborted ? "interrupted by user (SIGINT)" : `reached max steps (${this.config.maxSteps})`;
+        this.saveSession(steps, buildCmd, lastBuild);
+        return this.finish(false, steps, buildCmd, `Agent stopped: ${reason}`);
+    }
+    /** Persist current agent state to .scoder/sessions/<id>.json. */
+    saveSession(steps, buildCmd, lastBuild) {
+        this.lastBuildResult = lastBuild;
+        this.session.save({
+            task: this.currentTask,
+            model: this.client.model,
+            provider: this.config.provider,
+            buildCmd,
+            steps,
+            maxSteps: this.config.maxSteps,
+            messages: this.messages,
+            lastBuild: lastBuild
+                ? { success: lastBuild.success, command: lastBuild.command, output: lastBuild.output.slice(0, 10_000) }
+                : null,
+        }, this.sessionCreatedAt);
+    }
+    /** Explicitly verify the build (independent of what the LLM claims). */
+    async checkBuild(buildCmd) {
+        const res = await runBuild(this.config.workdir, buildCmd);
+        ui.buildStatus(res.success, res.output);
+        this.logger.log({ type: "build", success: res.success, command: buildCmd, output: res.output.slice(0, 10_000) });
+        return res;
+    }
+    finish(success, steps, buildCmd, summary) {
+        if (success) {
+            ui.success(`Task complete in ${steps} step(s). Build passed: ${buildCmd}`);
+        }
+        else {
+            ui.error(`Task NOT complete. ${summary}`);
+        }
+        this.logger.log({ type: "finish", success, steps });
+        return { success, steps, buildCmd, summary: summary.slice(0, 2000) };
+    }
+}

package/dist/build.js

@@ -0,0 +1,44 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { toolRunCommand } from "./tools.js";
+/** Detect a sensible build command from project files in workdir. */
+export function detectBuildCommand(workdir) {
+    const pkgPath = resolve(workdir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            if (pkg.scripts?.build)
+                return "npm run build";
+        }
+        catch {
+            // fall through
+        }
+    }
+    if (existsSync(resolve(workdir, "Makefile")))
+        return "make";
+    if (existsSync(resolve(workdir, "go.mod")))
+        return "go build ./...";
+    if (existsSync(resolve(workdir, "Cargo.toml")))
+        return "cargo build";
+    if (existsSync(resolve(workdir, "pyproject.toml")))
+        return "python -m compileall .";
+    if (existsSync(resolve(workdir, "tsconfig.json")))
+        return "npx tsc --noEmit";
+    return null;
+}
+/**
+ * Run the build command. This is the agent's stop condition:
+ * exit code 0 == task complete.
+ */
+/**
+ * Run the build command. This is the agent's stop condition:
+ * exit code 0 == task complete.
+ */
+export async function runBuild(workdir, command) {
+    const res = await toolRunCommand(workdir, { command, timeout_secs: 600 });
+    return {
+        success: res.ok,
+        command,
+        output: res.output,
+    };
+}

package/dist/config.js

@@ -0,0 +1,93 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_MODEL = "gpt-4o-mini";
+const ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const ANTHROPIC_DEFAULT_MODEL = "claude-sonnet-4-5";
+function loadRcFile(workdir) {
+    for (const name of [".scoderrc.json", ".scoderrc"]) {
+        const p = resolve(workdir, name);
+        if (existsSync(p)) {
+            try {
+                return JSON.parse(readFileSync(p, "utf8"));
+            }
+            catch {
+                // malformed rc file -> ignore
+            }
+        }
+    }
+    return {};
+}
+function parsePermissionMode(raw) {
+    if (raw === "auto" || raw === "ask" || raw === "readonly")
+        return raw;
+    return "auto";
+}
+function parseList(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.filter((x) => typeof x === "string");
+}
+export function loadConfig(overrides = {}) {
+    const workdir = overrides.workdir ?? process.cwd();
+    const rc = loadRcFile(workdir);
+    // Provider auto-detection: explicit flag > env > rc > baseUrl/model heuristics
+    const providerRaw = overrides.provider ??
+        process.env.SCODER_PROVIDER ??
+        rc.provider ??
+        undefined;
+    const isAnthropic = providerRaw === "anthropic" ||
+        (providerRaw === undefined &&
+            /api\.anthropic\.com/.test(process.env.SCODER_BASE_URL ?? process.env.OPENAI_BASE_URL ?? rc.baseUrl ?? "")) ||
+        (providerRaw === undefined &&
+            /^claude-/i.test(overrides.model ?? process.env.SCODER_MODEL ?? rc.model ?? ""));
+    const provider = providerRaw === "anthropic" || isAnthropic ? "anthropic" : "openai";
+    // Validate maxSteps: NaN/0/negative would silently break the agent loop
+    // (steps < NaN is always false → the loop never runs).
+    const rawMaxSteps = Number(process.env.SCODER_MAX_STEPS ?? rc.maxSteps ?? 40);
+    const validatedMaxSteps = Number.isFinite(rawMaxSteps) && rawMaxSteps >= 1 ? Math.floor(rawMaxSteps) : 40;
+    const cfg = {
+        provider,
+        baseUrl: overrides.baseUrl ?? process.env.SCODER_BASE_URL ?? process.env.OPENAI_BASE_URL ?? rc.baseUrl ?? (isAnthropic ? ANTHROPIC_BASE_URL : DEFAULT_BASE_URL),
+        apiKey: overrides.apiKey ??
+            process.env.SCODER_API_KEY ??
+            (isAnthropic ? process.env.ANTHROPIC_API_KEY : undefined) ??
+            process.env.OPENAI_API_KEY ??
+            rc.apiKey ??
+            "",
+        model: overrides.model ?? process.env.SCODER_MODEL ?? process.env.OPENAI_MODEL ?? rc.model ?? (isAnthropic ? ANTHROPIC_DEFAULT_MODEL : DEFAULT_MODEL),
+        workdir,
+        buildCmd: overrides.buildCmd ?? process.env.SCODER_BUILD_CMD ?? rc.buildCmd ?? null,
+        maxSteps: overrides.maxSteps ?? validatedMaxSteps,
+        maxTokens: 8192,
+        temperature: 0.2,
+        yes: overrides.yes ?? false,
+        noSave: overrides.noSave ?? process.env.SCODER_NO_SAVE === "1",
+        logFile: overrides.logFile ??
+            // "1" means auto-path (.scoder/logs/<session>.jsonl); any other non-empty
+            // value is treated as an explicit path. A bare string "1" would otherwise
+            // resolve to a file literally named "1".
+            (process.env.SCODER_LOG_FILE === "1"
+                ? true
+                : process.env.SCODER_LOG_FILE || undefined),
+        mcpServers: rc.mcpServers,
+        stream: overrides.stream ?? (process.env.SCODER_STREAM !== "0" ? true : false),
+        permissionMode: overrides.permissionMode ??
+            parsePermissionMode(process.env.SCODER_PERMISSION ?? rc.permission ?? rc.permissions?.mode ?? "auto"),
+    };
+    // Secrets hygiene: warn if apiKey is set in the rc file (risk of accidental commit)
+    if (rc.apiKey && !process.env.SCODER_NO_APIKEY_WARNING) {
+        console.error(`\n⚠  WARNING: API key found in .scoderrc.json — this file may be committed to git.\n` +
+            `   Prefer the environment variable SCODER_API_KEY (or OPENAI_API_KEY) instead,\n` +
+            `   and add .scoderrc.json to .gitignore. Suppress: SCODER_NO_APIKEY_WARNING=1\n`);
+    }
+    return cfg;
+}
+/** Extract permission lists from the rc file (loaded again here to avoid widening AgentConfig). */
+export function loadPermissionLists(workdir) {
+    const rc = loadRcFile(workdir);
+    return {
+        allowCommands: parseList(rc.permissions?.allowCommands),
+        denyCommands: parseList(rc.permissions?.denyCommands),
+    };
+}

package/dist/context.js

@@ -0,0 +1,44 @@
+const MAX_MESSAGES = 120; // keep history under control for long runs
+/**
+ * Trim message history to stay within token budget.
+ * Strategy: keep system prompt + last N messages, compact older user/assistant pairs.
+ */
+export function trimHistory(messages) {
+    if (messages.length <= MAX_MESSAGES)
+        return messages;
+    // Keep system + last MAX_MESSAGES-1
+    const system = messages[0].role === "system" ? messages[0] : null;
+    const rest = system ? messages.slice(1) : messages;
+    const trimmed = rest.slice(-(MAX_MESSAGES - 1));
+    if (system) {
+        return [system, ...trimmed];
+    }
+    return trimmed;
+}
+/**
+ * Strict heuristic: does the assistant's plain-text message claim the task is
+ * finished? Deliberately narrow — bare words like "done" or "finished" appear
+ * in almost any sentence ("I'm not done yet", "package.json is finished with"),
+ * which previously triggered spurious build checks. Requires an explicit
+ * completion phrase instead.
+ */
+export function claimsCompletion(text) {
+    return /\b(?:task\s+(?:is\s+)?(?:now\s+)?(?:complete[d]?|done|finished)|all\s+(?:done|finished)|work\s+is\s+(?:now\s+)?(?:complete[d]?|done|finished)|tests?\s+(?:all\s+)?pass(?:ed|ing)?\s*[-—]\s*(?:task|everything)\s+complete[d]?)\b/i.test(text);
+}
+/**
+ * Summarize a long output to keep context lean.
+ * For very long tool outputs, keep beginning + error lines + end.
+ */
+export function summariseOutput(output, maxChars = 4000) {
+    if (output.length <= maxChars)
+        return output;
+    const lines = output.split("\n");
+    if (lines.length <= 30)
+        return output.slice(0, maxChars) + "\n... [truncated]";
+    const keepStart = Math.min(10, Math.floor(lines.length * 0.1));
+    const keepEnd = Math.min(10, Math.floor(lines.length * 0.1));
+    const snippet = lines.slice(0, keepStart).join("\n") +
+        `\n... [${lines.length - keepStart - keepEnd} lines omitted] ...\n` +
+        lines.slice(-keepEnd).join("\n");
+    return snippet.slice(0, maxChars) + "\n... [truncated]";
+}