@akira-tl/forgerelay 0.5.4 → 0.5.6

package/dist/operations/batch/executor.js

@@ -0,0 +1,216 @@
+import { resolve } from "node:path";
+import { openAiConversationScopeId } from "../../request-meta.js";
+import { BatchScheduler } from "./scheduler.js";
+export class BatchExecutor {
+    dependencies;
+    scheduler;
+    shellSurface;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.scheduler = dependencies.scheduler ?? new BatchScheduler();
+        this.shellSurface = dependencies.shellSurface ?? "bash";
+    }
+    async run(workspaceId, input, context) {
+        const workspace = this.dependencies.workspaces.getWorkspace(workspaceId);
+        let response;
+        await this.dependencies.lifecycle.run({
+            tool: "batch",
+            workspace: workspaceSnapshot(workspace),
+            conversationScopeId: openAiConversationScopeId(context.requestMeta),
+            request: {
+                workspaceId,
+                concurrency: input.concurrency ?? Math.min(input.tasks.length, 10),
+                tasks: input.tasks.map((task) => ({ id: task.id, operation: task.operation })),
+            },
+            operation: async (parentContext) => {
+                const scheduled = input.tasks.map((task) => this.scheduledTask(workspace, task, context, parentContext));
+                const results = await this.scheduler.run(scheduled, {
+                    concurrency: input.concurrency,
+                    signal: context.signal,
+                });
+                const children = results.map((result, index) => {
+                    const task = input.tasks[index];
+                    if (result.status === "error") {
+                        return {
+                            id: task.id,
+                            operation: task.operation,
+                            status: "error",
+                            error: result.error,
+                        };
+                    }
+                    const childResult = sanitizeChildResult(result.value.response);
+                    return {
+                        id: task.id,
+                        operation: task.operation,
+                        status: result.value.failed ? "error" : "done",
+                        result: childResult,
+                        ...(result.value.failed
+                            ? { error: childFailureMessage(result.value.response) }
+                            : {}),
+                    };
+                });
+                const failed = children.filter((child) => child.status === "error").length;
+                response = {
+                    status: failed > 0 ? "partial" : "done",
+                    tasks: children.length,
+                    completed: children.length - failed,
+                    failed,
+                    results: children,
+                };
+                return {
+                    childCount: children.length,
+                    completed: children.length - failed,
+                    failed,
+                };
+            },
+            outcome: batchParentOutcome,
+        });
+        if (!response)
+            throw new Error("Batch execution completed without a response.");
+        return response;
+    }
+    scheduledTask(workspace, task, context, parent) {
+        return {
+            id: task.id,
+            claims: taskClaims(workspace.root, task),
+            ...(batchTaskIsExclusive(task, this.dependencies.capabilityBatchPolicy) ? { exclusive: true } : {}),
+            run: async (signal) => {
+                const response = await this.runCoreTask(workspace.id, task, {
+                    ...context,
+                    signal,
+                    parentActivityId: parent.activityId,
+                    turnId: parent.turnId,
+                });
+                return {
+                    response,
+                    failed: this.dependencies.resultIsError(response),
+                };
+            },
+        };
+    }
+    runCoreTask(workspaceId, task, context) {
+        switch (task.operation) {
+            case "read":
+                return this.dependencies.coreOperations.read({
+                    workspaceId,
+                    path: task.path,
+                    offset: task.offset,
+                    limit: task.limit,
+                }, context);
+            case "write":
+                return this.dependencies.coreOperations.write({
+                    workspaceId,
+                    path: task.path,
+                    content: task.content,
+                }, context);
+            case "edit":
+                return this.dependencies.coreOperations.edit({
+                    workspaceId,
+                    path: task.path,
+                    edits: task.edits,
+                }, context);
+            case "rename":
+                return this.dependencies.coreOperations.rename({
+                    workspaceId,
+                    path: task.path,
+                    newPath: task.newPath,
+                }, context);
+            case "delete":
+                return this.dependencies.coreOperations.delete({
+                    workspaceId,
+                    path: task.path,
+                    recursive: task.recursive,
+                }, context);
+            case "capability.run":
+                return this.dependencies.coreOperations.capabilityRun({
+                    workspaceId,
+                    name: task.name,
+                    arguments: task.arguments,
+                }, { ...context, batch: true });
+            case "bash.run":
+                return this.dependencies.coreOperations.shellRun({
+                    workspaceId,
+                    command: task.command,
+                    surface: this.shellSurface,
+                    tty: task.tty,
+                    columns: task.columns,
+                    rows: task.rows,
+                    workingDirectory: task.workingDirectory,
+                    yieldTimeMs: task.yieldTimeMs,
+                    timeoutMs: task.timeoutMs,
+                    maxOutputTokens: task.maxOutputTokens,
+                }, context);
+        }
+    }
+}
+export function batchTaskIsExclusive(task, capabilityBatchPolicy) {
+    if (task.operation === "bash.run")
+        return true;
+    if (task.operation !== "capability.run")
+        return false;
+    return capabilityBatchPolicy?.(task.name) === "serial";
+}
+function batchParentOutcome(summary) {
+    return summary.failed > 0
+        ? { type: "failed", error: `${summary.failed} of ${summary.childCount} Batch tasks failed.` }
+        : { type: "succeeded" };
+}
+function taskClaims(root, task) {
+    switch (task.operation) {
+        case "read":
+            return [{ key: batchPathKey(root, task.path), mode: "read" }];
+        case "write":
+        case "edit":
+        case "delete":
+            return [{ key: batchPathKey(root, task.path), mode: "write" }];
+        case "rename":
+            return [
+                { key: batchPathKey(root, task.path), mode: "write" },
+                { key: batchPathKey(root, task.newPath), mode: "write" },
+            ];
+        case "capability.run":
+        case "bash.run":
+            return [];
+    }
+}
+function batchPathKey(root, path) {
+    const resolved = resolve(root, path);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function sanitizeChildResult(result) {
+    if (typeof result !== "object" || result === null) {
+        return { content: [{ type: "text", text: String(result ?? "") }] };
+    }
+    const record = result;
+    const content = Array.isArray(record.content) ? record.content : [];
+    const structuredContent = typeof record.structuredContent === "object" &&
+        record.structuredContent !== null &&
+        !Array.isArray(record.structuredContent)
+        ? record.structuredContent
+        : undefined;
+    return {
+        content,
+        ...(structuredContent ? { structuredContent } : {}),
+        ...(record.isError === true ? { isError: true } : {}),
+    };
+}
+function childFailureMessage(result) {
+    const sanitized = sanitizeChildResult(result);
+    const text = sanitized.content.flatMap((entry) => {
+        if (typeof entry !== "object" || entry === null)
+            return [];
+        const value = entry.text;
+        return typeof value === "string" ? [value] : [];
+    }).join("\n").trim();
+    return text || "Batch child returned an error result.";
+}
+function workspaceSnapshot(workspace) {
+    return {
+        id: workspace.id,
+        root: workspace.root,
+        mode: workspace.mode,
+        ...(workspace.sourceRoot ? { sourceRoot: workspace.sourceRoot } : {}),
+        ...(workspace.worktree?.branch ? { branch: workspace.worktree.branch } : {}),
+        ...(workspace.worktree?.targetBranch ? { targetBranch: workspace.worktree.targetBranch } : {}),
+    };
+}

package/dist/operations/batch/scheduler.js

@@ -0,0 +1,108 @@
+import { relative, sep } from "node:path";
+export class BatchScheduler {
+    async run(tasks, options = {}) {
+        validateTasks(tasks);
+        const concurrency = resolveConcurrency(tasks.length, options.concurrency);
+        const signal = options.signal ?? new AbortController().signal;
+        signal.throwIfAborted();
+        const pending = new Set(tasks.map((_task, index) => index));
+        const active = new Map();
+        const results = new Array(tasks.length);
+        while (pending.size > 0 || active.size > 0) {
+            signal.throwIfAborted();
+            this.startRunnable(tasks, pending, active, concurrency, signal);
+            if (active.size === 0) {
+                throw new Error("Batch scheduler could not make progress.");
+            }
+            const settled = await Promise.race([...active.values()].map((entry) => entry.promise));
+            active.delete(settled.index);
+            if (signal.aborted) {
+                await Promise.allSettled([...active.values()].map((entry) => entry.promise));
+                throw abortReason(signal);
+            }
+            const task = tasks[settled.index];
+            results[settled.index] = settled.status === "done"
+                ? { id: task.id, status: "done", value: settled.value }
+                : { id: task.id, status: "error", error: errorMessage(settled.error) };
+        }
+        return results.map((result, index) => {
+            if (!result)
+                throw new Error(`Batch task ${tasks[index]?.id ?? index} did not produce a result.`);
+            return result;
+        });
+    }
+    startRunnable(tasks, pending, active, concurrency, signal) {
+        while (active.size < concurrency) {
+            signal.throwIfAborted();
+            const index = [...pending].find((candidate) => canStart(tasks[candidate], active));
+            if (index === undefined)
+                return;
+            const task = tasks[index];
+            pending.delete(index);
+            const promise = Promise.resolve()
+                .then(() => task.run(signal))
+                .then((value) => ({ index, status: "done", value }))
+                .catch((error) => ({ index, status: "error", error }));
+            active.set(index, { task, promise });
+        }
+    }
+}
+function validateTasks(tasks) {
+    if (tasks.length < 1 || tasks.length > 100) {
+        throw new Error(`Batch task count must be between 1 and 100; received ${tasks.length}.`);
+    }
+    const ids = new Set();
+    for (const task of tasks) {
+        if (!task.id.trim())
+            throw new Error("Batch task id must not be empty.");
+        if (ids.has(task.id))
+            throw new Error(`Batch task ids must be unique; duplicate id: ${task.id}.`);
+        ids.add(task.id);
+    }
+}
+function resolveConcurrency(taskCount, requested) {
+    const concurrency = requested ?? Math.min(taskCount, 10);
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 10) {
+        throw new Error(`Batch concurrency must be an integer between 1 and 10; received ${concurrency}.`);
+    }
+    return concurrency;
+}
+function canStart(task, active) {
+    if (task.exclusive)
+        return active.size === 0;
+    for (const entry of active.values()) {
+        if (entry.task.exclusive)
+            return false;
+        if (claimsConflict(task.claims, entry.task.claims))
+            return false;
+    }
+    return true;
+}
+function claimsConflict(left, right) {
+    for (const first of left) {
+        for (const second of right) {
+            if (first.mode === "read" && second.mode === "read")
+                continue;
+            if (pathsOverlap(first.key, second.key))
+                return true;
+        }
+    }
+    return false;
+}
+function pathsOverlap(left, right) {
+    if (left === right)
+        return true;
+    return isInside(left, right) || isInside(right, left);
+}
+function isInside(path, root) {
+    const rel = relative(root, path);
+    return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error
+        ? signal.reason
+        : new Error(signal.reason === undefined ? "Batch execution was cancelled." : String(signal.reason));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/operations/batch/types.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+const taskId = z.string().min(1).max(128);
+const path = z.string().min(1);
+const capabilityName = z.string().regex(/^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/);
+const editEntry = z.object({
+    oldText: z.string(),
+    newText: z.string(),
+}).strict();
+export const batchCoreTaskSchema = z.discriminatedUnion("operation", [
+    z.object({
+        id: taskId,
+        operation: z.literal("read"),
+        path,
+        offset: z.number().int().positive().optional(),
+        limit: z.number().int().positive().optional(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("write"),
+        path,
+        content: z.string(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("edit"),
+        path,
+        edits: z.array(editEntry).min(1),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("rename"),
+        path,
+        newPath: path,
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("delete"),
+        path,
+        recursive: z.boolean().optional(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("capability.run"),
+        name: capabilityName,
+        arguments: z.record(z.string(), z.unknown()).optional(),
+    }).strict(),
+    z.object({
+        id: taskId,
+        operation: z.literal("bash.run"),
+        command: z.string().min(1),
+        tty: z.boolean().optional(),
+        columns: z.number().int().min(1).max(1_000).optional(),
+        rows: z.number().int().min(1).max(1_000).optional(),
+        workingDirectory: z.string().optional(),
+        yieldTimeMs: z.number().int().min(0).max(300_000).optional(),
+        timeoutMs: z.number().int().min(1).max(86_400_000).optional(),
+        maxOutputTokens: z.number().int().positive().max(100_000).optional(),
+    }).strict(),
+]);
+export const batchExecuteInputSchema = z.object({
+    tasks: z.array(batchCoreTaskSchema).min(1).max(100),
+    concurrency: z.number().int().min(1).max(10).optional(),
+}).strict().superRefine((input, context) => {
+    const ids = new Set();
+    for (const task of input.tasks) {
+        if (ids.has(task.id)) {
+            context.addIssue({
+                code: "custom",
+                path: ["tasks"],
+                message: `Batch task ids must be unique; duplicate id: ${task.id}.`,
+            });
+            return;
+        }
+        ids.add(task.id);
+    }
+});

package/dist/operations/bulk-mutation.js

@@ -0,0 +1,41 @@
+export async function executeSequentialBulkMutation(options) {
+    const items = [];
+    for (let index = 0; index < options.paths.length; index += 1) {
+        options.signal?.throwIfAborted();
+        const path = options.paths[index];
+        try {
+            const response = await options.run(path);
+            const error = options.isError(response);
+            items.push({
+                path,
+                status: error ? "error" : "done",
+                result: options.resultText(response),
+                response,
+            });
+            if (error) {
+                appendUnexecuted(items, options.paths, index + 1);
+                break;
+            }
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw error;
+            items.push({
+                path,
+                status: "error",
+                result: error instanceof Error ? error.message : String(error),
+            });
+            appendUnexecuted(items, options.paths, index + 1);
+            break;
+        }
+    }
+    const completed = items.filter((item) => item.status === "done").length;
+    const failed = items.filter((item) => item.status === "error").length;
+    const unexecuted = items.filter((item) => item.status === "unexecuted").length;
+    return { items, completed, failed, unexecuted };
+}
+function appendUnexecuted(items, paths, start) {
+    for (let index = start; index < paths.length; index += 1) {
+        items.push({ path: paths[index], status: "unexecuted" });
+    }
+}

package/dist/operations/bulk-read.js

@@ -0,0 +1,28 @@
+export async function executeBulkRead(options) {
+    const children = await Promise.all(options.paths.map(async (path) => {
+        try {
+            const response = await options.run(path);
+            return {
+                path,
+                status: options.isError(response) ? "error" : "done",
+                result: options.resultText(response),
+                response,
+            };
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw error;
+            return {
+                path,
+                status: "error",
+                result: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }));
+    const failed = children.filter((child) => child.status === "error").length;
+    return {
+        children,
+        succeeded: children.length - failed,
+        failed,
+    };
+}

package/dist/operations/core-operation-executor.js

@@ -0,0 +1,30 @@
+export class CoreOperationExecutor {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    read(input, context) {
+        return this.handlers.read(input, context);
+    }
+    write(input, context) {
+        return this.handlers.write(input, context);
+    }
+    edit(input, context) {
+        return this.handlers.edit(input, context);
+    }
+    rename(input, context) {
+        return this.handlers.rename(input, context);
+    }
+    delete(input, context) {
+        return this.handlers.delete(input, context);
+    }
+    shellRun(input, context) {
+        return this.handlers.shellRun(input, context);
+    }
+    capabilityRun(input, context) {
+        return this.handlers.capabilityRun(input, context);
+    }
+}
+export function createCoreOperationExecutor(handlers) {
+    return new CoreOperationExecutor(handlers);
+}

package/dist/operations/native-bulk-mutations.js

@@ -0,0 +1,134 @@
+import { preflightDeletePaths } from "../file-mutations.js";
+import { preflightEditFiles } from "../pi-tools.js";
+import { openAiConversationScopeId } from "../request-meta.js";
+import { executeSequentialBulkMutation } from "./bulk-mutation.js";
+export class NativeBulkMutationExecutor {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async edit(input, context) {
+        const { workspaceId, paths, edits } = input;
+        const workspace = this.dependencies.workspaces.getWorkspace(workspaceId);
+        let response;
+        await this.runParent(workspace, context, "edit", { workspaceId, paths, edits }, async (parentContext) => {
+            await this.dependencies.preflightInstructions(workspace, paths);
+            await preflightEditFiles(paths, edits, {
+                cwd: workspace.root,
+                root: workspace.root,
+                fileRoots: this.dependencies.workspaces.fileToolRoots(workspace),
+            }, context.signal);
+            const execution = await executeSequentialBulkMutation({
+                paths,
+                signal: context.signal,
+                run: (path) => this.dependencies.coreOperations.edit({ workspaceId, path, edits }, childContext(context, parentContext)),
+                isError: this.dependencies.resultIsError,
+                resultText: this.dependencies.resultText,
+            });
+            response = buildResponse(paths.length, execution, "applied", this.dependencies.resultContent);
+            return summary(paths.length, execution.completed, execution.failed, execution.unexecuted);
+        }, mutationParentOutcome("Edit"));
+        if (!response)
+            throw new Error("Bulk Edit completed without a response.");
+        return response;
+    }
+    async delete(input, context) {
+        const { workspaceId, paths, recursive } = input;
+        const workspace = this.dependencies.workspaces.getWorkspace(workspaceId);
+        let response;
+        await this.runParent(workspace, context, "delete", { workspaceId, paths, recursive: recursive ?? false }, async (parentContext) => {
+            await this.dependencies.preflightInstructions(workspace, paths);
+            await preflightDeletePaths(paths.map((path) => ({ path, recursive })), {
+                cwd: workspace.root,
+                allowedRoots: this.dependencies.workspaces.fileToolRoots(workspace),
+            });
+            const execution = await executeSequentialBulkMutation({
+                paths,
+                signal: context.signal,
+                run: (path) => this.dependencies.coreOperations.delete({ workspaceId, path, recursive }, childContext(context, parentContext)),
+                isError: this.dependencies.resultIsError,
+                resultText: this.dependencies.resultText,
+            });
+            response = buildResponse(paths.length, execution, "deleted", this.dependencies.resultContent);
+            return summary(paths.length, execution.completed, execution.failed, execution.unexecuted);
+        }, mutationParentOutcome("Delete"));
+        if (!response)
+            throw new Error("Bulk Delete completed without a response.");
+        return response;
+    }
+    runParent(workspace, context, tool, request, operation, outcome) {
+        return this.dependencies.lifecycle.run({
+            tool,
+            workspace: workspaceSnapshot(workspace),
+            conversationScopeId: openAiConversationScopeId(context.requestMeta),
+            request,
+            operation,
+            outcome,
+        });
+    }
+}
+function childContext(context, parent) {
+    return {
+        ...context,
+        parentActivityId: parent.activityId,
+        turnId: parent.turnId,
+    };
+}
+function workspaceSnapshot(workspace) {
+    return {
+        id: workspace.id,
+        root: workspace.root,
+        mode: workspace.mode,
+        ...(workspace.sourceRoot ? { sourceRoot: workspace.sourceRoot } : {}),
+        ...(workspace.worktree?.branch ? { branch: workspace.worktree.branch } : {}),
+        ...(workspace.worktree?.targetBranch ? { targetBranch: workspace.worktree.targetBranch } : {}),
+    };
+}
+function summary(requested, completed, failed, unexecuted) {
+    return {
+        childCount: completed + failed,
+        requested,
+        completed,
+        failed,
+        unexecuted,
+    };
+}
+function mutationParentOutcome(tool) {
+    return (result) => result.failed > 0
+        ? {
+            type: "failed",
+            error: `${result.failed} child ${tool} failed; ${result.unexecuted} target(s) were not executed.`,
+        }
+        : { type: "succeeded" };
+}
+function buildResponse(requested, execution, successStatus, resultContent) {
+    const content = execution.items.flatMap((item) => [
+        { type: "text", text: `--- ${item.path} · ${item.status} ---` },
+        ...(item.response
+            ? resultContent(item.response)
+            : item.result
+                ? [{ type: "text", text: item.result }]
+                : []),
+    ]);
+    const result = content
+        .filter((entry) => entry.type === "text")
+        .map((entry) => entry.text)
+        .join("\n");
+    return {
+        content,
+        structuredContent: {
+            result,
+            status: execution.failed > 0 ? "partial" : successStatus,
+            results: execution.items.map(({ path, status, result: itemResult }) => ({
+                path,
+                status,
+                ...(itemResult !== undefined ? { result: itemResult } : {}),
+            })),
+            ...(successStatus === "applied" ? { files: requested } : { paths: requested }),
+            completed: execution.completed,
+            failed: execution.failed,
+            unexecuted: execution.unexecuted,
+        },
+        ...(execution.failed > 0 ? { isError: true } : {}),
+    };
+}

package/dist/pi-tools.js

@@ -1,3 +1,5 @@
+import { constants } from "node:fs";
+import { access as fsAccess, readFile as fsReadFile, realpath as fsRealpath } from "node:fs/promises";
 import { createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, } from "@earendil-works/pi-coding-agent";
 import { resolveCanonicalAllowedPath } from "./roots.js";
 function toMcpContent(result) {
@@ -53,6 +55,40 @@ export async function editFileTool(input, context) {
         edits: input.edits,
     }, context);
 }
+export async function preflightEditFiles(paths, edits, context, signal) {
+    const seen = new Map();
+    for (const path of paths) {
+        const response = await preflightEditFileTool({ path, edits }, context, signal);
+        if (response.isError) {
+            const message = response.content
+                .filter((entry) => entry.type === "text")
+                .map((entry) => entry.text)
+                .join("\n");
+            throw new Error(`Bulk Edit preflight failed for ${path}: ${message}`);
+        }
+        const absolute = await resolveCanonicalAllowedPath(path, context.cwd, context.fileRoots ?? [context.root]);
+        const canonical = await fsRealpath(absolute);
+        const previous = seen.get(canonical);
+        if (previous) {
+            throw new Error(`Bulk Edit targets overlap: ${previous} and ${path} resolve to the same file.`);
+        }
+        seen.set(canonical, path);
+    }
+}
+export async function preflightEditFileTool(input, context, signal) {
+    signal?.throwIfAborted();
+    const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.fileRoots ?? [context.root]);
+    const tool = createEditTool(context.cwd, {
+        operations: {
+            readFile: fsReadFile,
+            writeFile: async () => { },
+            access: (absolutePath) => fsAccess(absolutePath, constants.R_OK | constants.W_OK),
+        },
+    });
+    const response = await runTool((params) => tool.execute("edit_file", params, signal), { path, edits: input.edits }, context);
+    signal?.throwIfAborted();
+    return response;
+}
 export async function grepFilesTool(input, context) {
     const path = input.path
         ? await resolveCanonicalAllowedPath(input.path, context.cwd, context.fileRoots ?? [context.root])