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

package/src/agent/tool-schemas.ts

@@ -4,15 +4,22 @@ const CWD_NOTE = "Paths are relative to the session working directory unless abs
 
 export function toolSchemas(): ToolSchema[] {
     return [
-        schema("shell", "Run a shell command. Long commands return a session id for polling.", {
+        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", CWD_NOTE, { path: { type: "string" } }, ["path"]),
-        schema("read_many", CWD_NOTE, { paths: { type: "array", items: { type: "string" } } }, ["paths"]),
+        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" },
@@ -24,8 +31,15 @@ export function toolSchemas(): ToolSchema[] {
         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" } }, ["from", "to"]),
-        schema("delete_file", "Delete a file or directory.", { path: { type: "string" } }, ["path"]),
+        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" },
@@ -39,12 +53,17 @@ export function toolSchemas(): ToolSchema[] {
         schema("grep", "Search file contents with a regular expression.", {
             pattern: { type: "string" },
             path: { type: "string" },
-            maxDepth: { type: "number" },
+            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 an exact text occurrence.", {
+        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"]),
     ];

package/src/agent/tools/append_file.ts

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { appendFile, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import { resolvePath } from "./paths.js";
@@ -21,8 +22,9 @@ export const appendFileTool: Tool = {
     },
     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: { touched: [file] } };
+        return { ok: true, output: `appended ${file}`, sideEffects: existed ? { touched: [file] } : { created: [file] } };
     },
 };

package/src/agent/tools/apply_patch.ts

@@ -1,6 +1,8 @@
 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";
 
@@ -38,10 +40,29 @@ export const applyPatchTool: Tool = {
         if (review.kind === "deny")
             return { ok: false, output: `patch denied: ${review.reason}` };
         if (review.kind === "pending") {
-            return {
-                ok: false,
-                output: `patch needs approval (${review.reason}), but no approval resolver is registered; nothing was written.`,
-            };
+            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") : "";
@@ -52,3 +73,23 @@ export const applyPatchTool: Tool = {
         };
     },
 };
+
+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

@@ -1,8 +1,18 @@
-import { copyFile, mkdir } from "node:fs/promises";
+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 { invalid, preparePath, requiredString } from "./validate.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",
@@ -25,8 +35,22 @@ export const copyFileTool: Tool = {
     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: { touched: [to] } };
+        return {
+            ok: true,
+            output: `copied ${from} to ${to}`,
+            sideEffects: existed ? { touched: [to] } : { created: [to] },
+        };
     },
 };

package/src/agent/tools/delete_file.ts

@@ -1,13 +1,14 @@
-import { rm } from "node:fs/promises";
+import { lstat, rm } from "node:fs/promises";
 import { resolvePath } from "./paths.js";
 import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.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 {
@@ -20,7 +21,25 @@ export const deleteFileTool: Tool = {
     },
     async execute(call, ctx) {
         const file = resolvePath(ctx.cwd, call);
-        await rm(file, { recursive: true, force: true });
+        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

@@ -1,25 +1,57 @@
 import { grepFiles } from "./readers.js";
 import { resolvePath } from "./paths.js";
 import type { Tool } from "./types.js";
-import { invalid, numberOption, preparePath, requiredString } from "./validate.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 {
-            requiredString(call, "pattern");
+            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(err.message);
+            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: await grepFiles(ctx.cwd, resolvePath(ctx.cwd, call, "."), requiredString(call, "pattern"), numberOption(call.maxDepth, 4)),
+            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/make_dir.ts

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { resolvePath } from "./paths.js";
 import type { Tool } from "./types.js";
@@ -20,7 +21,8 @@ export const makeDirTool: Tool = {
     },
     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: { created: [dir] } };
+        return { ok: true, output: `created ${dir}`, sideEffects: existed ? undefined : { created: [dir] } };
     },
 };

package/src/agent/tools/move_path.ts

@@ -1,4 +1,4 @@
-import { mkdir, rename } from "node:fs/promises";
+import { cp, mkdir, rename, rm } from "node:fs/promises";
 import { lstatSync } from "node:fs";
 import { dirname } from "node:path";
 import { sandboxPath } from "./paths.js";
@@ -15,6 +15,33 @@ function exists(path: string): boolean {
     }
 }
 
+export interface MoveOps {
+    rename: typeof rename;
+    cp: typeof cp;
+    rm: typeof rm;
+}
+
+export async function moveWithFallback(from: string, to: string, ops: MoveOps = { rename, cp, rm }): Promise<"rename" | "copy"> {
+    try {
+        await ops.rename(from, to);
+        return "rename";
+    }
+    catch (err: any) {
+        if (err?.code !== "EXDEV")
+            throw err;
+        await ops.cp(from, to, { recursive: true, force: false, errorOnExist: true });
+        try {
+            await ops.rm(from, { recursive: true, force: false });
+        }
+        catch (cleanup: any) {
+            throw Object.assign(new Error(`copied ${from} to ${to}, but could not remove the source: ${cleanup?.message ?? String(cleanup)}`), {
+                code: "UNKNOWN",
+            });
+        }
+        return "copy";
+    }
+}
+
 export const movePathTool: Tool = {
     name: "move_path",
     requiresTrust: true,
@@ -31,7 +58,7 @@ export const movePathTool: Tool = {
             if (!checkedTo.ok)
                 return checkedTo;
             if (exists(to))
-                return invalid(`move target exists: ${to}`);
+                return invalid(`move target exists: ${to}`, "EEXIST", "Choose a target that does not exist.");
             return { ok: true };
         }
         catch (err: any) {
@@ -42,9 +69,15 @@ export const movePathTool: Tool = {
         const from = sandboxPath(ctx.cwd, requiredString(call, "from"));
         const to = sandboxPath(ctx.cwd, requiredString(call, "to"));
         if (exists(to))
-            return { ok: false, output: `move target exists: ${to}` };
+            return { ok: false, output: `move target exists: ${to}`, code: "EEXIST", hint: "Choose a target that does not exist." };
         await mkdir(dirname(to), { recursive: true });
-        await rename(from, to);
-        return { ok: true, output: `moved ${from} to ${to}`, sideEffects: { removed: [from], touched: [to] } };
+        const method = await moveWithFallback(from, to);
+        return {
+            ok: true,
+            output: method === "copy"
+                ? `moved ${from} to ${to} (cross-device copy + remove)`
+                : `moved ${from} to ${to}`,
+            sideEffects: { removed: [from], touched: [to] },
+        };
     },
 };

package/src/agent/tools/read_file.ts

@@ -1,7 +1,9 @@
-import { readTextFile } from "./readers.js";
+import { readFileRange, readTextFileResult } from "./readers.js";
 import { resolvePath } from "./paths.js";
 import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
+import { clampInt, invalid, optionalNumber, preparePath, requiredString } from "./validate.js";
+
+const MAX_READ_LINES = 2000;
 
 export const readFileTool: Tool = {
     name: "read_file",
@@ -11,6 +13,12 @@ export const readFileTool: Tool = {
         let path: string;
         try {
             path = requiredString(call, "path");
+            const offset = optionalNumber(call, "offset");
+            const limit = optionalNumber(call, "limit");
+            if (offset !== undefined && offset < 1)
+                return invalid("offset must be >= 1");
+            if (limit !== undefined && limit < 1)
+                return invalid("limit must be >= 1");
         }
         catch (err: any) {
             return invalid(err.message);
@@ -18,6 +26,59 @@ export const readFileTool: Tool = {
         return preparePath(ctx.cwd, path);
     },
     async execute(call, ctx) {
-        return { ok: true, output: await readTextFile(resolvePath(ctx.cwd, call)) };
+        const file = resolvePath(ctx.cwd, call);
+        const offset = optionalNumber(call, "offset");
+        const limit = optionalNumber(call, "limit");
+        if (offset === undefined && limit === undefined) {
+            const result = await readTextFileResult(file);
+            const output = result.truncated
+                ? `${result.text}\n[... truncated at ${result.returnedBytes} of ${result.totalBytes} bytes; use offset/limit, grep, or a narrower file ...]`
+                : result.text;
+            return {
+                ok: true,
+                output,
+                truncated: result.truncated,
+                totalLines: result.totalLines,
+                returnedLines: result.returnedLines,
+                totalBytes: result.totalBytes,
+                returnedBytes: result.returnedBytes,
+            };
+        }
+        const start = clampInt(offset, 1, 1, 1_000_000);
+        const count = clampInt(limit, MAX_READ_LINES, 1, MAX_READ_LINES);
+        const result = await readFileRange(file, start, count, { signal: ctx.signal });
+        if (result.binary) {
+            return {
+                ok: true,
+                output: result.text,
+                truncated: false,
+                totalLines: 0,
+                returnedLines: 0,
+                totalBytes: result.totalBytes,
+                returnedBytes: 0,
+            };
+        }
+        if (result.returnedLines === 0 && start > result.totalLines) {
+            return {
+                ok: false,
+                output: `offset ${start} is beyond the end of ${file} (${result.totalLines} lines)`,
+                code: "NOT_FOUND",
+                hint: "Use a smaller offset or read without offset.",
+                totalLines: result.totalLines,
+                returnedLines: 0,
+            };
+        }
+        const end = start + result.returnedLines - 1;
+        const header = `[lines ${start}-${end} of ${result.totalLines}${result.scannedAll ? "" : "+"}]\n`;
+        return {
+            ok: true,
+            output: header + result.text,
+            truncated: result.truncated,
+            hint: result.scannedAll ? undefined : "totalLines is a lower bound; the file scan hit FASTCODE_READ_SCAN_MAX_BYTES.",
+            totalLines: result.totalLines,
+            returnedLines: result.returnedLines,
+            totalBytes: result.totalBytes,
+            returnedBytes: result.returnedBytes,
+        };
     },
 };

package/src/agent/tools/read_many.ts

@@ -1,6 +1,6 @@
-import { readMany } from "./readers.js";
+import { readManyResult } from "./readers.js";
 import type { Tool } from "./types.js";
-import { invalid, preparePath, stringArray } from "./validate.js";
+import { invalid, optionalNumber, preparePath, stringArray } from "./validate.js";
 
 export const readManyTool: Tool = {
     name: "read_many",
@@ -10,6 +10,11 @@ export const readManyTool: Tool = {
         let paths: string[];
         try {
             paths = stringArray(call, "paths");
+            if (paths.length === 0)
+                return invalid("paths must contain at least one path");
+            const maxBytes = optionalNumber(call, "maxBytes");
+            if (maxBytes !== undefined && maxBytes < 1)
+                return invalid("maxBytes must be >= 1");
         }
         catch (err: any) {
             return invalid(err.message);
@@ -22,6 +27,19 @@ export const readManyTool: Tool = {
         return { ok: true };
     },
     async execute(call, ctx) {
-        return { ok: true, output: await readMany(ctx.cwd, stringArray(call, "paths")) };
+        const paths = stringArray(call, "paths");
+        const requested = optionalNumber(call, "maxBytes");
+        const maxBytes = requested === undefined ? undefined : Math.max(1, Math.floor(requested));
+        const result = await readManyResult(ctx.cwd, paths, maxBytes);
+        return {
+            ok: true,
+            output: result.text,
+            truncated: result.truncated,
+            totalBytes: result.totalBytes,
+            returnedBytes: result.returnedBytes,
+            filesRead: result.filesRead,
+            filesSkipped: result.filesSkipped,
+            hint: result.filesSkipped > 0 ? `${result.filesSkipped} file(s) skipped by the read_many byte budget.` : undefined,
+        };
     },
 };