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

package/dist/lib/model-meta.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const UNKNOWN_MODEL_META = {
+    contextWindow: 32_768,
+    supportsTools: false,
+    charsPerToken: 2.5,
+};
+const PROVIDER_META = {
+    anthropic: { contextWindow: 1_000_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 64_000 },
+    openai: { contextWindow: 400_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 32_000 },
+    google: { contextWindow: 1_048_576, supportsTools: true, charsPerToken: 3.6, maxOutputTokens: 65_536 },
+    deepseek: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
+    openrouter: { contextWindow: 128_000, supportsTools: true, charsPerToken: 2.5, maxOutputTokens: 16_384 },
+    groq: { contextWindow: 128_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 8_192 },
+    mistral: { contextWindow: 128_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 8_192 },
+    xai: { contextWindow: 256_000, supportsTools: true, charsPerToken: 3.8, maxOutputTokens: 16_384 },
+    moonshot: { contextWindow: 256_000, supportsTools: true, charsPerToken: 2.0, maxOutputTokens: 16_384 },
+    zhipu: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
+    qwen: { contextWindow: 128_000, supportsTools: true, charsPerToken: 1.7, maxOutputTokens: 8_192 },
+    ollama: { contextWindow: 32_768, supportsTools: true, charsPerToken: 2.5, maxOutputTokens: 4_096 },
+    custom: { contextWindow: 32_768, supportsTools: false, charsPerToken: 2.5 },
+};
+const MODEL_OVERRIDES = {
+    "claude-haiku-5.5": { contextWindow: 200_000 },
+    "claude-haiku-4.5": { contextWindow: 200_000 },
+    "claude-sonnet-5": { contextWindow: 1_000_000 },
+    "claude-opus-5": { contextWindow: 1_000_000 },
+    "claude-sonnet-4.6": { contextWindow: 1_000_000 },
+    "claude-opus-4.6": { contextWindow: 1_000_000 },
+    "gpt-4o": { contextWindow: 128_000 },
+    "gpt-4o-mini": { contextWindow: 128_000 },
+    "gpt-4.1": { contextWindow: 1_000_000 },
+    o3: { contextWindow: 200_000 },
+    "o4-mini": { contextWindow: 200_000 },
+    "gemini-3.5-flash-lite": { contextWindow: 1_048_576 },
+    "gemini-3.1-flash-lite": { contextWindow: 1_048_576 },
+    "deepseek-v4-pro": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "deepseek-flash": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "glm-5.3": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "glm-5.2": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "qwen3.8-max": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "qwen3.8-flash": { contextWindow: 128_000, charsPerToken: 1.7 },
+    "kimi-k3": { contextWindow: 256_000, charsPerToken: 2.0 },
+    "grok-4.7": { contextWindow: 256_000, charsPerToken: 3.8 },
+    "mistral-large-latest": { contextWindow: 128_000, charsPerToken: 3.8 },
+};
+let overrideCache;
+export function modelMetaOverridePath() {
+    const root = process.env["FASTCODE_HOME"] ?? join(homedir(), ".fastcode");
+    return join(root, "model-meta.json");
+}
+export function clearModelMetaCache() {
+    overrideCache = undefined;
+}
+function loadOverrides() {
+    if (overrideCache)
+        return overrideCache;
+    const file = modelMetaOverridePath();
+    if (!existsSync(file)) {
+        overrideCache = {};
+        return overrideCache;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(file, "utf8"));
+        overrideCache = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    }
+    catch {
+        overrideCache = {};
+    }
+    return overrideCache;
+}
+function usable(meta) {
+    return Boolean(meta) && typeof meta === "object";
+}
+function apply(base, ...layers) {
+    const next = { ...base };
+    for (const layer of layers) {
+        if (!usable(layer))
+            continue;
+        if (typeof layer.contextWindow === "number" && layer.contextWindow > 0)
+            next.contextWindow = Math.floor(layer.contextWindow);
+        if (typeof layer.charsPerToken === "number" && layer.charsPerToken > 0)
+            next.charsPerToken = layer.charsPerToken;
+        if (typeof layer.supportsTools === "boolean")
+            next.supportsTools = layer.supportsTools;
+        if (typeof layer.maxOutputTokens === "number" && layer.maxOutputTokens > 0)
+            next.maxOutputTokens = Math.floor(layer.maxOutputTokens);
+    }
+    return next;
+}
+export function getModelMeta(providerId, model) {
+    const provider = providerId && PROVIDER_META[providerId] ? PROVIDER_META[providerId] : UNKNOWN_MODEL_META;
+    const overrides = loadOverrides();
+    const keys = [
+        providerId && model ? `${providerId}/${model}` : undefined,
+        providerId && model ? `${providerId}::${model}` : undefined,
+        model,
+    ].filter((key) => Boolean(key));
+    const layers = keys.map((key) => overrides[key]);
+    return apply(provider, model ? MODEL_OVERRIDES[model] : undefined, ...layers);
+}
+export function estTokens(text, options = {}) {
+    if (!text)
+        return 0;
+    const ratio = typeof options === "number"
+        ? options
+        : options.charsPerToken ?? getModelMeta(options.providerId, options.model).charsPerToken;
+    return Math.ceil(text.length / Math.max(0.1, ratio));
+}
+export function estMessagesTokens(messages, options = {}) {
+    return messages.reduce((sum, message) => sum + estTokens(message.content ?? "", options), 0);
+}

