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

package/dist/commands/about.d.ts

@@ -0,0 +1,8 @@
+export declare const aboutCommand: {
+    name: string;
+    description: string;
+    aliases: string[];
+    run(): {
+        message: string;
+    };
+};

package/dist/commands/about.js

@@ -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/dist/commands/agent.d.ts

@@ -0,0 +1,11 @@
+export declare const agentCommand: {
+    name: string;
+    description: string;
+    run({ args, state, actions }: {
+        args: any;
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+    };
+};

package/dist/commands/agent.js

@@ -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/dist/commands/attach.d.ts

@@ -0,0 +1,9 @@
+export declare const attachCommand: {
+    name: string;
+    description: string;
+    run({ args }: {
+        args: any;
+    }): Promise<{
+        message: string;
+    }>;
+};

package/dist/commands/attach.js

@@ -0,0 +1,15 @@
+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/dist/commands/bg.d.ts

@@ -0,0 +1,7 @@
+export declare const bgCommand: {
+    name: string;
+    description: string;
+    run(): {
+        message: string;
+    };
+};

package/dist/commands/bg.js

@@ -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/dist/commands/cancel.d.ts

@@ -0,0 +1,10 @@
+export declare const cancelCommand: {
+    name: string;
+    description: string;
+    run({ state, actions }: {
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+    };
+};

package/dist/commands/cancel.js

@@ -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/dist/commands/clear.d.ts

@@ -0,0 +1,11 @@
+export declare const clearCommand: {
+    name: string;
+    description: string;
+    aliases: string[];
+    run({ actions }: {
+        actions: any;
+    }): {
+        message: string;
+        silent: boolean;
+    };
+};

package/dist/commands/clear.js

@@ -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/dist/commands/compact.d.ts

@@ -0,0 +1,10 @@
+export declare const compactCommand: {
+    name: string;
+    description: string;
+    run({ state, actions }: {
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+    };
+};

package/dist/commands/compact.js

@@ -0,0 +1,22 @@
+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/dist/commands/config.d.ts

@@ -0,0 +1,7 @@
+export declare const configCommand: {
+    name: string;
+    description: string;
+    run(): {
+        message: string;
+    };
+};

package/dist/commands/config.js

@@ -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/dist/commands/context.d.ts

@@ -0,0 +1,7 @@
+export declare const contextCommand: {
+    name: string;
+    description: string;
+    run(ctx: any): {
+        message: string;
+    };
+};

package/dist/commands/context.js

@@ -0,0 +1,24 @@
+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/dist/commands/cost.d.ts

@@ -0,0 +1,9 @@
+export declare const costCommand: {
+    name: string;
+    description: string;
+    run({ state }: {
+        state: any;
+    }): {
+        message: string;
+    };
+};

package/dist/commands/cost.js

@@ -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/dist/commands/cwd.d.ts

@@ -0,0 +1,7 @@
+export declare const cwdCommand: {
+    name: string;
+    description: string;
+    run(): {
+        message: string;
+    };
+};

package/dist/commands/cwd.js

@@ -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/dist/commands/edit.d.ts

@@ -0,0 +1,10 @@
+export declare const editCommand: {
+    name: string;
+    description: string;
+    run({ state, actions }: {
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+    };
+};

package/dist/commands/edit.js

@@ -0,0 +1,36 @@
+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/dist/commands/effort.d.ts

@@ -0,0 +1,25 @@
+import type { ReasoningEffort } from "../types.js";
+export declare const effortCommand: {
+    name: string;
+    description: string;
+    run({ args, state, actions }: {
+        args: any;
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+        picker?: undefined;
+    } | {
+        message: string;
+        picker: {
+            title: string;
+            current: any;
+            items: {
+                value: ReasoningEffort;
+                label: ReasoningEffort;
+                hint: string;
+            }[];
+            onSelect: (value: any) => any;
+        };
+    };
+};

package/dist/commands/effort.js

@@ -0,0 +1,48 @@
+import { getProvider } from "../providers/index.js";
+const EFFORTS = ["auto", "low", "medium", "high", "max"];
+const HINTS = {
+    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) => {
+            actions.setReasoningEffort(value);
+            return describe(value, provider, supported);
+        };
+        if (args.length > 0) {
+            const value = args[0].toLowerCase();
+            if (!EFFORTS.includes(value)) {
+                return { message: `Unknown effort "${args[0]}". Choose: ${EFFORTS.join(", ")}.` };
+            }
+            return { message: apply(value) };
+        }
+        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)),
+            },
+        };
+    },
+};
+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/dist/commands/exit.d.ts

@@ -0,0 +1,9 @@
+export declare const exitCommand: {
+    name: string;
+    description: string;
+    aliases: string[];
+    run(): {
+        message: string;
+        quit: boolean;
+    };
+};

package/dist/commands/exit.js

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

package/dist/commands/expand.d.ts

