@este.systems/dsc 0.1.0

package/dist/index.js

@@ -0,0 +1,830 @@
+import * as readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { promises as fsp } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { AVAILABLE_MODELS, DEFAULT_MODEL, DeepSeekError, configPath, hasApiKey, recordUsage, } from "./api.js";
+import { runAgent, formatCost, formatStatus, estimateContextTokens } from "./agent.js";
+import * as history from "./history.js";
+import * as approval from "./approval.js";
+import * as replHistory from "./repl_history.js";
+import * as audit from "./audit.js";
+import { compactSession } from "./compact.js";
+import { Spinner, StatusBar } from "./ui.js";
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RED = "\x1b[31m";
+function parseArgs(argv) {
+    const out = { model: DEFAULT_MODEL, yolo: false, resume: true, modelExplicit: false };
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--yolo" || a === "-y") {
+            out.yolo = true;
+        }
+        else if (a === "--model" || a === "-m") {
+            const v = argv[++i];
+            if (!AVAILABLE_MODELS.includes(v)) {
+                throw new Error(`unknown model: ${v} (available: ${AVAILABLE_MODELS.join(", ")})`);
+            }
+            out.model = v;
+            out.modelExplicit = true;
+        }
+        else if (a === "--no-resume") {
+            out.resume = false;
+        }
+        else if (a === "--resume") {
+            const v = argv[i + 1];
+            if (v && !v.startsWith("-")) {
+                out.resumeId = v;
+                i++;
+            }
+            out.resume = true;
+        }
+        else if (a === "--help" || a === "-h") {
+            out.help = true;
+        }
+        else if (a.startsWith("-")) {
+            throw new Error(`unknown flag: ${a}`);
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    if (positional.length)
+        out.prompt = positional.join(" ");
+    return out;
+}
+function printHelp() {
+    process.stdout.write(`dsc — CLI coding agent for DeepSeek
+
+Usage:
+  dsc                       Start interactive REPL
+  dsc "your prompt here"    One-shot mode: run agent on prompt and exit
+
+Flags:
+  -m, --model <name>        Model: ${AVAILABLE_MODELS.join(" | ")} (default: ${DEFAULT_MODEL})
+  -y, --yolo                Skip approval prompts for write/edit/bash
+      --no-resume           Start a fresh session instead of resuming
+      --resume [id]         Resume a session (default: most recent for this cwd)
+  -h, --help                Show this help
+
+API key (in priority order):
+  $DEEPSEEK_API_KEY         Env var, takes precedence if set
+  ${configPath()}
+                            JSON file. Accepted shapes:
+                              {"api_key": "sk-..."}
+                              {"env": {"DEEPSEEK_API_KEY": "sk-..."}}
+                              {"env": {"ANTHROPIC_AUTH_TOKEN": "sk-..."}}  (claude-switcher compat)
+
+REPL commands:
+  /clear         Start a new session (current one stays on disk)
+  /cost          Show token usage and estimated cost
+  /model         Show or switch model (e.g. /model deepseek-v4-flash)
+  /yolo          Toggle approval mode
+  /reasoning [on|off]
+                 Show or hide reasoning_content streamed by thinking models
+                 (toggle when no arg)
+  /list          List sessions in this cwd
+  /save <name>   Give the current session a friendly name (used by /resume
+                 and shown in /list).
+  /rename <text> Replace the "assistant:" prefix on streamed turns with
+                 <text> (a name, glyph, or anything you like). No arg
+                 prints the current label; --reset / default restores it.
+  /resume <ref>  Resume a session by index from /list, by /save'd name,
+                 by id, or 'last' for the most recent.
+  /audit [path|show [N]]
+                 Default / 'path': print the JSONL audit log path.
+                 'show [N]': render the last N entries inline (default 10).
+  /transcript    Print the full conversation, including any messages that
+                 /compact previously archived (kept on disk, not sent to
+                 the API).
+  /compact [N]   Summarize older turns into a synthetic block (kept in the
+                 system prompt) and move them to the archive (visible via
+                 /transcript). Keeps the last N user turns verbatim
+                 (default N=4). Cumulative across re-runs.
+  /edit [text]   Compose the next prompt in $EDITOR (good for paste-heavy
+                 or multi-line input). Optional initial text seeds the buffer.
+  /exit          Quit
+
+Multi-line input:
+  End a line with a single \\ to continue on the next line (bash-style).
+  An even number of trailing backslashes is treated as literal.
+  For paste-heavy or longer drafts, use /edit.
+
+Audit log:
+  Every tool call (bash, edits, reads, fetches, rejections) is recorded
+  as one JSON line at ${audit.auditLogPath()}.
+  Disable with DSC_NO_AUDIT=1.
+
+Auto-compact:
+  When estimated context tokens exceed DSC_AUTO_COMPACT_AT (default 50000;
+  set to 0 / off / false to disable), dsc runs /compact 4 automatically
+  after the current turn. Manual /compact still works regardless.
+`);
+}
+async function main() {
+    let cli;
+    try {
+        cli = parseArgs(process.argv.slice(2));
+    }
+    catch (e) {
+        process.stderr.write(`${RED}${e.message}${RESET}\n`);
+        process.exit(2);
+    }
+    if (cli.help) {
+        printHelp();
+        return;
+    }
+    // Auto-compact threshold (token-count of estimated context). Set to 0 to
+    // disable. Default 50K — well below the 1M model limit, but tuned to keep
+    // per-turn input cost from creeping. Override via DSC_AUTO_COMPACT_AT.
+    const AUTO_COMPACT_AT_TOKENS = (() => {
+        const raw = process.env.DSC_AUTO_COMPACT_AT;
+        if (!raw)
+            return 50_000;
+        if (raw === "0" || raw === "off" || raw === "false")
+            return 0;
+        const n = parseInt(raw, 10);
+        return Number.isFinite(n) && n > 0 ? n : 50_000;
+    })();
+    const AUTO_COMPACT_KEEP = 4;
+    if (!hasApiKey()) {
+        process.stderr.write(`${RED}No DeepSeek API key found.${RESET}\n`);
+        process.stderr.write(`Either export DEEPSEEK_API_KEY, or create ${configPath()} containing:\n`);
+        process.stderr.write(`  {"api_key": "sk-..."}\n`);
+        process.stderr.write(`(also accepts {"env": {"ANTHROPIC_AUTH_TOKEN": "sk-..."}} for claude-switcher compat)\n`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    // Migrate old per-cwd file to the new sessions dir if present.
+    await history.migrateLegacyIfPresent(cwd, cli.model);
+    let session = history.newSession(cwd, cli.model);
+    // The system prompt is rebuilt per turn inside runAgent so cwd/date/status
+    // are always current — we no longer persist a stale copy at messages[0].
+    let restoredTurns = 0;
+    if (cli.resume) {
+        let target = null;
+        if (cli.resumeId) {
+            const loaded = await history.loadSession(cli.resumeId);
+            if (loaded) {
+                session = loaded;
+                target = { id: loaded.id };
+            }
+            else {
+                process.stderr.write(`${RED}session not found: ${cli.resumeId}${RESET}\n`);
+                process.exit(1);
+            }
+        }
+        else {
+            target = await history.mostRecentForCwd(cwd);
+            if (target) {
+                const loaded = await history.loadSession(target.id);
+                if (loaded)
+                    session = loaded;
+            }
+        }
+        restoredTurns = session.messages.filter((m) => m.role === "user").length;
+    }
+    let messages = session.messages;
+    let stats = session.stats;
+    let model = cli.modelExplicit ? cli.model : session.model;
+    const toolCtx = {
+        cwd,
+        yolo: cli.yolo,
+        filesTouched: stats.files_touched,
+        sessionId: session.id,
+    };
+    // Single-in-flight, coalescing save. Multiple persist() calls during one
+    // save's RTT collapse into one re-save at the end with the latest state.
+    // Awaiting persist() returns when *all* queued state is on disk.
+    let savePromise = null;
+    let savePending = false;
+    const persist = () => {
+        savePending = true;
+        if (savePromise)
+            return savePromise;
+        savePromise = (async () => {
+            while (savePending) {
+                savePending = false;
+                try {
+                    session.model = model;
+                    session.messages = messages;
+                    session.stats = stats;
+                    await history.saveSession(session);
+                }
+                catch (e) {
+                    process.stderr.write(`${DIM}(history save failed: ${e.message})${RESET}\n`);
+                }
+            }
+            savePromise = null;
+        })();
+        return savePromise;
+    };
+    const statusBar = new StatusBar();
+    const sessionStart = Date.now();
+    let showReasoning = true;
+    const currentStatusLine = () => formatStatus(stats, model, {
+        yolo: toolCtx.yolo,
+        reasoning: showReasoning,
+        contextTokens: estimateContextTokens(messages),
+        sessionSeconds: Math.floor((Date.now() - sessionStart) / 1000),
+        compacted: !!session.compaction,
+    });
+    const refreshStatus = () => statusBar.render(currentStatusLine());
+    let pendingAbort = null;
+    const formatApiError = (e) => {
+        if (e.status === 401) {
+            return `API key rejected (401). Check $DEEPSEEK_API_KEY or ${configPath()}.`;
+        }
+        if (e.status === 429)
+            return "Rate-limited (429). Try again in a moment.";
+        if (e.status === 400 && e.body) {
+            let detail = e.body;
+            try {
+                const parsed = JSON.parse(e.body);
+                detail = parsed?.error?.message ?? detail;
+            }
+            catch { }
+            return `Bad request (400): ${detail}`;
+        }
+        return e.message;
+    };
+    const runTurn = async (userText) => {
+        messages.push({ role: "user", content: userText });
+        pendingAbort = new AbortController();
+        try {
+            await runAgent({
+                model,
+                stats,
+                toolCtx,
+                messages,
+                signal: pendingAbort.signal,
+                onTurn: () => {
+                    refreshStatus();
+                    // Make every committed message durable. Coalesces if a save is in
+                    // flight, so back-to-back tool turns don't queue N saves.
+                    void persist();
+                },
+                showReasoning,
+                getStatusLine: currentStatusLine,
+                getSummary: () => session.compaction?.summary,
+                assistantLabel: session.assistantLabel,
+            });
+        }
+        catch (e) {
+            if (e.name === "AbortError" || pendingAbort?.signal.aborted) {
+                process.stderr.write(`\n${DIM}(interrupted)${RESET}\n`);
+            }
+            else if (e instanceof DeepSeekError) {
+                process.stderr.write(`\n${RED}${formatApiError(e)}${RESET}\n`);
+                if (e.body && e.status !== 400) {
+                    process.stderr.write(`${DIM}${e.body.slice(0, 1000)}${RESET}\n`);
+                }
+            }
+            else {
+                process.stderr.write(`\n${RED}${e.message}${RESET}\n`);
+            }
+        }
+        finally {
+            pendingAbort = null;
+        }
+        // No final refreshStatus here — the last onTurn inside runAgent already
+        // printed the post-push status; re-printing would just double the bar.
+        await persist();
+    };
+    // One-shot mode
+    if (cli.prompt) {
+        await runTurn(cli.prompt);
+        process.stdout.write(`\n${DIM}${formatCost(stats, model)}${RESET}\n`);
+        return;
+    }
+    // REPL
+    process.stdout.write(`${BOLD}dsc${RESET} ${DIM}(${model}${cli.yolo ? ", yolo" : ""})${RESET}  `);
+    process.stdout.write(`${DIM}type /help for commands, ESC to interrupt a turn, Ctrl+D to exit${RESET}\n`);
+    if (restoredTurns > 0) {
+        process.stdout.write(`${DIM}restored ${restoredTurns}-turn history (use /clear to reset)${RESET}\n`);
+    }
+    statusBar.enable();
+    refreshStatus();
+    const cleanup = () => statusBar.disable();
+    process.on("exit", cleanup);
+    let lastSigintMs = 0;
+    process.on("SIGINT", () => {
+        if (pendingAbort && !pendingAbort.signal.aborted) {
+            pendingAbort.abort();
+            return;
+        }
+        const now = Date.now();
+        if (now - lastSigintMs < 1000) {
+            cleanup();
+            process.exit(130);
+        }
+        lastSigintMs = now;
+        process.stdout.write(`\n${DIM}(press Ctrl+C again within 1s to exit)${RESET}\n`);
+    });
+    const rl = readline.createInterface({
+        input,
+        output,
+        historySize: 1000,
+        completer: completeSlashCommand,
+    });
+    approval.setAsker((q) => rl.question(q));
+    // ESC interrupts the current turn — more intuitive than Ctrl+C for "stop
+    // what the agent is doing right now". readline already puts stdin in raw
+    // mode and emits 'keypress' events for terminal input, so we just listen.
+    // Standalone ESC fires after a short disambiguation delay; ESC-prefixed
+    // sequences (arrow keys etc) come through as their named keys instead.
+    const onKeypress = (_str, key) => {
+        if (key?.name === "escape" &&
+            pendingAbort &&
+            !pendingAbort.signal.aborted) {
+            pendingAbort.abort();
+        }
+    };
+    process.stdin.on("keypress", onKeypress);
+    // Also catch readline's own SIGINT path for Ctrl+C — defends against the
+    // case where readline intercepts the signal before our process.on handler.
+    rl.on("SIGINT", () => {
+        if (pendingAbort && !pendingAbort.signal.aborted) {
+            pendingAbort.abort();
+        }
+    });
+    // Seed up/down history from disk (newest first per readline's convention).
+    void replHistory.compact();
+    const past = await replHistory.load();
+    const rlAny = rl;
+    rlAny.history.length = 0;
+    rlAny.history.push(...past.slice().reverse());
+    while (true) {
+        let line;
+        try {
+            line = await readPromptInput(rl);
+        }
+        catch {
+            break; // Ctrl+D
+        }
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Persist the user's submitted line to the on-disk history file. Slash
+        // commands are recorded too — recalling "/resume 3" is useful.
+        void replHistory.append(trimmed);
+        if (trimmed.startsWith("/")) {
+            const [cmd, ...rest] = trimmed.slice(1).split(/\s+/);
+            const arg = rest.join(" ");
+            if (cmd === "exit" || cmd === "quit") {
+                break;
+            }
+            else if (cmd === "help") {
+                printHelp();
+            }
+            else if (cmd === "clear") {
+                // Start a brand-new session; old session stays on disk. System prompt
+                // is rebuilt per turn so we don't seed messages with one.
+                session = history.newSession(cwd, model);
+                messages = session.messages;
+                stats = session.stats;
+                toolCtx.filesTouched = stats.files_touched;
+                toolCtx.sessionId = session.id;
+                refreshStatus();
+                process.stdout.write(`${DIM}new session started (${session.id})${RESET}\n`);
+            }
+            else if (cmd === "list") {
+                const all = await history.listSessions(cwd);
+                if (!all.length) {
+                    process.stdout.write(`${DIM}no sessions for ${cwd}${RESET}\n`);
+                }
+                else {
+                    all.forEach((s, i) => {
+                        const ago = formatRelative(s.updated_at);
+                        const here = s.id === session.id ? `${BOLD}*${RESET} ` : "  ";
+                        const label = s.name ? `${BOLD}${s.name}${RESET} (${s.model})` : s.model;
+                        process.stdout.write(`${here}${String(i + 1).padStart(2, " ")}. ${label}  ${ago}  (${s.message_count} msgs)  ${DIM}${s.first_user_message || "—"}${RESET}\n`);
+                    });
+                }
+            }
+            else if (cmd === "save") {
+                const name = arg.trim();
+                if (!name) {
+                    process.stdout.write(`${RED}usage: /save <name>${RESET}\n`);
+                }
+                else {
+                    session.name = name;
+                    await persist();
+                    process.stdout.write(`${DIM}session saved as "${name}" (id ${session.id})${RESET}\n`);
+                }
+            }
+            else if (cmd === "rename") {
+                const text = arg.trim();
+                if (!text) {
+                    const cur = session.assistantLabel ?? "assistant:";
+                    process.stdout.write(`${DIM}assistant label: "${cur}"${RESET}\n`);
+                }
+                else if (text === "--reset" || text === "default") {
+                    delete session.assistantLabel;
+                    await persist();
+                    process.stdout.write(`${DIM}assistant label reset to default${RESET}\n`);
+                }
+                else {
+                    session.assistantLabel = text;
+                    await persist();
+                    process.stdout.write(`${DIM}assistant label → "${text}"${RESET}\n`);
+                }
+            }
+            else if (cmd === "resume") {
+                const all = await history.listSessions(cwd);
+                if (!all.length) {
+                    process.stdout.write(`${DIM}no sessions to resume${RESET}\n`);
+                }
+                else {
+                    let target = null;
+                    if (!arg || arg === "last") {
+                        target = all[0];
+                    }
+                    else if (/^\d+$/.test(arg)) {
+                        const idx = parseInt(arg, 10) - 1;
+                        target = all[idx] ?? null;
+                        if (!target)
+                            process.stdout.write(`${RED}no session at index ${arg} (have ${all.length})${RESET}\n`);
+                    }
+                    else {
+                        // Match by name first (most-recent wins on tie since `all` is
+                        // sorted desc by updated_at), then fall back to id.
+                        target =
+                            all.find((s) => s.name === arg) ??
+                                all.find((s) => s.id === arg) ??
+                                null;
+                        if (!target)
+                            process.stdout.write(`${RED}no session with name or id ${arg}${RESET}\n`);
+                    }
+                    if (target) {
+                        const loaded = await history.loadSession(target.id);
+                        if (!loaded) {
+                            process.stdout.write(`${RED}failed to load session ${target.id}${RESET}\n`);
+                        }
+                        else {
+                            session = loaded;
+                            messages = session.messages;
+                            stats = session.stats;
+                            model = session.model;
+                            toolCtx.filesTouched = stats.files_touched;
+                            toolCtx.sessionId = session.id;
+                            refreshStatus();
+                            const userTurns = messages.filter((m) => m.role === "user").length;
+                            process.stdout.write(`${DIM}resumed ${session.id} (${userTurns} turns, model ${model})${RESET}\n`);
+                        }
+                    }
+                }
+            }
+            else if (cmd === "cost") {
+                process.stdout.write(`${DIM}${formatCost(stats, model)}${RESET}\n`);
+            }
+            else if (cmd === "model") {
+                if (!arg) {
+                    process.stdout.write(`${DIM}current model: ${model}${RESET}\n`);
+                }
+                else if (!AVAILABLE_MODELS.includes(arg)) {
+                    process.stdout.write(`${RED}unknown model: ${arg} (available: ${AVAILABLE_MODELS.join(", ")})${RESET}\n`);
+                }
+                else {
+                    model = arg;
+                    refreshStatus();
+                    process.stdout.write(`${DIM}model -> ${model}${RESET}\n`);
+                    await persist();
+                }
+            }
+            else if (cmd === "yolo") {
+                toolCtx.yolo = !toolCtx.yolo;
+                refreshStatus();
+                process.stdout.write(`${DIM}yolo: ${toolCtx.yolo}${RESET}\n`);
+            }
+            else if (cmd === "reasoning") {
+                if (arg === "on")
+                    showReasoning = true;
+                else if (arg === "off")
+                    showReasoning = false;
+                else
+                    showReasoning = !showReasoning; // toggle when no arg
+                refreshStatus();
+                process.stdout.write(`${DIM}reasoning: ${showReasoning ? "on" : "off"}${RESET}\n`);
+            }
+            else if (cmd === "audit") {
+                const sub = arg.trim();
+                if (sub.startsWith("show")) {
+                    const nRaw = sub.replace(/^show\s*/, "").trim();
+                    const n = nRaw ? parseInt(nRaw, 10) : NaN;
+                    const limit = Number.isFinite(n) && n > 0 ? n : 10;
+                    await renderAuditEntries(limit);
+                }
+                else if (!sub || sub === "path") {
+                    process.stdout.write(`${DIM}${audit.auditLogPath()}${RESET}\n`);
+                }
+                else {
+                    process.stdout.write(`${RED}usage: /audit | /audit path | /audit show [N]${RESET}\n`);
+                }
+            }
+            else if (cmd === "transcript") {
+                const archived = session.archivedMessages ?? [];
+                if (archived.length === 0 && messages.length === 0) {
+                    process.stdout.write(`${DIM}(no messages)${RESET}\n`);
+                }
+                else {
+                    if (archived.length > 0) {
+                        process.stdout.write(`${DIM}── archived (${archived.length} messages)${RESET}\n`);
+                        for (const m of archived)
+                            renderTranscriptMessage(m, true);
+                    }
+                    if (messages.length > 0) {
+                        process.stdout.write(`${DIM}── active (${messages.length} messages)${RESET}\n`);
+                        for (const m of messages)
+                            renderTranscriptMessage(m, false);
+                    }
+                }
+            }
+            else if (cmd === "compact") {
+                const keepRaw = arg ? parseInt(arg, 10) : NaN;
+                const keep = Number.isFinite(keepRaw) ? Math.max(0, keepRaw) : 4;
+                await runCompaction(keep, false);
+            }
+            else if (cmd === "edit") {
+                const draft = openEditor(arg ? arg + "\n" : "");
+                if (draft === null) {
+                    process.stdout.write(`${RED}editor failed${RESET}\n`);
+                }
+                else if (!draft.trim()) {
+                    process.stdout.write(`${DIM}(empty draft, not sent)${RESET}\n`);
+                }
+                else {
+                    process.stdout.write(`${DIM}── editor draft (${draft.length} chars):${RESET}\n`);
+                    process.stdout.write(draft.replace(/\n/g, "\n  ") + "\n");
+                    process.stdout.write(`${DIM}──${RESET}\n`);
+                    void replHistory.append(draft);
+                    await runTurnWithHistorySnapshot(draft);
+                }
+            }
+            else {
+                process.stdout.write(`${RED}unknown command: /${cmd}${RESET}\n`);
+            }
+            continue;
+        }
+        await runTurnWithHistorySnapshot(trimmed);
+    }
+    async function runTurnWithHistorySnapshot(text) {
+        // Snapshot rl.history so approval y/N answers (which readline auto-adds)
+        // don't leak into up-arrow recall.
+        const histSnapshot = rlAny.history.slice();
+        try {
+            await runTurn(text);
+        }
+        finally {
+            rlAny.history.length = 0;
+            rlAny.history.push(...histSnapshot);
+        }
+        // After every turn, kick off an auto-compaction if ctx is over budget.
+        if (AUTO_COMPACT_AT_TOKENS > 0) {
+            const ctx = estimateContextTokens(messages);
+            if (ctx > AUTO_COMPACT_AT_TOKENS) {
+                await runCompaction(AUTO_COMPACT_KEEP, true);
+            }
+        }
+    }
+    async function runCompaction(keep, auto) {
+        const beforeMessages = messages.length;
+        const beforeChars = messages.reduce((n, m) => n + (typeof m.content === "string" ? m.content.length : 0), 0);
+        if (auto) {
+            process.stdout.write(`${DIM}── auto-compact (ctx > ${AUTO_COMPACT_AT_TOKENS} tokens)${RESET}\n`);
+        }
+        const spinner = new Spinner("compacting");
+        spinner.start();
+        try {
+            const result = await compactSession(session, keep, model);
+            spinner.stop();
+            if (!result) {
+                if (!auto) {
+                    process.stdout.write(`${DIM}nothing to compact (need more than ${keep} user turns)${RESET}\n`);
+                }
+                return;
+            }
+            // Move the summarized messages into the on-disk archive so /transcript
+            // can still show them. They're no longer sent to the API.
+            session.archivedMessages = [
+                ...(session.archivedMessages ?? []),
+                ...result.droppedMessages,
+            ];
+            session.messages = result.remainingMessages;
+            messages = session.messages;
+            session.compaction = {
+                summary: result.summary,
+                compacted_at: Date.now(),
+                turns_removed: (session.compaction?.turns_removed ?? 0) + result.turnsRemoved,
+            };
+            stats.prompts += 1;
+            recordUsage(stats, result.usage);
+            const afterChars = messages.reduce((n, m) => n + (typeof m.content === "string" ? m.content.length : 0), 0);
+            const summaryChars = result.summary.length;
+            process.stdout.write(`${DIM}compacted ${result.turnsRemoved} user turn(s); messages ${beforeMessages} → ${messages.length}; chars ${beforeChars} → ${afterChars} + ${summaryChars} summary${RESET}\n`);
+            refreshStatus();
+            await persist();
+        }
+        catch (e) {
+            spinner.stop();
+            if (e instanceof DeepSeekError) {
+                process.stderr.write(`${RED}compaction failed: ${formatApiError(e)}${RESET}\n`);
+            }
+            else {
+                process.stderr.write(`${RED}compaction failed: ${e.message}${RESET}\n`);
+            }
+        }
+    }
+    approval.setAsker(null);
+    process.stdin.removeListener("keypress", onKeypress);
+    rl.close();
+    statusBar.disable();
+    process.stdout.write(`\n${DIM}${formatCost(stats, model)}${RESET}\n`);
+}
+async function renderAuditEntries(limit) {
+    let text;
+    try {
+        text = await fsp.readFile(audit.auditLogPath(), "utf8");
+    }
+    catch {
+        process.stdout.write(`${DIM}(no audit log yet)${RESET}\n`);
+        return;
+    }
+    const lines = text.split("\n").filter((l) => l.length > 0).slice(-limit);
+    if (lines.length === 0) {
+        process.stdout.write(`${DIM}(empty)${RESET}\n`);
+        return;
+    }
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const ts = typeof entry.ts === "string" ? entry.ts.slice(11, 19) : "";
+        const ok = entry.approved === false
+            ? `${RED}✗${RESET}`
+            : entry.error
+                ? `${RED}!${RESET}`
+                : `${DIM}✓${RESET}`;
+        const tool = String(entry.tool ?? "?");
+        const summary = summarizeAuditEntry(entry);
+        process.stdout.write(`${DIM}${ts}${RESET}  ${ok} ${BOLD}${tool.padEnd(11)}${RESET}  ${summary}\n`);
+    }
+}
+function summarizeAuditEntry(e) {
+    const trim = (v, n = 80) => {
+        const s = typeof v === "string" ? v : "";
+        return s.length <= n ? s : s.slice(0, n) + "…";
+    };
+    switch (e.tool) {
+        case "bash":
+            return trim(e.command, 100);
+        case "write_file":
+        case "edit_file":
+        case "read_file":
+            return trim(e.path);
+        case "grep":
+            return `"${trim(e.pattern, 40)}" in ${trim(e.path, 40)}`;
+        case "glob":
+            return trim(e.pattern);
+        case "web_search":
+            return `"${trim(e.query, 80)}"`;
+        case "web_fetch":
+            return trim(e.url, 100);
+        default:
+            return "";
+    }
+}
+// Slash commands the REPL recognizes. Used both for tab completion and as
+// a single source of truth for what's accepted (kept in sync with the if/
+// else chain in main()).
+const SLASH_COMMANDS = [
+    "audit",
+    "clear",
+    "compact",
+    "cost",
+    "edit",
+    "exit",
+    "help",
+    "list",
+    "model",
+    "quit",
+    "reasoning",
+    "rename",
+    "resume",
+    "save",
+    "transcript",
+    "yolo",
+];
+// readline-style completer: returns [matches, substringMatched]. We complete
+// the slash-command name only; subcommand args (e.g. /resume <name>) are not
+// completed yet — keep it simple and predictable.
+function completeSlashCommand(line) {
+    if (!line.startsWith("/"))
+        return [[], line];
+    const partial = line.slice(1);
+    if (partial.includes(" "))
+        return [[], line]; // past the command word
+    const matches = SLASH_COMMANDS.filter((c) => c.startsWith(partial)).map((c) => "/" + c);
+    return [matches, line];
+}
+function renderTranscriptMessage(m, archived) {
+    const tag = archived ? `${DIM}archived${RESET} ` : "";
+    const role = m.role;
+    const color = role === "user" ? "\x1b[36m" : role === "assistant" ? "\x1b[35m" : DIM;
+    const content = typeof m.content === "string" ? m.content : "";
+    process.stdout.write(`\n${tag}${BOLD}${color}${role}${RESET}\n`);
+    if (m.tool_calls && m.tool_calls.length) {
+        for (const tc of m.tool_calls) {
+            process.stdout.write(`${DIM}  → ${tc.function.name}(${truncateForTranscript(tc.function.arguments, 200)})${RESET}\n`);
+        }
+    }
+    if (m.tool_call_id) {
+        process.stdout.write(`${DIM}  ← tool_call_id: ${m.tool_call_id}${RESET}\n`);
+    }
+    if (content)
+        process.stdout.write(content + "\n");
+}
+function truncateForTranscript(s, n) {
+    return s.length <= n ? s : s.slice(0, n) + "…";
+}
+function formatRelative(ts) {
+    const s = Math.max(0, Math.floor((Date.now() - ts) / 1000));
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    const d = Math.floor(h / 24);
+    return `${d}d ago`;
+}
+/**
+ * Read one logical user prompt, supporting bash-style backslash continuation:
+ * an odd number of trailing backslashes on a submitted line means "continue
+ * on the next line"; the last backslash is consumed and replaced with a
+ * literal newline. An even count (e.g. \\) is treated as literal trailing
+ * backslashes and the line submits.
+ */
+async function readPromptInput(rl) {
+    const FIRST = `${BOLD}> ${RESET}`;
+    const CONT = `${DIM}… ${RESET}`;
+    let buf = "";
+    let prompt = FIRST;
+    while (true) {
+        const line = await rl.question(prompt);
+        const trailing = (line.match(/\\+$/) || [""])[0].length;
+        if (trailing % 2 === 1) {
+            buf += line.slice(0, -1) + "\n";
+            prompt = CONT;
+            continue;
+        }
+        buf += line;
+        return buf;
+    }
+}
+/**
+ * Open $EDITOR (preferring $VISUAL) on a temp .md file seeded with `initial`.
+ * Returns the file's contents on save, or null if the editor failed to launch.
+ * Empty/whitespace-only results are returned as "" so the caller can decide
+ * whether to skip the turn.
+ */
+function openEditor(initial) {
+    const editor = process.env.VISUAL || process.env.EDITOR || "vi";
+    const tmpDir = mkdtempSync(path.join(os.tmpdir(), "dsc-edit-"));
+    const tmpFile = path.join(tmpDir, "prompt.md");
+    try {
+        writeFileSync(tmpFile, initial, "utf8");
+        const r = spawnSync(editor, [tmpFile], { stdio: "inherit" });
+        if (r.error)
+            return null;
+        const content = readFileSync(tmpFile, "utf8");
+        return content.replace(/\n+$/, "");
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // best-effort
+        }
+    }
+}
+main().catch((e) => {
+    process.stderr.write(`${RED}fatal: ${e.message}${RESET}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map