@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/dist/commands/about.js

@@ -9,7 +9,7 @@ export const aboutCommand = {
             `Platform: ${platformLabel()}  •  Node ${process.version}`,
             ``,
             `GitHub:   https://github.com/dateName/fastcode-termux`,
-            `Skills:   https://skillshub.wtf`,
+            `Skills:   configure a registry with /skills registry <url>`,
         ];
         return { message: lines.join("\n") };
     },

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

@@ -7,5 +7,6 @@ export declare const clearCommand: {
     }): {
         message: string;
         silent: boolean;
+        cleared: boolean;
     };
 };

package/dist/commands/clear.js

@@ -4,6 +4,6 @@ export const clearCommand = {
     aliases: ["cls"],
     run({ actions }) {
         actions.clearHistory();
-        return { message: "Conversation cleared.", silent: false };
+        return { message: "Conversation cleared.", silent: false, cleared: true };
     },
 };

package/dist/commands/compact.d.ts

@@ -0,0 +1,22 @@
+export declare const compactCommand: {
+    name: string;
+    description: string;
+    run({ state, actions }: {
+        state: any;
+        actions: any;
+    }): {
+        message: string;
+        compacted?: undefined;
+    } | {
+        message: string;
+        compacted: {
+            summaryRef: string;
+            source: string;
+            beforeTokens: number;
+            afterTokens: number;
+            droppedMessages: number;
+            keepMessages: number;
+            reason: string;
+        };
+    };
+};

package/dist/commands/compact.js

@@ -0,0 +1,34 @@
+import { compactMessages, compactionConfigFromEnv } 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 config = compactionConfigFromEnv();
+        if (!config.enabled)
+            return { message: "Compaction is disabled by FASTCODE_COMPACTION." };
+        const meta = getModelMeta(state.providerId, state.model);
+        const result = compactMessages(state.history, { ...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}` : ""),
+            compacted: {
+                summaryRef: result.summaryFile,
+                source: "local",
+                beforeTokens: result.beforeTokens,
+                afterTokens: result.afterTokens,
+                droppedMessages: result.droppedMessages,
+                keepMessages: result.keptMessages,
+                reason: "manual",
+            },
+        };
+    },
+};

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,25 @@
+import { compactionConfigFromEnv, 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 config = compactionConfigFromEnv();
+        const tokens = estMessagesTokens(ctx.state.history, {
+            providerId: ctx.state.providerId,
+            model: ctx.state.model,
+        });
+        const threshold = localThresholdTokens(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(config.localThresholdRatio * 100)}%)${config.enabled ? "" : "  [disabled]"}`,
+                `Heap: ${heapMb.toFixed(1)} MB / ${config.heapLimitMb} MB${heapExceeded(config) ? "  [forced compaction]" : ""}`,
+                `Messages: ${ctx.state.history.length}  ·  chars/token: ~${meta.charsPerToken}`,
+            ].join("\n"),
+        };
+    },
+};

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/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/index.js

