@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/src/cli.ts

@@ -0,0 +1,335 @@
+/**
+ * CLI argument parsing.
+ *
+ * \`fastcode\` launches the TUI. The non-interactive helpers let you configure
+ * and script FastCode straight from a Termux shell, without starting Ink:
+ * provider/model selection, config paths, skills, doctor and update.
+ */
+import meow from "meow";
+import { readPackageMeta } from "./lib/pkg.js";
+import { installSkill, listInstalledSkills, uninstallSkill, searchRegistry } from "./skills/manager.js";
+import { loadConfig, saveConfig, resolveProviderKey } from "./config/store.js";
+import { getPaths } from "./config/paths.js";
+import { PROVIDERS, getProvider } from "./providers/index.js";
+import { collectDiagnostics, formatDiagnostics } from "./lib/diagnostics.js";
+import { existsSync } from "node:fs";
+import { latestSessionFile, listSessions, projectionPath, readSession, resolveSessionFile } from "./session/log.js";
+import { readProjection, sessionMetaFromFile } from "./session/projection.js";
+import { listTrusted, trustProject, untrustProject } from "./config/trust.js";
+const NL = String.fromCharCode(10);
+const HELP = [
+    "",
+    "  FastCode — multi-LLM TUI coding assistant",
+    "",
+    "  Usage",
+    "    $ fastcode                       Launch the TUI",
+    "    $ fastcode \"explain this repo\"   Launch the TUI with an initial prompt",
+    "",
+    "  Model & provider (no TUI needed)",
+    "    $ fastcode provider              List providers",
+    "    $ fastcode provider <id>         Set the default provider",
+    "    $ fastcode model                 List models for the current provider",
+    "    $ fastcode model <id>            Set the default model",
+    "    $ fastcode config                Print config file and data paths",
+    "    $ fastcode config path           Print just the config file path",
+    "    $ fastcode sessions              List saved sessions (JSONL)",
+    "    $ fastcode sessions show <id>    Print a saved session",
+    "    $ fastcode resume [id|latest]    Resume a saved session in the TUI",
+    "",
+    "  Trust (first-run safety)",
+    "    $ fastcode trust [dir]           Trust a folder (enables agent tools)",
+    "    $ fastcode untrust [dir]         Revoke trust for a folder",
+    "    $ fastcode trusted               List trusted folders",
+    "",
+    "  Skills & maintenance",
+    "    $ fastcode skills list           Print installed skills",
+    "    $ fastcode skills install <id>   Install a skill from the registry",
+    "    $ fastcode skills uninstall <id> Remove an installed skill",
+    "    $ fastcode skills search <q>     Search the registry",
+    "    $ fastcode doctor                Environment diagnostics (Termux/mobile)",
+    "    $ fastcode update                Check for a newer release",
+    "",
+    "  Options",
+    "    --version, -v   Show version",
+    "    --help, -h      Show this help",
+    "",
+    "  Files (on Termux, edit them directly with nano):",
+    "    config.json   provider, model, theme, agent mode, enabled skills",
+    "    auth.json     API keys only, kept in a SEPARATE file (chmod 0600)",
+    "",
+    "  API keys may also come from ENV (DEEPSEEK_API_KEY, ANTHROPIC_API_KEY,",
+    "  OPENAI_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY, GROQ_API_KEY,",
+    "  MISTRAL_API_KEY, XAI_API_KEY, MOONSHOT_API_KEY, ZHIPUAI_API_KEY,",
+    "  DASHSCOPE_API_KEY) or from /login inside the TUI.",
+    "  Override the data directory with FASTCODE_HOME.",
+    "",
+].join(NL);
+export async function parseCli(): Promise<any> {
+    const cli = meow(HELP, {
+        importMeta: import.meta,
+        flags: {
+            version: { type: "boolean", shortFlag: "v" },
+        },
+        autoHelp: true,
+        autoVersion: true,
+    });
+    // First positional dictates the sub-command. Anything else is a prompt.
+    const [first, ...rest] = cli.input;
+    if (first === "provider") {
+        const cfg = loadConfig();
+        const paths = getPaths();
+        if (rest.length === 0) {
+            const lines = ["Providers (current: " + cfg.providerId + ")"];
+            for (const p of PROVIDERS) {
+                const marker = p.id === cfg.providerId ? "●" : " ";
+                const auth = p.authEnv.length === 0 ? "(no key needed)" : "[" + p.authEnv.join(", ") + "]";
+                lines.push("  " + marker + " " + p.id.padEnd(12) + " " + p.label + "  " + auth);
+            }
+            lines.push("");
+            lines.push("Switch:  fastcode provider <id>");
+            lines.push("Or edit: " + paths.config);
+            console.log(lines.join(NL));
+            return { done: true };
+        }
+        const next = getProvider(rest[0]);
+        if (!next) {
+            console.error("Unknown provider: " + rest[0] + ". Run: fastcode provider");
+            process.exit(1);
+        }
+        saveConfig({ ...cfg, providerId: next.id, model: next.defaultModel });
+        console.log("Provider: " + next.id + " (" + next.label + ")");
+        console.log("Model:    " + next.defaultModel);
+        console.log("Saved to " + paths.config);
+        console.log("API keys stay in " + paths.auth + " (untouched)");
+        return { done: true };
+    }
+    if (first === "model") {
+        const cfg = loadConfig();
+        const paths = getPaths();
+        if (rest.length === 0) {
+            const provider = getProvider(cfg.providerId);
+            console.log("Provider: " + cfg.providerId + "   Model: " + cfg.model);
+            if (provider) {
+                let models = [];
+                try {
+                    const { key } = resolveProviderKey(provider.id, provider.authEnv);
+                    models = await provider.listModels(key);
+                }
+                catch {
+                    models = [];
+                }
+                if (models.length > 0) {
+                    console.log("");
+                    console.log("Known models for " + provider.label + " (use /model in the TUI for the live list):");
+                    for (const m of models.slice(0, 40)) {
+                        const marker = m.id === cfg.model ? "●" : " ";
+                        console.log("  " + marker + " " + m.id + (m.label ? "  — " + m.label : ""));
+                    }
+                }
+            }
+            console.log("");
+            console.log("Switch:  fastcode model <id>");
+            console.log("Or edit: " + paths.config);
+            return { done: true };
+        }
+        const id = rest.join(" ");
+        saveConfig({ ...cfg, model: id });
+        console.log("Model: " + id + "   (provider " + cfg.providerId + ")");
+        console.log("Saved to " + paths.config);
+        return { done: true };
+    }
+    if (first === "config") {
+        const paths = getPaths();
+        if (rest[0] === "path") {
+            console.log(paths.config);
+            return { done: true };
+        }
+        const cfg = loadConfig();
+        console.log("Config file: " + paths.config);
+        console.log("Keys file:   " + paths.auth + "   (separate file, chmod 0600)");
+        console.log("");
+        console.log(JSON.stringify(cfg, null, 2));
+        return { done: true };
+    }
+    if (first === "sessions") {
+        const all = listSessions();
+        if (all.length === 0) {
+            console.log("No sessions yet. They are appended to " + getPaths().sessions);
+            return { done: true };
+        }
+        if (rest[0] === "show") {
+            const idOrFile = rest[1] ?? all[0].id;
+            const entries = readSession(idOrFile);
+            for (const entry of entries) {
+                if (entry.type === "message")
+                    console.log("[" + entry.role + "] " + entry.content);
+                else if (entry.type === "user" || entry.type === "assistant_raw")
+                    console.log("[" + entry.type + "] " + String(entry.content ?? "").slice(0, 300));
+                else
+                    console.log("[" + entry.type + "]");
+            }
+            const file = resolveSessionFile(idOrFile);
+            const projection = readProjection(file);
+            console.log("");
+            if (projection) {
+                console.log("[projection] " + projectionPath(file));
+                console.log("  messages: " + projection.messages.length + " · activeFiles: " + projection.activeFiles.length + " · lastFactSeq: " + projection.lastFactSeq);
+            }
+            else {
+                console.log("[projection] (none)");
+            }
+            return { done: true };
+        }
+        console.log("Sessions (newest first):");
+        for (const entry of all.slice(0, 20)) {
+            console.log("  " + entry.id + "   " + (entry.bytes / 1024).toFixed(1) + "KB   " + entry.messages + " msgs   " + entry.modified);
+        }
+        console.log("");
+        console.log("Resume:  fastcode resume [id|latest]");
+        console.log("Show:    fastcode sessions show <id>");
+        return { done: true };
+    }
+    if (first === "resume") {
+        const target = rest[0];
+        const file = !target || target === "latest" ? latestSessionFile() : resolveSessionFile(target);
+        if (!file || !existsSync(file)) {
+            console.error("No saved session to resume. Start one with: fastcode");
+            process.exit(1);
+        }
+        const meta = sessionMetaFromFile(file);
+        if (meta.cwd) {
+            if (existsSync(meta.cwd)) {
+                process.chdir(meta.cwd);
+                console.log("Working directory: " + meta.cwd);
+            }
+            else {
+                console.log("Session directory no longer exists: " + meta.cwd + " (staying in " + process.cwd() + ")");
+            }
+        }
+        if (meta.providerId)
+            console.log("Session model: " + meta.providerId + "::" + meta.model);
+        console.log("Resuming " + file);
+        return { done: false, resume: file };
+    }
+    if (first === "trust" || first === "untrust" || first === "trusted") {
+        if (first === "trusted") {
+            const all = listTrusted();
+            if (all.length === 0) {
+                console.log("No trusted folders yet. Run: fastcode trust");
+                return { done: true };
+            }
+            for (const entry of all)
+                console.log("  " + entry.path + "   (" + entry.addedAt + ")");
+            return { done: true };
+        }
+        const dir = rest[0] ?? process.cwd();
+        if (first === "trust") {
+            console.log("Trusted: " + trustProject(dir));
+        }
+        else {
+            console.log(untrustProject(dir) ? "Removed from the trusted list: " + dir : "Not in the trusted list: " + dir);
+        }
+        return { done: true };
+    }
+    if (first === "skills") {
+        const sub = rest[0] ?? "list";
+        const args = rest.slice(1);
+        if (sub === "list" || sub === "ls") {
+            const installed = listInstalledSkills();
+            if (installed.length === 0) {
+                console.log("No skills installed. Try: fastcode skills install <id>");
+            }
+            else {
+                for (const s of installed)
+                    console.log(s.name + "\t" + s.source + "\t" + s.path);
+            }
+            return { done: true };
+        }
+        if (sub === "install" || sub === "add") {
+            if (args.length === 0) {
+                console.error("Usage: fastcode skills install <id|owner/repo|url>");
+                process.exit(1);
+            }
+            const cfg = loadConfig();
+            const force = args.includes("--force");
+            const spec = args.filter((a) => a !== "--force").join(" ");
+            const skill = await installSkill(spec, { registry: cfg.skillsRegistry, force });
+            console.log("Installed " + skill.name + " -> " + skill.path);
+            return { done: true };
+        }
+        if (sub === "uninstall" || sub === "remove" || sub === "rm") {
+            if (args.length === 0) {
+                console.error("Usage: fastcode skills uninstall <id>");
+                process.exit(1);
+            }
+            const ok = uninstallSkill(args[0]);
+            console.log(ok ? "Removed " + args[0] + "." : "No skill named " + args[0] + ".");
+            return { done: true };
+        }
+        if (sub === "search") {
+            if (args.length === 0) {
+                console.error("Usage: fastcode skills search <query>");
+                process.exit(1);
+            }
+            const cfg = loadConfig();
+            const hits = await searchRegistry(args.join(" "), cfg.skillsRegistry);
+            if (hits.length === 0)
+                console.log("No matches.");
+            for (const h of hits.slice(0, 20)) {
+                console.log(h.slug + "\t" + (h.description ?? ""));
+            }
+            return { done: true };
+        }
+        console.error("Unknown skills sub-command: " + sub);
+        process.exit(1);
+    }
+    if (first === "doctor") {
+        console.log(formatDiagnostics(collectDiagnostics()));
+        return { done: true };
+    }
+    if (first === "update") {
+        console.log(await updateReport());
+        return { done: true };
+    }
+    // No sub-command → treat all positionals as the initial prompt.
+    const prompt = cli.input.length > 0 ? cli.input.join(" ") : undefined;
+    return prompt ? { prompt, done: false } : { done: false };
+}
+function compareVersions(a, b) {
+    const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+    const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d > 0 ? 1 : -1;
+    }
+    return 0;
+}
+async function updateReport() {
+    const meta = readPackageMeta();
+    const lines = ["FastCode " + meta.version, ""];
+    const registry = process.env["FASTCODE_UPDATE_REGISTRY"] ??
+        "https://registry.npmjs.org/" + encodeURIComponent(meta.name) + "/latest";
+    try {
+        const res = await fetch(registry, { headers: { accept: "application/json" } });
+        if (!res.ok)
+            throw new Error(res.status + " " + res.statusText);
+        const payload: any = await res.json();
+        const latest = payload.version;
+        const cmp = compareVersions(latest, meta.version);
+        lines.push("Published latest: " + latest);
+        lines.push(cmp > 0
+            ? "Update available: " + meta.version + " -> " + latest
+            : cmp < 0
+                ? "This build (" + meta.version + ") is newer than the published " + latest + "."
+                : "You are up to date.");
+    }
+    catch (err) {
+        lines.push("Could not reach the registry: " + err.message);
+    }
+    lines.push("");
+    lines.push("Update with one of:");
+    lines.push("  npm install -g " + meta.name + "@latest");
+    lines.push("  # or from a checkout:  git pull && npm install -g .");
+    return lines.join(NL);
+}

