@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/src/agent/tools/apply_patch.ts

@@ -1,54 +0,0 @@
-import { parsePatch } from "../../patch/parse.js";
-import { planPatch, reviewPatchPlan } from "../../patch/plan.js";
-import { applyPatchPlan } from "../../patch/apply.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") {
-            return {
-                ok: false,
-                output: `patch needs approval (${review.reason}), but no approval resolver is registered; nothing was written.`,
-            };
-        }
-        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 },
-        };
-    },
-};

package/src/agent/tools/copy_file.ts

@@ -1,32 +0,0 @@
-import { copyFile, mkdir } 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";
-
-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"));
-        await mkdir(dirname(to), { recursive: true });
-        await copyFile(from, to);
-        return { ok: true, output: `copied ${from} to ${to}`, sideEffects: { touched: [to] } };
-    },
-};

package/src/agent/tools/delete_file.ts

@@ -1,26 +0,0 @@
-import { rm } from "node:fs/promises";
-import { resolvePath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
-
-export const deleteFileTool: Tool = {
-    name: "delete_file",
-    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 file = resolvePath(ctx.cwd, call);
-        await rm(file, { recursive: true, force: true });
-        return { ok: true, output: `deleted ${file}`, sideEffects: { removed: [file] } };
-    },
-};

package/src/agent/tools/grep.ts

@@ -1,25 +0,0 @@
-import { grepFiles } from "./readers.js";
-import { resolvePath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, numberOption, preparePath, requiredString } from "./validate.js";
-
-export const grepTool: Tool = {
-    name: "grep",
-    stateScope: "call",
-    revalidate: ["sandboxRoots"],
-    prepare(call, ctx) {
-        try {
-            requiredString(call, "pattern");
-        }
-        catch (err: any) {
-            return invalid(err.message);
-        }
-        return preparePath(ctx.cwd, typeof call.path === "string" ? call.path : ".");
-    },
-    async execute(call, ctx) {
-        return {
-            ok: true,
-            output: await grepFiles(ctx.cwd, resolvePath(ctx.cwd, call, "."), requiredString(call, "pattern"), numberOption(call.maxDepth, 4)),
-        };
-    },
-};

package/src/agent/tools/index.ts

@@ -1,34 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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);
-        await mkdir(dir, { recursive: true });
-        return { ok: true, output: `created ${dir}`, sideEffects: { created: [dir] } };
-    },
-};

package/src/agent/tools/move_path.ts