@@ -7,6 +7,7 @@ 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";
@@ -17,6 +18,17 @@ 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";
+import { threadsCommand } from "./threads.js";
 export const COMMANDS = [
     helpCommand,
     agentCommand,
@@ -27,6 +39,7 @@ export const COMMANDS = [
     exitCommand,
     modelCommand,
     providerCommand,
+    effortCommand,
     loginCommand,
     logoutCommand,
     skillsCommand,
@@ -37,6 +50,17 @@ export const COMMANDS = [
     aboutCommand,
     configCommand,
     whoamiCommand,
+    contextCommand,
+    jobsCommand,
+    killCommand,
+    cancelCommand,
+    steerCommand,
+    compactCommand,
+    expandCommand,
+    attachCommand,
+    bgCommand,
+    editCommand,
+    threadsCommand,
 ];
 export function findCommand(name) {
     const lower = name.toLowerCase();

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,17 @@
+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 age = Math.max(0, Math.round((Date.now() - job.startedAt) / 1000));
+            const command = job.command.length > 80 ? job.command.slice(0, 77) + "…" : job.command;
+            return `${job.id}  ${job.status}${exit}  ${age}s  ${(job.bytes / 1024).toFixed(1)}KB  ${command}`;
+        });
+        return { message: ["Shell sessions:", ...lines, "", "Kill one with: /kill <id>", "Completed sessions are pruned after 10 minutes; resident pool cap is 2."].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,13 @@
+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 group killed; setsid descendants may escape).`
+                : `No running session named ${id}.` };
+    },
+};

package/dist/commands/login.d.ts

@@ -1,14 +1,16 @@
 /**
- * Save a key scoped to one provider + model and describe it for the terminal.
- * Shared by the `/login` command and the guided flow in the app.
+ * 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 function maskLoginEcho(args: any): string;
 export declare const loginCommand: {
     name: string;
     description: string;
-    run({ args, state, actions }: {
+    run({ args, actions }: {
         args: any;
-        state: any;
         actions: any;
     }): {
         message: string;

package/dist/commands/login.js

@@ -2,8 +2,10 @@ import { getProvider, PROVIDERS } from "../providers/index.js";
 import { maskKey, setCredential } from "../config/store.js";
 import { getPaths } from "../config/paths.js";
 /**
- * Save a key scoped to one provider + model and describe it for the terminal.
- * Shared by the `/login` command and the guided flow in the app.
+ * 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 function saveScopedKey(providerId, providerLabel, model, key) {
     const trimmed = key.trim();
@@ -12,20 +14,32 @@ export function saveScopedKey(providerId, providerLabel, model, key) {
     return [
         "Saved API key",
         `  provider  ${providerLabel} (${providerId})`,
-        `  model     ${model}`,
+        `  scope     all ${providerId} models (saved from ${model || "unknown"})`,
         `  key       ${maskKey(trimmed)}`,
         `  stored    ${paths.auth} (mode 0600)`,
         "",
-        `Remove with /logout ${providerId} ${model}`,
+        `Remove with /logout ${providerId}`,
     ].join("\n");
 }
+export function maskLoginEcho(args) {
+    const parts = ["/login", args[0] ?? ""];
+    if (args.length === 2) {
+        parts.push("********");
+    }
+    else if (args.length >= 3) {
+        parts.push(args[1]);
+        for (let i = 2; i < args.length; i += 1)
+            parts.push("********");
+    }
+    return parts.filter((part) => part !== "").join(" ");
+}
 export const loginCommand = {
     name: "login",
-    description: "Bind an API key to a provider + model. Usage: /login [provider] [model] [key]",
-    run({ args, state, actions }) {
+    description: "Bind a provider-wide API key. Usage: /login [provider] [model] [key]",
+    run({ args, actions }) {
         if (args.length === 0) {
-            actions.startLogin({});
-            return { message: introText(state) };
+            actions.startLogin({ flow: "login" });
+            return { message: "Configure a provider: choose a provider and model, then enter its API key." };
         }
         const provider = getProvider(args[0]);
         if (!provider) {
@@ -36,26 +50,14 @@ export const loginCommand = {
         }
         if (args.length === 1) {
             actions.startLogin({ provider: provider.id });
-            return { message: `Provider: ${provider.label} (${provider.id}).\nNow pick the model this key is for.` };
+            return { message: `Provider: ${provider.label} (${provider.id}).\nThe key will apply to every model of this provider.` };
         }
         const model = args[1];
         if (args.length === 2) {
             actions.startLogin({ provider: provider.id, model });
-            return { message: `Provider: ${provider.id} · model: ${model}.\nNow paste the API key (input is masked).` };
+            return { message: `Provider: ${provider.id} · saved from model: ${model}.\nNow paste the API key (input is masked).` };
         }
         const key = args.slice(2).join(" ");
         return { message: saveScopedKey(provider.id, provider.label, model, key) };
     },
 };
-function introText(state) {
-    const env = getProvider(state.providerId)?.authEnv?.[0] ?? "PROVIDER_API_KEY";
-    return [
-        "Bind an API key to a specific provider + model.",
-        "",
-        `  current scope: ${state.providerId} · ${state.model}`,
-        "",
-        "FastCode will ask for the provider, then the model, then the key.",
-        "  one-liner:  /login <provider> <model> <key>",
-        `  or set:     export ${env}=<key>   (provider-wide, any model)`,
-    ].join("\n");
-}

package/dist/commands/logout.js

@@ -8,11 +8,11 @@ export const logoutCommand = {
             const credentials = listCredentials();
             if (credentials.length === 0)
                 return { message: "No stored keys. Use /login to add one." };
-            const lines = ["Stored keys (provider :: model):"];
+            const lines = ["Stored keys (provider-wide):"];
             for (const c of credentials)
-                lines.push(`  ${c.provider}::${c.model}   ${maskKey(c.key)}`);
+                lines.push(`  ${c.provider}   ${maskKey(c.key)}`);
             lines.push("");
-            lines.push("Remove: /logout <provider> <model>");
+            lines.push("Remove: /logout <provider>");
             lines.push("        /logout <provider> --all");
             return { message: lines.join("\n") };
         }
@@ -29,25 +29,17 @@ export const logoutCommand = {
             };
         }
         if (args.length >= 2) {
-            const model = args[1];
-            const ok = removeCredential(provider.id, model);
+            const ok = removeCredential(provider.id);
             return {
                 message: ok
-                    ? `Removed stored key for ${provider.id}::${model}.`
-                    : `No stored key for ${provider.id}::${model}.`,
+                    ? `Removed the stored key for ${provider.id} (applies to all its models).`
+                    : `No stored key for ${provider.id}.`,
             };
         }
         const forProvider = listCredentials().filter((c) => c.provider === provider.id);
         if (forProvider.length === 0)
             return { message: `No stored key for ${provider.label}.` };
-        if (forProvider.length === 1) {
-            removeCredential(forProvider[0].provider, forProvider[0].model);
-            return { message: `Removed stored key for ${forProvider[0].provider}::${forProvider[0].model}.` };
-        }
-        const lines = [`${provider.label} has ${forProvider.length} stored keys — pick one to remove:`];
-        for (const c of forProvider)
-            lines.push(`  /logout ${c.provider} ${c.model}   (${maskKey(c.key)})`);
-        lines.push(`  /logout ${provider.id} --all   (remove all)`);
-        return { message: lines.join("\n") };
+        removeCredential(provider.id);
+        return { message: `Removed the stored key for ${provider.label} (all models).` };
     },
 };

package/dist/commands/model.d.ts

@@ -1,3 +1,4 @@
+export declare function isValidModelId(value: any): boolean;
 export declare const modelCommand: {
     name: string;
     description: string;

package/dist/commands/model.js

@@ -1,30 +1,18 @@
 import { getProviderOrThrow } from "../providers/index.js";
-import { resolveProviderKey } from "../config/store.js";
+export function isValidModelId(value) {
+    return /^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,199}$/.test(value);
+}
 export const modelCommand = {
     name: "model",
-    description: "List models for the current provider, or switch model. Usage: /model [id]",
+    description: "Pick a model interactively, or switch with /model <id>",
     async run({ args, state, actions }) {
         const provider = getProviderOrThrow(state.providerId);
-        if (args.length === 0) {
-            const { key } = resolveProviderKey(provider.id, provider.authEnv);
-            const models = await provider.listModels(key);
-            if (models.length === 0) {
-                return { message: `No models available from ${provider.label}.` };
-            }
-            const lines = [`Models for ${provider.label}:`];
-            for (const m of models.slice(0, 50)) {
-                const marker = m.id === state.model ? "● " : "  ";
-                const label = m.label ? ` — ${m.label}` : "";
-                lines.push(`${marker}${m.id}${label}`);
-            }
-            if (models.length > 50)
-                lines.push(`  … and ${models.length - 50} more.`);
-            lines.push("");
-            lines.push("Switch with `/model <id>`.");
-            return { message: lines.join("\n") };
+        if (args.length > 0) {
+            const id = args.join(" ");
+            actions.setModel(id);
+            return { message: `Model set to ${id}.` };
         }
-        const id = args.join(" ");
-        actions.setModel(id);
-        return { message: `Model set to ${id}.` };
+        actions.startLogin({ flow: "model", provider: provider.id, model: state.model });
+        return { message: `Configure ${provider.label}: choose a model, then enter its API key.` };
     },
 };

package/dist/commands/provider.d.ts

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