package/dist/lib/native-tools.d.ts

@@ -0,0 +1,12 @@
+import type { NativeToolCall } from "../types.js";
+export type ToolCallAccumulator = Map<number, NativeToolCall>;
+export interface ToolCallDelta {
+    index?: number;
+    id?: string;
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export declare function mergeToolCallDelta(accumulator: ToolCallAccumulator, delta: ToolCallDelta): void;
+export declare function finalizeToolCalls(accumulator: ToolCallAccumulator): NativeToolCall[];

package/dist/lib/native-tools.js

@@ -0,0 +1,21 @@
+export function mergeToolCallDelta(accumulator, delta) {
+    const index = typeof delta.index === "number" && Number.isFinite(delta.index) ? delta.index : accumulator.size;
+    const entry = accumulator.get(index) ?? { id: "", name: "", arguments: "" };
+    if (typeof delta.id === "string" && delta.id)
+        entry.id = delta.id;
+    if (typeof delta.function?.name === "string" && delta.function.name)
+        entry.name = delta.function.name;
+    if (typeof delta.function?.arguments === "string")
+        entry.arguments += delta.function.arguments;
+    accumulator.set(index, entry);
+}
+export function finalizeToolCalls(accumulator) {
+    return Array.from(accumulator.entries())
+        .sort((a, b) => a[0] - b[0])
+        .filter(([, call]) => Boolean(call.name))
+        .map(([index, call]) => ({
+        id: call.id || `call_${index}`,
+        name: call.name,
+        arguments: call.arguments || "{}",
+    }));
+}

package/dist/lib/net.d.ts

@@ -0,0 +1,33 @@
+import type { ChatChunk } from "../types.js";
+export declare class QuotaError extends Error {
+    readonly code = "QUOTA";
+    constructor(message: string);
+}
+export declare class IncompleteStreamError extends Error {
+    readonly partialText: string;
+    constructor(message: string, partialText: string);
+}
+export interface RetryRequestOptions {
+    retries?: number;
+    backoffMs?: number[];
+    retryOn?: (error: Error) => boolean;
+    signal?: AbortSignal;
+}
+export interface RetryStreamOptions {
+    clientRequestId?: string;
+    lastAcc?: string;
+    retries?: number;
+    backoffMs?: number[];
+    retryOn?: (error: Error) => boolean;
+    signal?: AbortSignal;
+    onRetry?: (error: Error, attempt: number) => void;
+    onReset?: () => void;
+}
+export interface StreamChunk extends ChatChunk {
+    reset?: boolean;
+}
+export declare function isRetryableError(error: Error): boolean;
+export declare function retryRequest<T>(fn: (attempt: number) => Promise<T>, options?: RetryRequestOptions): Promise<T>;
+export declare function retryStream(send: (options: {
+    clientRequestId: string;
+}) => AsyncGenerator<ChatChunk>, options?: RetryStreamOptions): AsyncGenerator<StreamChunk>;

package/dist/lib/net.js

@@ -0,0 +1,168 @@
+import { randomUUID } from "node:crypto";
+export class QuotaError extends Error {
+    code = "QUOTA";
+    constructor(message) {
+        super(message);
+        this.name = "QuotaError";
+    }
+}
+export class IncompleteStreamError extends Error {
+    partialText;
+    constructor(message, partialText) {
+        super(message);
+        this.name = "IncompleteStreamError";
+        this.partialText = partialText;
+    }
+}
+const DEFAULT_BACKOFF = [1000, 2000, 4000];
+const STREAM_BACKOFF = [400, 800, 1600];
+export function isRetryableError(error) {
+    const message = String(error?.message ?? error);
+    if (/\b(401|402|403|404)\b/.test(message))
+        return false;
+    if (/timeout|timed? ?out|ECONNRESET|ECONNREFUSED|ENOTFOUND|ETIMEDOUT|EPIPE|fetch failed|network|socket hang up|terminated|other side closed|stream ended before done/i.test(message))
+        return true;
+    return /\b(429|5\d\d)\b/.test(message);
+}
+function isQuotaError(error) {
+    return /\b429\b|quota|insufficient|rate limit|billing|balance/i.test(String(error?.message ?? error));
+}
+export async function retryRequest(fn, options = {}) {
+    const attempts = Math.max(1, Math.floor(options.retries ?? 3));
+    const backoff = options.backoffMs ?? DEFAULT_BACKOFF;
+    const retryOn = options.retryOn ?? isRetryableError;
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        if (options.signal?.aborted)
+            throw abortError();
+        try {
+            return await fn(attempt);
+        }
+        catch (err) {
+            lastError = toError(err);
+            if (attempt >= attempts - 1 || !retryOn(lastError))
+                break;
+            await delay(backoff[Math.min(attempt, backoff.length - 1)], options.signal);
+        }
+    }
+    if (lastError && isQuotaError(lastError))
+        throw new QuotaError(lastError.message);
+    throw lastError ?? new Error("retryRequest failed");
+}
+export async function* retryStream(send, options = {}) {
+    const clientRequestId = options.clientRequestId ?? randomUUID();
+    const attempts = Math.max(1, Math.floor(options.retries ?? 1) + 1);
+    const backoff = options.backoffMs ?? STREAM_BACKOFF;
+    const retryOn = options.retryOn ?? isRetryableError;
+    let delivered = options.lastAcc ?? "";
+    let lastError;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        if (options.signal?.aborted)
+            throw abortError();
+        let buffering = delivered.length > 0;
+        let pending = "";
+        let doneSeen = false;
+        let usage;
+        let toolCalls;
+        try {
+            for await (const chunk of send({ clientRequestId })) {
+                if (options.signal?.aborted)
+                    throw abortError();
+                if (chunk.usage)
+                    usage = chunk.usage;
+                if (chunk.toolCalls)
+                    toolCalls = chunk.toolCalls;
+                const delta = chunk.delta ?? "";
+                if (!delta) {
+                    if (!buffering && !chunk.done)
+                        yield chunk;
+                    if (chunk.done)
+                        doneSeen = true;
+                    continue;
+                }
+                if (buffering) {
+                    pending += delta;
+                    const matchedPrefix = delivered.startsWith(pending) || pending.startsWith(delivered);
+                    if (delivered.startsWith(pending)) {
+                        if (pending.length === delivered.length) {
+                            buffering = false;
+                            pending = "";
+                        }
+                        if (chunk.done)
+                            doneSeen = true;
+                        continue;
+                    }
+                    if (matchedPrefix) {
+                        const extra = pending.slice(delivered.length);
+                        buffering = false;
+                        pending = "";
+                        if (extra) {
+                            delivered += extra;
+                            yield { ...chunk, delta: extra, done: false };
+                        }
+                    }
+                    else {
+                        buffering = false;
+                        delivered = pending;
+                        pending = "";
+                        options.onReset?.();
+                        yield { ...chunk, delta: delivered, reset: true, done: false };
+                    }
+                    if (chunk.done)
+                        doneSeen = true;
+                    continue;
+                }
+                delivered += delta;
+                yield { ...chunk, done: false };
+                if (chunk.done)
+                    doneSeen = true;
+            }
+            if (!doneSeen)
+                throw new IncompleteStreamError("stream ended before done", delivered);
+            yield {
+                delta: "",
+                done: true,
+                ...(usage ? { usage } : {}),
+                ...(toolCalls ? { toolCalls } : {}),
+            };
+            return;
+        }
+        catch (err) {
+            lastError = toError(err);
+            if (options.signal?.aborted)
+                throw abortError();
+            if (attempt >= attempts - 1 || !retryOn(lastError)) {
+                lastError.partialText = delivered;
+                throw lastError;
+            }
+            options.onRetry?.(lastError, attempt + 1);
+            await delay(backoff[Math.min(attempt, backoff.length - 1)], options.signal);
+        }
+    }
+    throw lastError ?? new Error("retryStream failed");
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(abortError());
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function abortError() {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}

