sakuracode 0.0.0-stage → 0.1.0

package/dist/code/src/ansi.js

@@ -0,0 +1,220 @@
+// Terminal text helpers: styles, stripping, display width and wrapping that keeps styles.
+const ESC = "\u001b";
+// SGR sequences (colours, bold) and OSC 8 hyperlinks; the only escapes this application writes inside text.
+const ESCAPE_PATTERN = /\u001b\[[0-9;]*m|\u001b\]8;[^\u0007\u001b]*(?:\u0007|\u001b\\)/y;
+function makeStyler(open, close, enabled) {
+    return enabled ? (text) => `${ESC}[${open}m${text}${ESC}[${close}m` : (text) => text;
+}
+export function createPalette(enabled) {
+    return {
+        bold: makeStyler("1", "22", enabled),
+        dim: makeStyler("2", "22", enabled),
+        italic: makeStyler("3", "23", enabled),
+        underline: makeStyler("4", "24", enabled),
+        strike: makeStyler("9", "29", enabled),
+        red: makeStyler("31", "39", enabled),
+        green: makeStyler("32", "39", enabled),
+        yellow: makeStyler("33", "39", enabled),
+        blue: makeStyler("34", "39", enabled),
+        magenta: makeStyler("35", "39", enabled),
+        cyan: makeStyler("36", "39", enabled),
+        gray: makeStyler("90", "39", enabled),
+        inverse: makeStyler("7", "27", enabled),
+    };
+}
+/** A hyperlink; terminals that do not know OSC 8 show the text only. */
+export function hyperlink(text, url, enabled) {
+    return enabled ? `${ESC}]8;;${url}${ESC}\\${text}${ESC}]8;;${ESC}\\` : text;
+}
+export function stripAnsi(text) {
+    return text.replace(/\u001b\[[0-9;?]*[A-Za-z]|\u001b\]8;[^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "");
+}
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const WIDE_RANGES = [
+    [0x1100, 0x115f],
+    [0x2e80, 0x303e],
+    [0x3041, 0x33ff],
+    [0x3400, 0x4dbf],
+    [0x4e00, 0x9fff],
+    [0xa000, 0xa4cf],
+    [0xac00, 0xd7a3],
+    [0xf900, 0xfaff],
+    [0xfe30, 0xfe6f],
+    [0xff00, 0xff60],
+    [0xffe0, 0xffe6],
+    [0x1f300, 0x1f64f],
+    [0x1f680, 0x1f6ff],
+    [0x1f900, 0x1f9ff],
+    [0x20000, 0x3fffd],
+];
+function graphemeWidth(grapheme) {
+    const code = grapheme.codePointAt(0) ?? 0;
+    if (code === 0)
+        return 0;
+    if (code < 32 || (code >= 0x7f && code < 0xa0))
+        return 0;
+    if (code >= 0x300 && code <= 0x36f)
+        return 0;
+    if (code === 0x200b || code === 0xfe0f)
+        return 0;
+    if (WIDE_RANGES.some(([low, high]) => code >= low && code <= high))
+        return 2;
+    if (grapheme.includes("️") && code > 0x2000)
+        return 2;
+    return 1;
+}
+/** How many terminal columns a text takes (escapes count zero, CJK and emoji count two). */
+export function displayWidth(text) {
+    let width = 0;
+    for (const { segment } of segmenter.segment(stripAnsi(text)))
+        width += graphemeWidth(segment);
+    return width;
+}
+function tokenize(text) {
+    const tokens = [];
+    let index = 0;
+    let plain = "";
+    const flush = () => {
+        if (!plain)
+            return;
+        for (const { segment } of segmenter.segment(plain))
+            tokens.push({ kind: "text", value: segment, width: graphemeWidth(segment) });
+        plain = "";
+    };
+    while (index < text.length) {
+        if (text[index] === ESC) {
+            ESCAPE_PATTERN.lastIndex = index;
+            const match = ESCAPE_PATTERN.exec(text);
+            if (match) {
+                flush();
+                tokens.push({ kind: "escape", value: match[0], width: 0 });
+                index += match[0].length;
+                continue;
+            }
+        }
+        plain += text[index];
+        index += 1;
+    }
+    flush();
+    return tokens;
+}
+/** Cuts a text to a number of columns, adding "…" when something was cut. Styles are closed at the cut. */
+export function truncate(text, width) {
+    if (displayWidth(text) <= width)
+        return text;
+    let used = 0;
+    let out = "";
+    let styled = false;
+    for (const token of tokenize(text)) {
+        if (token.kind === "escape") {
+            out += token.value;
+            styled = true;
+            continue;
+        }
+        if (used + token.width > width - 1)
+            break;
+        out += token.value;
+        used += token.width;
+    }
+    return `${out}…${styled ? `${ESC}[0m` : ""}`;
+}
+const isSpace = (token) => token.kind === "text" && /^\s$/.test(token.value);
+/**
+ * Wraps text to a width. Breaks at spaces when it can and inside a word when it must (long words, CJK text).
+ * A style that is active at a break is closed at the end of the line and opened again on the next one.
+ * Newlines in the input start a new line.
+ */
+export function wrapAnsi(text, width) {
+    const limit = Math.max(1, width);
+    const result = [];
+    for (const paragraph of text.split("\n"))
+        result.push(...wrapParagraph(paragraph, limit));
+    return result;
+}
+function wrapParagraph(paragraph, width) {
+    const tokens = tokenize(paragraph);
+    const lines = [];
+    let active = [];
+    let line = "";
+    let lineWidth = 0;
+    let pendingSpace = [];
+    // escapes seen after a space belong to the next word, so a style never covers the space before it
+    let pendingEscapes = [];
+    const track = (token) => {
+        if (token.kind !== "escape" || !token.value.includes("["))
+            return;
+        active = /^\u001b\[0?m$/.test(token.value) ? [] : [...active, token.value];
+    };
+    const endLine = () => {
+        lines.push(active.length > 0 ? `${line}${ESC}[0m` : line);
+        line = active.join("");
+        lineWidth = 0;
+    };
+    let index = 0;
+    while (index < tokens.length) {
+        const token = tokens[index];
+        if (token.kind === "escape") {
+            if (pendingSpace.length > 0)
+                pendingEscapes.push(token);
+            else {
+                line += token.value;
+                track(token);
+            }
+            index += 1;
+            continue;
+        }
+        if (isSpace(token)) {
+            pendingSpace.push(token);
+            index += 1;
+            continue;
+        }
+        // collect a word: consecutive non-space text tokens (escapes inside stay attached)
+        const word = [];
+        let wordWidth = 0;
+        while (index < tokens.length && !isSpace(tokens[index])) {
+            const next = tokens[index];
+            word.push(next);
+            wordWidth += next.width;
+            index += 1;
+        }
+        const spaceWidth = lineWidth === 0 ? 0 : pendingSpace.length;
+        if (lineWidth > 0 && lineWidth + spaceWidth + wordWidth > width)
+            endLine();
+        else if (lineWidth > 0) {
+            line += pendingSpace.map((space) => space.value).join("");
+            lineWidth += spaceWidth;
+        }
+        else if (lines.length === 0 && pendingSpace.length > 0) {
+            // leading indentation of the paragraph is kept
+            line += pendingSpace.map((space) => space.value).join("");
+            lineWidth += pendingSpace.length;
+        }
+        pendingSpace = [];
+        for (const escape of pendingEscapes) {
+            line += escape.value;
+            track(escape);
+        }
+        pendingEscapes = [];
+        for (const piece of word) {
+            if (piece.kind === "escape") {
+                line += piece.value;
+                track(piece);
+                continue;
+            }
+            if (lineWidth + piece.width > width && lineWidth > 0)
+                endLine();
+            line += piece.value;
+            lineWidth += piece.width;
+        }
+    }
+    for (const escape of pendingEscapes) {
+        line += escape.value;
+        track(escape);
+    }
+    lines.push(active.length > 0 ? `${line}${ESC}[0m` : line);
+    return lines;
+}
+/** Pads with spaces to a display width (never cuts). */
+export function padEnd(text, width) {
+    return text + " ".repeat(Math.max(0, width - displayWidth(text)));
+}

package/dist/code/src/cli.js

@@ -0,0 +1,211 @@
+// The command line: parses arguments, loads the config, and starts the interactive session or a non-interactive run.
+import { existsSync, readFileSync } from "node:fs";
+import { imageMediaType } from "./images.js";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { ConfigError, configDirectory, readConfigFile, resolveSettings } from "./config.js";
+import { runExec } from "./exec-mode.js";
+import { createFauxClient } from "./framework-testing.js";
+import { parseInvocation } from "./invocation.js";
+import { isPermissionName, PERMISSION_NAMES } from "./permissions.js";
+import { listProviders, ProviderSetupError } from "./providers.js";
+import { createSessionStore, sessionLabel } from "./session-store.js";
+import { runTui } from "./tui/app.js";
+const manifest = createRequire(import.meta.url)("#manifest");
+export const VERSION = manifest.version;
+const HELP = `sakuracode ${VERSION}: a terminal coding agent on the Sakura framework.
+
+Usage:
+  sakuracode [options] [prompt]          interactive session (the prompt is sent at once)
+  sakuracode exec [options] <prompt|->   run one prompt without a screen ("-" reads stdin)
+  sakuracode exec resume [id|--last] [prompt]   continue a session without a screen
+  sakuracode resume [id|--last] [prompt] continue a session (a picker without id)
+  sakuracode fork <id|--last>            copy a session into a new one and continue there
+  sakuracode review [--base BRANCH | --commit SHA] [focus]   review changes, then print the review
+  sakuracode sessions                    list sessions
+  sakuracode providers                   list providers and whether their key is set
+
+Options:
+  -m, --model NAME          model of the provider
+      --provider NAME       deepseek, opencode, or one from the config file
+  -p, --profile NAME        settings profile from the config file
+      --permissions NAME    ${PERMISSION_NAMES.join(" | ")} (default auto: every call is reviewed)
+      --yolo                same as --permissions full-access (nothing is reviewed)
+  -i, --image FILE[,FILE]   attach image files to the first prompt (png, jpg, gif, webp, bmp)
+      --redact              hide secrets from the model (off by default)
+      --no-redact           force redaction off
+      --thinking LEVEL      off | low | medium | high
+      --max-tokens N        output limit per model request
+  -C, --cwd DIR             directory to start in (tools are not restricted to it)
+      --resume REF          continue the session REF (id, prefix, "last")
+      --last                with resume/fork: the most recent session
+      --json                exec: write events as JSON lines
+      --raw                 exec: write the Markdown reply as it is even on a terminal
+  -q, --quiet               exec: no progress on stderr
+  -o, --output-last-message FILE   exec: also write the final reply to FILE
+      --no-color            no colours
+  -h, --help, -v, --version
+
+Config: ${"~/.sakura/config.toml"} (SAKURA_HOME changes the directory). Keys: DEEPSEEK_API_KEY, OPENCODE_API_KEY.`;
+function parseCliArgs(argv) {
+    return parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            help: { type: "boolean", short: "h" },
+            version: { type: "boolean", short: "v" },
+            provider: { type: "string" },
+            model: { type: "string", short: "m" },
+            profile: { type: "string", short: "p" },
+            yolo: { type: "boolean" },
+            image: { type: "string", short: "i", multiple: true },
+            base: { type: "string" },
+            commit: { type: "string" },
+            permissions: { type: "string" },
+            redact: { type: "boolean" },
+            "no-redact": { type: "boolean" },
+            thinking: { type: "string" },
+            "max-tokens": { type: "string" },
+            cwd: { type: "string", short: "C" },
+            resume: { type: "string" },
+            last: { type: "boolean" },
+            json: { type: "boolean" },
+            raw: { type: "boolean" },
+            quiet: { type: "boolean", short: "q" },
+            "output-last-message": { type: "string", short: "o" },
+            "no-color": { type: "boolean" },
+        },
+    });
+}
+function flagLayer(values) {
+    const layer = {};
+    if (values.provider)
+        layer.provider = values.provider;
+    if (values.model)
+        layer.model = values.model;
+    if (values.permissions) {
+        if (!isPermissionName(values.permissions))
+            throw new ConfigError(`--permissions must be one of ${PERMISSION_NAMES.join(", ")}`);
+        layer.permissions = values.permissions;
+    }
+    if (values.yolo)
+        layer.permissions = "full-access";
+    if (values.redact)
+        layer.redaction = true;
+    if (values["no-redact"])
+        layer.redaction = false;
+    if (values.thinking) {
+        if (!["off", "low", "medium", "high"].includes(values.thinking))
+            throw new ConfigError("--thinking must be off, low, medium or high");
+        layer.thinking = values.thinking;
+    }
+    if (values["max-tokens"]) {
+        const number = Number(values["max-tokens"]);
+        if (!Number.isSafeInteger(number) || number <= 0)
+            throw new ConfigError("--max-tokens must be a positive integer");
+        layer.maxTokens = number;
+    }
+    return layer;
+}
+/** The test hook: a JSON file of scripted turns replaces the real model. */
+function fauxClients(env) {
+    const file = env.SAKURACODE_FAUX_SCRIPT;
+    if (!file)
+        return undefined;
+    const turns = JSON.parse(readFileSync(file, "utf8"));
+    const reviewerFile = env.SAKURACODE_FAUX_REVIEWER;
+    const reviewer = reviewerFile ? createFauxClient(JSON.parse(readFileSync(reviewerFile, "utf8"))) : undefined;
+    return { agent: createFauxClient(turns), ...(reviewer ? { reviewer } : {}) };
+}
+async function readAll(stream) {
+    let text = "";
+    stream.setEncoding("utf8");
+    for await (const chunk of stream)
+        text += chunk;
+    return text;
+}
+export async function main(argv, io) {
+    try {
+        return await run(argv, io);
+    }
+    catch (error) {
+        if (error instanceof ConfigError || error instanceof ProviderSetupError || error.code?.startsWith("ERR_PARSE_ARGS")) {
+            const usage = error.code?.startsWith("ERR_PARSE_ARGS") ? " (see --help)" : "";
+            io.stderr.write(`sakuracode: ${error.message}${usage}\n`);
+            return 2;
+        }
+        io.stderr.write(`sakuracode: ${error.stack ?? String(error)}\n`);
+        return 1;
+    }
+}
+async function run(argv, io) {
+    const { values, positionals } = parseCliArgs(argv);
+    if (values.help) {
+        io.stdout.write(`${HELP}\n`);
+        return 0;
+    }
+    if (values.version) {
+        io.stdout.write(`sakuracode ${VERSION}\n`);
+        return 0;
+    }
+    const home = homedir();
+    const directory = configDirectory(io.env, home);
+    const file = readConfigFile(join(directory, "config.toml"));
+    const settings = resolveSettings({ file, profile: values.profile, env: io.env, flags: flagLayer(values) });
+    const store = createSessionStore(join(directory, "sessions"));
+    const cwd = resolve(io.cwd, values.cwd ?? ".");
+    const clients = fauxClients(io.env);
+    const images = (values.image ?? []).flatMap((entry) => entry.split(",")).map((entry) => resolve(cwd, entry.trim()));
+    for (const image of images)
+        if (imageMediaType(image) === undefined || !existsSync(image))
+            throw new ConfigError(`--image: ${image} is not an existing png, jpg, gif, webp or bmp file`);
+    const controller = { settings, cwd, home, env: io.env, store, ...(images.length > 0 ? { images } : {}), ...(clients ? { clients } : {}) };
+    const color = !values["no-color"] && !io.env.NO_COLOR && Boolean(io.stdout.isTTY);
+    const invocation = parseInvocation(positionals, { last: values.last, resume: values.resume, base: values.base, commit: values.commit });
+    if (invocation.mode === "providers")
+        return listProvidersCommand(settings, io);
+    if (invocation.mode === "sessions")
+        return listSessionsCommand(store, io);
+    if (invocation.mode === "exec") {
+        let prompt = invocation.prompt;
+        if (prompt === "-" || (prompt === "" && !io.stdin.isTTY))
+            prompt = (await readAll(io.stdin)).trim();
+        if (prompt === "")
+            throw new ConfigError("exec needs a prompt (an argument, or text on stdin)");
+        let cancel = () => undefined;
+        const onSigint = () => cancel();
+        process.once("SIGINT", onSigint);
+        try {
+            return await runExec({ prompt, json: Boolean(values.json), render: Boolean(io.stdout.isTTY) && !values.raw, quiet: Boolean(values.quiet), color, outputLastMessage: values["output-last-message"], resume: invocation.resume }, { controller, stdout: io.stdout, stderr: io.stderr, onCancelable: (fn) => (cancel = fn) });
+        }
+        finally {
+            process.removeListener("SIGINT", onSigint);
+        }
+    }
+    if (!io.stdin.isTTY || !io.stdout.isTTY)
+        throw new ConfigError("the interactive session needs a terminal; use `sakuracode exec` for pipes and scripts");
+    return runTui({
+        controller,
+        start: invocation.resume !== undefined ? { resume: invocation.resume } : {},
+        stdin: io.stdin,
+        stdout: io.stdout,
+        color,
+        version: VERSION,
+        initialPrompt: invocation.slash ?? (invocation.prompt.trim() === "" ? undefined : invocation.prompt),
+    });
+}
+function listProvidersCommand(settings, io) {
+    for (const entry of listProviders(settings, io.env))
+        io.stdout.write(`${entry.name.padEnd(12)} ${entry.definition.model.padEnd(24)} ${entry.definition.keyEnv} ${entry.keyPresent ? "set" : "NOT SET"}\n`);
+    return 0;
+}
+async function listSessionsCommand(store, io) {
+    const sessions = (await store.list()).filter((meta) => meta.title !== undefined);
+    if (sessions.length === 0)
+        io.stdout.write("No sessions yet.\n");
+    for (const meta of sessions)
+        io.stdout.write(`${meta.id}  ${new Date(meta.updatedAt).toISOString().slice(0, 16).replace("T", " ")}  ${meta.model}  ${sessionLabel(meta)}\n`);
+    return 0;
+}

