zeitlich 0.2.46 → 0.2.47

package/src/tools/edit/handler.test.ts

@@ -0,0 +1,177 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { InMemorySandboxProvider } from "../../adapters/sandbox/inmemory/index";
+import type { Sandbox, SandboxCreateOptions } from "../../lib/sandbox";
+import { SandboxManager } from "../../lib/sandbox/manager";
+import type { RouterContext } from "../../lib/tool-router/types";
+import { withSandbox } from "../../lib/tool-router/with-sandbox";
+import { applyEditPlan, editHandler, multiEditHandler } from "./handler";
+
+describe("edit handlers", () => {
+  let manager: SandboxManager<SandboxCreateOptions, Sandbox, "inMemory">;
+  let sandboxId: string;
+
+  const ctx = (id: string): RouterContext => ({
+    sandboxId: id,
+    threadId: "test-thread",
+    toolCallId: "test-call",
+    toolName: "FileEdit",
+  });
+
+  beforeEach(async () => {
+    manager = new SandboxManager(new InMemorySandboxProvider());
+    const result = await manager.create({
+      initialFiles: {
+        "/src/app.ts": [
+          "export function greet(name: string) {",
+          '  return "hello " + name;',
+          "}",
+          "",
+          "export const status = 'draft';",
+          "export const repeated = 'draft';",
+          "",
+        ].join("\n"),
+      },
+    });
+    expect(result).not.toBeNull();
+    sandboxId = (result as NonNullable<typeof result>).sandboxId;
+  });
+
+  it("applies one unique exact replacement", async () => {
+    const handler = withSandbox(manager, editHandler);
+
+    const response = await handler(
+      {
+        file_path: "/src/app.ts",
+        old_string: '  return "hello " + name;',
+        new_string: "  return `hello ${name}`;",
+      },
+      ctx(sandboxId)
+    );
+
+    const sandbox = await manager.getSandbox(sandboxId);
+    await expect(sandbox.fs.readFile("/src/app.ts")).resolves.toContain(
+      "return `hello ${name}`;"
+    );
+    expect(response.data?.success).toBe(true);
+    expect(response.data?.replacements).toBe(1);
+    expect(response.data?.hunks?.[0]).toMatchObject({
+      oldStartLine: 2,
+      newStartLine: 2,
+      oldLines: ['  return "hello " + name;'],
+      newLines: ["  return `hello ${name}`;"],
+    });
+  });
+
+  it("refuses ambiguous single edits without replace_all", async () => {
+    const handler = withSandbox(manager, editHandler);
+
+    const response = await handler(
+      {
+        file_path: "/src/app.ts",
+        old_string: "draft",
+        new_string: "ready",
+      },
+      ctx(sandboxId)
+    );
+
+    const sandbox = await manager.getSandbox(sandboxId);
+    await expect(sandbox.fs.readFile("/src/app.ts")).resolves.toContain(
+      "status = 'draft'"
+    );
+    expect(response.data?.success).toBe(false);
+    expect(response.toolResponse).toContain("appears 2 times");
+  });
+
+  it("supports replace_all for one edit", async () => {
+    const handler = withSandbox(manager, editHandler);
+
+    const response = await handler(
+      {
+        file_path: "/src/app.ts",
+        old_string: "draft",
+        new_string: "ready",
+        replace_all: true,
+      },
+      ctx(sandboxId)
+    );
+
+    const sandbox = await manager.getSandbox(sandboxId);
+    const content = await sandbox.fs.readFile("/src/app.ts");
+    expect(content).toContain("status = 'ready'");
+    expect(content).toContain("repeated = 'ready'");
+    expect(response.data?.success).toBe(true);
+    expect(response.data?.replacements).toBe(2);
+  });
+
+  it("applies multiple edits sequentially and atomically", async () => {
+    const handler = withSandbox(manager, multiEditHandler);
+
+    const response = await handler(
+      {
+        file_path: "/src/app.ts",
+        edits: [
+          {
+            old_string: '  return "hello " + name;',
+            new_string: "  return `hello ${name}`;",
+          },
+          { old_string: "draft", new_string: "ready", replace_all: true },
+        ],
+      },
+      { ...ctx(sandboxId), toolName: "FileMultiEdit" }
+    );
+
+    const sandbox = await manager.getSandbox(sandboxId);
+    const content = await sandbox.fs.readFile("/src/app.ts");
+    expect(content).toContain("return `hello ${name}`;");
+    expect(content).toContain("status = 'ready'");
+    expect(content).toContain("repeated = 'ready'");
+    expect(response.data?.success).toBe(true);
+    expect(response.data?.replacements).toBe(3);
+    expect(response.data?.hunks).toHaveLength(3);
+  });
+
+  it("leaves the file unchanged when a later multi-edit fails", async () => {
+    const handler = withSandbox(manager, multiEditHandler);
+    const sandbox = await manager.getSandbox(sandboxId);
+    const before = await sandbox.fs.readFile("/src/app.ts");
+
+    const response = await handler(
+      {
+        file_path: "/src/app.ts",
+        edits: [
+          {
+            old_string: '  return "hello " + name;',
+            new_string: "  return `hello ${name}`;",
+          },
+          { old_string: "missing text", new_string: "replacement" },
+        ],
+      },
+      { ...ctx(sandboxId), toolName: "FileMultiEdit" }
+    );
+
+    await expect(sandbox.fs.readFile("/src/app.ts")).resolves.toBe(before);
+    expect(response.data?.success).toBe(false);
+    expect(response.toolResponse).toContain("edit 1");
+  });
+});
+
+describe("applyEditPlan", () => {
+  it("rejects empty old_string before mutating content", () => {
+    const result = applyEditPlan("abc", [{ old_string: "", new_string: "x" }]);
+
+    expect(result).toMatchObject({ ok: false, editIndex: 0 });
+  });
+
+  it("treats replacement text literally", () => {
+    const result = applyEditPlan("a.$^ b.$^", [
+      { old_string: ".$^", new_string: "literal" },
+    ]);
+
+    expect(result).toMatchObject({ ok: false });
+
+    const unique = applyEditPlan("a.$^", [
+      { old_string: ".$^", new_string: "literal" },
+    ]);
+    expect(unique).toMatchObject({ ok: true, content: "aliteral" });
+  });
+});