package/src/commands/about.ts

@@ -0,0 +1,16 @@
+import { platformLabel } from "../lib/platform.js";
+export const aboutCommand = {
+    name: "about",
+    description: "Show version, platform, and links.",
+    aliases: ["version"],
+    run() {
+        const lines = [
+            `FastCode  — multi-LLM TUI coding assistant`,
+            `Platform: ${platformLabel()}  •  Node ${process.version}`,
+            ``,
+            `GitHub:   https://github.com/dateName/fastcode-termux`,
+            `Skills:   https://skillshub.wtf`,
+        ];
+        return { message: lines.join("\n") };
+    },
+};

package/src/commands/agent.ts

@@ -0,0 +1,18 @@
+export const agentCommand = {
+    name: "agent",
+    description: "Toggle coding-agent tools. Usage: /agent [on|off|status]",
+    run({ args, state, actions }) {
+        const sub = (args[0] ?? "status").toLowerCase();
+        if (sub === "on") {
+            actions.setAgentMode(true);
+            return { message: "Agent mode enabled. FastCode can run shell and file tools." };
+        }
+        if (sub === "off") {
+            actions.setAgentMode(false);
+            return { message: "Agent mode disabled." };
+        }
+        return {
+            message: `Agent mode: ${state.agentMode ? "on" : "off"}\n\nUse /agent on to let FastCode run local shell and file tools.`,
+        };
+    },
+};

