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

package/dist/commands/login.js

@@ -0,0 +1,63 @@
+import { getProvider, PROVIDERS } from "../providers/index.js";
+import { maskKey, setCredential } from "../config/store.js";
+import { getPaths } from "../config/paths.js";
+/**
+ * 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();
+    setCredential(providerId, model, trimmed);
+    const paths = getPaths();
+    return [
+        "Saved API key",
+        `  provider  ${providerLabel} (${providerId})`,
+        `  scope     all ${providerId} models (saved from ${model || "unknown"})`,
+        `  key       ${maskKey(trimmed)}`,
+        `  stored    ${paths.auth} (mode 0600)`,
+        "",
+        `Remove with /logout ${providerId}`,
+    ].join("\n");
+}
+export const loginCommand = {
+    name: "login",
+    description: "Bind a provider-wide API key. 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}).\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} · 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 a provider-wide API key (reused by every model of that provider).",
+        "",
+        `  current provider: ${state.providerId}`,
+        "",
+        "FastCode will ask for the provider, then optionally a model name, 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,45 @@
+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-wide):"];
+            for (const c of credentials)
+                lines.push(`  ${c.provider}   ${maskKey(c.key)}`);
+            lines.push("");
+            lines.push("Remove: /logout <provider>");
+            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 ok = removeCredential(provider.id);
+            return {
+                message: ok
+                    ? `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}.` };
+        removeCredential(provider.id);
+        return { message: `Removed the stored key for ${provider.label} (all models).` };
+    },
+};

package/dist/commands/model.d.ts

@@ -0,0 +1,24 @@
+export declare const modelCommand: {
+    name: string;
+    description: string;
+    run({ args, state, actions }: {
+        args: any;
+        state: any;
+        actions: any;
+    }): Promise<{
+        message: string;
+        picker?: undefined;
+    } | {
+        message: string;
+        picker: {
+            title: string;
+            current: any;
+            items: {
+                value: any;
+                label: any;
+                hint: string;
+            }[];
+            onSelect: (id: any) => void;
+        };
+    }>;
+};

package/dist/commands/model.js

@@ -0,0 +1,50 @@
+import { getProviderOrThrow, probeProvider } from "../providers/index.js";
+import { resolveProviderKey } from "../config/store.js";
+export const modelCommand = {
+    name: "model",
+    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 id = args.join(" ");
+            actions.setModel(id);
+            return { message: `Model set to ${id}.` };
+        }
+        const { key } = resolveProviderKey(provider.id, provider.authEnv);
+        const fetched = await provider.listModels(key).catch(() => []);
+        const models = dedupe(fetched);
+        if (models.length === 0) {
+            return { message: `No models available from ${provider.label}.` };
+        }
+        const online = await probeProvider(provider, key);
+        const list = models.slice(0, 50);
+        return {
+            message: `Models for ${provider.label}: ${list.length}${online ? "" : " (offline — showing the built-in list)"}.\n` +
+                "Use ↑/↓, a number, or Enter to select.",
+            picker: {
+                title: `Select model · ${provider.label}${online ? "" : " (offline)"}`,
+                current: state.model,
+                items: list.map((m) => ({
+                    value: m.id,
+                    label: m.id,
+                    hint: m.label ? `— ${m.label}` : undefined,
+                })),
+                onSelect: (id) => {
+                    actions.setModel(id);
+                    actions.pushSystemMessage(`Model set to ${id}.`);
+                },
+            },
+        };
+    },
+};
+function dedupe(models) {
+    const seen = new Set();
+    const out = [];
+    for (const model of models) {
+        if (!model?.id || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        out.push(model);
+    }
+    return out;
+}

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,24 @@
+export declare const providerCommand: {
+    name: string;
+    description: string;
+    run({ args, actions, state }: {
+        args: any;
+        actions: any;
+        state: any;
+    }): {
+        message: string;
+        picker: {
+            title: string;
+            current: any;
+            items: {
+                value: string;
+                label: string;
+                hint: string;
+            }[];
+            onSelect: (id: any) => void;
+        };
+    } | {
+        message: string;
+        picker?: undefined;
+    };
+};

package/dist/commands/provider.js

@@ -0,0 +1,39 @@
+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) {
+            return {
+                message: "Select a provider (↑/↓ or a number, Enter to confirm).",
+                picker: {
+                    title: "Select provider",
+                    current: state.providerId,
+                    items: PROVIDERS.map((p) => ({
+                        value: p.id,
+                        label: `${p.id.padEnd(12)} ${p.label}`,
+                        hint: p.authEnv.length === 0 ? "(no key needed)" : `[${p.authEnv.join(", ")}]`,
+                    })),
+                    onSelect: (id) => {
+                        const next = getProvider(id);
+                        if (!next)
+                            return;
+                        actions.setProvider(next.id);
+                        actions.setModel(next.defaultModel);
+                        actions.pushSystemMessage(`Provider set to ${next.label}. Default model: ${next.defaultModel}.`);
+                    },
+                },
+            };
+        }
+        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;
+    }>;
+};

package/dist/commands/skills.js

@@ -0,0 +1,106 @@
+import { installSkill, uninstallSkill, listInstalledSkills, searchRegistry, getSkill, } from "../skills/manager.js";
+export const skillsCommand = {
+    name: "skills",
+    description: "Manage Agent Skills (download from skills.sh and toggle).",
+    async run({ args, state, actions }) {
+        const sub = (args[0] ?? "list").toLowerCase();
+        const rest = args.slice(1);
+        if (sub === "list" || sub === "ls") {
+            const installed = listInstalledSkills();
+            if (installed.length === 0) {
+                return {
+                    message: "No skills installed. Try `/skills search <query>` or `/skills install <name>`.",
+                };
+            }
+            const lines = ["Installed skills:"];
+            for (const s of installed) {
+                const enabled = state.enabledSkills.includes(s.name) ? "● " : "  ";
+                lines.push(`${enabled}${s.name}  — ${truncate(s.description, 80)}`);
+                lines.push(`    source: ${s.source}`);
+            }
+            lines.push("");
+            lines.push("Toggle with `/skills enable <name>` or `/skills disable <name>`.");
+            return { message: lines.join("\n") };
+        }
+        if (sub === "search") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills search <query>" };
+            const hits = await searchRegistry(rest.join(" "), state.skillsRegistry);
+            if (hits.length === 0) {
+                return { message: `No skills found for "${rest.join(" ")}".` };
+            }
+            const lines = [`Skills matching "${rest.join(" ")}":`];
+            for (const h of hits.slice(0, 20)) {
+                lines.push(`  • ${h.slug}  — ${truncate(h.description ?? "", 80)}`);
+            }
+            lines.push("");
+            lines.push("Install with `/skills install <slug>`.");
+            return { message: lines.join("\n") };
+        }
+        if (sub === "install" || sub === "add") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills install <name|owner/repo|url>" };
+            const force = rest.includes("--force");
+            const spec = rest.filter((r) => r !== "--force").join(" ");
+            try {
+                const skill = await installSkill(spec, { registry: state.skillsRegistry, force });
+                return {
+                    message: `Installed skill "${skill.name}" → ${skill.path}\n${truncate(skill.description, 200)}\n\nEnable with /skills enable ${skill.name}`,
+                };
+            }
+            catch (err) {
+                return { message: `Install failed: ${err.message}` };
+            }
+        }
+        if (sub === "uninstall" || sub === "remove" || sub === "rm") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills uninstall <name>" };
+            const ok = uninstallSkill(rest[0]);
+            if (ok)
+                actions.disableSkill(rest[0]);
+            return { message: ok ? `Uninstalled "${rest[0]}".` : `No skill named "${rest[0]}".` };
+        }
+        if (sub === "enable" || sub === "use") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills enable <name>" };
+            const skill = getSkill(rest[0]);
+            if (!skill)
+                return { message: `Skill "${rest[0]}" is not installed.` };
+            actions.enableSkill(skill.name);
+            return { message: `Enabled skill "${skill.name}".` };
+        }
+        if (sub === "disable" || sub === "off") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills disable <name>" };
+            actions.disableSkill(rest[0]);
+            return { message: `Disabled skill "${rest[0]}".` };
+        }
+        if (sub === "info" || sub === "show") {
+            if (rest.length === 0)
+                return { message: "Usage: /skills info <name>" };
+            const skill = getSkill(rest[0]);
+            if (!skill)
+                return { message: `Skill "${rest[0]}" is not installed.` };
+            const head = `# ${skill.name}\n_${skill.description}_\n\nSource: ${skill.source}\n\n---\n\n`;
+            return { message: head + skill.body };
+        }
+        if (sub === "registry") {
+            if (rest.length === 0) {
+                return { message: `Skills registry: ${state.skillsRegistry}` };
+            }
+            // Mutate via AppActions so the in-memory React state stays in sync —
+            // direct saveConfig() would be silently overwritten by the next state
+            // change because app.tsx persists in-memory config on every update.
+            actions.setSkillsRegistry(rest[0]);
+            return { message: `Skills registry set to ${rest[0]}.` };
+        }
+        return {
+            message: "Unknown subcommand. Try: list, search, install, uninstall, enable, disable, info, registry.",
+        };
+    },
+};
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return s.slice(0, n - 1) + "…";
+}

package/dist/commands/steer.d.ts

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

package/dist/commands/steer.js

@@ -0,0 +1,13 @@
+export const steerCommand = {
+    name: "steer",
+    description: "Add guidance to the next request of an active run (/steer <text>)",
+    run({ args, state, actions }) {
+        const text = args.join(" ").trim();
+        if (!text)
+            return { message: "Usage: /steer <guidance>" };
+        if (!state.busy)
+            return { message: "No active run. Just send the guidance as the next message." };
+        actions.steer(text);
+        return { message: "Steering queued for the next request." };
+    },
+};

package/dist/commands/system.d.ts

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

package/dist/commands/system.js

@@ -0,0 +1,20 @@
+export const systemCommand = {
+    name: "system",
+    description: "Show or set the system prompt. Usage: /system [new prompt]",
+    run({ raw, state, actions }) {
+        // Strip the leading "/system" verb keeping the rest verbatim, including
+        // whitespace, so multi-paragraph prompts survive.
+        const stripped = raw.replace(/^\/system\s*/i, "");
+        if (!stripped.trim()) {
+            return {
+                message: [
+                    "Current system prompt:",
+                    "",
+                    state.systemPrompt,
+                ].join("\n"),
+            };
+        }
+        actions.setSystemPrompt(stripped);
+        return { message: "System prompt updated." };
+    },
+};