package/src/tools/edit/handler.ts

@@ -1,15 +1,200 @@
 import type { ActivityToolHandler } from "../../lib/tool-router";
 import type { SandboxContext } from "../../lib/tool-router/with-sandbox";
-import type { FileEditArgs } from "./tool";
+import type { FileEditArgs, FileMultiEditArgs } from "./tool";
 
 interface EditResult {
   path: string;
   success: boolean;
   replacements: number;
+  hunks?: EditHunk[];
 }
 
-function escapeRegExp(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+export interface EditHunk {
+  editIndex: number;
+  oldStartLine: number;
+  oldEndLine: number;
+  newStartLine: number;
+  newEndLine: number;
+  oldLines: string[];
+  newLines: string[];
+}
+
+type TextEdit = FileMultiEditArgs["edits"][number];
+
+interface EditPlanSuccess {
+  ok: true;
+  content: string;
+  replacements: number;
+  hunks: EditHunk[];
+}
+
+interface EditPlanFailure {
+  ok: false;
+  message: string;
+  editIndex?: number;
+}
+
+type EditPlanResult = EditPlanSuccess | EditPlanFailure;
+
+function splitLines(text: string): string[] {
+  if (text.length === 0) return [];
+  return text.replace(/\r\n/g, "\n").split("\n");
+}
+
+function lineNumberAt(content: string, index: number): number {
+  let line = 1;
+  for (let i = 0; i < index; i++) {
+    if (content.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+
+function lineEnd(startLine: number, lines: string[]): number {
+  return lines.length === 0 ? startLine : startLine + lines.length - 1;
+}
+
+function indicesOf(content: string, needle: string): number[] {
+  const indices: number[] = [];
+  let cursor = 0;
+  while (cursor <= content.length) {
+    const index = content.indexOf(needle, cursor);
+    if (index === -1) break;
+    indices.push(index);
+    cursor = index + needle.length;
+  }
+  return indices;
+}
+
+function makeHunk(
+  editIndex: number,
+  beforeContent: string,
+  replacementIndex: number,
+  oldString: string,
+  newString: string
+): EditHunk {
+  const oldStartLine = lineNumberAt(beforeContent, replacementIndex);
+  const oldLines = splitLines(oldString);
+  const newLines = splitLines(newString);
+  return {
+    editIndex,
+    oldStartLine,
+    oldEndLine: lineEnd(oldStartLine, oldLines),
+    newStartLine: oldStartLine,
+    newEndLine: lineEnd(oldStartLine, newLines),
+    oldLines,
+    newLines,
+  };
+}
+
+function applyOneEdit(
+  content: string,
+  edit: TextEdit,
+  editIndex: number
+): EditPlanResult {
+  const { old_string, new_string, replace_all = false } = edit;
+
+  if (old_string.length === 0) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: old_string for edit ${editIndex} must not be empty.`,
+    };
+  }
+
+  if (old_string === new_string) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: old_string and new_string must be different for edit ${editIndex}.`,
+    };
+  }
+
+  const matches = indicesOf(content, old_string);
+
+  if (matches.length === 0) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: Could not find old_string for edit ${editIndex}. Make sure it matches exactly (whitespace-sensitive).`,
+    };
+  }
+
+  if (!replace_all && matches.length > 1) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: old_string for edit ${editIndex} appears ${matches.length} times. Provide more context to make it unique, or use replace_all: true for that edit.`,
+    };
+  }
+
+  if (replace_all) {
+    const hunks = matches.map((index) =>
+      makeHunk(editIndex, content, index, old_string, new_string)
+    );
+    return {
+      ok: true,
+      content: content.split(old_string).join(new_string),
+      replacements: matches.length,
+      hunks,
+    };
+  }
+
+  const index = matches[0];
+  if (index === undefined) {
+    return {
+      ok: false,
+      editIndex,
+      message: `Error: Could not find old_string for edit ${editIndex}.`,
+    };
+  }
+  return {
+    ok: true,
+    content:
+      content.slice(0, index) +
+      new_string +
+      content.slice(index + old_string.length),
+    replacements: 1,
+    hunks: [makeHunk(editIndex, content, index, old_string, new_string)],
+  };
+}
+
+export function applyEditPlan(
+  content: string,
+  edits: readonly TextEdit[]
+): EditPlanResult {
+  if (edits.length === 0) {
+    return {
+      ok: false,
+      message: "Error: edits must contain at least one edit.",
+    };
+  }
+
+  let current = content;
+  let replacements = 0;
+  const hunks: EditHunk[] = [];
+
+  for (const [index, edit] of edits.entries()) {
+    const result = applyOneEdit(current, edit, index);
+    if (!result.ok) return result;
+    current = result.content;
+    replacements += result.replacements;
+    hunks.push(...result.hunks);
+  }
+
+  return { ok: true, content: current, replacements, hunks };
+}
+
+function editFailureResult(
+  filePath: string,
+  message: string
+): {
+  toolResponse: string;
+  data: EditResult;
+} {
+  return {
+    toolResponse: message,
+    data: { path: filePath, success: false, replacements: 0 },
+  };
 }
 
 /**
@@ -26,66 +211,83 @@ export const editHandler: ActivityToolHandler<
   const { fs } = sandbox;
   const { file_path, old_string, new_string, replace_all = false } = args;
 
-  if (old_string === new_string) {
-    return {
-      toolResponse: `Error: old_string and new_string must be different.`,
-      data: { path: file_path, success: false, replacements: 0 },
-    };
-  }
-
   try {
     const exists = await fs.exists(file_path);
     if (!exists) {
-      return {
-        toolResponse: `Error: File "${file_path}" does not exist.`,
-        data: { path: file_path, success: false, replacements: 0 },
-      };
+      return editFailureResult(
+        file_path,
+        `Error: File "${file_path}" does not exist.`
+      );
     }
 
     const content = await fs.readFile(file_path);
+    const result = applyEditPlan(content, [
+      { old_string, new_string, replace_all },
+    ]);
 
-    if (!content.includes(old_string)) {
-      return {
-        toolResponse: `Error: Could not find the specified text in "${file_path}". Make sure old_string matches exactly (whitespace-sensitive).`,
-        data: { path: file_path, success: false, replacements: 0 },
-      };
+    if (!result.ok) {
+      return editFailureResult(file_path, result.message);
     }
 
-    const escapedOldString = escapeRegExp(old_string);
-    const globalRegex = new RegExp(escapedOldString, "g");
-    const occurrences = (content.match(globalRegex) || []).length;
+    await fs.writeFile(file_path, result.content);
 
-    if (!replace_all && occurrences > 1) {
-      return {
-        toolResponse: `Error: old_string appears ${occurrences} times in "${file_path}". Either provide more context to make it unique, or use replace_all: true.`,
-        data: { path: file_path, success: false, replacements: 0 },
-      };
-    }
+    const summary = replace_all
+      ? `Replaced ${result.replacements} occurrence(s)`
+      : `Replaced 1 occurrence`;
+
+    return {
+      toolResponse: `${summary} in ${file_path}`,
+      data: {
+        path: file_path,
+        success: true,
+        replacements: result.replacements,
+        hunks: result.hunks,
+      },
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      toolResponse: `Error editing file "${file_path}": ${message}`,
+      data: { path: file_path, success: false, replacements: 0 },
+    };
+  }
+};
 
-    let newContent: string;
-    let replacements: number;
-
-    if (replace_all) {
-      newContent = content.split(old_string).join(new_string);
-      replacements = occurrences;
-    } else {
-      const index = content.indexOf(old_string);
-      newContent =
-        content.slice(0, index) +
-        new_string +
-        content.slice(index + old_string.length);
-      replacements = 1;
+export const multiEditHandler: ActivityToolHandler<
+  FileMultiEditArgs,
+  EditResult,
+  SandboxContext
+> = async (args, { sandbox }) => {
+  const { fs } = sandbox;
+  const { file_path, edits } = args;
+
+  try {
+    const exists = await fs.exists(file_path);
+    if (!exists) {
+      return editFailureResult(
+        file_path,
+        `Error: File "${file_path}" does not exist.`
+      );
     }
 
-    await fs.writeFile(file_path, newContent);
+    const content = await fs.readFile(file_path);
+    const result = applyEditPlan(content, edits);
 
-    const summary = replace_all
-      ? `Replaced ${replacements} occurrence(s)`
-      : `Replaced 1 occurrence`;
+    if (!result.ok) {
+      const suffix = result.editIndex === undefined ? "" : ` in ${file_path}`;
+      return editFailureResult(file_path, `${result.message}${suffix}`);
+    }
+
+    await fs.writeFile(file_path, result.content);
 
     return {
-      toolResponse: `${summary} in ${file_path}`,
-      data: { path: file_path, success: true, replacements },
+      toolResponse: `Applied ${edits.length} edit(s), ${result.replacements} replacement(s) in ${file_path}`,
+      data: {
+        path: file_path,
+        success: true,
+        replacements: result.replacements,
+        hunks: result.hunks,
+      },
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown error";

package/src/tools/edit/tool.ts

@@ -1,6 +1,17 @@
 import { z } from "zod";
 import type { ToolDefinition } from "../../lib/tool-router";
 
+const textEditSchema = z.object({
+  old_string: z.string().describe("The exact text to replace"),
+  new_string: z.string().describe("The text to replace it with"),
+  replace_all: z
+    .boolean()
+    .optional()
+    .describe(
+      "If true, replace all occurrences of old_string for this edit (default: false)"
+    ),
+});
+
 export const editTool = {
   name: "FileEdit" as const,
   description: `Edit specific sections of a file by replacing text.
@@ -38,3 +49,32 @@ IMPORTANT:
 } satisfies ToolDefinition;
 
 export type FileEditArgs = z.infer<typeof editTool.schema>;
+
+export const multiEditTool = {
+  name: "FileMultiEdit" as const,
+  description: `Apply multiple exact text replacements to one file in order.
+
+Usage:
+- Use this when a task needs several related edits in the same file
+- Each edit is applied to the file content produced by the prior edit
+- The operation is atomic: if any edit fails, the file is left unchanged
+
+IMPORTANT:
+- You must read the file first (in this session) before editing it
+- Each old_string must match exactly (whitespace-sensitive)
+- Each old_string must be unique unless that edit uses replace_all: true
+- old_string and new_string must be different for every edit
+`,
+  schema: z.object({
+    file_path: z
+      .string()
+      .describe("The absolute virtual path to the file to modify"),
+    edits: z
+      .array(textEditSchema)
+      .min(1)
+      .describe("Exact replacements to apply sequentially to the file"),
+  }),
+  strict: true,
+} satisfies ToolDefinition;
+
+export type FileMultiEditArgs = z.infer<typeof multiEditTool.schema>;

package/src/tools/task-create/handler.ts

@@ -30,7 +30,7 @@ export function createTaskCreateHandler<
     stateManager.setTask(task);
 
     return {
-      toolResponse: JSON.stringify(task, null, 2),
+      toolResponse: `Task ${task.id} created`,
       data: task,
     };
   };

package/src/tools/task-update/handler.ts

@@ -64,7 +64,7 @@ export function createTaskUpdateHandler<
     stateManager.setTask(task);
 
     return {
-      toolResponse: JSON.stringify(task, null, 2),
+      toolResponse: `Task ${task.id} updated`,
       data: task,
     };
   };

package/src/workflow.ts

@@ -237,8 +237,8 @@ export { readFileTool } from "./tools/read-file/tool";
 export type { FileReadArgs } from "./tools/read-file/tool";
 export { writeFileTool } from "./tools/write-file/tool";
 export type { FileWriteArgs } from "./tools/write-file/tool";
-export { editTool } from "./tools/edit/tool";
-export type { FileEditArgs } from "./tools/edit/tool";
+export { editTool, multiEditTool } from "./tools/edit/tool";
+export type { FileEditArgs, FileMultiEditArgs } from "./tools/edit/tool";
 
 // Workflow task tools (state-only, no activities needed)
 export { taskCreateTool } from "./tools/task-create/tool";

package/dist/proxy-BxFyd6cg.d.cts

@@ -1,24 +0,0 @@
-import { proxyActivities, ActivityInterfaceFor } from '@temporalio/workflow';
-import { T as ThreadOps } from './types-CnuN9T6t.cjs';
-
-/**
- * Shared proxy helper for thread operations.
- *
- * Each adapter re-exports a thin wrapper that supplies its prefix and
- * casts the return type to carry the adapter's native content type.
- */
-
-/**
- * Creates a workflow-safe Temporal activity proxy for {@link ThreadOps}.
- *
- * The proxy resolves activity names by combining the adapter prefix with
- * the workflow scope, so each adapter + workflow combination gets its own
- * namespace.
- *
- * @param adapterPrefix - Adapter identifier (e.g. "anthropic", "googleGenAI", "langChain")
- * @param scope - Optional workflow scope override. Defaults to `workflowInfo().workflowType`.
- * @param options - Optional Temporal `proxyActivities` options.
- */
-declare function createThreadOpsProxy(adapterPrefix: string, scope?: string, options?: Parameters<typeof proxyActivities>[0]): ActivityInterfaceFor<ThreadOps>;
-
-export { createThreadOpsProxy as c };

package/dist/proxy-Cskmj4Yx.d.ts

@@ -1,24 +0,0 @@
-import { proxyActivities, ActivityInterfaceFor } from '@temporalio/workflow';
-import { T as ThreadOps } from './types-CwN6_tAL.js';
-
-/**
- * Shared proxy helper for thread operations.
- *
- * Each adapter re-exports a thin wrapper that supplies its prefix and
- * casts the return type to carry the adapter's native content type.
- */
-
-/**
- * Creates a workflow-safe Temporal activity proxy for {@link ThreadOps}.
- *
- * The proxy resolves activity names by combining the adapter prefix with
- * the workflow scope, so each adapter + workflow combination gets its own
- * namespace.
- *
- * @param adapterPrefix - Adapter identifier (e.g. "anthropic", "googleGenAI", "langChain")
- * @param scope - Optional workflow scope override. Defaults to `workflowInfo().workflowType`.
- * @param options - Optional Temporal `proxyActivities` options.
- */
-declare function createThreadOpsProxy(adapterPrefix: string, scope?: string, options?: Parameters<typeof proxyActivities>[0]): ActivityInterfaceFor<ThreadOps>;
-
-export { createThreadOpsProxy as c };