@este.systems/dsc 0.2.2 → 0.4.0

package/dist/tui.js

@@ -2,21 +2,28 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from "ink";
 import { App } from "./tui/App.js";
 import { getState, setState } from "./store.js";
-import { AVAILABLE_MODELS, DEFAULT_MODEL, DeepSeekError, computeCostUsd, configPath, hasApiKey, recordUsage, } from "./api.js";
+import { AVAILABLE_MODELS, DEFAULT_MODEL, DeepSeekError, apiKeySource, computeCostUsd, configPath, hasApiKey, recordUsage, saveApiKey, saveSearchKey, } from "./api.js";
+import { getProviderKey } from "./search.js";
 import { runAgent, formatCost, estimateContextTokens, } from "./agent.js";
 import * as history from "./history.js";
 import * as approval from "./approval.js";
 import * as audit from "./audit.js";
 import * as replHistory from "./repl_history.js";
 import { promises as fsp } from "node:fs";
+import { homedir } from "node:os";
+import * as path from "node:path";
 import { compactSession } from "./compact.js";
 import { formatVersionInfo } from "./version.js";
 import { openEditor } from "./editor.js";
+import { checkForUpdate, runUpdate } from "./update.js";
+import { copyToClipboard } from "./clipboard.js";
 const AUTO_COMPACT_AT_TOKENS = Number(process.env.DSC_AUTO_COMPACT ?? "0") || 0;
 const AUTO_COMPACT_KEEP = Number(process.env.DSC_AUTO_COMPACT_KEEP ?? "4") || 4;