package/dist/lib/pkg.d.ts

@@ -0,0 +1,5 @@
+export interface PackageMeta {
+    name: string;
+    version: string;
+}
+export declare function readPackageMeta(): PackageMeta;

package/dist/lib/pkg.js

@@ -0,0 +1,27 @@
+/**
+ * Read this package's package.json (name + version) from any layout.
+ *
+ * The same source runs three ways, so `import.meta.url` points at different
+ * depths; try every plausible relative path and fall back gracefully.
+ *
+ *   - tsx / dev:    src/lib/pkg.ts        -> ../../package.json
+ *   - tsc output:   dist/lib/pkg.js       -> ../../package.json
+ *   - esbuild bundle: dist/cli.js         -> ../package.json
+ */
+import { readFileSync } from "node:fs";
+const FALLBACK = { name: "@datename/fastcode-termux", version: "0.0.0" };
+const CANDIDATES = ["../package.json", "../../package.json", "../../../package.json"];
+export function readPackageMeta() {
+    for (const rel of CANDIDATES) {
+        try {
+            const meta = JSON.parse(readFileSync(new URL(rel, import.meta.url), "utf8"));
+            if (meta && typeof meta.version === "string") {
+                return { name: meta.name ?? FALLBACK.name, version: meta.version };
+            }
+        }
+        catch {
+            /* try the next candidate */
+        }
+    }
+    return FALLBACK;
+}

