@datename/fastcode-termux 0.0.0-stage → 0.1.6

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/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/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/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/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/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,58 @@
+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 { 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";
+export const COMMANDS = [
+    helpCommand,
+    agentCommand,
+    toolsCommand,
+    cwdCommand,
+    pluginCommand,
+    clearCommand,
+    exitCommand,
+    modelCommand,
+    providerCommand,
+    loginCommand,
+    logoutCommand,
+    skillsCommand,
+    themeCommand,
+    costCommand,
+    resetCommand,
+    systemCommand,
+    aboutCommand,
+    configCommand,
+    whoamiCommand,
+];
+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/login.d.ts

@@ -0,0 +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.
+ */
+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;
+    };
+};

package/dist/commands/login.js

@@ -0,0 +1,61 @@
+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.
+ */
+export function saveScopedKey(providerId, providerLabel, model, key) {
+    const trimmed = key.trim();
+    setCredential(providerId, model, trimmed);
+    const paths = getPaths();
+    return [
+        "Saved API key",
+        `  provider  ${providerLabel} (${providerId})`,
+        `  model     ${model}`,
+        `  key       ${maskKey(trimmed)}`,
+        `  stored    ${paths.auth} (mode 0600)`,
+        "",
+        `Remove with /logout ${providerId} ${model}`,
+    ].join("\n");
+}
+export const loginCommand = {
+    name: "login",
+    description: "Bind an API key to a provider + model. Usage: /login [provider] [model] [key]",
+    run({ args, state, actions }) {
+        if (args.length === 0) {
+            actions.startLogin({});
+            return { message: introText(state) };
+        }
+        const provider = getProvider(args[0]);
+        if (!provider) {
+            return { message: `Unknown provider "${args[0]}". Available: ${PROVIDERS.map((p) => p.id).join(", ")}` };
+        }
+        if (provider.authEnv.length === 0) {
+            return { message: `${provider.label} doesn't require an API key. Nothing to save.` };
+        }
+        if (args.length === 1) {
+            actions.startLogin({ provider: provider.id });
+            return { message: `Provider: ${provider.label} (${provider.id}).\nNow pick the model this key is for.` };
+        }
+        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).` };
+        }
+        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.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,53 @@
+import { getProvider } from "../providers/index.js";
+import { listCredentials, maskKey, removeCredential, removeCredentialsForProvider } from "../config/store.js";
+export const logoutCommand = {
+    name: "logout",
+    description: "Remove a stored API key. Usage: /logout <provider> [model] | /logout <provider> --all",
+    run({ args }) {
+        if (args.length === 0) {
+            const credentials = listCredentials();
+            if (credentials.length === 0)
+                return { message: "No stored keys. Use /login to add one." };
+            const lines = ["Stored keys (provider :: model):"];
+            for (const c of credentials)
+                lines.push(`  ${c.provider}::${c.model}   ${maskKey(c.key)}`);
+            lines.push("");
+            lines.push("Remove: /logout <provider> <model>");
+            lines.push("        /logout <provider> --all");
+            return { message: lines.join("\n") };
+        }
+        const id = args[0];
+        const provider = getProvider(id);
+        if (!provider)
+            return { message: `Unknown provider "${id}".` };
+        if (args.includes("--all")) {
+            const removed = removeCredentialsForProvider(provider.id);
+            return {
+                message: removed > 0
+                    ? `Removed ${removed} stored key(s) for ${provider.label}.`
+                    : `No stored key for ${provider.label}.`,
+            };
+        }
+        if (args.length >= 2) {
+            const model = args[1];
+            const ok = removeCredential(provider.id, model);
+            return {
+                message: ok
+                    ? `Removed stored key for ${provider.id}::${model}.`
+                    : `No stored key for ${provider.id}::${model}.`,
+            };
+        }
+        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") };
+    },
+};

package/dist/commands/model.d.ts

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

package/dist/commands/model.js

@@ -0,0 +1,30 @@
+import { getProviderOrThrow } from "../providers/index.js";
+import { resolveProviderKey } from "../config/store.js";
+export const modelCommand = {
+    name: "model",
+    description: "List models for the current provider, or switch model. Usage: /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") };
+        }
+        const id = args.join(" ");
+        actions.setModel(id);
+        return { message: `Model set to ${id}.` };
+    },
+};

package/dist/commands/plugin.d.ts

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

package/dist/commands/plugin.js

@@ -0,0 +1,74 @@
+import { getPlugin, importPlugin, listInstalledPlugins, removePlugin, } from "../plugins/manager.js";
+export const pluginCommand = {
+    name: "plugin",
+    description: "Manage always-active plugin packs. Usage: /plugin [list|import|enable|disable|remove|info]",
+    run({ args, state, actions }) {
+        const sub = (args[0] ?? "list").toLowerCase();
+        if (sub === "list") {
+            const plugins = listInstalledPlugins();
+            if (plugins.length === 0)
+                return { message: "No plugins installed. Import one with /plugin import <path> [name]." };
+            return {
+                message: [
+                    "Installed plugins:",
+                    "",
+                    ...plugins.map((p) => {
+                        const enabled = state.enabledPlugins.includes(p.name) ? "●" : " ";
+                        return `${enabled} ${p.name} — ${p.description}`;
+                    }),
+                ].join("\n"),
+            };
+        }
+        if (sub === "import") {
+            const source = args[1];
+            if (!source)
+                return { message: "Usage: /plugin import <folder-path> [name]" };
+            const plugin = importPlugin(source, args[2]);
+            actions.enablePlugin(plugin.name);
+            return { message: `Imported and enabled plugin ${plugin.name}.` };
+        }
+        if (sub === "enable") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin enable <name>" };
+            const plugin = getPlugin(name);
+            if (!plugin)
+                return { message: `Plugin not found: ${name}` };
+            actions.enablePlugin(plugin.name);
+            return { message: `Enabled plugin ${plugin.name}.` };
+        }
+        if (sub === "disable") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin disable <name>" };
+            actions.disablePlugin(name);
+            return { message: `Disabled plugin ${name}.` };
+        }
+        if (sub === "remove") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin remove <name>" };
+            actions.disablePlugin(name);
+            return { message: removePlugin(name) ? `Removed plugin ${name}.` : `Plugin not found: ${name}` };
+        }
+        if (sub === "info") {
+            const name = args[1];
+            if (!name)
+                return { message: "Usage: /plugin info <name>" };
+            const plugin = getPlugin(name);
+            if (!plugin)
+                return { message: `Plugin not found: ${name}` };
+            return {
+                message: [
+                    `Plugin: ${plugin.name}`,
+                    `Path: ${plugin.path}`,
+                    `Description: ${plugin.description}`,
+                    `Skills: ${plugin.skills.map((s) => s.name).join(", ") || "none"}`,
+                    "",
+                    plugin.body.slice(0, 4000),
+                ].join("\n"),
+            };
+        }
+        return { message: "Usage: /plugin [list|import|enable|disable|remove|info]" };
+    },
+};

package/dist/commands/provider.d.ts

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

package/dist/commands/provider.js

@@ -0,0 +1,28 @@
+import { PROVIDERS, getProvider } from "../providers/index.js";
+export const providerCommand = {
+    name: "provider",
+    description: "List or switch the active LLM provider. Usage: /provider [id]",
+    run({ args, actions, state }) {
+        if (args.length === 0) {
+            const lines = ["Available providers:"];
+            for (const p of PROVIDERS) {
+                const marker = p.id === state.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 with `/provider <id>` (e.g. `/provider openrouter`).");
+            return { message: lines.join("\n") };
+        }
+        const target = args[0];
+        const next = getProvider(target);
+        if (!next) {
+            return { message: `Unknown provider "${target}". Try /provider with no args.` };
+        }
+        actions.setProvider(next.id);
+        actions.setModel(next.defaultModel);
+        return {
+            message: `Provider set to ${next.label}. Default model: ${next.defaultModel}. Use /model to change.`,
+        };
+    },
+};

package/dist/commands/reset.d.ts

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

package/dist/commands/reset.js

@@ -0,0 +1,13 @@
+import { DEFAULT_CONFIG, saveConfig } from "../config/store.js";
+export const resetCommand = {
+    name: "reset",
+    description: "Reset config to defaults (does not touch API keys).",
+    run({ actions }) {
+        saveConfig({ ...DEFAULT_CONFIG });
+        actions.setProvider(DEFAULT_CONFIG.providerId);
+        actions.setModel(DEFAULT_CONFIG.model);
+        actions.setTheme(DEFAULT_CONFIG.theme);
+        actions.setSystemPrompt(DEFAULT_CONFIG.systemPrompt);
+        return { message: "Config reset to defaults." };
+    },
+};

package/dist/commands/skills.d.ts

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