package/src/commands/attach.ts

@@ -0,0 +1,16 @@
+import { pollShellSession } from "../agent/shell-session.js";
+
+export const attachCommand = {
+    name: "attach",
+    description: "Show new output from a background shell session (/attach <id>)",
+    async run({ args }) {
+        const id = args[0];
+        if (!id)
+            return { message: "Usage: /attach <session-id>  (see /jobs)" };
+        const result = await pollShellSession(id, 0);
+        if (!result)
+            return { message: `Unknown session: ${id}` };
+        const status = result.status === "running" ? "running" : `${result.status} (exit ${result.exitCode ?? "?"})`;
+        return { message: `[session ${id}] ${status}\n${result.output || "(no new output)"}` };
+    },
+};

package/src/commands/bg.ts

@@ -0,0 +1,9 @@
+export const bgCommand = {
+    name: "bg",
+    description: "Explain backgrounding (long shell commands auto-background after ~2s)",
+    run() {
+        return {
+            message: "Long shell commands already return a session id after ~2s; use /jobs to list them, /attach <id> for new output, /kill <id> to stop.",
+        };
+    },
+};

package/src/commands/cancel.ts

@@ -0,0 +1,10 @@
+export const cancelCommand = {
+    name: "cancel",
+    description: "Cancel the active agent run (soft keyboard alternative to Esc)",
+    run({ state, actions }) {
+        if (!state.busy)
+            return { message: "Nothing is running." };
+        actions.cancelRun();
+        return { message: "Cancelling the active run…" };
+    },
+};