package/dist/lib/platform.d.ts

@@ -0,0 +1,7 @@
+export declare function detectPlatform(): "darwin" | "linux" | "win32" | "termux" | "other";
+export declare const isTermux: () => boolean;
+export declare const isWindows: () => boolean;
+export declare const isMac: () => boolean;
+/** Human-readable label for the status bar. */
+export declare function platformLabel(): NodeJS.Platform | "Termux" | "Linux" | "macOS" | "Windows";
+export declare function safeHome(): string;

package/dist/lib/platform.js

@@ -0,0 +1,57 @@
+/**
+ * Cross-platform detection and small helpers.
+ *
+ * FastCode targets Termux, Linux, macOS, and Windows. Most of our
+ * environment-aware behavior keys off these flags rather than scattering
+ * `process.platform === "..."` checks across the codebase.
+ */
+import { platform, homedir } from "node:os";
+export function detectPlatform() {
+    // Termux exposes PREFIX=/data/data/com.termux/files/usr. The extra check
+    // makes us robust to users who manually export PREFIX for other reasons.
+    const prefix = process.env["PREFIX"];
+    // Termux exports TERMUX_VERSION; PREFIX=/data/data/com.termux/files/usr is a
+    // strong secondary signal. Neither requires the directory to exist yet.
+    if (process.platform === "android" ||
+        Boolean(process.env["TERMUX_VERSION"]) ||
+        (prefix && prefix.includes("com.termux"))) {
+        return "termux";
+    }
+    switch (process.platform) {
+        case "linux":
+        case "darwin":
+        case "win32":
+            return process.platform;
+        default:
+            return "other";
+    }
+}
+export const isTermux = () => detectPlatform() === "termux";
+export const isWindows = () => process.platform === "win32";
+export const isMac = () => process.platform === "darwin";
+/** Human-readable label for the status bar. */
+export function platformLabel() {
+    const p = detectPlatform();
+    switch (p) {
+        case "termux":
+            return "Termux";
+        case "linux":
+            return "Linux";
+        case "darwin":
+            return "macOS";
+        case "win32":
+            return "Windows";
+        default:
+            return platform();
+    }
+}
+export function safeHome() {
+    // os.homedir() can return undefined on weird CI containers; fall back
+    // to $HOME / %USERPROFILE% / cwd in that order.
+    const fromOs = homedir();
+    if (fromOs)
+        return fromOs;
+    return (process.env["HOME"] ??
+        process.env["USERPROFILE"] ??
+        process.cwd());
+}

package/dist/lib/startup.d.ts

@@ -0,0 +1,6 @@
+export declare function createStartupTranscript(config: any): {
+    id: number;
+    role: string;
+    content: string;
+    markdown: boolean;
+}[];

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/patch/apply.d.ts

@@ -0,0 +1,15 @@
+import type { PatchPlan, PlannedFile } from "./plan.js";
+export interface AppliedFile {
+    path: string;
+    kind: PlannedFile["kind"];
+    diff: string;
+}
+export interface ApplyResult {
+    ok: boolean;
+    output: string;
+    files: AppliedFile[];
+    touched: string[];
+    removed: string[];
+    warnings: string[];
+}
+export declare function applyPatchPlan(plan: PatchPlan): ApplyResult;