package/dist/commands/theme.d.ts

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

package/dist/commands/theme.js

@@ -0,0 +1,22 @@
+import { THEMES } from "../config/themes.js";
+export const themeCommand = {
+    name: "theme",
+    description: "List or switch the color theme. Usage: /theme [id]",
+    run({ args, state, actions }) {
+        if (args.length === 0) {
+            const lines = ["Themes:"];
+            for (const id of Object.keys(THEMES)) {
+                const marker = id === state.theme ? "● " : "  ";
+                lines.push(`${marker}${id}  — ${THEMES[id].label}`);
+            }
+            lines.push("");
+            lines.push("Switch with `/theme <id>`.");
+            return { message: lines.join("\n") };
+        }
+        const id = args[0];
+        if (!THEMES[id])
+            return { message: `Unknown theme "${id}".` };
+        actions.setTheme(id);
+        return { message: `Theme set to ${id}.` };
+    },
+};

package/dist/commands/tools.d.ts

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

package/dist/commands/tools.js

@@ -0,0 +1,29 @@
+export const toolsCommand = {
+    name: "tools",
+    description: "Show local coding-agent tools.",
+    run() {
+        return {
+            message: [
+                "FastCode agent tools:",
+                "",
+                "  shell             Run terminal commands in the sandbox root",
+                "  pwd               Print sandbox root",
+                "  read_file         Read one file",
+                "  read_many         Read multiple files",
+                "  write_file        Replace/create a file",
+                "  append_file       Append to a file",
+                "  apply_patch       Apply focused patch hunks",
+                "  replace_in_file   Replace exact text in a file",
+                "  list_files        List files recursively",
+                "  grep              Search files",
+                "  stat_path         Inspect file metadata",
+                "  make_dir          Create directories",
+                "  copy_file         Copy a file",
+                "  move_path         Move/rename a path",
+                "  delete_file       Delete a path",
+                "",
+                "Sandbox: file tools are rooted at the current working directory.",
+            ].join("\n"),
+        };
+    },
+};

package/dist/commands/whoami.d.ts

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