@datename/fastcode-termux 0.1.6 → 0.1.8-beta.0

package/src/agent/stream.ts

@@ -0,0 +1,143 @@
+/**
+ * Streaming request runner with an idle timeout and prefix-safe retry.
+ *
+ * `provider.stream()` only exposes the caller's AbortSignal, so a connection
+ * that stalls after the headers arrive can wait forever. This wrapper adds:
+ *   • an idle timer reset on every chunk (default 60s),
+ *   • retries routed through `retryStream`, which skips the already delivered
+ *     prefix instead of duplicating tokens,
+ *   • `incomplete` detection so the chat loop can tell "server closed early"
+ *     from a normal finish.
+ */
+import type { ChatChunk, ChatRequest, Provider } from "../types.js";
+import { IncompleteStreamError, retryStream } from "../lib/net.js";
+
+export interface RunStreamOptions {
+    signal?: AbortSignal;
+    idleTimeoutMs?: number;
+    maxRetries?: number;
+    onDelta?: (delta: string, text: string) => void;
+    onReset?: () => void;
+    clientRequestId?: string;
+    retryBackoffMs?: number[];
+}
+
+export interface RunStreamResult {
+    text: string;
+    usage?: ChatChunk["usage"];
+    toolCalls?: ChatChunk["toolCalls"];
+    incomplete: boolean;
+    retried: number;
+}
+
+export async function runStream(provider: Provider, req: ChatRequest, apiKey: string | undefined, options: RunStreamOptions = {}): Promise<RunStreamResult> {
+    const idleTimeoutMs = positive(options.idleTimeoutMs, 60_000);
+    const maxRetries = Math.max(0, Math.floor(options.maxRetries ?? 1));
+    let retried = 0;
+    let text = "";
+    let usage: ChatChunk["usage"];
+    let toolCalls: ChatChunk["toolCalls"];
+    let sawDone = false;
+    const send = async function* ({ clientRequestId }: { clientRequestId: string }) {
+        yield* attemptChunks(provider, { ...req, clientRequestId }, apiKey, {
+            signal: options.signal,
+            idleTimeoutMs,
+        });
+    };
+    try {
+        for await (const chunk of retryStream(send, {
+            clientRequestId: options.clientRequestId,
+            retries: maxRetries,
+            signal: options.signal,
+            backoffMs: options.retryBackoffMs,
+            onRetry: () => {
+                retried += 1;
+            },
+            onReset: options.onReset,
+        })) {
+            if (chunk.reset)
+                text = chunk.delta ?? "";
+            else if (chunk.delta)
+                text += chunk.delta;
+            if (chunk.delta)
+                options.onDelta?.(chunk.delta, text);
+            if (chunk.usage)
+                usage = chunk.usage;
+            if (chunk.toolCalls)
+                toolCalls = chunk.toolCalls;
+            if (chunk.done)
+                sawDone = true;
+        }
+    }
+    catch (err) {
+        if (err instanceof IncompleteStreamError) {
+            return { text: err.partialText || text, usage, toolCalls, incomplete: true, retried };
+        }
+        if (err && typeof err === "object" && !(err as { partialText?: string }).partialText && text)
+            (err as { partialText?: string }).partialText = text;
+        throw err;
+    }
+    return { text, usage, toolCalls, incomplete: !sawDone, retried };
+}
+
+interface AttemptOptions {
+    signal?: AbortSignal;
+    idleTimeoutMs: number;
+}
+
+async function* attemptChunks(provider: Provider, req: ChatRequest, apiKey: string | undefined, options: AttemptOptions): AsyncGenerator<ChatChunk> {
+    const parent = options.signal;
+    const child = new AbortController();
+    let timedOut = false;
+    const forwardAbort = () => child.abort();
+    if (parent) {
+        if (parent.aborted)
+            child.abort();
+        else
+            parent.addEventListener("abort", forwardAbort, { once: true });
+    }
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const resetIdle = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timedOut = true;
+            child.abort();
+        }, options.idleTimeoutMs);
+    };
+    resetIdle();
+    try {
+        for await (const chunk of provider.stream({ ...req, signal: child.signal }, apiKey)) {
+            resetIdle();
+            yield chunk;
+            if (chunk.done)
+                return;
+        }
+    }
+    catch (err) {
+        if (parent?.aborted)
+            throw abortError();
+        if (timedOut)
+            throw new Error(`stream idle timeout after ${options.idleTimeoutMs}ms (no data received)`);
+        throw toError(err);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        parent?.removeEventListener("abort", forwardAbort);
+    }
+}
+
+function abortError(): Error {
+    const error = new Error("Aborted");
+    error.name = "AbortError";
+    return error;
+}
+
+function toError(value: unknown): Error {
+    return value instanceof Error ? value : new Error(String(value));
+}
+
+function positive(value: number | undefined, fallback: number): number {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}

