@datename/fastcode-termux 0.0.0-stage → 0.1.6

package/dist/lib/startup.js

@@ -0,0 +1,25 @@
+import { resolveApiKey } from "../config/store.js";
+import { getProviderOrThrow } from "../providers/index.js";
+export function createStartupTranscript(config) {
+    const messages = [
+        `Welcome to FastCode. Provider: **${config.providerId}** · model: **${config.model}**.\n\nType **/help** to list slash commands, or just start chatting.`,
+    ];
+    const provider = getProviderOrThrow(config.providerId);
+    if (provider.authEnv.length > 0) {
+        const lookup = resolveApiKey(provider.id, config.model, provider.authEnv);
+        if (lookup.status === "unbound") {
+            messages.push(`Stored ${provider.label} key isn't bound to a model, so it won't be used. ` +
+                `Re-bind it with \`/login ${provider.id} ${config.model} <key>\` (or \`/logout ${provider.id}\` to discard it).`);
+        }
+        else if (lookup.status === "missing") {
+            messages.push(`No API key for ${provider.label} · ${config.model}. ` +
+                `Run \`/login ${provider.id} ${config.model} <key>\`, or set ${provider.authEnv[0]} (provider-wide, any model).`);
+        }
+    }
+    return messages.map((content, index) => ({
+        id: index + 1,
+        role: "system",
+        content,
+        markdown: true,
+    }));
+}

package/dist/lib/uiMode.d.ts