package/src/commands/clear.ts

@@ -0,0 +1,9 @@
+export const clearCommand = {
+    name: "clear",
+    description: "Clear the current conversation history.",
+    aliases: ["cls"],
+    run({ actions }) {
+        actions.clearHistory();
+        return { message: "Conversation cleared.", silent: false };
+    },
+};

package/src/commands/compact.ts

@@ -0,0 +1,23 @@
+import { compactMessages, DEFAULT_COMPACTION_CONFIG } from "../agent/compaction.js";
+import { getModelMeta } from "../lib/model-meta.js";
+
+export const compactCommand = {
+    name: "compact",
+    description: "Force local context compaction now",
+    run({ state, actions }) {
+        const meta = getModelMeta(state.providerId, state.model);
+        const result = compactMessages(state.history, { ...DEFAULT_COMPACTION_CONFIG, localThresholdRatio: 0 }, {
+            contextWindow: meta.contextWindow,
+            providerId: state.providerId,
+            model: state.model,
+            force: true,
+        });
+        if (!result.compacted)
+            return { message: "Nothing to compact (history is already small)." };
+        actions.replaceHistory(result.messages);
+        return {
+            message: `[context compacted] ${result.beforeTokens} → ${result.afterTokens} tokens (${result.droppedMessages} messages summarized).` +
+                (result.summaryFile ? `\nSummary: ${result.summaryFile}` : ""),
+        };
+    },
+};