package/dist/code/src/config.js

@@ -0,0 +1,183 @@
+// The config file and how settings are resolved: defaults < file < profile < environment < command-line flags.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { isPermissionName } from "./permissions.js";
+import { parseToml } from "./toml.js";
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+    }
+}
+const THINKING = ["off", "low", "medium", "high"];
+export const DEFAULT_SETTINGS = {
+    provider: undefined,
+    model: undefined,
+    thinking: undefined,
+    permissions: "auto",
+    redaction: false,
+    maxTokens: undefined,
+    cacheTtlMinutes: 5,
+    autoCompactMinTokens: 20_000,
+    autoCompactIdle: true,
+    providers: {},
+    mcpServers: {},
+};
+export const emptyFileConfig = () => ({ profiles: {}, providers: {}, mcpServers: {} });
+export function configDirectory(env, home) {
+    return env.SAKURA_HOME ?? join(home, ".sakura");
+}
+export function readConfigFile(path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return emptyFileConfig();
+        throw new ConfigError(`cannot read ${path}: ${error.message}`);
+    }
+    return parseConfig(text, path);
+}
+export function parseConfig(text, label = "config") {
+    let table;
+    try {
+        table = parseToml(text);
+    }
+    catch (error) {
+        throw new ConfigError(`${label}: ${error.message}`);
+    }
+    const { profiles, providers, mcp, ...top } = table;
+    const config = { ...readLayer(top, label), profiles: {}, providers: {}, mcpServers: {} };
+    for (const [name, value] of Object.entries(asTable(profiles, "profiles", label)))
+        config.profiles[name] = readLayer(asTable(value, `profiles.${name}`, label), `${label} profile ${name}`);
+    for (const [name, value] of Object.entries(asTable(providers, "providers", label)))
+        config.providers[name] = readProvider(asTable(value, `providers.${name}`, label), name, label);
+    const servers = asTable(asTable(mcp, "mcp", label).servers, "mcp.servers", label);
+    for (const [name, value] of Object.entries(servers))
+        config.mcpServers[name] = readMcpServer(asTable(value, `mcp.servers.${name}`, label), name, label);
+    return config;
+}
+function asTable(value, name, label) {
+    if (value === undefined)
+        return {};
+    if (typeof value !== "object" || Array.isArray(value))
+        throw new ConfigError(`${label}: ${name} must be a table`);
+    return value;
+}
+const LAYER_KEYS = new Set(["provider", "model", "thinking", "permissions", "redaction", "max_tokens", "cache_ttl_minutes", "auto_compact_min_tokens", "auto_compact_idle"]);
+function readLayer(table, label) {
+    for (const key of Object.keys(table))
+        if (!LAYER_KEYS.has(key))
+            throw new ConfigError(`${label}: unknown setting "${key}"`);
+    const layer = {};
+    if (table.provider !== undefined)
+        layer.provider = text(table.provider, "provider", label);
+    if (table.model !== undefined)
+        layer.model = text(table.model, "model", label);
+    if (table.thinking !== undefined) {
+        const value = text(table.thinking, "thinking", label);
+        if (!THINKING.includes(value))
+            throw new ConfigError(`${label}: thinking must be one of ${THINKING.join(", ")}`);
+        layer.thinking = value;
+    }
+    if (table.permissions !== undefined) {
+        const value = text(table.permissions, "permissions", label);
+        if (!isPermissionName(value))
+            throw new ConfigError(`${label}: unknown permissions preset "${value}"`);
+        layer.permissions = value;
+    }
+    if (table.redaction !== undefined) {
+        if (typeof table.redaction !== "boolean")
+            throw new ConfigError(`${label}: redaction must be true or false`);
+        layer.redaction = table.redaction;
+    }
+    if (table.max_tokens !== undefined)
+        layer.maxTokens = positive(table.max_tokens, "max_tokens", label);
+    if (table.cache_ttl_minutes !== undefined)
+        layer.cacheTtlMinutes = positive(table.cache_ttl_minutes, "cache_ttl_minutes", label);
+    if (table.auto_compact_min_tokens !== undefined)
+        layer.autoCompactMinTokens = positive(table.auto_compact_min_tokens, "auto_compact_min_tokens", label);
+    if (table.auto_compact_idle !== undefined) {
+        if (typeof table.auto_compact_idle !== "boolean")
+            throw new ConfigError(`${label}: auto_compact_idle must be true or false`);
+        layer.autoCompactIdle = table.auto_compact_idle;
+    }
+    return layer;
+}
+const text = (value, name, label) => {
+    if (typeof value !== "string" || value === "")
+        throw new ConfigError(`${label}: ${name} must be a non-empty string`);
+    return value;
+};
+const positive = (value, name, label) => {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0)
+        throw new ConfigError(`${label}: ${name} must be a positive integer`);
+    return value;
+};
+function stringMap(value, name, label) {
+    if (value === undefined)
+        return undefined;
+    return Object.fromEntries(Object.entries(asTable(value, name, label)).map(([key, inner]) => [key, text(inner, `${name}.${key}`, label)]));
+}
+function readProvider(table, name, label) {
+    const where = `${label}: providers.${name}`;
+    for (const required of ["base_url", "model", "key_env"])
+        if (table[required] === undefined)
+            throw new ConfigError(`${where} needs ${required}`);
+    const known = new Set(["base_url", "model", "key_env", "context_window", "compat", "images", "headers", "session_header"]);
+    for (const key of Object.keys(table))
+        if (!known.has(key))
+            throw new ConfigError(`${where}: unknown setting "${key}"`);
+    const headers = stringMap(table.headers, "headers", where);
+    if (table.images !== undefined && typeof table.images !== "boolean")
+        throw new ConfigError(`${where}: images must be true or false`);
+    return {
+        baseUrl: text(table.base_url, "base_url", where),
+        model: text(table.model, "model", where),
+        keyEnv: text(table.key_env, "key_env", where),
+        contextWindow: table.context_window === undefined ? 128_000 : positive(table.context_window, "context_window", where),
+        ...(table.compat !== undefined ? { compat: text(table.compat, "compat", where) } : {}),
+        ...(table.images !== undefined ? { images: table.images } : {}),
+        ...(headers ? { headers } : {}),
+        ...(table.session_header !== undefined ? { sessionHeader: text(table.session_header, "session_header", where) } : {}),
+    };
+}
+function readMcpServer(table, name, label) {
+    const where = `${label}: mcp.servers.${name}`;
+    if (table.command === undefined)
+        throw new ConfigError(`${where} needs command`);
+    const args = table.args;
+    if (args !== undefined && (!Array.isArray(args) || args.some((item) => typeof item !== "string")))
+        throw new ConfigError(`${where}: args must be a list of strings`);
+    const env = stringMap(table.env, "env", where);
+    return { command: text(table.command, "command", where), ...(args ? { args: args } : {}), ...(env ? { env } : {}) };
+}
+/** The environment variables that can set a layer (SAKURA_PROVIDER, SAKURA_MODEL). */
+export function environmentLayer(env) {
+    return { ...(env.SAKURA_PROVIDER ? { provider: env.SAKURA_PROVIDER } : {}), ...(env.SAKURA_MODEL ? { model: env.SAKURA_MODEL } : {}) };
+}
+export function resolveSettings(input) {
+    const profileName = input.profile ?? undefined;
+    const profile = profileName === undefined ? {} : input.file.profiles[profileName];
+    if (profile === undefined)
+        throw new ConfigError(`unknown profile "${profileName}" (profiles: ${Object.keys(input.file.profiles).join(", ") || "none"})`);
+    const { profiles: _profiles, providers: _providers, mcpServers: _mcp, ...fileLayer } = input.file;
+    const layers = [fileLayer, profile, environmentLayer(input.env), input.flags ?? {}];
+    const merged = Object.assign({}, ...layers.map(definedOnly));
+    return {
+        ...DEFAULT_SETTINGS,
+        provider: merged.provider,
+        model: merged.model,
+        thinking: merged.thinking,
+        permissions: merged.permissions ?? DEFAULT_SETTINGS.permissions,
+        redaction: merged.redaction ?? DEFAULT_SETTINGS.redaction,
+        maxTokens: merged.maxTokens,
+        cacheTtlMinutes: merged.cacheTtlMinutes ?? DEFAULT_SETTINGS.cacheTtlMinutes,
+        autoCompactMinTokens: merged.autoCompactMinTokens ?? DEFAULT_SETTINGS.autoCompactMinTokens,
+        autoCompactIdle: merged.autoCompactIdle ?? DEFAULT_SETTINGS.autoCompactIdle,
+        providers: input.file.providers,
+        mcpServers: input.file.mcpServers,
+    };
+}
+const definedOnly = (layer) => Object.fromEntries(Object.entries(layer).filter(([, value]) => value !== undefined));