-// Minimal arg parsing for the TUI entry. Mirrors the subset of flags the
-// REPL accepts that meaningfully affect a one-shot turn. Anything fancier
-// (e.g. --model, --resume <id>) still has to go through --repl for now.
+class CliError extends Error {
+}
+// Full arg parsing for the TUI entry — this is the only entry point now
+// that the readline REPL is gone. Anything the old REPL accepted needs to
+// be handled here.
 function parseArgs(argv) {
     const out = {};
     const positional = [];
@@ -30,9 +37,24 @@ function parseArgs(argv) {
             out.yolo = true;
         else if (a === "--no-resume")
             out.noResume = true;
+        else if (a === "--resume") {
+            const v = argv[i + 1];
+            if (v && !v.startsWith("-")) {
+                out.resumeId = v;
+                i++;
+            }
+            out.resume = true;
+        }
+        else if (a === "--model" || a === "-m") {
+            const v = argv[++i];
+            if (!AVAILABLE_MODELS.includes(v)) {
+                throw new CliError(`unknown model: ${v} (available: ${AVAILABLE_MODELS.join(", ")})`);
+            }
+            out.model = v;
+            out.modelExplicit = true;
+        }
         else if (a.startsWith("-")) {
-            // Unknown flags fall through silently — bin routes --repl-only flags
-            // (--model, --resume <id>) to index.ts instead.
+            throw new CliError(`unknown flag: ${a}`);
         }
         else
             positional.push(a);
@@ -42,41 +64,59 @@ function parseArgs(argv) {
     return out;
 }
 async function main() {
-    const cli = parseArgs(process.argv.slice(2));
+    let cli;
+    try {
+        cli = parseArgs(process.argv.slice(2));
+    }
+    catch (e) {
+        if (e instanceof CliError) {
+            process.stderr.write(`${e.message}\n`);
+            process.exit(2);
+        }
+        throw e;
+    }
     if (cli.version) {
         process.stdout.write(formatVersionInfo() + "\n");
         process.exit(0);
     }
     if (cli.help) {
         process.stdout.write([
-            "dsc — CLI coding agent for DeepSeek (TUI)",
+            "dsc — CLI coding agent for DeepSeek",
             "",
             "Usage:",
-            "  dsc                       Start the TUI",
-            "  dsc \"your prompt here\"    One-shot: run and exit",
-            "  dsc --repl                Use the readline REPL instead",
+            "  dsc                            Start the TUI",
+            "  dsc \"your prompt here\"         One-shot: run and exit",
             "",
-            "Flags handled here:",
-            "  -y, --yolo                Skip approval prompts",
-            "      --no-resume           Don't auto-resume the latest session",
-            "  -v, --version             Print version and exit",
-            "  -h, --help                Show this help",
-            "",
-            "All other flags (--model, --resume <id>) go through --repl.",
+            "Flags:",
+            "  -m, --model <name>             " + AVAILABLE_MODELS.join(" | "),
+            "  -y, --yolo                     Skip approval prompts",
+            "      --no-resume                Don't auto-resume the latest session",
+            "      --resume [id]              Resume the most recent (or by id)",
+            "  -v, --version                  Print version and exit",
+            "  -h, --help                     Show this help",
         ].join("\n") + "\n");
         process.exit(0);
     }
-    if (!hasApiKey()) {
-        process.stderr.write(`No DeepSeek API key found.\n` +
-            `Either export DEEPSEEK_API_KEY, or create ${configPath()} containing:\n` +
-            `  {"api_key": "sk-..."}\n`);
-        process.exit(1);
-    }
+    // First-launch UX: don't hard-exit when there's no API key. Boot the
+    // TUI and surface a one-line system message telling the user how to
+    // set one via /api-key. Submitting a turn before setting the key will
+    // surface DeepSeekError, which we already render as a system error.
+    const startupKeyMissing = !hasApiKey();
     const cwd = process.cwd();
     await history.migrateLegacyIfPresent(cwd, DEFAULT_MODEL);
-    // Auto-resume most recent for cwd unless --no-resume; otherwise fresh.
     let session = history.newSession(cwd, DEFAULT_MODEL);
-    if (!cli.noResume) {
+    if (cli.resumeId) {
+        // Explicit --resume <id>: load that session by id, error out if it
+        // doesn't exist rather than silently falling back to a new session.
+        const loaded = await history.loadSession(cli.resumeId);
+        if (!loaded) {
+            process.stderr.write(`session not found: ${cli.resumeId}\n`);
+            process.exit(1);
+        }
+        session = loaded;
+    }
+    else if (!cli.noResume) {
+        // Auto-resume most recent for this cwd; otherwise fresh.
         const target = await history.mostRecentForCwd(cwd);
         if (target) {
             const loaded = await history.loadSession(target.id);
@@ -88,13 +128,17 @@ async function main() {
     // out for the new session's arrays without restarting the process.
     let messages = session.messages;
     let stats = session.stats;
-    let model = session.model;
+    // --model on the command line overrides the session's stored model.
+    // Without --model, the session's model wins so resuming preserves what
+    // the user picked last time.
+    let model = cli.modelExplicit && cli.model ? cli.model : session.model;
     const initialAutoContinue = Number(process.env.DSC_AUTO_CONTINUE ?? "0") || 0;
     const toolCtx = {
         cwd,
         yolo: !!cli.yolo,
         filesTouched: stats.files_touched,
         sessionId: session.id,
+        sessionApprovals: new Set(),
     };
     // Coalescing save (same shape as REPL).
     let savePromise = null;
@@ -166,15 +210,16 @@ async function main() {
     // 1-second tick so the session timer in StatusBar advances even when idle.
     const timerId = setInterval(syncStatus, 1000);
     // Install the approval asker — routes confirm* calls through the
-    // ApprovalDialog component. The diff/preview body printed by confirm*
-    // still goes to stdout and will appear above ink's dynamic frame; that's
-    // acceptable for a first cut and gets cleaned up in a later commit.
-    approval.setAsker((q) => new Promise((resolve) => {
+    // ApprovalDialog component. The structured payload (title + body + kind)
+    // goes into the dialog so the diff/preview renders inline in the yellow
+    // bordered box rather than bleeding above ink's dynamic frame.
+    approval.setAsker((req) => new Promise((resolve) => {
         setState({
             approval: {
-                title: "Confirm",
-                body: "",
-                question: q,
+                title: req.title,
+                body: req.body ?? "",
+                kind: req.kind,
+                question: req.question,
                 resolve,
             },
         });
@@ -439,11 +484,17 @@ async function main() {
                     "/lang [name|off]        force the model to reply in a language",
                     "/auto-continue [N|off]  auto-grant N extra MAX_TOOL_DEPTH budgets",
                     "/cost                   show token usage and cost",
+                    "/copy                   copy last assistant response to clipboard",
                     "/version                show version info",
                     "/compact [keep]         summarize old turns (default keep=4)",
                     "/transcript             dump full message log",
                     "/audit [path|show N]    audit log info",
                     "/queue [clear]          list or clear queued prompts",
+                    "/export [path]          write current session JSON for transfer",
+                    "/import <path>          load session JSON; rebinds cwd here (--keep-cwd to skip)",
+                    "/api-key [key]          show source / save api key to config file",
+                    "/search-key [p] [key]   show search-provider keys / save brave|tavily key",
+                    "/update                 check npm for a newer dsc and install it",
                     "/exit                   exit",
                 ].join("\n"));
                 return true;
@@ -453,6 +504,10 @@ async function main() {
                 stats = session.stats;
                 toolCtx.filesTouched = stats.files_touched;
                 toolCtx.sessionId = session.id;
+                // Per-tool always-approval is conversation-scoped, so /clear has
+                // to drop it — otherwise the user would carry over implicit trust
+                // they made to a session they just walked away from.
+                toolCtx.sessionApprovals = new Set();
                 setState({ history: [], current: null });
                 info(`new session started (${session.id})`);
                 syncStatus();
@@ -560,6 +615,32 @@ async function main() {
             case "cost":
                 info(formatCost(stats, model));
                 return true;
+            case "copy": {
+                // Copy the most recent assistant response to the OS clipboard. The
+                // last *assistant* (not tool, not system, not user) is what the
+                // user usually wants — the actual answer text.
+                const state = getState();
+                let target;
+                for (let i = state.history.length - 1; i >= 0; i--) {
+                    const m = state.history[i];
+                    if (m.role === "assistant" && m.content) {
+                        target = m;
+                        break;
+                    }
+                }
+                if (!target) {
+                    info("no assistant message to copy");
+                    return true;
+                }
+                try {
+                    await copyToClipboard(target.content);
+                    info(`copied ${target.content.length} chars to clipboard`);
+                }
+                catch (e) {
+                    info(`error: ${e.message}`);
+                }
+                return true;
+            }
             case "model":
                 if (!arg) {
                     info(`current model: ${model}`);
@@ -648,6 +729,117 @@ async function main() {
             case "version":
                 info(formatVersionInfo());
                 return true;
+            case "update": {
+                // Two-phase: check first so we don't run npm install when we're
+                // already current. Force-fetches the latest (ignores the 24h cache
+                // because the user explicitly asked) and reports either way.
+                info("checking npm for a newer version…");
+                try {
+                    const check = await checkForUpdate({ force: true });
+                    if (!check.newerAvailable) {
+                        info(`up to date (${check.current})`);
+                        return true;
+                    }
+                    info(`installing ${check.latest} (currently ${check.current}) via npm…`);
+                    const r = await runUpdate();
+                    if (!r.ok) {
+                        // npm prints reasonably descriptive errors itself; pass them
+                        // through so EACCES / permission issues are obvious.
+                        info(`error: update failed\n${r.output.slice(-1500)}\n\n` +
+                            `If this is a permission error, try: sudo npm install -g @este.systems/dsc@latest`);
+                        return true;
+                    }
+                    info(`installed ${check.latest}. Exit and re-run \`dsc\` to pick up the new version.`);
+                }
+                catch (e) {
+                    info(`error: update failed: ${e.message}`);
+                }
+                return true;
+            }
+            case "api-key": {
+                const text = arg.trim();
+                if (!text) {
+                    // No arg: show where the key is configured (don't print the key
+                    // itself; that's not the kind of thing /command output should
+                    // splash to scrollback).
+                    const src = apiKeySource();
+                    if (src === "env") {
+                        info("api key: set via $DEEPSEEK_API_KEY (env)");
+                    }
+                    else if (src === "file") {
+                        info(`api key: stored in ${configPath()}`);
+                    }
+                    else {
+                        info(`api key: not set\nGet one at https://platform.deepseek.com/api_keys, then run /api-key <key> (or export DEEPSEEK_API_KEY in your shell).`);
+                    }
+                    return true;
+                }
+                try {
+                    const written = await saveApiKey(text);
+                    info(`api key saved to ${written}`);
+                }
+                catch (e) {
+                    info(`error: ${e.message}`);
+                }
+                return true;
+            }
+            case "search-key": {
+                // /search-key                            -> list providers + status + URLs
+                // /search-key <provider>                 -> show that provider's status + URL
+                // /search-key <provider> <key>           -> save it to config
+                const tokens = arg.trim().split(/\s+/).filter(Boolean);
+                const [providerArg, ...keyParts] = tokens;
+                const keyArg = keyParts.join(" ");
+                const SIGNUP = {
+                    brave: "https://api-dashboard.search.brave.com/app/keys",
+                    tavily: "https://app.tavily.com/",
+                };
+                const ENV_VAR = {
+                    brave: "BRAVE_API_KEY",
+                    tavily: "TAVILY_API_KEY",
+                };
+                const sourceFor = (p) => {
+                    if (process.env[ENV_VAR[p]])
+                        return "env";
+                    return getProviderKey(p) ? "file" : null;
+                };
+                const lineFor = (p) => {
+                    const src = sourceFor(p);
+                    const status = src === "env"
+                        ? `set via $${ENV_VAR[p]}`
+                        : src === "file"
+                            ? "stored in config"
+                            : "not set";
+                    return `  ${p}: ${status}  —  ${SIGNUP[p]}`;
+                };
+                if (!providerArg) {
+                    info([
+                        "search providers:",
+                        lineFor("brave"),
+                        lineFor("tavily"),
+                        "",
+                        "To save a key: /search-key <provider> <key>",
+                        "Pick the active provider with DSC_SEARCH_PROVIDER or `search.provider` in the config.",
+                    ].join("\n"));
+                    return true;
+                }
+                if (providerArg !== "brave" && providerArg !== "tavily") {
+                    info(`error: unknown provider '${providerArg}' (expected: brave | tavily)`);
+                    return true;
+                }
+                if (!keyArg) {
+                    info(`${providerArg}: ${sourceFor(providerArg) ?? "not set"}\nsignup: ${SIGNUP[providerArg]}`);
+                    return true;
+                }
+                try {
+                    const written = await saveSearchKey(providerArg, keyArg);
+                    info(`${providerArg} key saved to ${written}`);
+                }
+                catch (e) {
+                    info(`error: ${e.message}`);
+                }
+                return true;
+            }
             case "audit": {
                 const sub = arg.trim();
                 if (!sub || sub === "path") {
@@ -712,6 +904,70 @@ async function main() {
                 await runCompaction(keep, false);
                 return true;
             }
+            case "export": {
+                // `/export [path]` — writes the current session JSON. Relative
+                // paths resolve against the launch cwd, not against the session's
+                // recorded cwd, so it lands where the user actually is. Default
+                // target is the cwd, named after /save'd name (or id) and date.
+                const dest = arg.trim() || ".";
+                const absDest = path.isAbsolute(dest) ? dest : path.resolve(cwd, dest);
+                try {
+                    await persist(); // flush any pending writes before export
+                    const written = await history.exportSession(session.id, absDest);
+                    info(`exported to ${written}`);
+                }
+                catch (e) {
+                    info(`error: export failed: ${e.message}`);
+                }
+                return true;
+            }
+            case "import": {
+                // `/import <path>` — reads a session JSON, rebinds its cwd to the
+                // current directory so auto-resume picks it up here, and loads it
+                // as the active session immediately. Keep the previous cwd with
+                // `--keep-cwd` (positional flag, kept simple).
+                const tokens = arg.trim().split(/\s+/).filter(Boolean);
+                const keepCwd = tokens.includes("--keep-cwd");
+                const file = tokens.find((t) => !t.startsWith("--"));
+                if (!file) {
+                    info("error: usage: /import <path> [--keep-cwd]");
+                    return true;
+                }
+                const absFile = path.isAbsolute(file) ? file : path.resolve(cwd, file);
+                try {
+                    const loaded = await history.importSession(absFile, {
+                        rebindCwd: keepCwd ? undefined : cwd,
+                    });
+                    session = loaded;
+                    messages = session.messages;
+                    stats = session.stats;
+                    model = session.model;
+                    toolCtx.filesTouched = stats.files_touched;
+                    toolCtx.sessionId = session.id;
+                    // Refill the visible history so the user sees the imported
+                    // conversation right away (same logic the /resume path uses).
+                    const restored = [];
+                    for (const m of messages) {
+                        if (m.role === "system")
+                            continue;
+                        restored.push({
+                            id: `r-${restored.length}`,
+                            role: m.role,
+                            content: typeof m.content === "string" ? m.content : "",
+                            tool_call_id: m.tool_call_id,
+                        });
+                    }
+                    setState({ history: restored, current: null, model });
+                    syncStatus();
+                    const userTurns = messages.filter((m) => m.role === "user").length;
+                    const cwdNote = keepCwd ? "" : " (cwd rebound to here)";
+                    info(`imported ${session.id} (${userTurns} turns, model ${model})${cwdNote}`);
+                }
+                catch (e) {
+                    info(`error: import failed: ${e.message}`);
+                }
+                return true;
+            }
             case "edit": {
                 // ink owns the terminal — unmount before spawning $EDITOR so the
                 // editor gets a clean screen. We also clear `history` before the
@@ -747,6 +1003,16 @@ async function main() {
             void replHistory.append(text);
         }
         if (text.startsWith("/")) {
+            // Echo the command into history so the user can see which command
+            // produced the system-line output that follows. Without this the
+            // info() lines look orphaned — especially when you scroll back
+            // and there's no record of what triggered each one.
+            setState((s) => ({
+                history: [
+                    ...s.history,
+                    { id: `u-${s.history.length}`, role: "user", content: text },
+                ],
+            }));
             void handleSlash(text);
             return;
         }
@@ -793,6 +1059,63 @@ async function main() {
         process.exit(0);
     }
     mountApp();
+    // One-time welcome panel. Stamped via a touch-file under XDG_STATE_HOME
+    // so we never nag the same user twice. New users get an orientation
+    // (key, /help, hotkeys); the more-targeted "no API key" reminder fires
+    // on every subsequent launch when no key is configured.
+    const stateDir = (() => {
+        const xdg = process.env.XDG_STATE_HOME;
+        const base = xdg && xdg.length ? xdg : path.join(homedir(), ".local", "state");
+        return path.join(base, "dsc");
+    })();
+    const welcomeStamp = path.join(stateDir, "welcomed");
+    let alreadyWelcomed = false;
+    try {
+        await fsp.access(welcomeStamp);
+        alreadyWelcomed = true;
+    }
+    catch {
+        // first launch
+    }
+    if (!alreadyWelcomed) {
+        const lines = [
+            "Welcome to dsc — a CLI coding agent for DeepSeek.",
+            "",
+            "  /help            full command list (TAB completes any /command)",
+            "  Up / Down        recall past prompts",
+            "  ESC              abort a running turn",
+            "  Ctrl+D           exit",
+        ];
+        if (startupKeyMissing) {
+            lines.push("", "To get started, save your API key:", "  /api-key sk-...   (get one at https://platform.deepseek.com/api_keys)", "  or: export DEEPSEEK_API_KEY in your shell");
+        }
+        info(lines.join("\n"));
+        try {
+            await fsp.mkdir(stateDir, { recursive: true });
+            await fsp.writeFile(welcomeStamp, new Date().toISOString(), "utf8");
+        }
+        catch {
+            // best-effort; missing perms just means the welcome shows again
+        }
+    }
+    else if (startupKeyMissing) {
+        // Targeted nudge for returning users who somehow lost their key.
+        info(`No DeepSeek API key found. Run "/api-key <key>" to save one to ${configPath()}, or export DEEPSEEK_API_KEY in your shell.`);
+    }
+    // Fire-and-forget update probe. Uses the 24h cache by default so a
+    // chatty notice doesn't appear on every launch — only once per day,
+    // when the registry says we're behind. Failures are swallowed silently.
+    void (async () => {
+        try {
+            const check = await checkForUpdate();
+            if (check.newerAvailable) {
+                info(`update available: ${check.latest} (you have ${check.current}). Run /update to install.`);
+            }
+        }
+        catch {
+            // best-effort; offline launches shouldn't yell at the user
+        }
+    })();
 }
 function truncate(s, n) {
     return s.length <= n ? s : s.slice(0, n) + "…";