package/src/agent/tool-schemas.ts

@@ -0,0 +1,86 @@
+import type { ToolSchema } from "../types.js";
+
+const CWD_NOTE = "Paths are relative to the session working directory unless absolute.";
+
+export function toolSchemas(): ToolSchema[] {
+    return [
+        schema("shell", "Run a shell command. Long commands return a session id for polling. Killing a session kills its process group; setsid descendants may escape.", {
+            command: { type: "string" },
+            timeoutMs: { type: "number" },
+            session_id: { type: "string", description: "Poll an existing background session." },
+            waitMs: { type: "number", description: "Milliseconds to wait for new session output." },
+        }),
+        schema("pwd", "Print the current working directory.", {}),
+        schema("read_file", "Read a file. Use offset/limit (1-based lines) for a targeted range in large files.", {
+            path: { type: "string" },
+            offset: { type: "number", minimum: 1, description: "First line to return (1-based)." },
+            limit: { type: "number", minimum: 1, maximum: 2000, description: "Maximum lines to return (default 2000)." },
+        }, ["path"]),
+        schema("read_many", "Read several files under a shared byte budget.", {
+            paths: { type: "array", items: { type: "string" } },
+            maxBytes: { type: "number", minimum: 1, description: "Total output budget across all files." },
+        }, ["paths"]),
+        schema("write_file", "Replace a file with full contents.", {
+            path: { type: "string" },
+            content: { type: "string" },
+        }, ["path", "content"]),
+        schema("append_file", "Append text to a file.", {
+            path: { type: "string" },
+            content: { type: "string" },
+        }, ["path", "content"]),
+        schema("apply_patch", "Apply a multi-file patch (*** Begin Patch ... *** End Patch).", {
+            patch: { type: "string" },
+        }, ["patch"]),
+        schema("copy_file", CWD_NOTE, {
+            from: { type: "string" },
+            to: { type: "string" },
+            overwrite: { type: "boolean", description: "Replace an existing target explicitly (default false)." },
+        }, ["from", "to"]),
+        schema("delete_file", "Delete a file, or a directory with recursive:true.", {
+            path: { type: "string" },
+            recursive: { type: "boolean", description: "Required for directories (default false)." },
+        }, ["path"]),
+        schema("list_files", "List files under a directory.", {
+            path: { type: "string" },
+            maxDepth: { type: "number" },
+            detail: { type: "boolean" },
+        }),
+        schema("make_dir", "Create a directory.", { path: { type: "string" } }, ["path"]),
+        schema("move_path", "Move/rename a path; refuses an existing target.", {
+            from: { type: "string" },
+            to: { type: "string" },
+        }, ["from", "to"]),
+        schema("grep", "Search file contents with a regular expression.", {
+            pattern: { type: "string" },
+            path: { type: "string" },
+            maxDepth: { type: "number", minimum: 1, maximum: 20 },
+            caseSensitive: { type: "boolean", description: "Match case exactly (default false)." },
+            glob: { type: "string", description: "Only search files matching this glob, e.g. *.ts." },
+            context: { type: "number", minimum: 0, maximum: 10, description: "Context lines before/after each match." },
+            maxResults: { type: "number", minimum: 1, maximum: 5000, description: "Stop after this many matching lines." },
+        }, ["pattern"]),
+        schema("replace_in_file", "Replace exact text occurrences; expectedMatches makes the count explicit.", {
+            path: { type: "string" },
+            find: { type: "string" },
+            replace: { type: "string" },
+            expectedMatches: { type: "number", minimum: 1, description: "Fail without writing unless this exact count is found." },
+        }, ["path", "find", "replace"]),
+        schema("stat_path", "Show file metadata.", { path: { type: "string" } }, ["path"]),
+    ];
+}
+
+function schema(name: string, description: string, properties: Record<string, any>, required?: string[]): ToolSchema {
+    return {
+        type: "function",
+        function: {
+            name,
+            description,
+            parameters: {
+                type: "object",
+                properties,
+                ...(required && required.length > 0 ? { required } : {}),
+                additionalProperties: false,
+            },
+        },
+    };
+}

