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

package/dist/diff.js

@@ -0,0 +1,156 @@
+/**
+ * Minimal unified-diff generator (LCS-based, zero dependencies).
+ * Large inputs fall back to a summary (truncated: true).
+ */
+const MAX_DIFF_LINES = 2000; // per side; beyond this, summarize only
+const MAX_DIFF_TEXT_LINES = 120; // cap rendered diff lines
+/** LCS-based line diff producing ops in order. */
+function computeOps(a, b) {
+    const n = a.length;
+    const m = b.length;
+    // dp[i][j] = LCS length of a[i..] vs b[j..]
+    const dp = [];
+    for (let i = 0; i <= n; i++)
+        dp[i] = new Uint32Array(m + 1);
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            ops.push({ type: " ", line: a[i] });
+            i++;
+            j++;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            ops.push({ type: "-", line: a[i] });
+            i++;
+        }
+        else {
+            ops.push({ type: "+", line: b[j] });
+            j++;
+        }
+    }
+    while (i < n) {
+        ops.push({ type: "-", line: a[i] });
+        i++;
+    }
+    while (j < m) {
+        ops.push({ type: "+", line: b[j] });
+        j++;
+    }
+    return ops;
+}
+function splitLines(content) {
+    const lines = content.split("\n");
+    // Drop the artificial trailing empty element caused by a final newline
+    if (lines.length > 0 && content.endsWith("\n"))
+        lines.pop();
+    return lines;
+}
+/**
+ * Unified diff between old and new file content.
+ * oldContent === null means the file is new (all additions).
+ */
+export function unifiedDiff(path, oldContent, newContent) {
+    if (oldContent === newContent) {
+        return { text: "", added: 0, removed: 0, truncated: false };
+    }
+    const a = oldContent === null ? [] : splitLines(oldContent);
+    const b = splitLines(newContent);
+    if (a.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES) {
+        return { text: "", added: b.length, removed: a.length, truncated: true };
+    }
+    const ops = computeOps(a, b);
+    const added = ops.filter((o) => o.type === "+").length;
+    const removed = ops.filter((o) => o.type === "-").length;
+    if (added === 0 && removed === 0)
+        return { text: "", added: 0, removed: 0, truncated: false };
+    const header = `--- a/${path}\n+++ b/${path}\n`;
+    const hunks = buildHunks(ops, 3);
+    let text = header + hunks.join("\n");
+    let truncated = false;
+    const textLines = text.split("\n");
+    if (textLines.length > MAX_DIFF_TEXT_LINES) {
+        // Cap rendered diff lines; report counts instead of the full diff
+        const kept = textLines.slice(0, MAX_DIFF_TEXT_LINES).join("\n");
+        text = `${kept}\n... [diff truncated: +${added} -${removed} lines total]`;
+        truncated = true;
+    }
+    return { text, added, removed, truncated };
+}
+/** Build unified-diff hunks with `context` lines of context around changes. */
+function buildHunks(ops, context) {
+    // Indices of changed ops
+    const changed = [];
+    for (let i = 0; i < ops.length; i++) {
+        if (ops[i].type !== " ")
+            changed.push(i);
+    }
+    if (changed.length === 0)
+        return [];
+    // Prefix counts: lines in old/new file before op index i
+    const prefixA = new Int32Array(ops.length + 1); // counts "-" and " "
+    const prefixB = new Int32Array(ops.length + 1); // counts "+" and " "
+    for (let i = 0; i < ops.length; i++) {
+        prefixA[i + 1] = prefixA[i] + (ops[i].type === "+" ? 0 : 1);
+        prefixB[i + 1] = prefixB[i] + (ops[i].type === "-" ? 0 : 1);
+    }
+    // Group change indices into hunks (merge when gap <= 2*context)
+    const groups = [];
+    let gs = changed[0];
+    let prev = changed[0];
+    for (let k = 1; k < changed.length; k++) {
+        if (changed[k] - prev > context * 2) {
+            groups.push([gs, prev]);
+            gs = changed[k];
+        }
+        prev = changed[k];
+    }
+    groups.push([gs, prev]);
+    const hunks = [];
+    for (const [gStart, gEnd] of groups) {
+        const start = Math.max(0, gStart - context);
+        const end = Math.min(ops.length - 1, gEnd + context);
+        let aCount = 0;
+        let bCount = 0;
+        const body = [];
+        for (let k = start; k <= end; k++) {
+            const op = ops[k];
+            body.push(op.type + op.line);
+            if (op.type === "-")
+                aCount++;
+            else if (op.type === "+")
+                bCount++;
+            else {
+                aCount++;
+                bCount++;
+            }
+        }
+        // 1-based start lines; for empty side use the "line before" convention
+        const aStart = aCount > 0 ? prefixA[start] + 1 : prefixA[start];
+        const bStart = bCount > 0 ? prefixB[start] + 1 : prefixB[start];
+        const header = `@@ -${aStart},${aCount} +${bStart},${bCount} @@`;
+        hunks.push(header + "\n" + body.join("\n"));
+    }
+    return hunks;
+}
+/** Count added/removed lines for a summary like "+12 -3". */
+export function diffCounts(oldContent, newContent) {
+    if (oldContent === newContent)
+        return { added: 0, removed: 0 };
+    const a = oldContent === null ? [] : splitLines(oldContent);
+    const b = splitLines(newContent);
+    if (a.length > MAX_DIFF_LINES || b.length > MAX_DIFF_LINES) {
+        return { added: b.length, removed: a.length };
+    }
+    const ops = computeOps(a, b);
+    return {
+        added: ops.filter((o) => o.type === "+").length,
+        removed: ops.filter((o) => o.type === "-").length,
+    };
+}

package/dist/index.js

@@ -0,0 +1,285 @@
+#!/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 { 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 --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)
+  -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 "--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;
+    }
+    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.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);
+});