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

package/src/agent/tools/replace_in_file.ts

@@ -0,0 +1,32 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+
+export const replaceInFileTool: Tool = {
+    name: "replace_in_file",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        try {
+            requiredString(call, "path");
+            requiredString(call, "find");
+            requiredString(call, "replace");
+        }
+        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 find = requiredString(call, "find");
+        const replacement = requiredString(call, "replace");
+        const source = await readFile(file, "utf8");
+        if (!source.includes(find))
+            return { ok: false, output: `text not found in ${file}` };
+        await writeFile(file, source.split(find).join(replacement), "utf8");
+        return { ok: true, output: `replaced text in ${file}`, sideEffects: { touched: [file] } };
+    },
+};

package/src/agent/tools/shell.ts

@@ -0,0 +1,53 @@
+import type { ShellExecResult } from "../shell-session.js";
+import { executeShellCommand, pollShellSession } from "../shell-session.js";
+import type { Tool } from "./types.js";
+import { invalid, numberOption } from "./validate.js";
+
+export const shellTool: Tool = {
+    name: "shell",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    approvalHints: { mayRequireApproval: true },
+    prepare(call) {
+        if (typeof call.session_id === "string" && call.session_id.trim())
+            return { ok: true };
+        if (typeof call.command !== "string" || call.command.trim() === "")
+            return invalid("command must be a non-empty string");
+        return { ok: true };
+    },
+    async execute(call, ctx) {
+        if (typeof call.session_id === "string" && call.session_id.trim()) {
+            const polled = await pollShellSession(call.session_id, numberOption(call.waitMs, 0));
+            if (!polled)
+                return { ok: false, output: `unknown shell session: ${call.session_id}` };
+            return formatPoll(call.session_id, polled);
+        }
+        const result = await executeShellCommand(call.command, ctx.cwd, {
+            signal: ctx.signal,
+            turn: ctx.turn,
+            timeoutMs: numberOption(call.timeoutMs, 120000),
+        });
+        return formatExec(result);
+    },
+};
+
+function formatExec(result: ShellExecResult): { ok: boolean; output: string } {
+    if (result.status !== "running")
+        return { ok: result.ok, output: result.output || `[command ${result.status}]` };
+    const header = `[session ${result.sessionId}] running`;
+    const body = result.output ? "\n" + result.output : "";
+    return {
+        ok: true,
+        output: `${header}${body}\n\nPoll with: {"tool":"shell","session_id":"${result.sessionId}"}`,
+    };
+}
+
+function formatPoll(id: string, result: ShellExecResult): { ok: boolean; output: string } {
+    const status = result.status === "running"
+        ? `running (next poll ~${Math.round((result.nextPollMs ?? 1000) / 1000)}s)`
+        : `${result.status}${result.exitCode !== undefined && result.exitCode !== null ? ` (exit ${result.exitCode})` : ""}`;
+    const header = `[session ${id}] ${status}`;
+    const body = result.output ? "\n" + result.output : result.status === "running" ? "\n(no new output)" : "";
+    return { ok: result.ok, output: header + body };
+}

package/src/agent/tools/stat_path.ts

@@ -0,0 +1,33 @@
+import { stat } from "node:fs/promises";
+import { resolvePath } from "./paths.js";
+import type { Tool } from "./types.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+
+export const statPathTool: Tool = {
+    name: "stat_path",
+    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) {
+        const file = resolvePath(ctx.cwd, call);
+        const info = await stat(file);
+        return {
+            ok: true,
+            output: JSON.stringify({
+                path: file,
+                type: info.isDirectory() ? "dir" : info.isFile() ? "file" : "other",
+                size: info.size,
+                modified: info.mtime.toISOString(),
+            }, null, 2),
+        };
+    },
+};

package/src/agent/tools/types.ts

@@ -0,0 +1,42 @@
+export type StateScope = "call" | "turn" | "session";
+
+export type RevalidateKey = "trust" | "sandboxRoots" | "schema" | "modelCaps";
+
+export interface SideEffects {
+  touched?: string[];
+  created?: string[];
+  removed?: string[];
+}
+
+export interface ToolCall {
+  tool: string;
+  [key: string]: any;
+}
+
+export interface ToolResult {
+  ok: boolean;
+  output: string;
+  sideEffects?: SideEffects;
+}
+
+export interface ToolCtx {
+    cwd: string;
+    signal?: AbortSignal;
+    turn?: number;
+}
+
+export type Prepared = { ok: true } | { ok: false; output: string };
+
+export interface ApprovalHints {
+  mayRequireApproval: boolean;
+}
+
+export interface Tool {
+  name: string;
+  requiresTrust?: boolean;
+  stateScope: StateScope;
+  revalidate?: RevalidateKey[];
+  approvalHints?: ApprovalHints;
+  prepare(call: ToolCall, ctx: ToolCtx): Prepared;
+  execute(call: ToolCall, ctx: ToolCtx): Promise<ToolResult>;
+}

package/src/agent/tools/validate.ts

@@ -0,0 +1,35 @@
+import { sandboxPath } from "./paths.js";
+import type { Prepared, ToolCall } from "./types.js";
+
+export function invalid(output: string): Prepared {
+    return { ok: false, output };
+}
+
+export function requiredString(call: ToolCall, key: string): string {
+    const value = call[key];
+    if (typeof value !== "string")
+        throw new Error(`${key} must be a string`);
+    return value;
+}
+
+export function stringArray(call: ToolCall, key: string): string[] {
+    const value = call[key];
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new Error(`${key} must be an array of strings`);
+    }
+    return value;
+}
+
+export function numberOption(value: any, fallback: number): number {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export function preparePath(cwd: string, raw: string): Prepared {
+    try {
+        sandboxPath(cwd, raw);
+        return { ok: true };
+    }
+    catch (err: any) {
+        return invalid(err?.message ?? String(err));
+    }
+}

package/src/agent/tools/write_file.ts

@@ -0,0 +1,28 @@
+import { mkdir, writeFile } 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 writeFileTool: Tool = {
+    name: "write_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);
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, requiredString(call, "content"), "utf8");
+        return { ok: true, output: `wrote ${file}`, sideEffects: { touched: [file] } };
+    },
+};

package/src/agent/tools.ts

@@ -0,0 +1,3 @@
+export { assertToolContract, registry, runAgentTool, ToolRegistry } from "./registry.js";
+export { TOOLS } from "./tools/index.js";
+export type { RevalidateKey, SideEffects, StateScope, Tool, ToolCall, ToolCtx, ToolResult } from "./tools/types.js";