@canonical/summon 0.1.0

package/src/__tests__/effect.test.ts

@@ -0,0 +1,816 @@
+import { describe, expect, it } from "vitest";
+import {
+  copyDirectoryEffect,
+  copyFileEffect,
+  deleteDirectoryEffect,
+  deleteFileEffect,
+  describeEffect,
+  execEffect,
+  existsEffect,
+  getAffectedPaths,
+  globEffect,
+  isWriteEffect,
+  logEffect,
+  makeDirEffect,
+  parallelEffect,
+  promptEffect,
+  raceEffect,
+  readContextEffect,
+  readFileEffect,
+  writeContextEffect,
+  writeFileEffect,
+} from "../effect.js";
+import { pure } from "../task.js";
+
+// =============================================================================
+// File System Effect Constructors
+// =============================================================================
+
+describe("Effect Constructors - File System", () => {
+  describe("readFileEffect", () => {
+    it("creates a ReadFile effect with the given path", () => {
+      const effect = readFileEffect("/path/to/file.txt");
+
+      expect(effect._tag).toBe("ReadFile");
+      expect((effect as { path: string }).path).toBe("/path/to/file.txt");
+    });
+
+    it("handles absolute paths", () => {
+      const effect = readFileEffect("/absolute/path/file.ts");
+      expect((effect as { path: string }).path).toBe("/absolute/path/file.ts");
+    });
+
+    it("handles relative paths", () => {
+      const effect = readFileEffect("./relative/path/file.ts");
+      expect((effect as { path: string }).path).toBe("./relative/path/file.ts");
+    });
+
+    it("handles paths with special characters", () => {
+      const effect = readFileEffect("/path/with spaces/file (1).txt");
+      expect((effect as { path: string }).path).toBe(
+        "/path/with spaces/file (1).txt",
+      );
+    });
+
+    it("handles paths with unicode characters", () => {
+      const effect = readFileEffect("/путь/到/ファイル.txt");
+      expect((effect as { path: string }).path).toBe("/путь/到/ファイル.txt");
+    });
+  });
+
+  describe("writeFileEffect", () => {
+    it("creates a WriteFile effect with path and content", () => {
+      const effect = writeFileEffect("/output/file.txt", "Hello, World!");
+
+      expect(effect._tag).toBe("WriteFile");
+      expect((effect as { path: string }).path).toBe("/output/file.txt");
+      expect((effect as { content: string }).content).toBe("Hello, World!");
+    });
+
+    it("handles empty content", () => {
+      const effect = writeFileEffect("/empty.txt", "");
+      expect((effect as { content: string }).content).toBe("");
+    });
+
+    it("handles multiline content", () => {
+      const content = "line1\nline2\nline3";
+      const effect = writeFileEffect("/multiline.txt", content);
+      expect((effect as { content: string }).content).toBe(content);
+    });
+
+    it("handles large content", () => {
+      const content = "x".repeat(100000);
+      const effect = writeFileEffect("/large.txt", content);
+      expect((effect as { content: string }).content.length).toBe(100000);
+    });
+
+    it("handles content with special characters", () => {
+      const content = 'Special: @#$%^&*()[]{}|\\;"<>\n\t\r';
+      const effect = writeFileEffect("/special.txt", content);
+      expect((effect as { content: string }).content).toBe(content);
+    });
+
+    it("handles JSON content", () => {
+      const jsonContent = JSON.stringify({
+        key: "value",
+        nested: { arr: [1, 2, 3] },
+      });
+      const effect = writeFileEffect("/data.json", jsonContent);
+      expect((effect as { content: string }).content).toBe(jsonContent);
+    });
+  });
+
+  describe("copyFileEffect", () => {
+    it("creates a CopyFile effect with source and dest", () => {
+      const effect = copyFileEffect("/source/file.txt", "/dest/file.txt");
+
+      expect(effect._tag).toBe("CopyFile");
+      expect((effect as { source: string }).source).toBe("/source/file.txt");
+      expect((effect as { dest: string }).dest).toBe("/dest/file.txt");
+    });
+
+    it("handles same directory copy", () => {
+      const effect = copyFileEffect("/dir/original.txt", "/dir/copy.txt");
+      expect((effect as { source: string }).source).toBe("/dir/original.txt");
+      expect((effect as { dest: string }).dest).toBe("/dir/copy.txt");
+    });
+
+    it("handles cross-directory copy", () => {
+      const effect = copyFileEffect(
+        "/source/dir/file.txt",
+        "/different/dest/file.txt",
+      );
+      expect((effect as { source: string }).source).toBe(
+        "/source/dir/file.txt",
+      );
+      expect((effect as { dest: string }).dest).toBe(
+        "/different/dest/file.txt",
+      );
+    });
+  });
+
+  describe("copyDirectoryEffect", () => {
+    it("creates a CopyDirectory effect with source and dest", () => {
+      const effect = copyDirectoryEffect("/source/dir", "/dest/dir");
+
+      expect(effect._tag).toBe("CopyDirectory");
+      expect((effect as { source: string }).source).toBe("/source/dir");
+      expect((effect as { dest: string }).dest).toBe("/dest/dir");
+    });
+  });
+
+  describe("deleteFileEffect", () => {
+    it("creates a DeleteFile effect with the given path", () => {
+      const effect = deleteFileEffect("/path/to/delete.txt");
+
+      expect(effect._tag).toBe("DeleteFile");
+      expect((effect as { path: string }).path).toBe("/path/to/delete.txt");
+    });
+  });
+
+  describe("deleteDirectoryEffect", () => {
+    it("creates a DeleteDirectory effect with the given path", () => {
+      const effect = deleteDirectoryEffect("/path/to/delete/dir");
+
+      expect(effect._tag).toBe("DeleteDirectory");
+      expect((effect as { path: string }).path).toBe("/path/to/delete/dir");
+    });
+  });
+
+  describe("makeDirEffect", () => {
+    it("creates a MakeDir effect with default recursive true", () => {
+      const effect = makeDirEffect("/new/directory");
+
+      expect(effect._tag).toBe("MakeDir");
+      expect((effect as { path: string }).path).toBe("/new/directory");
+      expect((effect as { recursive: boolean }).recursive).toBe(true);
+    });
+
+    it("creates a MakeDir effect with explicit recursive true", () => {
+      const effect = makeDirEffect("/new/directory", true);
+      expect((effect as { recursive: boolean }).recursive).toBe(true);
+    });
+
+    it("creates a MakeDir effect with recursive false", () => {
+      const effect = makeDirEffect("/new/directory", false);
+      expect((effect as { recursive: boolean }).recursive).toBe(false);
+    });
+  });
+
+  describe("existsEffect", () => {
+    it("creates an Exists effect with the given path", () => {
+      const effect = existsEffect("/path/to/check");
+
+      expect(effect._tag).toBe("Exists");
+      expect((effect as { path: string }).path).toBe("/path/to/check");
+    });
+  });
+
+  describe("globEffect", () => {
+    it("creates a Glob effect with pattern and cwd", () => {
+      const effect = globEffect("**/*.ts", "/project/src");
+
+      expect(effect._tag).toBe("Glob");
+      expect((effect as { pattern: string }).pattern).toBe("**/*.ts");
+      expect((effect as { cwd: string }).cwd).toBe("/project/src");
+    });
+
+    it("handles complex glob patterns", () => {
+      const effect = globEffect("**/*.{ts,tsx,js,jsx}", "/src");
+      expect((effect as { pattern: string }).pattern).toBe(
+        "**/*.{ts,tsx,js,jsx}",
+      );
+    });
+
+    it("handles negation patterns", () => {
+      const effect = globEffect("!**/node_modules/**", "/project");
+      expect((effect as { pattern: string }).pattern).toBe(
+        "!**/node_modules/**",
+      );
+    });
+  });
+});
+
+// =============================================================================
+// Process Effect Constructors
+// =============================================================================
+
+describe("Effect Constructors - Process", () => {
+  describe("execEffect", () => {
+    it("creates an Exec effect with command and args", () => {
+      const effect = execEffect("npm", ["install"]);
+
+      expect(effect._tag).toBe("Exec");
+      expect((effect as { command: string }).command).toBe("npm");
+      expect((effect as { args: string[] }).args).toEqual(["install"]);
+      expect((effect as { cwd?: string }).cwd).toBeUndefined();
+    });
+
+    it("creates an Exec effect with cwd", () => {
+      const effect = execEffect("npm", ["install"], "/project");
+
+      expect((effect as { command: string }).command).toBe("npm");
+      expect((effect as { args: string[] }).args).toEqual(["install"]);
+      expect((effect as { cwd?: string }).cwd).toBe("/project");
+    });
+
+    it("handles empty args", () => {
+      const effect = execEffect("ls", []);
+      expect((effect as { args: string[] }).args).toEqual([]);
+    });
+
+    it("handles multiple args", () => {
+      const effect = execEffect("git", [
+        "commit",
+        "-m",
+        "Initial commit",
+        "--no-verify",
+      ]);
+      expect((effect as { args: string[] }).args).toEqual([
+        "commit",
+        "-m",
+        "Initial commit",
+        "--no-verify",
+      ]);
+    });
+
+    it("handles args with special characters", () => {
+      const effect = execEffect("echo", ['Hello "World"', "$PATH"]);
+      expect((effect as { args: string[] }).args).toEqual([
+        'Hello "World"',
+        "$PATH",
+      ]);
+    });
+  });
+});
+
+// =============================================================================
+// Prompt Effect Constructors
+// =============================================================================
+
+describe("Effect Constructors - Prompt", () => {
+  describe("promptEffect", () => {
+    it("creates a Prompt effect for text input", () => {
+      const question = {
+        type: "text" as const,
+        name: "username",
+        message: "Enter your name:",
+        default: "anonymous",
+      };
+      const effect = promptEffect(question);
+
+      expect(effect._tag).toBe("Prompt");
+      expect((effect as { question: typeof question }).question).toEqual(
+        question,
+      );
+    });
+
+    it("creates a Prompt effect for confirm", () => {
+      const question = {
+        type: "confirm" as const,
+        name: "proceed",
+        message: "Continue?",
+        default: true,
+      };
+      const effect = promptEffect(question);
+
+      expect(effect._tag).toBe("Prompt");
+      expect((effect as { question: typeof question }).question.type).toBe(
+        "confirm",
+      );
+    });
+
+    it("creates a Prompt effect for select", () => {
+      const question = {
+        type: "select" as const,
+        name: "framework",
+        message: "Choose a framework:",
+        choices: [
+          { label: "React", value: "react" },
+          { label: "Vue", value: "vue" },
+          { label: "Angular", value: "angular" },
+        ],
+        default: "react",
+      };
+      const effect = promptEffect(question);
+
+      expect(effect._tag).toBe("Prompt");
+      expect(
+        (effect as { question: typeof question }).question.choices,
+      ).toHaveLength(3);
+    });
+
+    it("creates a Prompt effect for multiselect", () => {
+      const question = {
+        type: "multiselect" as const,
+        name: "features",
+        message: "Select features:",
+        choices: [
+          { label: "TypeScript", value: "ts" },
+          { label: "ESLint", value: "eslint" },
+          { label: "Prettier", value: "prettier" },
+        ],
+        default: ["ts", "prettier"],
+      };
+      const effect = promptEffect(question);
+
+      expect(effect._tag).toBe("Prompt");
+      expect((effect as { question: typeof question }).question.type).toBe(
+        "multiselect",
+      );
+    });
+  });
+});
+
+// =============================================================================
+// Logging Effect Constructors
+// =============================================================================
+
+describe("Effect Constructors - Logging", () => {
+  describe("logEffect", () => {
+    it("creates a Log effect with debug level", () => {
+      const effect = logEffect("debug", "Debug message");
+
+      expect(effect._tag).toBe("Log");
+      expect((effect as { level: string }).level).toBe("debug");
+      expect((effect as { message: string }).message).toBe("Debug message");
+    });
+
+    it("creates a Log effect with info level", () => {
+      const effect = logEffect("info", "Info message");
+      expect((effect as { level: string }).level).toBe("info");
+    });
+
+    it("creates a Log effect with warn level", () => {
+      const effect = logEffect("warn", "Warning message");
+      expect((effect as { level: string }).level).toBe("warn");
+    });
+
+    it("creates a Log effect with error level", () => {
+      const effect = logEffect("error", "Error message");
+      expect((effect as { level: string }).level).toBe("error");
+    });
+
+    it("handles empty message", () => {
+      const effect = logEffect("info", "");
+      expect((effect as { message: string }).message).toBe("");
+    });
+
+    it("handles multiline message", () => {
+      const message = "Line 1\nLine 2\nLine 3";
+      const effect = logEffect("info", message);
+      expect((effect as { message: string }).message).toBe(message);
+    });
+  });
+});
+
+// =============================================================================
+// Context Effect Constructors
+// =============================================================================
+
+describe("Effect Constructors - Context", () => {
+  describe("readContextEffect", () => {
+    it("creates a ReadContext effect with the given key", () => {
+      const effect = readContextEffect("myKey");
+
+      expect(effect._tag).toBe("ReadContext");
+      expect((effect as { key: string }).key).toBe("myKey");
+    });
+
+    it("handles dot notation keys", () => {
+      const effect = readContextEffect("user.settings.theme");
+      expect((effect as { key: string }).key).toBe("user.settings.theme");
+    });
+  });
+
+  describe("writeContextEffect", () => {
+    it("creates a WriteContext effect with key and value", () => {
+      const effect = writeContextEffect("myKey", { data: 123 });
+
+      expect(effect._tag).toBe("WriteContext");
+      expect((effect as { key: string }).key).toBe("myKey");
+      expect((effect as { value: unknown }).value).toEqual({ data: 123 });
+    });
+
+    it("handles string value", () => {
+      const effect = writeContextEffect("name", "John");
+      expect((effect as { value: unknown }).value).toBe("John");
+    });
+
+    it("handles number value", () => {
+      const effect = writeContextEffect("count", 42);
+      expect((effect as { value: unknown }).value).toBe(42);
+    });
+
+    it("handles boolean value", () => {
+      const effect = writeContextEffect("enabled", true);
+      expect((effect as { value: unknown }).value).toBe(true);
+    });
+
+    it("handles null value", () => {
+      const effect = writeContextEffect("nullable", null);
+      expect((effect as { value: unknown }).value).toBeNull();
+    });
+
+    it("handles undefined value", () => {
+      const effect = writeContextEffect("optional", undefined);
+      expect((effect as { value: unknown }).value).toBeUndefined();
+    });
+
+    it("handles array value", () => {
+      const effect = writeContextEffect("items", [1, 2, 3]);
+      expect((effect as { value: unknown }).value).toEqual([1, 2, 3]);
+    });
+
+    it("handles complex nested value", () => {
+      const value = {
+        user: {
+          id: 1,
+          settings: {
+            theme: "dark",
+            notifications: { email: true, push: false },
+          },
+        },
+      };
+      const effect = writeContextEffect("state", value);
+      expect((effect as { value: unknown }).value).toEqual(value);
+    });
+  });
+});
+
+// =============================================================================
+// Concurrency Effect Constructors
+// =============================================================================
+
+describe("Effect Constructors - Concurrency", () => {
+  describe("parallelEffect", () => {
+    it("creates a Parallel effect with tasks", () => {
+      const tasks = [pure(1), pure(2), pure(3)];
+      const effect = parallelEffect(tasks);
+
+      expect(effect._tag).toBe("Parallel");
+      expect((effect as { tasks: unknown[] }).tasks).toHaveLength(3);
+    });
+
+    it("handles empty tasks array", () => {
+      const effect = parallelEffect([]);
+      expect((effect as { tasks: unknown[] }).tasks).toHaveLength(0);
+    });
+
+    it("handles single task", () => {
+      const effect = parallelEffect([pure(42)]);
+      expect((effect as { tasks: unknown[] }).tasks).toHaveLength(1);
+    });
+  });
+
+  describe("raceEffect", () => {
+    it("creates a Race effect with tasks", () => {
+      const tasks = [pure(1), pure(2)];
+      const effect = raceEffect(tasks);
+
+      expect(effect._tag).toBe("Race");
+      expect((effect as { tasks: unknown[] }).tasks).toHaveLength(2);
+    });
+
+    it("handles empty tasks array", () => {
+      const effect = raceEffect([]);
+      expect((effect as { tasks: unknown[] }).tasks).toHaveLength(0);
+    });
+  });
+});
+
+// =============================================================================
+// Effect Utilities
+// =============================================================================
+
+describe("Effect Utilities - describeEffect", () => {
+  it("describes ReadFile effect", () => {
+    const effect = readFileEffect("/path/to/file.txt");
+    expect(describeEffect(effect)).toBe("Read file: /path/to/file.txt");
+  });
+
+  it("describes WriteFile effect with byte count", () => {
+    const effect = writeFileEffect("/output.txt", "Hello, World!");
+    expect(describeEffect(effect)).toBe("Write file: /output.txt (13 bytes)");
+  });
+
+  it("describes CopyFile effect", () => {
+    const effect = copyFileEffect("/source.txt", "/dest.txt");
+    expect(describeEffect(effect)).toBe("Copy file: /source.txt → /dest.txt");
+  });
+
+  it("describes CopyDirectory effect", () => {
+    const effect = copyDirectoryEffect("/source/dir", "/dest/dir");
+    expect(describeEffect(effect)).toBe(
+      "Copy directory: /source/dir → /dest/dir",
+    );
+  });
+
+  it("describes DeleteFile effect", () => {
+    const effect = deleteFileEffect("/path/to/delete.txt");
+    expect(describeEffect(effect)).toBe("Delete file: /path/to/delete.txt");
+  });
+
+  it("describes DeleteDirectory effect", () => {
+    const effect = deleteDirectoryEffect("/path/to/delete/dir");
+    expect(describeEffect(effect)).toBe(
+      "Delete directory: /path/to/delete/dir",
+    );
+  });
+
+  it("describes MakeDir effect with recursive", () => {
+    const effect = makeDirEffect("/new/directory", true);
+    expect(describeEffect(effect)).toBe("Created /new/directory/");
+  });
+
+  it("describes MakeDir effect without recursive", () => {
+    const effect = makeDirEffect("/new/directory", false);
+    expect(describeEffect(effect)).toBe("Created /new/directory/");
+  });
+
+  it("describes Exists effect", () => {
+    const effect = existsEffect("/path/to/check");
+    expect(describeEffect(effect)).toBe("Check exists: /path/to/check");
+  });
+
+  it("describes Glob effect", () => {
+    const effect = globEffect("**/*.ts", "/src");
+    expect(describeEffect(effect)).toBe("Glob: **/*.ts in /src");
+  });
+
+  it("describes Exec effect", () => {
+    const effect = execEffect("npm", ["install", "--save-dev"]);
+    expect(describeEffect(effect)).toBe("Execute: npm install --save-dev");
+  });
+
+  it("describes Prompt effect", () => {
+    const effect = promptEffect({
+      type: "text",
+      name: "name",
+      message: "Enter your name:",
+    });
+    expect(describeEffect(effect)).toBe("Prompt: Enter your name:");
+  });
+
+  it("describes Log effect", () => {
+    const effect = logEffect("info", "Hello, World!");
+    expect(describeEffect(effect)).toBe("Log [info]: Hello, World!");
+  });
+
+  it("describes ReadContext effect", () => {
+    const effect = readContextEffect("myKey");
+    expect(describeEffect(effect)).toBe("Read context: myKey");
+  });
+
+  it("describes WriteContext effect", () => {
+    const effect = writeContextEffect("myKey", { data: 123 });
+    expect(describeEffect(effect)).toBe("Write context: myKey");
+  });
+
+  it("describes Parallel effect", () => {
+    const effect = parallelEffect([pure(1), pure(2), pure(3)]);
+    expect(describeEffect(effect)).toBe("Parallel: 3 tasks");
+  });
+
+  it("describes Race effect", () => {
+    const effect = raceEffect([pure(1), pure(2)]);
+    expect(describeEffect(effect)).toBe("Race: 2 tasks");
+  });
+});
+
+describe("Effect Utilities - isWriteEffect", () => {
+  it("returns true for WriteFile", () => {
+    expect(isWriteEffect(writeFileEffect("/path", "content"))).toBe(true);
+  });
+
+  it("returns true for CopyFile", () => {
+    expect(isWriteEffect(copyFileEffect("/source", "/dest"))).toBe(true);
+  });
+
+  it("returns true for CopyDirectory", () => {
+    expect(isWriteEffect(copyDirectoryEffect("/source", "/dest"))).toBe(true);
+  });
+
+  it("returns true for DeleteFile", () => {
+    expect(isWriteEffect(deleteFileEffect("/path"))).toBe(true);
+  });
+
+  it("returns true for DeleteDirectory", () => {
+    expect(isWriteEffect(deleteDirectoryEffect("/path"))).toBe(true);
+  });
+
+  it("returns true for MakeDir", () => {
+    expect(isWriteEffect(makeDirEffect("/path"))).toBe(true);
+  });
+
+  it("returns false for ReadFile", () => {
+    expect(isWriteEffect(readFileEffect("/path"))).toBe(false);
+  });
+
+  it("returns false for Exists", () => {
+    expect(isWriteEffect(existsEffect("/path"))).toBe(false);
+  });
+
+  it("returns false for Glob", () => {
+    expect(isWriteEffect(globEffect("**/*", "/"))).toBe(false);
+  });
+
+  it("returns false for Exec", () => {
+    expect(isWriteEffect(execEffect("echo", ["hello"]))).toBe(false);
+  });
+
+  it("returns false for Prompt", () => {
+    expect(
+      isWriteEffect(promptEffect({ type: "text", name: "x", message: "?" })),
+    ).toBe(false);
+  });
+
+  it("returns false for Log", () => {
+    expect(isWriteEffect(logEffect("info", "message"))).toBe(false);
+  });
+
+  it("returns false for ReadContext", () => {
+    expect(isWriteEffect(readContextEffect("key"))).toBe(false);
+  });
+
+  it("returns false for WriteContext", () => {
+    expect(isWriteEffect(writeContextEffect("key", "value"))).toBe(false);
+  });
+
+  it("returns false for Parallel", () => {
+    expect(isWriteEffect(parallelEffect([]))).toBe(false);
+  });
+
+  it("returns false for Race", () => {
+    expect(isWriteEffect(raceEffect([]))).toBe(false);
+  });
+});
+
+describe("Effect Utilities - getAffectedPaths", () => {
+  it("returns path for ReadFile", () => {
+    expect(getAffectedPaths(readFileEffect("/path/file.txt"))).toEqual([
+      "/path/file.txt",
+    ]);
+  });
+
+  it("returns path for WriteFile", () => {
+    expect(
+      getAffectedPaths(writeFileEffect("/path/file.txt", "content")),
+    ).toEqual(["/path/file.txt"]);
+  });
+
+  it("returns path for DeleteFile", () => {
+    expect(getAffectedPaths(deleteFileEffect("/path/file.txt"))).toEqual([
+      "/path/file.txt",
+    ]);
+  });
+
+  it("returns path for MakeDir", () => {
+    expect(getAffectedPaths(makeDirEffect("/new/dir"))).toEqual(["/new/dir"]);
+  });
+
+  it("returns path for Exists", () => {
+    expect(getAffectedPaths(existsEffect("/path/to/check"))).toEqual([
+      "/path/to/check",
+    ]);
+  });
+
+  it("returns source and dest for CopyFile", () => {
+    expect(
+      getAffectedPaths(copyFileEffect("/source.txt", "/dest.txt")),
+    ).toEqual(["/source.txt", "/dest.txt"]);
+  });
+
+  it("returns source and dest for CopyDirectory", () => {
+    expect(
+      getAffectedPaths(copyDirectoryEffect("/source/dir", "/dest/dir")),
+    ).toEqual(["/source/dir", "/dest/dir"]);
+  });
+
+  it("returns path for DeleteDirectory", () => {
+    expect(getAffectedPaths(deleteDirectoryEffect("/path/dir"))).toEqual([
+      "/path/dir",
+    ]);
+  });
+
+  it("returns cwd for Glob", () => {
+    expect(getAffectedPaths(globEffect("**/*.ts", "/src"))).toEqual(["/src"]);
+  });
+
+  it("returns empty array for Exec", () => {
+    expect(getAffectedPaths(execEffect("npm", ["install"]))).toEqual([]);
+  });
+
+  it("returns empty array for Prompt", () => {
+    expect(
+      getAffectedPaths(promptEffect({ type: "text", name: "x", message: "?" })),
+    ).toEqual([]);
+  });
+
+  it("returns empty array for Log", () => {
+    expect(getAffectedPaths(logEffect("info", "message"))).toEqual([]);
+  });
+
+  it("returns empty array for ReadContext", () => {
+    expect(getAffectedPaths(readContextEffect("key"))).toEqual([]);
+  });
+
+  it("returns empty array for WriteContext", () => {
+    expect(getAffectedPaths(writeContextEffect("key", "value"))).toEqual([]);
+  });
+
+  it("returns empty array for Parallel", () => {
+    expect(getAffectedPaths(parallelEffect([]))).toEqual([]);
+  });
+
+  it("returns empty array for Race", () => {
+    expect(getAffectedPaths(raceEffect([]))).toEqual([]);
+  });
+});
+
+// =============================================================================
+// Edge Cases
+// =============================================================================
+
+describe("Effect Constructors - Edge Cases", () => {
+  describe("Path handling", () => {
+    it("handles Windows-style paths", () => {
+      const effect = readFileEffect("C:\\Users\\name\\file.txt");
+      expect((effect as { path: string }).path).toBe(
+        "C:\\Users\\name\\file.txt",
+      );
+    });
+
+    it("handles trailing slashes", () => {
+      const effect = makeDirEffect("/path/to/dir/");
+      expect((effect as { path: string }).path).toBe("/path/to/dir/");
+    });
+
+    it("handles double slashes", () => {
+      const effect = readFileEffect("/path//to//file.txt");
+      expect((effect as { path: string }).path).toBe("/path//to//file.txt");
+    });
+
+    it("handles dot paths", () => {
+      const effect = readFileEffect("./file.txt");
+      expect((effect as { path: string }).path).toBe("./file.txt");
+    });
+
+    it("handles parent directory references", () => {
+      const effect = readFileEffect("../parent/file.txt");
+      expect((effect as { path: string }).path).toBe("../parent/file.txt");
+    });
+  });
+
+  describe("Content handling", () => {
+    it("handles binary-like content", () => {
+      const binaryLike = "\x00\x01\x02\x03";
+      const effect = writeFileEffect("/binary.dat", binaryLike);
+      expect((effect as { content: string }).content).toBe(binaryLike);
+    });
+
+    it("handles very long content", () => {
+      const longContent = "a".repeat(1_000_000);
+      const effect = writeFileEffect("/large.txt", longContent);
+      expect((effect as { content: string }).content.length).toBe(1_000_000);
+    });
+  });
+
+  describe("Exec command handling", () => {
+    it("handles command with path", () => {
+      const effect = execEffect("/usr/bin/node", ["script.js"]);
+      expect((effect as { command: string }).command).toBe("/usr/bin/node");
+    });
+
+    it("handles args with equals sign", () => {
+      const effect = execEffect("npm", [
+        "config",
+        "set",
+        "registry=https://npm.example.com",
+      ]);
+      expect((effect as { args: string[] }).args).toContain(
+        "registry=https://npm.example.com",
+      );
+    });
+  });
+});