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

package/dist/index.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { createInterface } from "node:readline";
+import { resolve } from "node:path";
+import { loadConfig } from "./config.js";
+import { Agent } from "./agent.js";
+import { listSessions, resolveSessionId, pruneSessions } from "./session.js";
+import { JsonlLogger } from "./logger.js";
+import { collectUsage, formatCostReport } from "./cost.js";
+import { getVersion as getPackageVersion } from "./version.js";
+import * as ui from "./ui.js";
+// Single source of truth: read version from package.json (see src/version.ts).
+const VERSION = getPackageVersion();
+const HELP = `scoder — autonomous coding agent CLI
+
+USAGE
+  scoder [options] "<task>"        Run a task autonomously until the build passes
+  scoder                           Start interactive session (chat + tools)
+  scoder list                      List saved sessions for this directory
+  scoder resume <id|last> [task]   Resume a saved session (optionally with a follow-up task)
+  scoder logs [id|last] [filter]   Print a session's JSONL log (requires --log-file runs)
+  scoder cost [--session <id>] [--last <n>]
+                                    Token usage & estimated cost from JSONL logs
+  scoder --version | --help
+
+OPTIONS
+  -m, --model <name>        LLM model (env SCODER_MODEL / OPENAI_MODEL, default gpt-4o-mini)
+  --base-url <url>          OpenAI-compatible API base URL (env SCODER_BASE_URL / OPENAI_BASE_URL)
+  -k, --api-key <key>       API key (env SCODER_API_KEY / OPENAI_API_KEY)
+  --provider <name>         openai | anthropic (env SCODER_PROVIDER; auto-detected from model/baseUrl)
+  -B, --build <cmd>         Build command = stop condition (auto-detected if omitted)
+  -d, --dir <path>          Working directory (default: current directory)
+  -s, --max-steps <n>       Max autonomous loop iterations (default 40)
+  -y, --yes                 Non-interactive mode (auto-approves commands)
+  --permission <mode>       auto | ask | readonly (env SCODER_PERMISSION, default auto)
+  --no-save                 Disable session auto-save to .scoder/sessions/
+  --log-file                Write a JSONL event log to .scoder/logs/<session>.jsonl
+                            (or set SCODER_LOG_FILE=1 / =/path/to/log.jsonl)
+  --session <id>            (cost) Aggregate usage of one specific session
+  --last <n>                (cost) Aggregate usage of the n most recent sessions
+  -h, --help                Show this help
+  -v, --version             Show version
+
+CONFIG FILE
+  .scoderrc.json in the working directory (see .scoderrc.example.json):
+    { "model": "...", "baseUrl": "...", "buildCmd": "...", "maxSteps": 40,
+      "permissions": { "mode": "auto", "allowCommands": ["npm "], "denyCommands": ["curl "] } }
+
+EXAMPLES
+  scoder "add a divide function to src/math.ts with tests"
+  scoder --build "make test" "fix the failing test in utils"
+  scoder --permission ask "npm install express and wire up a route"
+  scoder -m claude-sonnet-4-5 "refactor the parser module"   # auto-detects Anthropic
+  scoder resume last "now add unit tests"
+`;
+function parseArgs(argv) {
+    const args = { task: null, yes: false, help: false, version: false };
+    const rest = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = () => argv[++i];
+        switch (a) {
+            case "-m":
+            case "--model":
+                args.model = next();
+                break;
+            case "-k":
+            case "--api-key":
+                args.apiKey = next();
+                break;
+            case "--base-url":
+                args.baseUrl = next();
+                break;
+            case "-B":
+            case "--build":
+                args.buildCmd = next();
+                break;
+            case "-d":
+            case "--dir":
+                args.workdir = next();
+                break;
+            case "-s":
+            case "--max-steps":
+                args.maxSteps = Number(next());
+                break;
+            case "-y":
+            case "--yes":
+                args.yes = true;
+                break;
+            case "--permission": {
+                const mode = next();
+                if (mode !== "auto" && mode !== "ask" && mode !== "readonly") {
+                    throw new Error(`Invalid --permission mode: ${mode} (expected auto | ask | readonly)`);
+                }
+                args.permission = mode;
+                break;
+            }
+            case "--no-save":
+                args.noSave = true;
+                break;
+            case "--log-file":
+                args.logFile = true;
+                break;
+            case "--session":
+                args.costSession = next();
+                break;
+            case "--last": {
+                const n = Number(next());
+                if (!Number.isFinite(n) || n < 1) {
+                    throw new Error(`Invalid --last value (expected a positive integer): ${n}`);
+                }
+                args.costLast = Math.floor(n);
+                break;
+            }
+            case "--provider": {
+                const p = next();
+                if (p !== "openai" && p !== "anthropic") {
+                    throw new Error(`Invalid --provider: ${p} (expected openai | anthropic)`);
+                }
+                args.provider = p;
+                break;
+            }
+            case "-h":
+            case "--help":
+                args.help = true;
+                break;
+            case "-v":
+            case "--version":
+                args.version = true;
+                break;
+            default:
+                if (a.startsWith("-")) {
+                    throw new Error(`Unknown option: ${a} (see --help)`);
+                }
+                rest.push(a);
+        }
+    }
+    args.task = rest.length > 0 ? rest.join(" ") : null;
+    // Subcommands: scoder list | scoder resume <id|last> [follow-up task] | scoder logs [id]
+    if (rest.length > 0 && rest[0] === "list") {
+        args.subcommand = "list";
+        args.task = null;
+    }
+    else if (rest[0] === "resume") {
+        args.subcommand = "resume";
+        args.resumeId = rest[1] ?? "last";
+        args.task = rest.length > 2 ? rest.slice(2).join(" ") : null;
+    }
+    else if (rest[0] === "logs") {
+        args.subcommand = "logs";
+        args.logsId = rest[1] ?? "last";
+        args.logsFilter = rest.length > 2 ? rest.slice(2).join(" ") : undefined;
+    }
+    else if (rest[0] === "cost") {
+        args.subcommand = "cost";
+        args.task = null;
+    }
+    return args;
+}
+async function runOnce(cfg, task) {
+    const agent = new Agent(cfg);
+    process.on("SIGINT", () => {
+        ui.warn("\nSIGINT received — finishing current tool, then stopping...");
+        agent.abort();
+    });
+    try {
+        const result = await agent.run(task);
+        const pruned = pruneSessions(cfg.workdir, 7);
+        if (pruned > 0)
+            ui.info(`pruned ${pruned} old session(s)`);
+        return result.success ? 0 : 1;
+    }
+    catch (err) {
+        ui.error(err.message);
+        return 2;
+    }
+}
+async function repl(cfg) {
+    ui.header(`scoder interactive — model: ${cfg.model}`);
+    ui.info('Type a task and press Enter. "exit" or Ctrl+D to quit.');
+    const rl = createInterface({ input: process.stdin, output: process.stdout, prompt: "you> " });
+    // One shared session for the whole REPL conversation (plan P0.5 §4):
+    // every input is a follow-up turn, context carries over, saved continuously.
+    const agent = new Agent(cfg);
+    process.on("SIGINT", () => {
+        ui.warn("\nSIGINT — aborting current task...");
+        agent.abort();
+    });
+    let first = true;
+    for (;;) {
+        const line = await new Promise((res) => rl.question("you> ", res));
+        const input = line.trim();
+        if (!input)
+            continue;
+        if (input === "exit" || input === "quit")
+            break;
+        try {
+            const result = first ? await agent.run(input) : await agent.runTurn(input);
+            first = false;
+            if (!result.success)
+                ui.warn("task did not complete — try refining it");
+        }
+        catch (err) {
+            ui.error(err.message);
+        }
+    }
+    ui.info("bye");
+    process.exit(0);
+}
+async function main() {
+    let args;
+    try {
+        args = parseArgs(process.argv.slice(2));
+    }
+    catch (err) {
+        ui.error(err.message);
+        process.exit(2);
+    }
+    if (args.version) {
+        console.log(VERSION);
+        return;
+    }
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    const cfg = loadConfig({
+        model: args.model,
+        baseUrl: args.baseUrl,
+        apiKey: args.apiKey,
+        buildCmd: args.buildCmd ?? undefined,
+        workdir: args.workdir ? resolve(args.workdir) : undefined,
+        maxSteps: args.maxSteps,
+        yes: args.yes,
+        permissionMode: args.permission ?? undefined,
+        provider: args.provider ?? undefined,
+        noSave: args.noSave,
+        logFile: args.logFile,
+    });
+    // Subcommands
+    if (args.subcommand === "list") {
+        const sessions = listSessions(cfg.workdir);
+        if (sessions.length === 0) {
+            console.log("No saved sessions in this directory.");
+            return;
+        }
+        for (const s of sessions) {
+            console.log(`${s.id}  steps=${String(s.steps).padStart(3)}  ${s.updatedAt}  ${s.task}`);
+        }
+        return;
+    }
+    if (args.subcommand === "resume") {
+        const s = resolveSessionId(cfg.workdir, args.resumeId ?? "last");
+        if (!s) {
+            ui.error(`Session not found: ${args.resumeId ?? "last"}. Run \`scoder list\` to see saved sessions.`);
+            process.exit(2);
+        }
+        const agent = new Agent(cfg);
+        process.on("SIGINT", () => {
+            ui.warn("\nSIGINT received — finishing current tool, then stopping...");
+            agent.abort();
+        });
+        try {
+            const result = await agent.resume(s, args.task ?? undefined);
+            process.exit(result.success ? 0 : 1);
+        }
+        catch (err) {
+            ui.error(err.message);
+            process.exit(2);
+        }
+    }
+    if (args.subcommand === "logs") {
+        let id = args.logsId ?? "last";
+        if (id === "last") {
+            const sessions = listSessions(cfg.workdir);
+            if (sessions.length === 0) {
+                ui.error("No saved sessions in this directory. Run with --log-file to record logs.");
+                process.exit(2);
+            }
+            id = sessions[0].id;
+        }
+        const events = JsonlLogger.read(cfg.workdir, id);
+        if (events === null || events.length === 0) {
+            ui.error(`No log found for session ${id}. Logs require --log-file (or SCODER_LOG_FILE=1).`);
+            process.exit(2);
+        }
+        const filter = args.logsFilter?.toLowerCase();
+        for (const ev of events) {
+            const line = JSON.stringify(ev);
+            if (filter && !line.toLowerCase().includes(filter))
+                continue;
+            console.log(line);
+        }
+        return;
+    }
+    if (args.subcommand === "cost") {
+        const sessionCosts = collectUsage(cfg.workdir, {
+            sessionId: args.costSession,
+            last: args.costLast,
+            pricingOverrides: cfg.modelPricing,
+        });
+        console.log(formatCostReport(sessionCosts));
+        return;
+    }
+    if (args.task) {
+        const code = await runOnce(cfg, args.task);
+        process.exit(code);
+    }
+    await repl(cfg);
+}
+main().catch((err) => {
+    ui.error(`fatal: ${err.stack ?? err.message}`);
+    process.exit(2);
+});