package/src/commands/config.ts

@@ -0,0 +1,24 @@
+import { loadConfig } from "../config/store.js";
+import { getPaths } from "../config/paths.js";
+export const configCommand = {
+    name: "config",
+    description: "Print effective config & paths.",
+    run() {
+        const cfg = loadConfig();
+        const paths = getPaths();
+        const lines = [
+            "Config (~/.fastcode/config.json):",
+            JSON.stringify(cfg, null, 2),
+            "",
+            "Paths:",
+            `  root:     ${paths.root}`,
+            `  config:   ${paths.config}`,
+            `  auth:     ${paths.auth}`,
+            `  skills:   ${paths.skills}`,
+            `  plugins:  ${paths.plugins}`,
+            `  cache:    ${paths.cache}`,
+            `  sessions: ${paths.sessions}`,
+        ];
+        return { message: lines.join("\n") };
+    },
+};

package/src/commands/context.ts

@@ -0,0 +1,25 @@
+import { DEFAULT_COMPACTION_CONFIG, heapExceeded, localThresholdTokens } from "../agent/compaction.js";
+import { estMessagesTokens, getModelMeta } from "../lib/model-meta.js";
+
+export const contextCommand = {
+    name: "context",
+    description: "Show estimated context tokens, compaction threshold, and heap usage",
+    run(ctx) {
+        const meta = getModelMeta(ctx.state.providerId, ctx.state.model);
+        const tokens = estMessagesTokens(ctx.state.history, {
+            providerId: ctx.state.providerId,
+            model: ctx.state.model,
+        });
+        const threshold = localThresholdTokens(DEFAULT_COMPACTION_CONFIG, meta.contextWindow);
+        const percent = meta.contextWindow > 0 ? (tokens / meta.contextWindow) * 100 : 0;
+        const heapMb = process.memoryUsage().heapUsed / 1024 / 1024;
+        return {
+            message: [
+                `Context: ~${tokens.toLocaleString()} / ${meta.contextWindow.toLocaleString()} tokens (${percent.toFixed(1)}%)`,
+                `Compaction threshold: ${threshold.toLocaleString()} tokens (${Math.round(DEFAULT_COMPACTION_CONFIG.localThresholdRatio * 100)}%)`,
+                `Heap: ${heapMb.toFixed(1)} MB / ${DEFAULT_COMPACTION_CONFIG.heapLimitMb} MB${heapExceeded(DEFAULT_COMPACTION_CONFIG) ? "  [forced compaction]" : ""}`,
+                `Messages: ${ctx.state.history.length}  ·  chars/token: ~${meta.charsPerToken}`,
+            ].join("\n"),
+        };
+    },
+};

package/src/commands/cost.ts

@@ -0,0 +1,13 @@
+export const costCommand = {
+    name: "cost",
+    description: "Show approximate cost & token usage for this session.",
+    run({ state }) {
+        const lines = [
+            `Provider: ${state.providerId}`,
+            `Model:    ${state.model}`,
+            `Tokens:   ${state.totalInputTokens} in / ${state.totalOutputTokens} out`,
+            `Cost:     ~$${state.totalCostUsd.toFixed(4)}`,
+        ];
+        return { message: lines.join("\n") };
+    },
+};

package/src/commands/cwd.ts

@@ -0,0 +1,7 @@
+export const cwdCommand = {
+    name: "cwd",
+    description: "Show the current agent sandbox root.",
+    run() {
+        return { message: `Agent sandbox root:\n\n\`${process.cwd()}\`` };
+    },
+};

package/src/commands/edit.ts