package/src/agent/tools/append_file.ts

@@ -0,0 +1,30 @@
+import { existsSync } from "node:fs";
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+
+export const appendFileTool: Tool = {
+    name: "append_file",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        try {
+            requiredString(call, "path");
+            requiredString(call, "content");
+        }
+        catch (err: any) {
+            return invalid(err.message);
+        }
+        return preparePath(ctx.cwd, requiredString(call, "path"));
+    },
+    async execute(call, ctx) {
+        const file = resolvePath(ctx.cwd, call);
+        const existed = existsSync(file);
+        await mkdir(dirname(file), { recursive: true });
+        await appendFile(file, requiredString(call, "content"), "utf8");
+        return { ok: true, output: `appended ${file}`, sideEffects: existed ? { touched: [file] } : { created: [file] } };
+    },
+};

package/src/agent/tools/apply_patch.ts

@@ -0,0 +1,95 @@
+import { parsePatch } from "../../patch/parse.js";
+import { planPatch, reviewPatchPlan } from "../../patch/plan.js";
+import { applyPatchPlan } from "../../patch/apply.js";
+import { DEFAULT_ALLOW_OPTIONS, approvalRequestId, type ApprovalOption, type ApprovalRequest } from "../approval.js";
+import { approvalKey, isPreApproved, rememberApproval } from "../approval-store.js";
+import type { Tool } from "./types.js";
+import { invalid, requiredString } from "./validate.js";
+
+/**
+ * Atomic multi-file patch.
+ *
+ * Applies Add / Delete / Update / Move only after every file plan succeeds.
+ * Symbolic links are refused, CRLF and mode bits are preserved, and per-file
+ * diffs are returned. xattr / ACL are NOT preserved and the inode changes
+ * (tmp+rename); restart file watchers if they miss the change.
+ */
+export const applyPatchTool: Tool = {
+    name: "apply_patch",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    approvalHints: { mayRequireApproval: true },
+    prepare(call) {
+        let patch: string;
+        try {
+            patch = requiredString(call, "patch");
+        }
+        catch (err: any) {
+            return invalid(err.message);
+        }
+        const parsed = parsePatch(patch);
+        return parsed.ok === false ? invalid(parsed.output) : { ok: true };
+    },
+    async execute(call, ctx) {
+        const patch = requiredString(call, "patch");
+        const planned = planPatch(patch, ctx.cwd);
+        if (planned.ok === false)
+            return { ok: false, output: planned.output };
+        const review = reviewPatchPlan(planned.plan);
+        if (review.kind === "deny")
+            return { ok: false, output: `patch denied: ${review.reason}` };
+        if (review.kind === "pending") {
+            const key = approvalKey("apply_patch", call, ctx.cwd);
+            const catalogHash = ctx.catalogHash ?? "";
+            if (!isPreApproved(key, catalogHash)) {
+                if (!ctx.requestApproval) {
+                    return {
+                        ok: false,
+                        output: `patch needs approval (${review.reason}), but no approval resolver is registered; nothing was written.`,
+                    };
+                }
+                const request = patchApprovalRequest(call, review, planned.plan);
+                let decision;
+                try {
+                    decision = await ctx.requestApproval(request);
+                }
+                catch (err: any) {
+                    return { ok: false, output: `patch approval failed (fail closed): ${err?.message ?? String(err)}` };
+                }
+                if (!decision || decision.kind !== "allow") {
+                    const reason = decision?.kind === "deny" ? decision.reason : decision?.kind === "feedback" ? decision.text : "no allow decision";
+                    return { ok: false, output: `patch denied: ${reason ?? "no reason"}; nothing was written.` };
+                }
+                rememberApproval(key, catalogHash, decision.scope);
+            }
+        }
+        const applied = applyPatchPlan(planned.plan);
+        const warnings = applied.warnings.length > 0 ? "\n\nwarnings:\n" + applied.warnings.map((line) => "- " + line).join("\n") : "";
+        return {
+            ok: applied.ok,
+            output: applied.output + warnings,
+            sideEffects: { touched: applied.touched, removed: applied.removed },
+        };
+    },
+};
+
+function patchApprovalRequest(call: any, review: { reason: string; changedLines: number }, plan: any): ApprovalRequest {
+    const options = DEFAULT_ALLOW_OPTIONS.map((option) => ({ ...option })) as ApprovalOption[];
+    const denyIndex = options.findIndex((option) => option.kind === "deny");
+    const files = Array.isArray(plan?.files) ? plan.files : [];
+    const diff = files.map((file: any) => `${file.relPath ?? file.path}: ${file.changedLines ?? "?"} line(s)`).join("\n");
+    return {
+        id: approvalRequestId(),
+        tool: "apply_patch",
+        args: call,
+        reason: review.reason.includes("sensitive") ? "sensitive_path" : "large_diff",
+        options,
+        preview: diff ? { kind: "diff", text: diff } : undefined,
+        tier: 2,
+        prompt: `Apply patch? ${review.reason}`,
+        source: "system",
+        defaultIndex: denyIndex >= 0 ? denyIndex : 0,
+        timeoutMs: 120_000,
+    };
+}