package/dist/llm.js

@@ -0,0 +1,276 @@
+/**
+ * Minimal OpenAI-compatible chat-completions client with function calling
+ * and optional SSE streaming.
+ */
+import { withRetry } from "./retry.js";
+export class LlmError extends Error {
+    status;
+    retryAfterMs;
+    constructor(message, status, retryAfterMs) {
+        super(message);
+        this.name = "LlmError";
+        if (status !== undefined)
+            this.status = status;
+        if (retryAfterMs !== undefined)
+            this.retryAfterMs = retryAfterMs;
+    }
+}
+/** Build an LlmError from a failed Response, carrying status + Retry-After. */
+async function toLlmError(res, url) {
+    let body = await res.text().catch(() => "");
+    // Redact Bearer token and raw key patterns to avoid leaking secrets in logs/errors
+    body = body.replace(/Bearer\s+[^\s,&\]]+/gi, "Bearer ***REDACTED***");
+    body = body.replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-***REDACTED***");
+    const err = new LlmError(`LLM API error ${res.status} at ${url}: ${body.slice(0, 500)}`, res.status);
+    // Only honor a REAL Retry-After value: Number("") === 0 would zero the backoff
+    const retryAfterHeader = res.headers.get("retry-after");
+    if (retryAfterHeader != null && retryAfterHeader !== "") {
+        const sec = Number(retryAfterHeader);
+        if (Number.isFinite(sec) && sec > 0)
+            err.retryAfterMs = sec * 1000;
+    }
+    return err;
+}
+// ---------------------------------------------------------------------------
+// Request timeout / abort helpers
+// ---------------------------------------------------------------------------
+/** Default per-request timeout for LLM calls (a hung connection must not block the agent forever). */
+export const LLM_REQUEST_TIMEOUT_MS = 120_000;
+/**
+ * Combine an external signal with a request timeout.
+ * Returns a derived signal plus a cleanup fn (removes listeners).
+ * Works on Node >= 18 (no AbortSignal.any dependency).
+ */
+export function combinedSignal(external, timeoutMs) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(new DOMException("LLM request timed out", "TimeoutError")), timeoutMs);
+    const onExternal = () => ac.abort(new DOMException("aborted", "AbortError"));
+    if (external) {
+        if (external.aborted)
+            ac.abort(external.reason);
+        else
+            external.addEventListener("abort", onExternal, { once: true });
+    }
+    return {
+        signal: ac.signal,
+        cleanup: () => {
+            clearTimeout(timer);
+            external?.removeEventListener("abort", onExternal);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// SSE parsing helpers
+// ---------------------------------------------------------------------------
+const SSE_PREFIX = "data: ";
+const SSE_DONE = "[DONE]";
+/** Parse SSE chunks from an OpenAI-compatible stream. */
+function parseSSELine(line) {
+    if (!line.startsWith(SSE_PREFIX))
+        return null;
+    const data = line.slice(SSE_PREFIX.length);
+    if (data === SSE_DONE)
+        return null; // [DONE] signals end
+    return data;
+}
+// ---------------------------------------------------------------------------
+// LlmClient
+// ---------------------------------------------------------------------------
+export class LlmClient {
+    opts;
+    streamEnabled;
+    constructor(opts) {
+        this.opts = opts;
+        this.streamEnabled = opts.stream !== false; // default true
+    }
+    get model() {
+        return this.opts.model;
+    }
+    // ── Non-streaming ──────────────────────────────────────────────────────────
+    async chat(messages, tools, opts = {}) {
+        const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
+        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const body = JSON.stringify({
+            model: this.opts.model,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+            temperature: this.opts.temperature,
+            max_tokens: this.opts.maxTokens,
+            stream: false,
+        });
+        let res;
+        try {
+            res = await withRetry(async () => {
+                const r = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.opts.apiKey}` },
+                    body,
+                    signal,
+                });
+                if (!r.ok)
+                    throw await toLlmError(r, url);
+                return r;
+            }, {}, (attempt, delay, reason) => console.error(`⚠  LLM request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/3)...`));
+        }
+        finally {
+            cleanup();
+        }
+        const data = (await res.json());
+        const choice = data.choices?.[0]?.message;
+        if (!choice)
+            throw new LlmError("LLM API returned no message in response");
+        // Extract cached prompt tokens when the provider reports them
+        // (OpenAI-style: usage.prompt_tokens_details.cached_tokens).
+        let usage;
+        if (data.usage) {
+            usage = { ...data.usage };
+            const details = usage.prompt_tokens_details;
+            if (usage.cached_tokens === undefined && typeof details?.cached_tokens === "number") {
+                usage.cached_tokens = details.cached_tokens;
+            }
+        }
+        return {
+            message: {
+                role: "assistant",
+                content: choice.content ?? null,
+                stop_reason: choice.stop_reason ?? (choice.content ? "stop" : undefined),
+                tool_calls: choice.tool_calls?.map((tc) => ({
+                    id: tc.id ?? "",
+                    name: tc.function?.name ?? "",
+                    arguments: tc.function?.arguments ?? "",
+                })),
+            },
+            usage,
+        };
+    }
+    // ── Streaming ───────────────────────────────────────────────────────────────
+    /**
+     * Stream chat completions, yielding incremental chunks.
+     * Falls back to non-streaming on stream-related errors.
+     */
+    async *streamChat(messages, tools, opts = {}) {
+        const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
+        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const bodyStr = JSON.stringify({
+            model: this.opts.model,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+            temperature: this.opts.temperature,
+            max_tokens: this.opts.maxTokens,
+            stream: true,
+        });
+        let res;
+        try {
+            res = await withRetry(async () => {
+                const r = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.opts.apiKey}` },
+                    body: bodyStr,
+                    signal,
+                });
+                if (!r.ok)
+                    throw await toLlmError(r, url);
+                return r;
+            }, {}, (attempt, delay, reason) => console.error(`⚠  LLM stream request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s...`));
+        }
+        catch (err) {
+            cleanup(); // don't leak the 120s request timer — it would hang the process
+            throw new LlmError(`Stream fetch error after retries at ${url}: ${err.message}`);
+        }
+        if (!res.body) {
+            throw new LlmError("Response body is not readable (not a streaming response)");
+        }
+        // Accumulators for tool_calls across chunks
+        const accumulatedToolCalls = [];
+        let finalResult;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete lines
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? ""; // keep incomplete line in buffer
+                for (const rawLine of lines) {
+                    const json = parseSSELine(rawLine);
+                    if (!json)
+                        continue;
+                    let chunkData;
+                    try {
+                        chunkData = JSON.parse(json);
+                    }
+                    catch {
+                        continue; // skip malformed JSON lines
+                    }
+                    const choice = chunkData.choices?.[0];
+                    if (!choice)
+                        continue;
+                    const delta = choice.delta;
+                    // Text content delta
+                    if (delta?.content != null && delta.content.length > 0) {
+                        yield { contentDelta: delta.content, done: false };
+                    }
+                    // Tool call deltas
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!accumulatedToolCalls[idx]) {
+                                accumulatedToolCalls[idx] = { arguments: "" };
+                            }
+                            if (tc.id)
+                                accumulatedToolCalls[idx].id = tc.id;
+                            if (tc.function?.name)
+                                accumulatedToolCalls[idx].name = tc.function.name;
+                            if (tc.function?.arguments) {
+                                accumulatedToolCalls[idx].arguments += tc.function.arguments;
+                            }
+                            yield {
+                                toolCallDelta: {
+                                    index: idx,
+                                    id: tc.id,
+                                    name: tc.function?.name,
+                                    argumentsDelta: tc.function?.arguments,
+                                },
+                                done: false,
+                            };
+                        }
+                    }
+                    // Final chunk
+                    if (choice.finish_reason) {
+                        // Collect final tool_calls
+                        const toolCalls = accumulatedToolCalls
+                            .filter((tc) => tc.name)
+                            .map((tc) => ({
+                            id: tc.id ?? "",
+                            name: tc.name ?? "",
+                            arguments: tc.arguments,
+                        }));
+                        finalResult = {
+                            message: {
+                                role: "assistant",
+                                content: null,
+                                stop_reason: choice.finish_reason,
+                                tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                            },
+                            usage: chunkData.usage,
+                        };
+                    }
+                }
+            }
+        }
+        finally {
+            // Cancel the body (frees the socket) and clear the request timeout
+            try {
+                reader.cancel();
+            }
+            catch { /* already released */ }
+            reader.releaseLock();
+            cleanup();
+        }
+        yield { done: true, final: finalResult };
+    }
+}