@@ -1,50 +0,0 @@
-import { mkdir, rename } from "node:fs/promises";
-import { lstatSync } from "node:fs";
-import { dirname } from "node:path";
-import { sandboxPath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
-
-function exists(path: string): boolean {
-    try {
-        lstatSync(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-
-export const movePathTool: Tool = {
-    name: "move_path",
-    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;
-            const checkedTo = preparePath(ctx.cwd, to);
-            if (!checkedTo.ok)
-                return checkedTo;
-            if (exists(to))
-                return invalid(`move target exists: ${to}`);
-            return { ok: true };
-        }
-        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"));
-        if (exists(to))
-            return { ok: false, output: `move target exists: ${to}` };
-        await mkdir(dirname(to), { recursive: true });
-        await rename(from, to);
-        return { ok: true, output: `moved ${from} to ${to}`, sideEffects: { removed: [from], touched: [to] } };
-    },
-};

package/src/agent/tools/paths.ts

@@ -1,92 +0,0 @@
-import { existsSync, realpathSync } from "node:fs";
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { detectPlatform, safeHome } from "../../lib/platform.js";
-import { loadConfig } from "../../config/store.js";
-import type { ToolCall } from "./types.js";
-
-export function allowedRoots(cwd: string): string[] {
-    const roots = [resolve(cwd)];
-    const configured = (process.env["FASTCODE_ALLOW_PATHS"] ?? "")
-        .split(delimiter)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    for (const entry of configured)
-        roots.push(resolve(entry));
-    const sharedDirs = loadConfig().sharedDirs;
-    if (Array.isArray(sharedDirs)) {
-        for (const entry of sharedDirs) {
-            if (typeof entry !== "string" || !entry.trim())
-                continue;
-            roots.push(resolveSharedDir(cwd, entry.trim()));
-        }
-    }
-    if (detectPlatform() === "termux" && !isDisabled(process.env["FASTCODE_ALLOW_SHARED_STORAGE"])) {
-        const home = process.env["HOME"];
-        if (home) {
-            const shared = join(home, "storage", "shared");
-            if (existsSync(shared))
-                roots.push(shared);
-        }
-    }
-    return roots;
-}
-
-export function resolveSharedDir(cwd: string, entry: string): string {
-    const expanded = entry === "~" || entry.startsWith("~/") || entry.startsWith("~\\")
-        ? join(safeHome(), entry.slice(1))
-        : entry;
-    return isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
-}
-
-function isDisabled(value: string | undefined): boolean {
-    if (value === undefined)
-        return false;
-    return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
-}
-
-export function isInsideAny(child: string, roots: string[]): boolean {
-    return roots.some((root) => {
-        const rel = relative(root, child);
-        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
-    });
-}
-
-export function resolvePath(cwd: string, call: ToolCall, fallback = ""): string {
-    const raw = typeof call.path === "string" ? call.path : fallback;
-    return sandboxPath(cwd, raw);
-}
-
-export function sandboxPath(cwd: string, raw: string): string {
-    const target = resolve(cwd, raw);
-    const roots = allowedRoots(cwd);
-    const realRoots = roots.map((root) => realpathOf(root)).filter(Boolean) as string[];
-    const realTarget = realpathOf(target);
-    if (realTarget) {
-        if (isInsideAny(realTarget, realRoots))
-            return target;
-        throw new Error("path outside sandbox: " + raw);
-    }
-    if (isInsideAny(target, roots))
-        return target;
-    throw new Error("path outside sandbox: " + raw);
-}
-
-export function realpathOf(input: string): string | undefined {
-    let current = resolve(input);
-    const missing: string[] = [];
-    for (;;) {
-        if (existsSync(current)) {
-            try {
-                return join(realpathSync(current), ...missing.slice().reverse());
-            }
-            catch {
-                return undefined;
-            }
-        }
-        const parent = dirname(current);
-        if (parent === current)
-            return undefined;
-        missing.push(basename(current));
-        current = parent;
-    }
-}

package/src/agent/tools/pwd.ts

@@ -1,12 +0,0 @@
-import type { Tool } from "./types.js";
-
-export const pwdTool: Tool = {
-    name: "pwd",
-    stateScope: "call",
-    prepare() {
-        return { ok: true };
-    },
-    async execute(_call, ctx) {
-        return { ok: true, output: ctx.cwd };
-    },
-};

package/src/agent/tools/read_file.ts

@@ -1,23 +0,0 @@
-import { readTextFile } from "./readers.js";
-import { resolvePath } from "./paths.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, requiredString } from "./validate.js";
-
-export const readFileTool: Tool = {
-    name: "read_file",
-    stateScope: "call",
-    revalidate: ["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) {
-        return { ok: true, output: await readTextFile(resolvePath(ctx.cwd, call)) };
-    },
-};

package/src/agent/tools/read_many.ts

@@ -1,27 +0,0 @@
-import { readMany } from "./readers.js";
-import type { Tool } from "./types.js";
-import { invalid, preparePath, stringArray } from "./validate.js";
-
-export const readManyTool: Tool = {
-    name: "read_many",
-    stateScope: "call",
-    revalidate: ["sandboxRoots"],
-    prepare(call, ctx) {
-        let paths: string[];
-        try {
-            paths = stringArray(call, "paths");
-        }
-        catch (err: any) {
-            return invalid(err.message);
-        }
-        for (const path of paths) {
-            const checked = preparePath(ctx.cwd, path);
-            if (!checked.ok)
-                return checked;
-        }
-        return { ok: true };
-    },
-    async execute(call, ctx) {
-        return { ok: true, output: await readMany(ctx.cwd, stringArray(call, "paths")) };
-    },
-};

package/src/agent/tools/readers.ts

@@ -1,228 +0,0 @@
-import { open, readdir, stat } from "node:fs/promises";
-import { basename, extname, join } from "node:path";
-import { createIgnore, isBinaryName } from "../ignore.js";
-import { createOutputBuffer } from "../limits.js";
-import { allowedRoots, isInsideAny, realpathOf, sandboxPath } from "./paths.js";
-
-export async function readMany(cwd: string, paths: string[]): Promise<string> {
-    const blocks: string[] = [];
-    for (const path of paths) {
-        const file = sandboxPath(cwd, path);
-        blocks.push(`### ${file}\n${await readTextFile(file)}`);
-    }
-    return blocks.join("\n\n");
-}
-
-const CODE_EXT = new Set([
-    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".go", ".rs", ".java",
-    ".rb", ".php", ".cs", ".c", ".h", ".cpp", ".hpp", ".kt", ".swift", ".scala",
-    ".sh", ".lua", ".ex", ".exs", ".dart", ".vue", ".svelte",
-]);
-
-export async function listFiles(sandbox: string, root: string, maxDepth: number, detail: boolean): Promise<string> {
-    const out = createOutputBuffer();
-    const ignore = createIgnore(sandbox);
-    if (detail) {
-        await walkWithin(sandbox, root, maxDepth, async (file, info) => {
-            out.line((info.isDirectory() ? "dir " : "file") + " " + file);
-            return !out.full;
-        });
-        return out.value();
-    }
-    async function visitDir(dir: string, depth: number, label: string): Promise<void> {
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            out.line(`${indent(depth)}${label}/  (unreadable)`);
-            return;
-        }
-        entries = entries.filter((entry) => !ignore.ignored(entry.name, join(dir, entry.name), entry.isDirectory()));
-        entries.sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
-        const dirs = entries.filter((entry) => entry.isDirectory());
-        const files = entries.filter((entry) => entry.isFile());
-        out.line(`${indent(depth)}${label}/  (${files.length} file${files.length === 1 ? "" : "s"}, ${dirs.length} dir${dirs.length === 1 ? "" : "s"})`);
-        for (const entry of files) {
-            const full = join(dir, entry.name);
-            const info = await stat(full).catch(() => undefined);
-            if (!info)
-                continue;
-            let line = `${indent(depth + 1)}${entry.name}  (${formatSize(info.size)})`;
-            const symbols = await fileSymbols(full, entry.name, info.size);
-            if (symbols)
-                line += `  — ${symbols}`;
-            out.line(line);
-            if (out.full)
-                return;
-        }
-        if (depth >= maxDepth)
-            return;
-        for (const entry of dirs) {
-            await visitDir(join(dir, entry.name), depth + 1, entry.name);
-            if (out.full)
-                return;
-        }
-    }
-    await visitDir(root, 0, basename(root) || ".");
-    return out.value();
-}
-
-async function fileSymbols(file: string, name: string, size: number): Promise<string> {
-    if (size > 256 * 1024 || !CODE_EXT.has(extname(name).toLowerCase()))
-        return "";
-    try {
-        const text = await readTextFile(file, 64 * 1024);
-        const names = new Set<string>();
-        const patterns = [
-            /(?:^|\n)\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?(?:function|class|interface|type|enum|struct|trait|impl|def)\s+([A-Za-z_$][\w$]*)/g,
-            /(?:^|\n)\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\(|function)/g,
-        ];
-        for (const pattern of patterns) {
-            for (const match of text.matchAll(pattern)) {
-                names.add(match[1]);
-                if (names.size >= 8)
-                    break;
-            }
-        }
-        return Array.from(names).slice(0, 8).join(", ");
-    }
-    catch {
-        return "";
-    }
-}
-
-function indent(depth: number): string {
-    return "  ".repeat(depth);
-}
-
-export function formatSize(bytes: number): string {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-export async function grepFiles(sandbox: string, root: string, pattern: string, maxDepth: number): Promise<string> {
-    const re = new RegExp(pattern, "i");
-    const out = createOutputBuffer();
-    const maxBytes = grepMaxBytes();
-    await walkWithin(sandbox, root, maxDepth, async (file, info) => {
-        if (!info.isFile())
-            return;
-        if (isBinaryName(basename(file)))
-            return;
-        if (info.size > maxBytes) {
-            out.line(`${file}: skipped (${formatSize(info.size)} exceeds ${formatSize(maxBytes)})`);
-            return !out.full;
-        }
-        try {
-            const text = await readTextFile(file, maxBytes);
-            const lines = text.split(/\r?\n/);
-            lines.forEach((line, index) => {
-                if (re.test(line))
-                    out.line(file + ":" + (index + 1) + ": " + line);
-            });
-        }
-        catch {
-            // Binary or unreadable files are skipped.
-        }
-        return !out.full;
-    });
-    return out.value();
-}
-
-export async function readTextFile(file: string, limit = readMaxBytes()): Promise<string> {
-    const info = await stat(file);
-    if (!info.isFile())
-        throw new Error(`not a file: ${file}`);
-    const length = Math.min(info.size, limit);
-    const handle = await open(file, "r");
-    try {
-        const buffer = Buffer.alloc(length);
-        const { bytesRead } = await handle.read(buffer, 0, length, 0);
-        const slice = buffer.subarray(0, bytesRead);
-        if (slice.subarray(0, Math.min(8192, slice.length)).includes(0))
-            return `[binary file omitted: ${file} (${info.size} bytes)]`;
-        const text = slice.toString("utf8");
-        return info.size > length
-            ? `${text}\n[... truncated at ${length} of ${info.size} bytes; use grep or read a narrower file ...]`
-            : text;
-    }
-    finally {
-        await handle.close();
-    }
-}
-
-export function readMaxBytes(): number {
-    const raw = Number(process.env["FASTCODE_READ_MAX_BYTES"]);
-    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 200_000;
-}
-
-function grepMaxBytes(): number {
-    const raw = Number(process.env["FASTCODE_GREP_MAX_BYTES"]);
-    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 1_000_000;
-}
-
-async function walkWithin(sandbox: string, root: string, maxDepth: number, visit: (file: string, info: any) => Promise<boolean | void>): Promise<void> {
-    const roots = allowedRoots(sandbox).map((entry) => realpathOf(entry)).filter(Boolean) as string[];
-    const ignore = createIgnore(sandbox);
-    await walk(root, maxDepth, visit, 0, { roots, visited: 0, maxVisited: 5000, ignore }, []);
-}
-
-async function walk(node: string, maxDepth: number, visit: (file: string, info: any) => Promise<boolean | void>, depth = 0, state: any, chain: string[] = []): Promise<boolean | void> {
-    if (state.visited >= state.maxVisited)
-        return;
-    let info;
-    try {
-        info = await stat(node);
-    }
-    catch {
-        return;
-    }
-    let real;
-    try {
-        real = await realpathOf(node) ?? node;
-    }
-    catch {
-        real = node;
-    }
-    if (chain.includes(real))
-        return;
-    state.visited += 1;
-    const insideSandbox = !state.roots || state.roots.length === 0 || isInsideAny(real, state.roots);
-    let keepGoing: boolean | void = true;
-    try {
-        keepGoing = await visit(node, info);
-    }
-    catch {
-        // A visitor failure must not abort the surrounding walk.
-    }
-    if (keepGoing === false)
-        return false;
-    if (!info.isDirectory() || depth >= maxDepth || !insideSandbox)
-        return;
-    let entries;
-    try {
-        entries = await readdir(node, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    const nextChain = chain.concat(real);
-    for (const entry of entries) {
-        if (state.ignore?.ignored(entry.name, join(node, entry.name), entry.isDirectory()))
-            continue;
-        if (state.visited >= state.maxVisited)
-            return;
-        try {
-            const keepWalking = await walk(join(node, entry.name), maxDepth, visit, depth + 1, state, nextChain);
-            if (keepWalking === false)
-                return false;
-        }
-        catch {
-            // Keep walking siblings.
-        }
-    }
-}