zeitlich 0.2.15 → 0.2.17

package/src/adapters/sandbox/virtual/with-virtual-sandbox.ts

@@ -15,7 +15,7 @@ import { createVirtualSandbox } from "./index";
  * the parent workflow for the current file tree and resolver context.
  *
  * On each invocation the wrapper:
- * 1. Queries the workflow's `AgentState` for `fileTree` and `resolverContext`
+ * 1. Queries the workflow's `AgentState` for `fileTree`, `resolverContext`, and `workspaceBase`
  * 2. Creates an ephemeral {@link VirtualSandbox} from tree + provider's resolver
  * 3. Runs the inner handler
  * 4. Returns the handler's result together with any {@link TreeMutation}s
@@ -63,7 +63,7 @@ export function withVirtualSandbox<
     const state =
       await queryParentWorkflowState<VirtualSandboxState<TCtx, TMeta>>(client);
 
-    const { sandboxId, fileTree, resolverContext } = state;
+    const { sandboxId, fileTree, resolverContext, workspaceBase } = state;
     if (!fileTree || !sandboxId) {
       return {
         toolResponse: `Error: No fileTree/sandboxId in agent state. The ${context.toolName} tool requires a virtual sandbox.`,
@@ -75,7 +75,8 @@ export function withVirtualSandbox<
       sandboxId,
       fileTree,
       provider.resolver,
-      resolverContext
+      resolverContext,
+      workspaceBase ?? "/",
     );
     const response = await handler(args, { ...context, sandbox });
     const mutations = sandbox.fs.getMutations();

package/src/adapters/thread/langchain/activities.ts

@@ -96,7 +96,7 @@ export function createLangChainAdapter(
 
     async forkThread(
       sourceThreadId: string,
-      targetThreadId: string,
+      targetThreadId: string
     ): Promise<void> {
       const thread = createLangChainThreadManager({
         redis,
@@ -106,18 +106,20 @@ export function createLangChainAdapter(
     },
   };
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const makeInvoker = (model: BaseChatModel<any>): ModelInvoker<StoredMessage> =>
+  const makeInvoker = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    model: BaseChatModel<any>
+  ): ModelInvoker<StoredMessage> =>
     createLangChainModelInvoker({ redis, model });
 
   const invoker: ModelInvoker<StoredMessage> = config.model
     ? makeInvoker(config.model)
-    : ((() => {
+    : () => {
         throw new Error(
           "No default model provided to createLangChainAdapter. " +
             "Either pass `model` in the config or use `createModelInvoker(model)` instead."
         );
-      }) as unknown as ModelInvoker<StoredMessage>);
+      };
 
   return {
     threadOps,

package/src/lib/sandbox/tree.integration.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from "vitest";
+import { toTree } from "./tree";
+import type { SandboxFileSystem, DirentEntry } from "./types";
+
+function createMockFs(
+  structure: Record<string, { isDir: boolean; isLink?: boolean; linkTarget?: string }>,
+): SandboxFileSystem {
+  return {
+    workspaceBase: "/",
+    exists: async (path: string) => path in structure,
+    stat: async (path: string) => {
+      const entry = structure[path];
+      return {
+        isFile: entry ? !entry.isDir : false,
+        isDirectory: entry ? entry.isDir : false,
+        isSymbolicLink: entry?.isLink ?? false,
+        size: 0,
+        mtime: new Date(),
+      };
+    },
+    readdir: async (dir: string) => {
+      const prefix = dir.endsWith("/") ? dir : dir + "/";
+      return Object.keys(structure)
+        .filter((p) => p.startsWith(prefix) && !p.slice(prefix.length).includes("/"))
+        .map((p) => p.slice(prefix.length));
+    },
+    readdirWithFileTypes: async (dir: string): Promise<DirentEntry[]> => {
+      const prefix = dir.endsWith("/") ? dir : dir + "/";
+      return Object.entries(structure)
+        .filter(([p]) => p.startsWith(prefix) && !p.slice(prefix.length).includes("/"))
+        .map(([p, meta]) => ({
+          name: p.slice(prefix.length),
+          isFile: !meta.isDir && !meta.isLink,
+          isDirectory: meta.isDir,
+          isSymbolicLink: meta.isLink ?? false,
+        }));
+    },
+    readFile: async () => "",
+    readFileBuffer: async () => new Uint8Array(),
+    writeFile: async () => {},
+    appendFile: async () => {},
+    mkdir: async () => {},
+    rm: async () => {},
+    cp: async () => {},
+    mv: async () => {},
+    readlink: async (path: string) => structure[path]?.linkTarget ?? "",
+    resolvePath: (base: string, path: string) => base + "/" + path,
+  };
+}
+
+describe("toTree", () => {
+  it("renders a flat directory", async () => {
+    const fs = createMockFs({
+      "/a.txt": { isDir: false },
+      "/b.txt": { isDir: false },
+      "/c.txt": { isDir: false },
+    });
+
+    const tree = await toTree(fs);
+    expect(tree).toContain("a.txt");
+    expect(tree).toContain("b.txt");
+    expect(tree).toContain("c.txt");
+    expect(tree).toContain("├─");
+    expect(tree).toContain("└─");
+  });
+
+  it("renders nested directories", async () => {
+    const fs = createMockFs({
+      "/src": { isDir: true },
+      "/src/index.ts": { isDir: false },
+      "/src/utils.ts": { isDir: false },
+      "/package.json": { isDir: false },
+    });
+
+    const tree = await toTree(fs);
+    expect(tree).toContain("src/");
+    expect(tree).toContain("index.ts");
+    expect(tree).toContain("utils.ts");
+    expect(tree).toContain("package.json");
+  });
+
+  it("sorts directories before files", async () => {
+    const fs = createMockFs({
+      "/zebra.txt": { isDir: false },
+      "/alpha": { isDir: true },
+      "/beta.txt": { isDir: false },
+    });
+
+    const tree = await toTree(fs);
+    const lines = tree.split("\n");
+    const alphaLine = lines.findIndex((l) => l.includes("alpha/"));
+    const zebraLine = lines.findIndex((l) => l.includes("zebra.txt"));
+    expect(alphaLine).toBeLessThan(zebraLine);
+  });
+
+  it("renders symlinks with target", async () => {
+    const fs = createMockFs({
+      "/link.txt": { isDir: false, isLink: true, linkTarget: "/real.txt" },
+      "/real.txt": { isDir: false },
+    });
+
+    const tree = await toTree(fs);
+    expect(tree).toContain("link.txt");
+    expect(tree).toContain("→");
+    expect(tree).toContain("/real.txt");
+  });
+
+  it("respects depth limit", async () => {
+    const fs = createMockFs({
+      "/a": { isDir: true },
+      "/a/b": { isDir: true },
+      "/a/b/c.txt": { isDir: false },
+    });
+
+    const shallowTree = await toTree(fs, { depth: 1 });
+    expect(shallowTree).toContain("a/");
+    expect(shallowTree).toContain("(...)");
+    expect(shallowTree).not.toContain("c.txt");
+
+    const deepTree = await toTree(fs, { depth: 3 });
+    expect(deepTree).toContain("a/");
+    expect(deepTree).toContain("b/");
+    expect(deepTree).toContain("c.txt");
+  });
+
+  it("renders empty directory", async () => {
+    const fs = createMockFs({});
+
+    const tree = await toTree(fs);
+    expect(tree).toContain("/");
+  });
+
+  it("disables sorting when sort=false", async () => {
+    const fs = createMockFs({
+      "/z.txt": { isDir: false },
+      "/a.txt": { isDir: false },
+    });
+
+    const tree = await toTree(fs, { sort: false });
+    expect(tree).toContain("z.txt");
+    expect(tree).toContain("a.txt");
+  });
+
+  it("uses custom start directory", async () => {
+    const fs = createMockFs({
+      "/home/user/file.txt": { isDir: false },
+    });
+
+    const tree = await toTree(fs, { dir: "/home/user" });
+    expect(tree).toContain("user/");
+    expect(tree).toContain("file.txt");
+  });
+});

package/src/lib/sandbox/types.ts

@@ -24,6 +24,8 @@ export interface FileStat {
  * {@link SandboxNotSupportedError}.
  */
 export interface SandboxFileSystem {
+  /** Base directory used when resolving relative paths. */
+  readonly workspaceBase: string;
   readFile(path: string): Promise<string>;
   readFileBuffer(path: string): Promise<Uint8Array>;
   writeFile(path: string, content: string | Uint8Array): Promise<void>;