@@ -0,0 +1,10 @@
+export declare const expandCommand: {
+    name: string;
+    description: string;
+    run({ state, actions }: {
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+    };
+};

package/dist/commands/expand.js

@@ -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/dist/commands/help.d.ts

@@ -0,0 +1,6 @@
+export declare const helpCommand: {
+    name: string;
+    description: string;
+    aliases: string[];
+    run(): any;
+};

package/dist/commands/help.js

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

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+export declare const COMMANDS: any;
+export declare function findCommand(name: any): any;
+/** Parse a raw input string. Returns undefined if it's not a slash command. */
+export declare function parseSlash(input: any): {
+    name: any;
+    args: any;
+    raw: any;
+};
+export declare function runCommand(cmd: any, ctx: any): Promise<any>;

package/dist/commands/index.js

@@ -0,0 +1,80 @@
+import { agentCommand } from "./agent.js";
+import { cwdCommand } from "./cwd.js";
+import { helpCommand } from "./help.js";
+import { pluginCommand } from "./plugin.js";
+import { toolsCommand } from "./tools.js";
+import { clearCommand } from "./clear.js";
+import { exitCommand } from "./exit.js";
+import { modelCommand } from "./model.js";
+import { providerCommand } from "./provider.js";
+import { effortCommand } from "./effort.js";
+import { loginCommand } from "./login.js";
+import { logoutCommand } from "./logout.js";
+import { skillsCommand } from "./skills.js";
+import { themeCommand } from "./theme.js";
+import { costCommand } from "./cost.js";
+import { resetCommand } from "./reset.js";
+import { systemCommand } from "./system.js";
+import { aboutCommand } from "./about.js";
+import { configCommand } from "./config.js";
+import { whoamiCommand } from "./whoami.js";
+import { contextCommand } from "./context.js";
+import { jobsCommand } from "./jobs.js";
+import { killCommand } from "./kill.js";
+import { cancelCommand } from "./cancel.js";
+import { steerCommand } from "./steer.js";
+import { compactCommand } from "./compact.js";
+import { expandCommand } from "./expand.js";
+import { attachCommand } from "./attach.js";
+import { bgCommand } from "./bg.js";
+import { editCommand } from "./edit.js";
+export const COMMANDS = [
+    helpCommand,
+    agentCommand,
+    toolsCommand,
+    cwdCommand,
+    pluginCommand,
+    clearCommand,
+    exitCommand,
+    modelCommand,
+    providerCommand,
+    effortCommand,
+    loginCommand,
+    logoutCommand,
+    skillsCommand,
+    themeCommand,
+    costCommand,
+    resetCommand,
+    systemCommand,
+    aboutCommand,
+    configCommand,
+    whoamiCommand,
+    contextCommand,
+    jobsCommand,
+    killCommand,
+    cancelCommand,
+    steerCommand,
+    compactCommand,
+    expandCommand,
+    attachCommand,
+    bgCommand,
+    editCommand,
+];
+export function findCommand(name) {
+    const lower = name.toLowerCase();
+    return COMMANDS.find((c) => c.name === lower || (c.aliases ?? []).includes(lower));
+}
+/** Parse a raw input string. Returns undefined if it's not a slash command. */
+export function parseSlash(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/"))
+        return undefined;
+    const tokens = trimmed.slice(1).split(/\s+/);
+    const head = tokens.shift() ?? "";
+    if (!head)
+        return undefined;
+    return { name: head, args: tokens, raw: trimmed };
+}
+export async function runCommand(cmd, ctx) {
+    return await cmd.run(ctx);
+}

package/dist/commands/jobs.d.ts

@@ -0,0 +1,7 @@
+export declare const jobsCommand: {
+    name: string;
+    description: string;
+    run(): {
+        message: string;
+    };
+};

package/dist/commands/jobs.js

@@ -0,0 +1,16 @@
+import { listShellSessions } from "../agent/shell-session.js";
+export const jobsCommand = {
+    name: "jobs",
+    description: "List background shell sessions",
+    run() {
+        const jobs = listShellSessions();
+        if (jobs.length === 0)
+            return { message: "No shell sessions. Long commands return a session id automatically." };
+        const lines = jobs.map((job) => {
+            const exit = job.exitCode === undefined || job.exitCode === null ? "" : ` exit=${job.exitCode}`;
+            const command = job.command.length > 80 ? job.command.slice(0, 77) + "…" : job.command;
+            return `${job.id}  ${job.status}${exit}  ${(job.bytes / 1024).toFixed(1)}KB  ${command}`;
+        });
+        return { message: ["Shell sessions:", ...lines, "", "Kill one with: /kill <id>"].join("\n") };
+    },
+};

package/dist/commands/kill.d.ts

@@ -0,0 +1,7 @@
+export declare const killCommand: {
+    name: string;
+    description: string;
+    run(ctx: any): {
+        message: string;
+    };
+};

package/dist/commands/kill.js

@@ -0,0 +1,11 @@
+import { killShellSession } from "../agent/shell-session.js";
+export const killCommand = {
+    name: "kill",
+    description: "Kill a background shell session (/kill <id>)",
+    run(ctx) {
+        const id = ctx.args[0];
+        if (!id)
+            return { message: "Usage: /kill <session-id>  (see /jobs)" };
+        return { message: killShellSession(id) ? `Killed ${id} (process tree).` : `No running session named ${id}.` };
+    },
+};

package/dist/commands/login.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Save a provider-wide key and describe it for the terminal. `model` is kept
+ * for the `/login provider model key` one-liner and only recorded as the
+ * credential's origin — the key itself is reused by every model of that
+ * provider. Shared by the `/login` command and the guided flow in the app.
+ */
+export declare function saveScopedKey(providerId: any, providerLabel: any, model: any, key: any): string;
+export declare const loginCommand: {
+    name: string;
+    description: string;
+    run({ args, state, actions }: {
+        args: any;
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+    };
+};