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

package/dist/constants.js

@@ -0,0 +1,69 @@
+/**
+ * Central constants: model pricing for cost estimation.
+ *
+ * Prices are USD per 1M tokens (input / output), approximate list prices.
+ * They can be overridden per-project via the rc file:
+ *
+ *   .scoderrc.json:
+ *   { "modelPricing": { "my-model": { "input": 1.0, "output": 2.0 } } }
+ *
+ * Keys are matched as a PREFIX of the model name (case-insensitive), so
+ * "gpt-4o-mini" also covers "gpt-4o-mini-2024-07-18". More specific keys
+ * (longer prefix) win.
+ */
+/** Fallback price when a model is unknown (deliberately conservative, not zero). */
+export const DEFAULT_MODEL_PRICING = { input: 0.5, output: 1.5 };
+/** Approximate list prices, USD per 1M tokens. Longest matching prefix wins. */
+export const MODEL_PRICING = {
+    // OpenAI
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+    "gpt-4.1": { input: 2, output: 8 },
+    "gpt-4-turbo": { input: 10, output: 30 },
+    "gpt-4": { input: 30, output: 60 },
+    "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+    "o1": { input: 15, output: 60 },
+    "o1-mini": { input: 1.1, output: 4.4 },
+    "o3-mini": { input: 1.1, output: 4.4 },
+    "o3": { input: 2, output: 8 },
+    "o4-mini": { input: 1.1, output: 4.4 },
+    // Anthropic
+    "claude-opus-4": { input: 15, output: 75 },
+    "claude-sonnet-4": { input: 3, output: 15 },
+    "claude-haiku-4": { input: 0.8, output: 4 },
+    "claude-3-7-sonnet": { input: 3, output: 15 },
+    "claude-3-5-sonnet": { input: 3, output: 15 },
+    "claude-3-5-haiku": { input: 0.8, output: 4 },
+    "claude-3-haiku": { input: 0.25, output: 1.25 },
+    "claude-3-opus": { input: 15, output: 75 },
+    // Popular local/OpenAI-compatible providers (mostly $0 or nominal)
+    "llama3": { input: 0, output: 0 },
+    "qwen": { input: 0, output: 0 },
+    "deepseek-chat": { input: 0.27, output: 1.1 },
+    "deepseek-reasoner": { input: 0.55, output: 2.19 },
+};
+/**
+ * Resolve the price table for a model, honouring user overrides.
+ * `overrides` maps model-name prefixes to pricing and always wins over the
+ * built-in table. Longest matching prefix wins (case-insensitive).
+ */
+export function resolveModelPricing(model, overrides = {}) {
+    const m = model.toLowerCase();
+    let best = null;
+    // Built-in table first (longest prefix wins), then overrides — an override
+    // with the SAME prefix length replaces the built-in entry.
+    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+        const k = key.toLowerCase();
+        if (m.startsWith(k) && (!best || k.length > best.key.length)) {
+            best = { key: k, pricing };
+        }
+    }
+    for (const [key, pricing] of Object.entries(overrides)) {
+        const k = key.toLowerCase();
+        if (m.startsWith(k) && (!best || k.length >= best.key.length)) {
+            best = { key: k, pricing };
+        }
+    }
+    return best ? best.pricing : DEFAULT_MODEL_PRICING;
+}

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]";
+}

package/dist/cost.js