@@ -0,0 +1,2 @@
+export declare function shouldUseStableTerminalUi(platform?: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function shouldUseLiveStreamingUi(platform?: string, env?: NodeJS.ProcessEnv): boolean;

package/dist/lib/uiMode.js

@@ -0,0 +1,7 @@
+import { detectPlatform } from "./platform.js";
+export function shouldUseStableTerminalUi(platform = detectPlatform(), env = process.env) {
+    return platform === "termux" || env.FASTCODE_STABLE_UI === "1";
+}
+export function shouldUseLiveStreamingUi(platform = detectPlatform(), env = process.env) {
+    return !shouldUseStableTerminalUi(platform, env);
+}

package/dist/plugins/manager.d.ts

@@ -0,0 +1,23 @@
+export declare function listInstalledPlugins(): {
+    name: any;
+    description: any;
+    path: any;
+    body: string;
+    skills: any[];
+}[];
+export declare function getPlugin(name: any): {
+    name: any;
+    description: any;
+    path: any;
+    body: string;
+    skills: any[];
+};
+export declare function importPlugin(source: any, name: any): {
+    name: any;
+    description: any;
+    path: any;
+    body: string;
+    skills: any[];
+};
+export declare function removePlugin(name: any): boolean;
+export declare function buildPluginsPrompt(enabled: any): string;

package/dist/plugins/manager.js

@@ -0,0 +1,101 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { getPaths } from "../config/paths.js";
+export function listInstalledPlugins() {
+    const { plugins } = getPaths();
+    if (!existsSync(plugins))
+        return [];
+    return readdirSync(plugins, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => loadPlugin(join(plugins, entry.name), entry.name))
+        .filter((plugin) => plugin !== undefined)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getPlugin(name) {
+    return listInstalledPlugins().find((p) => p.name === name || basename(p.path) === name);
+}
+export function importPlugin(source, name) {
+    const { plugins } = getPaths();
+    const src = resolve(source);
+    if (!existsSync(src))
+        throw new Error(`Plugin source does not exist: ${source}`);
+    if (!statSync(src).isDirectory())
+        throw new Error("Plugin source must be a directory");
+    const folder = slugify(name ?? basename(src));
+    const target = join(plugins, folder);
+    if (existsSync(target))
+        rmSync(target, { recursive: true, force: true });
+    mkdirSync(target, { recursive: true });
+    cpSync(src, target, { recursive: true });
+    writeFileSync(join(target, ".fastcode-source"), src);
+    const loaded = loadPlugin(target, folder);
+    if (!loaded)
+        throw new Error("Plugin must include PLUGIN.md, README.md, or at least one SKILL.md");
+    return loaded;
+}
+export function removePlugin(name) {
+    const plugin = getPlugin(name);
+    if (!plugin)
+        return false;
+    rmSync(plugin.path, { recursive: true, force: true });
+    return true;
+}
+export function buildPluginsPrompt(enabled) {
+    if (enabled.length === 0)
+        return "";
+    const plugins = enabled.map(getPlugin).filter((p) => p !== undefined);
+    if (plugins.length === 0)
+        return "";
+    const chunks = plugins.map((plugin) => {
+        const skills = plugin.skills
+            .map((skill) => `<plugin-skill name="${skill.name}">\n${skill.body.trim()}\n</plugin-skill>`)
+            .join("\n\n");
+        return `<plugin name="${plugin.name}">\n${plugin.body.trim()}\n${skills ? `\n\n${skills}` : ""}\n</plugin>`;
+    });
+    return [
+        "",
+        "## Active plugins",
+        "The following plugins are always-active behavior packs. Follow them when relevant:",
+        "",
+        chunks.join("\n\n"),
+    ].join("\n");
+}
+function loadPlugin(path, fallbackName) {
+    const pluginMd = firstExisting([join(path, "PLUGIN.md"), join(path, "README.md")]);
+    const skillsDir = join(path, "skills");
+    const rootSkill = join(path, "SKILL.md");
+    const skills = [];
+    if (existsSync(rootSkill))
+        skills.push({ name: "root", body: readFileSync(rootSkill, "utf8") });
+    if (existsSync(skillsDir)) {
+        for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillPath = join(skillsDir, entry.name, "SKILL.md");
+            if (existsSync(skillPath))
+                skills.push({ name: entry.name, body: readFileSync(skillPath, "utf8") });
+        }
+    }
+    if (!pluginMd && skills.length === 0)
+        return undefined;
+    const body = pluginMd ? readFileSync(pluginMd, "utf8") : `Plugin ${fallbackName}`;
+    return {
+        name: fallbackName,
+        description: firstParagraph(body) || `${fallbackName} plugin`,
+        path,
+        body,
+        skills,
+    };
+}
+function firstExisting(paths) {
+    return paths.find((path) => existsSync(path));
+}
+function firstParagraph(markdown) {
+    return markdown
+        .split(/\n\s*\n/)
+        .map((part) => part.replace(/^#+\s*/, "").trim())
+        .find(Boolean);
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "plugin";
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,21 @@
+export declare const anthropicProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+};

package/dist/providers/anthropic.js

@@ -0,0 +1,107 @@
+import { streamSSE } from "../lib/http.js";
+const STATIC_MODELS = [
+    { id: "claude-sonnet-5.5", label: "Claude Sonnet 5.5", contextWindow: 1000000, pricing: { inputUsdPerM: 3, outputUsdPerM: 15 } },
+    { id: "claude-opus-5.5", label: "Claude Opus 5.5", contextWindow: 1000000, pricing: { inputUsdPerM: 15, outputUsdPerM: 75 } },
+    { id: "claude-haiku-5.5", label: "Claude Haiku 5.5", contextWindow: 200000, pricing: { inputUsdPerM: 0.8, outputUsdPerM: 4 } },
+    { id: "claude-sonnet-5", label: "Claude Sonnet 5" },
+    { id: "claude-opus-5", label: "Claude Opus 5" },
+    { id: "claude-sonnet-4.6", label: "Claude Sonnet 4.6" },
+    { id: "claude-opus-4.6", label: "Claude Opus 4.6" },
+    { id: "claude-haiku-4.5", label: "Claude Haiku 4.5" },
+];
+const BASE = "https://api.anthropic.com/v1";
+export const anthropicProvider = {
+    id: "anthropic",
+    label: "Anthropic (Claude)",
+    authEnv: ["ANTHROPIC_API_KEY", "CLAUDE_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "claude-sonnet-5.5",
+    async listModels(apiKey) {
+        // Query the live model list; fall back to the built-in list offline.
+        if (apiKey) {
+            try {
+                const res = await fetch(BASE + "/models", {
+                    headers: { "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
+                });
+                if (res.ok) {
+                    const json = await res.json();
+                    const ids = (json.data ?? [])
+                        .map((m) => m.id)
+                        .filter((id) => typeof id === "string" && id.length > 0);
+                    if (ids.length > 0) {
+                        const known = new Map(STATIC_MODELS.map((m) => [m.id, m]));
+                        return ids.map((id) => known.get(id) ?? { id });
+                    }
+                }
+            }
+            catch {
+                // network/auth issue → fall through to the static list
+            }
+        }
+        return STATIC_MODELS;
+    },
+    async *stream(req, apiKey) {
+        if (!apiKey) {
+            throw new Error("Missing ANTHROPIC_API_KEY. Bind one with /login anthropic <model> <key>, or set the env var.");
+        }
+        const messages = req.messages.map((m) => ({ role: m.role, content: m.content }));
+        const body = {
+            model: req.model,
+            messages,
+            ...(req.system ? { system: req.system } : {}),
+            stream: true,
+            max_tokens: req.maxOutputTokens ?? 4096,
+            ...(req.temperature !== undefined ? { temperature: req.temperature } : {}),
+        };
+        const res = await fetch(BASE + "/messages", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+                accept: "text/event-stream",
+            },
+            body: JSON.stringify(body),
+            signal: req.signal,
+        });
+        let usageInput = 0;
+        let usageOutput = 0;
+        for await (const ev of streamSSE(res)) {
+            let data;
+            try {
+                data = JSON.parse(ev.data);
+            }
+            catch {
+                continue;
+            }
+            const t = data.type;
+            if (t === "content_block_delta") {
+                const delta = data.delta?.text;
+                if (delta)
+                    yield { delta, done: false };
+            }
+            else if (t === "message_start") {
+                const u = data.message?.usage;
+                if (u?.input_tokens)
+                    usageInput = u.input_tokens;
+            }
+            else if (t === "message_delta") {
+                const u = data.usage;
+                if (u?.output_tokens)
+                    usageOutput = u.output_tokens;
+            }
+            else if (t === "message_stop") {
+                break;
+            }
+        }
+        const cost = priceFor(req.model, usageInput, usageOutput);
+        yield { delta: "", done: true, usage: { inputTokens: usageInput, outputTokens: usageOutput, costUsd: cost } };
+    },
+};
+function priceFor(modelId, input, output) {
+    const m = STATIC_MODELS.find((x) => x.id === modelId);
+    const p = m?.pricing;
+    if (!p?.inputUsdPerM || !p.outputUsdPerM)
+        return undefined;
+    return (input / 1000000) * p.inputUsdPerM + (output / 1000000) * p.outputUsdPerM;
+}

package/dist/providers/custom.d.ts

@@ -0,0 +1,24 @@
+export declare const customProvider: {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};

package/dist/providers/custom.js

@@ -0,0 +1,25 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+function baseUrl() {
+    return (process.env["FASTCODE_BASE_URL"] ?? "").trim().replace(/[/]+$/, "");
+}
+function defaultModel() {
+    return (process.env["FASTCODE_MODEL"] ?? "").trim() || "gpt-4o-mini";
+}
+function requireBaseUrl() {
+    const base = baseUrl();
+    if (!base) {
+        throw new Error("FASTCODE_BASE_URL is not set. Example: export FASTCODE_BASE_URL=https://api.example.com/v1");
+    }
+    return base;
+}
+export const customProvider = {
+    id: "custom",
+    label: "Custom (OpenAI-compatible)",
+    authEnv: [],
+    get baseUrl() {
+        return baseUrl();
+    },
+    defaultModel: defaultModel(),
+    listModels: () => listModelsHttp({ baseUrl: requireBaseUrl(), apiKey: process.env["FASTCODE_API_KEY"], staticModels: [] }),
+    stream: (req) => streamChatCompletion(req, { baseUrl: requireBaseUrl(), apiKey: process.env["FASTCODE_API_KEY"], staticModels: [] }),
+};

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,24 @@
+export declare const deepseekProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};

package/dist/providers/deepseek.js

@@ -0,0 +1,15 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.deepseek.com/v1";
+const STATIC = [
+    { id: "deepseek-v4-pro", label: "DeepSeek V4 Pro" },
+    { id: "deepseek-flash", label: "DeepSeek Flash" },
+];
+export const deepseekProvider = {
+    id: "deepseek",
+    label: "DeepSeek",
+    authEnv: ["DEEPSEEK_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "deepseek-v4-pro",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/dist/providers/google.d.ts

@@ -0,0 +1,24 @@
+export declare const googleProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};

package/dist/providers/google.js

@@ -0,0 +1,19 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://generativelanguage.googleapis.com/v1beta/openai";
+const STATIC = [
+    { id: "gemini-3.8-flash", label: "Gemini 3.8 Flash" },
+    { id: "gemini-3.7-flash", label: "Gemini 3.7 Flash" },
+    { id: "gemini-3.5-flash", label: "Gemini 3.5 Flash" },
+    { id: "gemini-3.5-flash-lite", label: "Gemini 3.5 Flash Lite" },
+    { id: "gemini-3.1-flash-lite", label: "Gemini 3.1 Flash Lite" },
+    { id: "gemini-4-argon", label: "Gemini 4 Argon" },
+];
+export const googleProvider = {
+    id: "google",
+    label: "Google Gemini",
+    authEnv: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "gemini-3.8-flash",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/dist/providers/groq.d.ts

@@ -0,0 +1,24 @@
+export declare const groqProvider: {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};

package/dist/providers/groq.js

@@ -0,0 +1,20 @@
+import { listModelsHttp, streamChatCompletion } from "./openaiCompatible.js";
+const BASE = "https://api.groq.com/openai/v1";
+const STATIC = [
+    { id: "llama-3.3-70b-versatile", label: "Llama 3.3 70B" },
+    { id: "meta-llama/llama-4-maverick-17b-128e-instruct", label: "Llama 4 Maverick" },
+    { id: "meta-llama/llama-4-scout-17b-16e-instruct", label: "Llama 4 Scout" },
+    { id: "moonshotai/kimi-k2-instruct", label: "Kimi K2" },
+    { id: "openai/gpt-oss-120b", label: "GPT-OSS 120B" },
+    { id: "qwen/qwen3-32b", label: "Qwen3 32B" },
+    { id: "llama-3.1-8b-instant", label: "Llama 3.1 8B instant" },
+];
+export const groqProvider = {
+    id: "groq",
+    label: "Groq",
+    authEnv: ["GROQ_API_KEY"],
+    baseUrl: BASE,
+    defaultModel: "llama-3.3-70b-versatile",
+    listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
+    stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC }),
+};

package/dist/providers/index.d.ts

@@ -0,0 +1,201 @@
+export declare const PROVIDERS: ({
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: string[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+})[];
+export declare function getProvider(id: any): {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: string[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};
+export declare function getProviderOrThrow(id: any): {
+    id: string;
+    label: string;
+    authEnv: string[];
+    baseUrl: string;
+    defaultModel: string;
+    listModels(apiKey: any): Promise<any>;
+    stream(req: any, apiKey: any): AsyncGenerator<{
+        delta: any;
+        done: boolean;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            costUsd: number;
+        };
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: string[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: (apiKey: any) => Promise<any>;
+    stream: (req: any, apiKey: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+} | {
+    id: string;
+    label: string;
+    authEnv: any[];
+    readonly baseUrl: string;
+    defaultModel: string;
+    listModels: () => Promise<any>;
+    stream: (req: any) => AsyncGenerator<{
+        delta: string;
+        done: boolean;
+        reasoning?: undefined;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        reasoning: string;
+        usage?: undefined;
+    } | {
+        delta: string;
+        done: boolean;
+        usage: any;
+        reasoning?: undefined;
+    }, void, unknown>;
+};