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

package/dist/agent/tools/shell.js

@@ -0,0 +1,48 @@
+import { executeShellCommand, pollShellSession } from "../shell-session.js";
+import { invalid, numberOption } from "./validate.js";
+export const shellTool = {
+    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) {
+    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, result) {
+    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/dist/agent/tools/stat_path.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "./types.js";
+export declare const statPathTool: Tool;

package/dist/agent/tools/stat_path.js

@@ -0,0 +1,31 @@
+import { stat } from "node:fs/promises";
+import { resolvePath } from "./paths.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+export const statPathTool = {
+    name: "stat_path",
+    stateScope: "call",
+    revalidate: ["sandboxRoots"],
+    prepare(call, ctx) {
+        let path;
+        try {
+            path = requiredString(call, "path");
+        }
+        catch (err) {
+            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/dist/agent/tools/types.d.ts

@@ -0,0 +1,39 @@
+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/dist/agent/tools/types.js

@@ -0,0 +1 @@
+export {};

package/dist/agent/tools/validate.d.ts

@@ -0,0 +1,6 @@
+import type { Prepared, ToolCall } from "./types.js";
+export declare function invalid(output: string): Prepared;
+export declare function requiredString(call: ToolCall, key: string): string;
+export declare function stringArray(call: ToolCall, key: string): string[];
+export declare function numberOption(value: any, fallback: number): number;
+export declare function preparePath(cwd: string, raw: string): Prepared;

package/dist/agent/tools/validate.js

@@ -0,0 +1,29 @@
+import { sandboxPath } from "./paths.js";
+export function invalid(output) {
+    return { ok: false, output };
+}
+export function requiredString(call, key) {
+    const value = call[key];
+    if (typeof value !== "string")
+        throw new Error(`${key} must be a string`);
+    return value;
+}
+export function stringArray(call, key) {
+    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, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+export function preparePath(cwd, raw) {
+    try {
+        sandboxPath(cwd, raw);
+        return { ok: true };
+    }
+    catch (err) {
+        return invalid(err?.message ?? String(err));
+    }
+}

package/dist/agent/tools/write_file.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from "./types.js";
+export declare const writeFileTool: Tool;

package/dist/agent/tools/write_file.js

@@ -0,0 +1,26 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { resolvePath } from "./paths.js";
+import { invalid, preparePath, requiredString } from "./validate.js";
+export const writeFileTool = {
+    name: "write_file",
+    requiresTrust: true,
+    stateScope: "turn",
+    revalidate: ["trust", "sandboxRoots"],
+    prepare(call, ctx) {
+        try {
+            requiredString(call, "path");
+            requiredString(call, "content");
+        }
+        catch (err) {
+            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/dist/agent/tools.d.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";

package/dist/agent/tools.js

@@ -0,0 +1,2 @@
+export { assertToolContract, registry, runAgentTool, ToolRegistry } from "./registry.js";
+export { TOOLS } from "./tools/index.js";

package/dist/app.d.ts

@@ -0,0 +1,4 @@
+export declare const App: ({ initialPrompt, resume }: {
+    initialPrompt: any;
+    resume: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;