package/src/agent/tools/copy_file.ts

@@ -0,0 +1,56 @@
+import { copyFile, mkdir, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import { sandboxPath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { booleanOption, invalid, preparePath, requiredString } from "./validate.js";
+
+async function exists(path: string): Promise<boolean> {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+
+export const copyFileTool: Tool = {
+    name: "copy_file",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        try {
+            const from = requiredString(call, "from");
+            const to = requiredString(call, "to");
+            const checkedFrom = preparePath(ctx.cwd, from);
+            if (!checkedFrom.ok)
+                return checkedFrom;
+            return preparePath(ctx.cwd, to);
+        }
+        catch (err: any) {
+            return invalid(err.message);
+        }
+    },
+    async execute(call, ctx) {
+        const from = sandboxPath(ctx.cwd, requiredString(call, "from"));
+        const to = sandboxPath(ctx.cwd, requiredString(call, "to"));
+        const overwrite = booleanOption(call.overwrite);
+        const existed = await exists(to);
+        if (existed && !overwrite) {
+            return {
+                ok: false,
+                output: `copy target exists: ${to}`,
+                code: "EEXIST",
+                hint: "Pass overwrite:true to replace the target explicitly.",
+            };
+        }
+        await mkdir(dirname(to), { recursive: true });
+        await copyFile(from, to);
+        return {
+            ok: true,
+            output: `copied ${from} to ${to}`,
+            sideEffects: existed ? { touched: [to] } : { created: [to] },
+        };
+    },
+};

package/src/agent/tools/delete_file.ts

@@ -0,0 +1,45 @@
+import { lstat, rm } from "node:fs/promises";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { booleanOption, invalid, preparePath, requiredString } from "./validate.js";
+
+export const deleteFileTool: Tool = {
+    name: "delete_file",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    approvalHints: { mayRequireApproval: true },
+    prepare(call, ctx) {
+        let path: string;
+        try {
+            path = requiredString(call, "path");
+        }
+        catch (err: any) {
+            return invalid(err.message);
+        }
+        return preparePath(ctx.cwd, path);
+    },
+    async execute(call, ctx) {
+        const file = resolvePath(ctx.cwd, call);
+        const recursive = booleanOption(call.recursive);
+        let info;
+        try {
+            info = await lstat(file);
+        }
+        catch (err: any) {
+            if (err?.code === "ENOENT")
+                return { ok: false, output: `path does not exist: ${file}`, code: "ENOENT", hint: "Check the path before deleting." };
+            throw err;
+        }
+        if (info.isDirectory() && !recursive) {
+            return {
+                ok: false,
+                output: `refusing to delete a directory without recursive:true: ${file}`,
+                code: "EISDIR",
+                hint: "Pass recursive:true to delete a directory tree.",
+            };
+        }
+        await rm(file, { recursive, force: false });
+        return { ok: true, output: `deleted ${file}`, sideEffects: { removed: [file] } };
+    },
+};

package/src/agent/tools/grep.ts

@@ -0,0 +1,57 @@
+import { grepFiles } from "./readers.js";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { booleanOption, clampInt, invalid, optionalNumber, preparePath, requiredString } from "./validate.js";
+
+const MAX_PATTERN_LENGTH = 1000;
+
+export const grepTool: Tool = {
+    name: "grep",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        let pattern: string;
+        try {
+            pattern = requiredString(call, "pattern");
+            if (pattern.length > MAX_PATTERN_LENGTH)
+                return invalid(`pattern is too long (max ${MAX_PATTERN_LENGTH} characters)`);
+            const flags = booleanOption(call.caseSensitive) ? "" : "i";
+            new RegExp(pattern, flags);
+            const context = optionalNumber(call, "context");
+            const maxResults = optionalNumber(call, "maxResults");
+            const maxDepth = optionalNumber(call, "maxDepth");
+            if (context !== undefined && (context < 0 || context > 10))
+                return invalid("context must be between 0 and 10");
+            if (maxResults !== undefined && (maxResults < 1 || maxResults > 5000))
+                return invalid("maxResults must be between 1 and 5000");
+            if (maxDepth !== undefined && (maxDepth < 1 || maxDepth > 20))
+                return invalid("maxDepth must be between 1 and 20");
+            if (call.glob !== undefined && typeof call.glob !== "string")
+                return invalid("glob must be a string");
+        }
+        catch (err: any) {
+            return invalid(`invalid regular expression: ${err?.message ?? String(err)}`, "INVALID_ARGS", "pattern must be a valid regular expression");
+        }
+        return preparePath(ctx.cwd, typeof call.path === "string" ? call.path : ".");
+    },
+    async execute(call, ctx) {
+        const pattern = requiredString(call, "pattern");
+        const result = await grepFiles(ctx.cwd, resolvePath(ctx.cwd, call, "."), {
+            pattern,
+            flags: booleanOption(call.caseSensitive) ? "" : "i",
+            glob: typeof call.glob === "string" ? call.glob : undefined,
+            context: clampInt(optionalNumber(call, "context"), 0, 0, 10),
+            maxResults: clampInt(optionalNumber(call, "maxResults"), 200, 1, 5000),
+            maxDepth: clampInt(optionalNumber(call, "maxDepth"), 4, 1, 20),
+            signal: ctx.signal,
+        });
+        return {
+            ok: true,
+            output: result.text,
+            truncated: result.truncated,
+            returnedLines: result.matchCount,
+            matches: result.matchCount,
+            hint: result.truncated ? "grep results were truncated by maxResults or the output cap." : undefined,
+        };
+    },
+};

package/src/agent/tools/index.ts

@@ -0,0 +1,34 @@
+import type { Tool } from "./types.js";
+import { shellTool } from "./shell.js";
+import { pwdTool } from "./pwd.js";
+import { readFileTool } from "./read_file.js";
+import { readManyTool } from "./read_many.js";
+import { writeFileTool } from "./write_file.js";
+import { appendFileTool } from "./append_file.js";
+import { applyPatchTool } from "./apply_patch.js";
+import { copyFileTool } from "./copy_file.js";
+import { deleteFileTool } from "./delete_file.js";
+import { listFilesTool } from "./list_files.js";
+import { makeDirTool } from "./make_dir.js";
+import { movePathTool } from "./move_path.js";
+import { grepTool } from "./grep.js";
+import { replaceInFileTool } from "./replace_in_file.js";
+import { statPathTool } from "./stat_path.js";
+
+export const TOOLS: Tool[] = [
+    shellTool,
+    pwdTool,
+    readFileTool,
+    readManyTool,
+    writeFileTool,
+    appendFileTool,
+    applyPatchTool,
+    copyFileTool,
+    deleteFileTool,
+    listFilesTool,
+    makeDirTool,
+    movePathTool,
+    grepTool,
+    replaceInFileTool,
+    statPathTool,
+];

package/src/agent/tools/list_files.ts

@@ -0,0 +1,19 @@
+import { listFiles } from "./readers.js";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { numberOption, preparePath } from "./validate.js";
+
+export const listFilesTool: Tool = {
+    name: "list_files",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        return preparePath(ctx.cwd, typeof call.path === "string" ? call.path : ".");
+    },
+    async execute(call, ctx) {
+        return {
+            ok: true,
+            output: await listFiles(ctx.cwd, resolvePath(ctx.cwd, call, "."), numberOption(call.maxDepth, 2), call.detail === true),
+        };
+    },
+};

package/src/agent/tools/make_dir.ts

@@ -0,0 +1,28 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+
+export const makeDirTool: Tool = {
+    name: "make_dir",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        let path: string;
+        try {
+            path = requiredString(call, "path");
+        }
+        catch (err: any) {
+            return invalid(err.message);
+        }
+        return preparePath(ctx.cwd, path);
+    },
+    async execute(call, ctx) {
+        const dir = resolvePath(ctx.cwd, call);
+        const existed = existsSync(dir);
+        await mkdir(dir, { recursive: true });
+        return { ok: true, output: `created ${dir}`, sideEffects: existed ? undefined : { created: [dir] } };
+    },
+};