@@ -0,0 +1,37 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export const editCommand = {
+    name: "edit",
+    description: "Edit the prompt in $EDITOR (works around Ink IME issues on Termux)",
+    run({ state, actions }) {
+        const file = join(tmpdir(), `fastcode-edit-${Date.now()}.md`);
+        writeFileSync(file, state.draft ?? "", "utf8");
+        const editor = process.env["EDITOR"] || process.env["VISUAL"] || "nano";
+        const wasRaw = Boolean(process.stdin.isTTY && process.stdin.isRaw);
+        try {
+            if (wasRaw)
+                process.stdin.setRawMode(false);
+            const result = spawnSync(editor, [file], { stdio: "inherit" });
+            if (result.error)
+                return { message: `Could not launch ${editor}: ${result.error.message}` };
+            const text = readFileSync(file, "utf8").trim();
+            if (!text)
+                return { message: "Editor closed with no text." };
+            actions.setInput(text);
+            return { message: "Draft loaded into the prompt; press Enter to send." };
+        }
+        finally {
+            if (wasRaw)
+                process.stdin.setRawMode(true);
+            try {
+                unlinkSync(file);
+            }
+            catch {
+                // temp file may already be gone
+            }
+        }
+    },
+};

package/src/commands/effort.ts

@@ -0,0 +1,49 @@
+import { getProvider } from "../providers/index.js";
+import type { ReasoningEffort } from "../types.js";
+const EFFORTS: ReasoningEffort[] = ["auto", "low", "medium", "high", "max"];
+const HINTS: Record<ReasoningEffort, string> = {
+    auto: "provider default (send nothing)",
+    low: "fast, minimal thinking",
+    medium: "balanced",
+    high: "deeper reasoning, slower",
+    max: "maximum budget where supported",
+};
+export const effortCommand = {
+    name: "effort",
+    description: "Set thinking effort (auto/low/medium/high/max). Usage: /effort [level]",
+    run({ args, state, actions }) {
+        const provider = getProvider(state.providerId);
+        const supported = provider?.supportsReasoning?.(state.model) ?? false;
+        const current = (state.reasoningEffort ?? "auto");
+        const apply = (value: ReasoningEffort) => {
+            actions.setReasoningEffort(value);
+            return describe(value, provider, supported);
+        };
+        if (args.length > 0) {
+            const value = args[0].toLowerCase();
+            if (!EFFORTS.includes(value as ReasoningEffort)) {
+                return { message: `Unknown effort "${args[0]}". Choose: ${EFFORTS.join(", ")}.` };
+            }
+            return { message: apply(value as ReasoningEffort) };
+        }
+        return {
+            message: `Thinking effort: ${current}${supported ? "" : " (this provider has no thinking parameter)"}`,
+            picker: {
+                title: `Thinking effort · ${provider?.label ?? state.providerId}`,
+                current,
+                items: EFFORTS.map((value) => ({ value, label: value, hint: HINTS[value] })),
+                onSelect: (value) => actions.pushSystemMessage(apply(value as ReasoningEffort)),
+            },
+        };
+    },
+};
+function describe(value, provider, supported) {
+    if (value === "auto") {
+        return "Thinking effort: auto — the provider's default is used (no thinking parameter is sent).";
+    }
+    if (!supported) {
+        return `Thinking effort saved as ${value}, but ${provider?.label ?? "this provider"} does not expose a thinking parameter; ` +
+            "requests will omit it. Switch to a reasoning-capable model/provider to use it.";
+    }
+    return `Thinking effort: ${value}. The next request will carry the provider-specific thinking parameter.`;
+}

package/src/commands/exit.ts

@@ -0,0 +1,8 @@
+export const exitCommand = {
+    name: "exit",
+    description: "Quit FastCode.",
+    aliases: ["quit", "q"],
+    run() {
+        return { message: "Bye!", quit: true };
+    },
+};

package/src/commands/expand.ts

@@ -0,0 +1,8 @@
+export const expandCommand = {
+    name: "expand",
+    description: "Toggle full tool output in the transcript (stable UI defaults to collapsed)",
+    run({ state, actions }) {
+        actions.setExpanded(!state.expanded);
+        return { message: state.expanded ? "Tool output: collapsed." : "Tool output: expanded (new output only)." };
+    },
+};

package/src/commands/help.ts

@@ -0,0 +1,18 @@
+import { COMMANDS } from "./index.js";
+export const helpCommand = {
+    name: "help",
+    description: "Show all available slash commands.",
+    aliases: ["h", "?"],
+    run() {
+        const visible = COMMANDS.filter((c) => !c.hidden);
+        const widest = Math.max(...visible.map((c) => c.name.length));
+        const lines = [
+            "Slash commands — type any of these at the prompt:",
+            "",
+            ...visible.map((c) => `  /${c.name.padEnd(widest)}   ${c.description}`),
+            "",
+            "Press ESC to cancel a streaming response. Press Ctrl+C twice to quit.",
+        ];
+        return { message: lines.join("\n") };
+    },
+};