@@ -0,0 +1,141 @@
+/**
+ * Usage & cost tracking (enterprise feature).
+ *
+ * Every LLM call writes an `llm_usage` event into the session JSONL log:
+ *   { ts, type: "llm_usage", model, provider, usage: { input_tokens, output_tokens, cached_tokens } }
+ *
+ * `scoder cost` reads those logs and aggregates tokens + estimated cost.
+ * All logic here is pure/filesystem-only so it stays unit-testable.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { resolveModelPricing } from "./constants.js";
+/** Extract `llm_usage` events from a list of raw log events. */
+export function extractUsageEvents(sessionId, events) {
+    const out = [];
+    for (const ev of events) {
+        if (ev.type !== "llm_usage")
+            continue;
+        const usage = (ev.usage ?? {});
+        const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+        out.push({
+            ts: typeof ev.ts === "string" ? ev.ts : undefined,
+            sessionId,
+            model: typeof ev.model === "string" ? ev.model : "unknown",
+            provider: typeof ev.provider === "string" ? ev.provider : undefined,
+            inputTokens: num(usage.input_tokens ?? usage.prompt_tokens),
+            outputTokens: num(usage.output_tokens ?? usage.completion_tokens),
+            cachedTokens: num(usage.cached_tokens),
+        });
+    }
+    return out;
+}
+/** Cost of one usage event in USD (cached tokens are billed like input tokens here — provider-specific discounts are approximated by the price table). */
+export function estimateEventCost(ev, overrides = {}) {
+    const p = resolveModelPricing(ev.model, overrides);
+    return (ev.inputTokens / 1_000_000) * p.input + (ev.outputTokens / 1_000_000) * p.output;
+}
+/** Aggregate usage events into totals + estimated cost. */
+export function aggregateUsage(events, overrides = {}) {
+    const agg = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0, costUsd: 0 };
+    for (const ev of events) {
+        agg.calls += 1;
+        agg.inputTokens += ev.inputTokens;
+        agg.outputTokens += ev.outputTokens;
+        agg.cachedTokens += ev.cachedTokens;
+        agg.costUsd += estimateEventCost(ev, overrides);
+    }
+    agg.costUsd = Math.round(agg.costUsd * 10_000) / 10_000; // round to $0.0001
+    return agg;
+}
+/** Parse a JSONL log file into raw events (null if missing/unreadable). */
+export function readJsonlLog(path) {
+    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;
+}
+/** List all session log files, newest id first (ids sort chronologically). */
+export function listLogSessions(workdir) {
+    const dir = resolve(workdir, ".scoder/logs");
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .map((f) => f.slice(0, -".jsonl".length))
+            .sort()
+            .reverse();
+    }
+    catch {
+        return [];
+    }
+}
+/** Load all usage events of a single session (or [] if no log). */
+export function loadSessionUsage(workdir, sessionId) {
+    const path = resolve(workdir, ".scoder/logs", `${sessionId}.jsonl`);
+    const events = readJsonlLog(path);
+    return events ? extractUsageEvents(sessionId, events) : [];
+}
+/**
+ * Collect usage for a selection of sessions:
+ *  - explicit id    -> that session
+ *  - "last n"       -> n most recent session logs
+ *  - all            -> every session log in the workdir
+ */
+export function collectUsage(workdir, opts = {}) {
+    let ids;
+    if (opts.sessionId) {
+        ids = [opts.sessionId];
+    }
+    else if (typeof opts.last === "number") {
+        const all = listLogSessions(workdir);
+        ids = all.slice(0, Math.max(0, opts.last));
+    }
+    else {
+        ids = listLogSessions(workdir);
+    }
+    return ids.map((id) => ({
+        sessionId: id,
+        aggregate: aggregateUsage(loadSessionUsage(workdir, id), opts.pricingOverrides),
+    }));
+}
+/** Render a human-readable cost report (also used by tests to assert output). */
+export function formatCostReport(sessionCosts) {
+    if (sessionCosts.length === 0) {
+        return "No LLM usage recorded. Run with --log-file (or SCODER_LOG_FILE=1) to record usage.";
+    }
+    const grand = { calls: 0, inputTokens: 0, outputTokens: 0, cachedTokens: 0, costUsd: 0 };
+    const lines = ["COST REPORT"];
+    for (const sc of sessionCosts) {
+        const a = sc.aggregate;
+        grand.calls += a.calls;
+        grand.inputTokens += a.inputTokens;
+        grand.outputTokens += a.outputTokens;
+        grand.cachedTokens += a.cachedTokens;
+        grand.costUsd += a.costUsd;
+        lines.push(`  ${sc.sessionId}  calls=${a.calls}  in=${a.inputTokens.toLocaleString("en-US")}  out=${a.outputTokens.toLocaleString("en-US")}  cached=${a.cachedTokens.toLocaleString("en-US")}  cost≈$${a.costUsd.toFixed(4)}`);
+    }
+    grand.costUsd = Math.round(grand.costUsd * 10_000) / 10_000;
+    lines.push(`TOTAL (${sessionCosts.length} session(s))  calls=${grand.calls}  in=${grand.inputTokens.toLocaleString("en-US")}  out=${grand.outputTokens.toLocaleString("en-US")}  cached=${grand.cachedTokens.toLocaleString("en-US")}  cost≈$${grand.costUsd.toFixed(4)}`);
+    return lines.join("\n");
+}
+/** Join a path under the workdir's log dir (exported for tests). */
+export function logFilePath(workdir, sessionId) {
+    return join(workdir, ".scoder/logs", `${sessionId}.jsonl`);
+}

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,
+    };
+}