zeitlich 0.2.2 → 0.2.4

package/src/tools/bash/bash.test.ts

@@ -1,7 +1,7 @@
 import { dirname } from "path";
 import { fileURLToPath } from "url";
 import { describe, expect, it } from "vitest";
-import { handleBashTool } from "./handler";
+import { createBashHandler } from "./handler";
 import { OverlayFs } from "just-bash";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -10,7 +10,7 @@ describe("bash with default options", () => {
   const fs = new OverlayFs({ root: __dirname, mountPoint: "/home/user" });
 
   it("executes echo and captures stdout", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "echo 'hello world'" },
       {}
     );
@@ -20,17 +20,17 @@ describe("bash with default options", () => {
   });
 
   it("returns exit code 0 for successful commands", async () => {
-    const { data } = await handleBashTool({fs})({ command: "true" }, {});
+    const { data } = await createBashHandler({fs})({ command: "true" }, {});
     expect(data?.exitCode).toBe(0);
   });
 
   it("returns non-zero exit code for failed commands", async () => {
-    const { data } = await handleBashTool({fs})({ command: "false" }, {});
+    const { data } = await createBashHandler({fs})({ command: "false" }, {});
     expect(data?.exitCode).toBe(1);
   });
 
   it("captures stderr output", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "echo 'error message' >&2" },
       {}
     );
@@ -39,7 +39,7 @@ describe("bash with default options", () => {
   });
 
   it("supports piping between commands", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "echo 'hello world' | tr 'a-z' 'A-Z'" },
       {}
     );
@@ -47,7 +47,7 @@ describe("bash with default options", () => {
   });
 
   it("supports command chaining with &&", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "echo 'first' && echo 'second'" },
       {}
     );
@@ -56,7 +56,7 @@ describe("bash with default options", () => {
   });
 
   it("handles multi-line output", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "printf 'line1\\nline2\\nline3'" },
       {}
     );
@@ -67,7 +67,7 @@ describe("bash with default options", () => {
   });
 
   it("handles commands with arguments and flags", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "echo -n 'no newline'" },
       {}
     );
