@datename/fastcode-termux 0.1.6 → 0.1.8-beta.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/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;

package/dist/patch/apply.js

@@ -0,0 +1,172 @@
+import { closeSync, constants as fsConstants, fchmodSync, lstatSync, mkdirSync, openSync, renameSync, rmSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+export function applyPatchPlan(plan) {
+    const warnings = [...plan.warnings];
+    const applied = [];
+    const touched = [];
+    const removed = [];
+    const temps = [];
+    try {
+        for (const file of plan.files) {
+            commit(file, warnings, temps);
+            applied.push(file);
+            if (file.kind === "delete") {
+                removed.push(file.path);
+            }
+            else if (file.kind === "add") {
+                touched.push(file.path);
+            }
+            else if (file.moveTo) {
+                removed.push(file.path);
+                touched.push(file.moveTo);
+            }
+            else {
+                touched.push(file.path);
+            }
+        }
+    }
+    catch (err) {
+        for (const tmp of temps) {
+            try {
+                rmSync(tmp, { force: true });
+            }
+            catch {
+                // best effort
+            }
+        }
+        rollback(applied, warnings);
+        return {
+            ok: false,
+            output: `patch failed: ${err?.message ?? String(err)}; rolled back ${applied.length} file(s)`,
+            files: [],
+            touched: [],
+            removed: [],
+            warnings,
+        };
+    }
+    const files = plan.files.map((file) => ({
+        path: file.moveTo ?? file.path,
+        kind: file.kind,
+        diff: file.diff,
+    }));
+    return {
+        ok: true,
+        output: [`applied ${plan.files.length} file(s)`, ...files.map((file) => file.diff)].join("\n\n"),
+        files,
+        touched,
+        removed,
+        warnings,
+    };
+}
+function commit(file, warnings, temps) {
+    if (file.kind === "delete") {
+        rejectSymlink(file.path);
+        unlinkSync(file.path);
+        return;
+    }
+    const target = file.moveTo ?? file.path;
+    if (file.kind === "add" || file.moveTo) {
+        if (lexists(target))
+            throw new Error(`target already exists: ${target}`);
+    }
+    rejectSymlink(target, true);
+    mkdirSync(dirname(target), { recursive: true });
+    const tmp = `${target}.fastcode-patch-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tmp`;
+    temps.push(tmp);
+    const flags = fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(tmp, flags, 0o600);
+    try {
+        writeSync(fd, file.newContent ?? "");
+        try {
+            fchmodSync(fd, file.origMode & 0o777);
+        }
+        catch {
+            warnings.push(`could not restore mode ${(file.origMode & 0o777).toString(8)} on ${target}; check permissions`);
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    rejectSymlink(target, true);
+    renameSync(tmp, target);
+    const index = temps.indexOf(tmp);
+    if (index >= 0)
+        temps.splice(index, 1);
+    if (file.moveTo) {
+        try {
+            unlinkSync(file.path);
+        }
+        catch (err) {
+            try {
+                rmSync(target, { force: true });
+            }
+            catch {
+                // best effort
+            }
+            throw err;
+        }
+    }
+}
+function rejectSymlink(path, allowMissing = false) {
+    try {
+        if (lstatSync(path).isSymbolicLink())
+            throw new Error(`refusing to write through a symbolic link: ${path}`);
+    }
+    catch (err) {
+        if (err?.code === "ENOENT" && allowMissing)
+            return;
+        throw err;
+    }
+}
+function lexists(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function rollback(applied, warnings) {
+    for (let i = applied.length - 1; i >= 0; i -= 1) {
+        const file = applied[i];
+        try {
+            if (file.kind === "add") {
+                rmSync(file.path, { force: true });
+                continue;
+            }
+            if (file.kind === "delete") {
+                restore(file.path, file.oldContent ?? "", file.origMode);
+                continue;
+            }
+            if (file.moveTo) {
+                rmSync(file.moveTo, { force: true });
+                restore(file.path, file.oldContent ?? "", file.origMode);
+                continue;
+            }
+            restore(file.path, file.oldContent ?? "", file.origMode);
+        }
+        catch (err) {
+            warnings.push(`rollback failed for ${file.path}: ${err?.message ?? String(err)}`);
+        }
+    }
+}
+function restore(path, content, mode) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.fastcode-restore-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tmp`;
+    const flags = fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | (fsConstants.O_NOFOLLOW ?? 0);
+    const fd = openSync(tmp, flags, 0o600);
+    try {
+        writeSync(fd, content);
+        try {
+            fchmodSync(fd, mode & 0o777);
+        }
+        catch {
+            // best effort during rollback
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, path);
+}

package/dist/patch/parse.d.ts

@@ -0,0 +1,29 @@
+export type PatchLineType = " " | "-" | "+";
+export interface PatchLine {
+    type: PatchLineType;
+    text: string;
+}
+export interface PatchHunk {
+    lines: PatchLine[];
+}
+export type PatchOp = {
+    kind: "add";
+    path: string;
+    lines: string[];
+} | {
+    kind: "delete";
+    path: string;
+} | {
+    kind: "update";
+    path: string;
+    hunks: PatchHunk[];
+    moveTo?: string;
+};
+export type ParseResult = {
+    ok: true;
+    ops: PatchOp[];
+} | {
+    ok: false;
+    output: string;
+};
+export declare function parsePatch(patch: string): ParseResult;

package/dist/patch/parse.js

@@ -0,0 +1,112 @@
+export function parsePatch(patch) {
+    const lines = String(patch ?? "").split(/\r?\n/);
+    if (lines[0] !== "*** Begin Patch")
+        return fail("patch must start with *** Begin Patch");
+    const ops = [];
+    const seen = new Set();
+    const claim = (path) => {
+        if (!path)
+            return "empty file path in patch";
+        if (seen.has(path))
+            return `duplicate file in patch: ${path}`;
+        seen.add(path);
+        return undefined;
+    };
+    let i = 1;
+    let foundEnd = false;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === "*** End Patch") {
+            foundEnd = true;
+            i += 1;
+            break;
+        }
+        if (line === "" || line === undefined) {
+            i += 1;
+            continue;
+        }
+        if (line.startsWith("*** Add File: ")) {
+            const path = line.slice("*** Add File: ".length).trim();
+            const duplicate = claim(path);
+            if (duplicate)
+                return fail(duplicate);
+            i += 1;
+            const content = [];
+            while (i < lines.length && !lines[i].startsWith("*** ")) {
+                const row = lines[i];
+                if (row === "") {
+                    content.push("");
+                    i += 1;
+                    continue;
+                }
+                if (!row.startsWith("+"))
+                    return fail(`Add File body must start with '+': ${row}`);
+                content.push(row.slice(1));
+                i += 1;
+            }
+            ops.push({ kind: "add", path, lines: content });
+            continue;
+        }
+        if (line.startsWith("*** Delete File: ")) {
+            const path = line.slice("*** Delete File: ".length).trim();
+            const duplicate = claim(path);
+            if (duplicate)
+                return fail(duplicate);
+            ops.push({ kind: "delete", path });
+            i += 1;
+            continue;
+        }
+        if (line.startsWith("*** Update File: ")) {
+            const path = line.slice("*** Update File: ".length).trim();
+            const duplicate = claim(path);
+            if (duplicate)
+                return fail(duplicate);
+            i += 1;
+            let moveTo;
+            if (i < lines.length && lines[i].startsWith("*** Move to: ")) {
+                moveTo = lines[i].slice("*** Move to: ".length).trim();
+                const movedDuplicate = claim(moveTo);
+                if (movedDuplicate)
+                    return fail(movedDuplicate);
+                i += 1;
+            }
+            const hunks = [];
+            let current;
+            while (i < lines.length && !lines[i].startsWith("*** ")) {
+                const row = lines[i];
+                if (row === "") {
+                    i += 1;
+                    continue;
+                }
+                if (row.startsWith("@@")) {
+                    current = { lines: [] };
+                    hunks.push(current);
+                    i += 1;
+                    continue;
+                }
+                const type = row[0];
+                if (type !== " " && type !== "-" && type !== "+")
+                    return fail(`invalid hunk line (must start with ' ', '-', or '+'): ${row}`);
+                if (!current) {
+                    current = { lines: [] };
+                    hunks.push(current);
+                }
+                current.lines.push({ type: type, text: row.slice(1) });
+                i += 1;
+            }
+            if (hunks.length === 0 && !moveTo)
+                return fail(`Update File has no hunks: ${path}`);
+            ops.push({ kind: "update", path, hunks, moveTo });
+            continue;
+        }
+        return fail(`unsupported patch directive: ${line}`);
+    }
+    if (!foundEnd)
+        return fail("patch must end with *** End Patch");
+    if (ops.length === 0)
+        return fail("patch contains no file operations");
+    return { ok: true, ops };
+}
+function fail(output) {
+    return { ok: false, output };
+}

package/dist/patch/plan.d.ts

@@ -0,0 +1,49 @@
+import { type PatchHunk } from "./parse.js";
+export interface PlannedFile {
+    kind: "add" | "delete" | "update";
+    relPath: string;
+    path: string;
+    moveRel?: string;
+    moveTo?: string;
+    existed: boolean;
+    origMode: number;
+    eol: "\n" | "\r\n";
+    oldContent?: string;
+    newContent?: string;
+    diff: string;
+    changedLines: number;
+}
+export interface PatchPlan {
+    files: PlannedFile[];
+    warnings: string[];
+}
+export type PlanResult = {
+    ok: true;
+    plan: PatchPlan;
+} | {
+    ok: false;
+    output: string;
+};
+export type PatchReview = {
+    kind: "allow";
+} | {
+    kind: "deny";
+    reason: string;
+} | {
+    kind: "pending";
+    reason: string;
+    changedLines: number;
+};
+export declare function planPatch(patch: string, cwd: string): PlanResult;
+export declare function reviewPatchPlan(plan: PatchPlan): PatchReview;
+export declare function detectEol(content: string): "\n" | "\r\n";
+type ApplyHunksResult = {
+    ok: true;
+    content: string;
+} | {
+    ok: false;
+    output: string;
+};
+export declare function applyHunks(oldContent: string, hunks: PatchHunk[]): ApplyHunksResult;
+export declare function makeDiff(oldPath: string | null, newPath: string | null, oldContent: string, newContent: string, kind: "add" | "delete" | "update"): string;
+export {};