package/dist/logger.js

@@ -0,0 +1,78 @@
+/**
+ * Structured JSONL session logging.
+ * One JSON object per line — parseable with jq or any log consumer.
+ * Never crashes the agent: write failures are swallowed after one warning.
+ */
+import { mkdirSync, appendFileSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export class JsonlLogger {
+    filePath;
+    warned = false;
+    constructor(path) {
+        this.filePath = path;
+    }
+    /**
+     * Create a logger for a session.
+     * logFile: true    -> <workdir>/.scoder/logs/<sessionId>.jsonl
+     *          string  -> that exact path
+     *          false/undefined -> disabled (no-op)
+     */
+    static forSession(workdir, sessionId, logFile) {
+        if (logFile === undefined || logFile === false || logFile === null) {
+            return new JsonlLogger(null);
+        }
+        const path = typeof logFile === "string" && logFile.length > 0
+            ? resolve(logFile)
+            : resolve(workdir, ".scoder/logs", `${sessionId}.jsonl`);
+        try {
+            mkdirSync(dirname(path), { recursive: true });
+            return new JsonlLogger(path);
+        }
+        catch (err) {
+            console.error(`⚠  logging disabled (cannot create log dir): ${err.message}`);
+            return new JsonlLogger(null);
+        }
+    }
+    get enabled() {
+        return this.filePath !== null;
+    }
+    /** Read a session's JSONL log file, returning parsed events (or null if missing/unreadable). */
+    static read(workdir, sessionId) {
+        const path = resolve(workdir, ".scoder/logs", `${sessionId}.jsonl`);
+        let content;
+        try {
+            content = readFileSync(path, "utf8");
+        }
+        catch {
+            return null;
+        }
+        const events = [];
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return events;
+    }
+    /** Append one event. Never throws. */
+    log(event) {
+        if (!this.filePath)
+            return;
+        try {
+            const line = JSON.stringify({ ts: new Date().toISOString(), ...event });
+            appendFileSync(this.filePath, line + "\n", "utf8");
+        }
+        catch (err) {
+            if (!this.warned) {
+                this.warned = true;
+                console.error(`⚠  log write failed (${err.message}) — disabling session log`);
+            }
+            this.filePath = null;
+        }
+    }
+}