@@ -75,7 +75,7 @@ describe("bash with default options", () => {
   });
 
   it("supports command substitution", async () => {
-    const { data } = await handleBashTool({fs})(
+    const { data } = await createBashHandler({fs})(
       { command: "echo \"count: $(echo 'a b c' | wc -w | tr -d ' ')\"" },
       {}
     );
@@ -83,7 +83,7 @@ describe("bash with default options", () => {
   });
 
   it("returns toolResponse string with formatted output", async () => {
-    const { toolResponse } = await handleBashTool({fs})(
+    const { toolResponse } = await createBashHandler({fs})(
       { command: "echo 'test'" },
       {}
     );
@@ -96,7 +96,7 @@ describe("bash with default options", () => {
 describe("bash with overlay filesystem", () => {
   it("sees files in the current directory", async () => {
     const fs = new OverlayFs({ root: __dirname, mountPoint: "/home/user" });
-    const { data } = await handleBashTool({fs})({ command: "ls" }, {});
+    const { data } = await createBashHandler({fs})({ command: "ls" }, {});
     expect(data?.stdout).toContain("bash.test.ts");
     expect(data?.stdout).toContain("handler.ts");
     expect(data?.stdout).toContain("tool.ts");

package/src/tools/bash/handler.ts

@@ -1,5 +1,5 @@
-import type { ActivityToolHandler } from "../../workflow";
-import type { bashToolSchemaType } from "./tool";
+import type { ActivityToolHandler } from "../../lib/tool-router";
+import type { BashArgs } from "./tool";
 import { Bash, type BashOptions } from "just-bash";
 
 type BashExecOut = {
@@ -11,10 +11,10 @@ type BashExecOut = {
 /** BashOptions with `fs` required */
 type BashToolOptions = Required<Pick<BashOptions, "fs">> & Omit<BashOptions, "fs">;
 
-export const handleBashTool: (
+export const createBashHandler: (
     bashOptions: BashToolOptions,
-) => ActivityToolHandler<bashToolSchemaType, BashExecOut | null> =
-  (bashOptions: BashToolOptions) => async (args: bashToolSchemaType, _context) => {
+) => ActivityToolHandler<BashArgs, BashExecOut | null> =
+  (bashOptions: BashToolOptions) => async (args: BashArgs, _context) => {
     const { command } = args;
 
     const mergedOptions: BashOptions = {

package/src/tools/bash/tool.ts

@@ -1,4 +1,5 @@
 import z from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const createBashToolDescription = ({
   fileTree,
@@ -31,6 +32,6 @@ Use this tool to:
       ),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type bashToolSchemaType = z.infer<typeof bashTool.schema>;
+export type BashArgs = z.infer<typeof bashTool.schema>;

package/src/tools/edit/handler.ts

@@ -1,38 +1,16 @@
-import type { EditToolSchemaType } from "./tool";
+import type { ActivityToolHandler } from "../../lib/tool-router";
+import type { FileEditArgs } from "./tool";
 import type { IFileSystem } from "just-bash";
 
 /**
  * Result of an edit operation
  */
-export interface EditResult {
+interface EditResult {
   path: string;
   success: boolean;
   replacements: number;
 }
 
-/**
- * Edit handler response
- */
-export interface EditHandlerResponse {
-  toolResponse: string;
-  data: EditResult;
-}
-
-/**
- * Options for edit handler
- */
-export interface EditHandlerOptions {
-  /**
-   * Set of file paths that have been read in this session.
-   * Required for enforcing read-before-write policy.
-   */
-  readFiles: Set<string>;
-  /**
-   * If true, skip the read-before-write check (not recommended)
-   */
-  skipReadCheck?: boolean;
-}
-
 /**
  * Escape special regex characters in a string
  */
@@ -41,116 +19,93 @@ function escapeRegExp(str: string): string {
 }
 
 /**
- * Edit handler that edits files within the scoped file tree.
+ * Creates an edit handler that edits files within the scoped file tree.
  *
- * @param args - Tool arguments (file_path, old_string, new_string, replace_all)
- * @param options - Additional options (readFiles, skipReadCheck)
+ * @param fs - File system implementation for I/O operations
+ * @returns An ActivityToolHandler for edit tool calls
  */
-export async function editHandler(
-  args: EditToolSchemaType,
+export function createEditHandler(
   fs: IFileSystem
-): Promise<EditHandlerResponse> {
-  const { file_path, old_string, new_string, replace_all = false } = args;
-
-  // Validate old_string !== new_string
-  if (old_string === new_string) {
-    return {
-      toolResponse: `Error: old_string and new_string must be different.`,
-      data: {
-        path: file_path,
-        success: false,
-        replacements: 0,
-      },
-    };
-  }
+): ActivityToolHandler<FileEditArgs, EditResult> {
+  return async (args) => {
+    const { file_path, old_string, new_string, replace_all = false } = args;
 
-  try {
-    // Check if file exists
-    const exists = await fs.exists(file_path);
-    if (!exists) {
+    // Validate old_string !== new_string
+    if (old_string === new_string) {
       return {
-        toolResponse: `Error: File "${file_path}" does not exist.`,
-        data: {
-          path: file_path,
-          success: false,
-          replacements: 0,
-        },
+        toolResponse: `Error: old_string and new_string must be different.`,
+        data: { path: file_path, success: false, replacements: 0 },
       };
     }
 
-    // Read current content
-    const content = await fs.readFile(file_path);
+    try {
+      // Check if file exists
+      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 },
+        };
+      }
+
+      // Read current content
+      const content = await fs.readFile(file_path);
+
+      // Check if old_string exists in the file
+      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 },
+        };
+      }
+
+      // Count occurrences
+      const escapedOldString = escapeRegExp(old_string);
+      const globalRegex = new RegExp(escapedOldString, "g");
+      const occurrences = (content.match(globalRegex) || []).length;
+
+      // Check uniqueness if not replace_all
+      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 },
+        };
+      }
+
+      // Perform replacement
+      let newContent: string;
+      let replacements: number;
+
+      if (replace_all) {
+        newContent = content.split(old_string).join(new_string);
+        replacements = occurrences;
+      } else {
+        // Replace only the first occurrence
+        const index = content.indexOf(old_string);
+        newContent =
+          content.slice(0, index) +
+          new_string +
+          content.slice(index + old_string.length);
+        replacements = 1;
+      }
+
+      // Write the modified content
+      await fs.writeFile(file_path, newContent);
+
+      const summary = replace_all
+        ? `Replaced ${replacements} occurrence(s)`
+        : `Replaced 1 occurrence`;
 
-    // Check if old_string exists in the file
-    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,
-        },
+        toolResponse: `${summary} in ${file_path}`,
+        data: { path: file_path, success: true, replacements },
       };
-    }
-
-    // Count occurrences
-    const escapedOldString = escapeRegExp(old_string);
-    const globalRegex = new RegExp(escapedOldString, "g");
-    const occurrences = (content.match(globalRegex) || []).length;
-
-    // Check uniqueness if not replace_all
-    if (!replace_all && occurrences > 1) {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
       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,
-        },
+        toolResponse: `Error editing file "${file_path}": ${message}`,
+        data: { path: file_path, success: false, replacements: 0 },
       };
     }
-
-    // Perform replacement
-    let newContent: string;
-    let replacements: number;
-
-    if (replace_all) {
-      newContent = content.split(old_string).join(new_string);
-      replacements = occurrences;
-    } else {
-      // Replace only the first occurrence
-      const index = content.indexOf(old_string);
-      newContent =
-        content.slice(0, index) +
-        new_string +
-        content.slice(index + old_string.length);
-      replacements = 1;
-    }
-
-    // Write the modified content
-    await fs.writeFile(file_path, newContent);
-
-    const summary = replace_all
-      ? `Replaced ${replacements} occurrence(s)`
-      : `Replaced 1 occurrence`;
-
-    return {
-      toolResponse: `${summary} in ${file_path}`,
-      data: {
-        path: file_path,
-        success: true,
-        replacements,
-      },
-    };
-  } 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,
-      },
-    };
-  }
+  };
 }

package/src/tools/edit/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const editTool = {
   name: "FileEdit" as const,
@@ -34,6 +35,6 @@ IMPORTANT:
       ),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type EditToolSchemaType = z.infer<typeof editTool.schema>;
+export type FileEditArgs = z.infer<typeof editTool.schema>;

package/src/tools/glob/handler.ts

@@ -1,62 +1,31 @@
+import type { ActivityToolHandler } from "../../lib/tool-router";
+import type { GlobArgs } from "./tool";
 import type { IFileSystem } from "just-bash";
 import { Bash } from "just-bash";
-import type { GlobToolSchemaType } from "./tool";
 
 /**
  * Result of a glob operation
  */
-export interface GlobResult {
+interface GlobResult {
   files: string[];
 }
 
 /**
- * Glob handler response
- */
-export interface GlobHandlerResponse {
-  toolResponse: string;
-  data: GlobResult;
-}
-
-/**
- * Glob handler that searches within the scoped file tree.
+ * Creates a glob handler that searches within the scoped file tree.
  *
- * @param args - Tool arguments (pattern, root)
- * @param provider - FileSystemProvider for I/O operations
+ * @param fs - File system implementation for I/O operations
+ * @returns An ActivityToolHandler for glob tool calls
  */
-export async function globHandler(
-  _args: GlobToolSchemaType,
+export function createGlobHandler(
   fs: IFileSystem
-): Promise<GlobHandlerResponse> {
-  // const { pattern, root } = args;
-  const _bash = new Bash({ fs });
-
-  return Promise.resolve({
-    toolResponse: "Hello, world!",
-    data: { files: [] },
-  });
-
-  // try {
-  //   const matches = await bash.exec(`glob ${root} -name "${pattern}"`);
-
-  //   if (matches.length === 0) {
-  //     return {
-  //       content: `No files found matching pattern: ${pattern}`,
-  //       result: { files: [] },
-  //     };
-  //   }
-
-  //   const paths = matches.map((node) => node.path);
-  //   const fileList = paths.map((p) => `  ${p}`).join("\n");
-
-  //   return {
-  //     content: `Found ${matches.length} file(s) matching "${pattern}":\n${fileList}`,
-  //     result: { files: matches },
-  //   };
-  // } catch (error) {
-  //   const message = error instanceof Error ? error.message : "Unknown error";
-  //   return {
-  //     content: `Error searching for files: ${message}`,
-  //     result: { files: [] },
-  //   };
-  // }
+): ActivityToolHandler<GlobArgs, GlobResult> {
+  return async (_args) => {
+    // const { pattern, root } = args;
+    const _bash = new Bash({ fs });
+
+    return {
+      toolResponse: "Hello, world!",
+      data: { files: [] },
+    };
+  };
 }

package/src/tools/glob/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const globTool = {
   name: "Glob" as const,
@@ -22,6 +23,6 @@ Examples:
       .describe("Optional root directory to search from"),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type GlobToolSchemaType = z.infer<typeof globTool.schema>;
+export type GlobArgs = z.infer<typeof globTool.schema>;

package/src/tools/grep/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const grepTool = {
   name: "Grep" as const,
@@ -40,6 +41,6 @@ Examples:
       .describe("Number of context lines to show around matches"),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type GrepToolSchemaType = z.infer<typeof grepTool.schema>;
+export type GrepArgs = z.infer<typeof grepTool.schema>;

package/src/tools/{read → read-file}/tool.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { ToolDefinition } from "../../lib/tool-router";
 
 export const readTool = {
   name: "FileRead" as const,
@@ -28,6 +29,6 @@ The tool returns the file content in an appropriate format:
       .describe("Maximum number of lines to read (for text files)"),
   }),
   strict: true,
-};
+} satisfies ToolDefinition;
 
-export type ReadToolSchemaType = z.infer<typeof readTool.schema>;
+export type FileReadArgs = z.infer<typeof readTool.schema>;

package/src/tools/{task → subagent}/handler.ts

@@ -1,26 +1,20 @@
 import { executeChild, workflowInfo, uuid4 } from "@temporalio/workflow";
 import type { ToolHandlerResponse } from "../../lib/tool-router";
-import type { SubagentConfig, SubagentInput } from "../../lib/types";
-import type { GenericTaskToolSchemaType } from "./tool";
+import type {
+  InferSubagentResult,
+  SubagentConfig,
+  SubagentInput,
+} from "../../lib/types";
+import type { SubagentArgs } from "./tool";
 
 /**
- * Result from a task handler execution
- */
-export interface TaskHandlerResult<TResult = unknown> {
-  /** The validated result from the child workflow */
-  result: TResult;
-  /** The child workflow ID (for reference/debugging) */
-  childWorkflowId: string;
-}
-
-/**
- * Creates a Task tool handler that spawns child workflows for configured subagents.
+ * Creates a Subagent tool handler that spawns child workflows for configured subagents.
  *
  * @param subagents - Array of subagent configurations
  * @returns A tool handler function that can be used with the tool router
  *
  * @example
- * const taskHandler = taskHandler([
+ * const subagentHandler = subagentHandler([
  *   {
  *     name: "researcher",
  *     description: "Researches topics",
@@ -29,13 +23,15 @@ export interface TaskHandlerResult<TResult = unknown> {
  *   },
  * ]);
  */
-export function createTaskHandler(subagents: SubagentConfig[]) {
+export function createSubagentHandler<
+  const T extends readonly SubagentConfig[],
+>(subagents: [...T]) {
   const { workflowId: parentWorkflowId, taskQueue: parentTaskQueue } =
     workflowInfo();
 
   return async (
-    args: GenericTaskToolSchemaType
-  ): Promise<ToolHandlerResponse<TaskHandlerResult>> => {
+    args: SubagentArgs
+  ): Promise<ToolHandlerResponse<InferSubagentResult<T[number]> | null>> => {
     const config = subagents.find((s) => s.name === args.subagent);
 
     if (!config) {
@@ -58,28 +54,19 @@ export function createTaskHandler(subagents: SubagentConfig[]) {
       taskQueue: config.taskQueue ?? parentTaskQueue,
     };
 
-    const childResult =
+    const { toolResponse, data } =
       typeof config.workflow === "string"
         ? await executeChild(config.workflow, childOpts)
         : await executeChild(config.workflow, childOpts);
 
     // Validate result if schema provided, otherwise pass through as-is
-    const validated = config.resultSchema
-      ? config.resultSchema.parse(childResult)
-      : childResult;
-
-    // Format content - stringify objects, pass strings through
-    const toolResponse =
-      typeof validated === "string"
-        ? validated
-        : JSON.stringify(validated, null, 2);
+    const validated = (
+      config.resultSchema ? config.resultSchema.parse(data) : null
+    ) as InferSubagentResult<T[number]> | null;
 
     return {
       toolResponse,
-      data: {
-        result: validated,
-        childWorkflowId,
-      },
+      data: validated,
     };
   };
 }