@aria-cli/tools 1.0.8 → 1.0.10

package/tests/executors/filesystem.test.ts

@@ -1,959 +0,0 @@
-/**
- * @aria/tools - Filesystem executor tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import * as os from "node:os";
-import { createHash } from "node:crypto";
-import type { ToolContext } from "../../src/types.js";
-import {
-  executeReadFile,
-  executeWriteFile,
-  executeEditFile,
-  executeLs,
-  executeGlob,
-  executeGrep,
-  FILESYSTEM_OUTPUT_LIMITS,
-  LS_INTERNALS,
-} from "../../src/executors/filesystem.js";
-
-// Helper to create a unique temp directory for each test
-const createTempDir = async (): Promise<string> => {
-  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-test-"));
-  return tempDir;
-};
-
-// Helper to clean up temp directory
-const cleanupTempDir = async (dir: string): Promise<void> => {
-  await fs.rm(dir, { recursive: true, force: true });
-};
-
-// Helper to create a context
-const createContext = (workingDir: string): ToolContext => ({
-  workingDir,
-  env: {},
-  confirm: async () => true,
-});
-
-describe("Filesystem Executors", () => {
-  let tempDir: string;
-  let ctx: ToolContext;
-
-  beforeEach(async () => {
-    tempDir = await createTempDir();
-    ctx = createContext(tempDir);
-  });
-
-  afterEach(async () => {
-    await cleanupTempDir(tempDir);
-  });
-
-  describe("executeReadFile", () => {
-    it("should read a file successfully", async () => {
-      const filePath = path.join(tempDir, "test.txt");
-      await fs.writeFile(filePath, "Hello, World!");
-
-      const result = await executeReadFile({ path: filePath }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe("Hello, World!");
-    });
-
-    it("should read a file with relative path", async () => {
-      const filePath = path.join(tempDir, "test.txt");
-      await fs.writeFile(filePath, "Relative test");
-
-      const result = await executeReadFile({ path: "test.txt" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe("Relative test");
-    });
-
-    it("should support offset and limit", async () => {
-      const filePath = path.join(tempDir, "lines.txt");
-      await fs.writeFile(filePath, "line1\nline2\nline3\nline4\nline5");
-
-      const result = await executeReadFile({ path: filePath, offset: 1, limit: 2 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe("line2\nline3");
-    });
-
-    it("should handle file with trailing newline correctly with offset/limit", async () => {
-      const filePath = path.join(tempDir, "trailing.txt");
-      // File ends with newline - common for text files
-      await fs.writeFile(filePath, "line1\nline2\nline3\n");
-
-      const result = await executeReadFile({ path: filePath, offset: 0, limit: 3 }, ctx);
-
-      expect(result.success).toBe(true);
-      // Should return 3 actual lines, not include empty line from trailing newline
-      expect(result.data).toBe("line1\nline2\nline3");
-    });
-
-    it("should handle offset beyond file length", async () => {
-      const filePath = path.join(tempDir, "short.txt");
-      await fs.writeFile(filePath, "line1\nline2");
-
-      const result = await executeReadFile({ path: filePath, offset: 10, limit: 5 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe("");
-    });
-
-    it("should truncate large reads by default and include resume offset guidance", async () => {
-      const filePath = path.join(tempDir, "large.txt");
-      const lines = Array.from({ length: 2500 }, (_, i) => `line-${i + 1}`);
-      await fs.writeFile(filePath, lines.join("\n"));
-
-      const result = await executeReadFile({ path: filePath }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as string;
-      expect(data.split("\n").length).toBe(2000);
-      expect(result.message).toContain("truncated");
-      expect(result.message).toContain("offset=2000");
-    });
-
-    it("should reject invalid offset/limit values", async () => {
-      const filePath = path.join(tempDir, "invalid.txt");
-      await fs.writeFile(filePath, "x");
-
-      const badOffset = await executeReadFile({ path: filePath, offset: -1 }, ctx);
-      expect(badOffset.success).toBe(false);
-      expect(badOffset.message).toContain("offset");
-
-      const badLimit = await executeReadFile({ path: filePath, limit: 0 }, ctx);
-      expect(badLimit.success).toBe(false);
-      expect(badLimit.message).toContain("limit");
-    });
-
-    it("should return error for non-existent file", async () => {
-      const result = await executeReadFile({ path: "nonexistent.txt" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("ENOENT");
-    });
-
-    it("should return error for directory", async () => {
-      const result = await executeReadFile({ path: tempDir }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toBeDefined();
-    });
-
-    it("should reject absolute paths outside the working directory", async () => {
-      const outsideDir = await createTempDir();
-      try {
-        const outsideFile = path.join(outsideDir, "outside.txt");
-        await fs.writeFile(outsideFile, "outside");
-
-        const result = await executeReadFile({ path: outsideFile }, ctx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("outside working directory");
-      } finally {
-        await cleanupTempDir(outsideDir);
-      }
-    });
-
-    it("should reject prefix-collision absolute paths outside the working directory", async () => {
-      const siblingDir = `${tempDir}-evil`;
-      await fs.mkdir(siblingDir, { recursive: true });
-      const siblingFile = path.join(siblingDir, "outside.txt");
-      await fs.writeFile(siblingFile, "outside");
-
-      const result = await executeReadFile({ path: siblingFile }, ctx);
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("outside working directory");
-    });
-
-    describe("home directory access", () => {
-      let fakeHome: string;
-      let originalHome: string | undefined;
-
-      beforeEach(async () => {
-        fakeHome = await createTempDir();
-        originalHome = process.env.HOME;
-        process.env.HOME = fakeHome;
-      });
-
-      afterEach(async () => {
-        process.env.HOME = originalHome;
-        await cleanupTempDir(fakeHome);
-      });
-
-      it("should allow reading files under home directory", async () => {
-        const homeFile = path.join(fakeHome, "notes.txt");
-        await fs.writeFile(homeFile, "hello from home");
-
-        // workingDir is tempDir (different from fakeHome), so this tests the home fallback
-        const result = await executeReadFile({ path: homeFile }, ctx);
-        expect(result.success).toBe(true);
-        expect(result.message).toContain("notes.txt");
-      });
-
-      it("should block access to ~/.ssh", async () => {
-        const sshDir = path.join(fakeHome, ".ssh");
-        await fs.mkdir(sshDir, { recursive: true });
-        await fs.writeFile(path.join(sshDir, "id_rsa"), "secret-key");
-
-        const result = await executeReadFile({ path: path.join(sshDir, "id_rsa") }, ctx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("sensitive home directory");
-      });
-
-      it("should block access to ~/.aws", async () => {
-        const awsDir = path.join(fakeHome, ".aws");
-        await fs.mkdir(awsDir, { recursive: true });
-        await fs.writeFile(path.join(awsDir, "credentials"), "secret");
-
-        const result = await executeReadFile({ path: path.join(awsDir, "credentials") }, ctx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("sensitive home directory");
-      });
-
-      it("should block access to ~/.gnupg", async () => {
-        const gpgDir = path.join(fakeHome, ".gnupg");
-        await fs.mkdir(gpgDir, { recursive: true });
-        await fs.writeFile(path.join(gpgDir, "private-keys"), "secret");
-
-        const result = await executeReadFile({ path: path.join(gpgDir, "private-keys") }, ctx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("sensitive home directory");
-      });
-
-      it("should block access to ~/.git-credentials", async () => {
-        const credFile = path.join(fakeHome, ".git-credentials");
-        await fs.writeFile(credFile, "https://user:token@github.com");
-
-        const result = await executeReadFile({ path: credFile }, ctx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("sensitive home directory");
-      });
-
-      it("should allow access to ~/.aria subdirectories", async () => {
-        const ariaDir = path.join(fakeHome, ".aria", "tools");
-        await fs.mkdir(ariaDir, { recursive: true });
-        await fs.writeFile(path.join(ariaDir, "my-tool.sh"), "#!/bin/bash\necho hi");
-
-        const result = await executeReadFile({ path: path.join(ariaDir, "my-tool.sh") }, ctx);
-        expect(result.success).toBe(true);
-      });
-
-      it("should allow listing home subdirectories that are not blocked", async () => {
-        const projectsDir = path.join(fakeHome, "projects");
-        await fs.mkdir(projectsDir, { recursive: true });
-        await fs.writeFile(path.join(projectsDir, "file.ts"), "code");
-
-        const result = await executeLs({ path: projectsDir }, ctx);
-        expect(result.success).toBe(true);
-      });
-
-      it("should block listing ~/.ssh", async () => {
-        const sshDir = path.join(fakeHome, ".ssh");
-        await fs.mkdir(sshDir, { recursive: true });
-        await fs.writeFile(path.join(sshDir, "config"), "Host *");
-
-        const result = await executeLs({ path: sshDir }, ctx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("sensitive home directory");
-      });
-
-      it("should allow access to ~/.ssh when autonomy is 'full'", async () => {
-        const fullCtx = createContext(tempDir);
-        fullCtx.autonomy = "full";
-
-        const sshDir = path.join(fakeHome, ".ssh");
-        await fs.mkdir(sshDir, { recursive: true });
-        await fs.writeFile(path.join(sshDir, "config"), "Host *");
-
-        const result = await executeReadFile({ path: path.join(sshDir, "config") }, fullCtx);
-        expect(result.success).toBe(true);
-      });
-
-      it("should still block ~/.ssh when autonomy is 'high'", async () => {
-        const highCtx = createContext(tempDir);
-        highCtx.autonomy = "high";
-
-        const sshDir = path.join(fakeHome, ".ssh");
-        await fs.mkdir(sshDir, { recursive: true });
-        await fs.writeFile(path.join(sshDir, "id_rsa"), "secret-key");
-
-        const result = await executeReadFile({ path: path.join(sshDir, "id_rsa") }, highCtx);
-        expect(result.success).toBe(false);
-        expect(result.message).toContain("sensitive home directory");
-      });
-    });
-  });
-
-  describe("executeWriteFile", () => {
-    it("should write a new file", async () => {
-      const filePath = path.join(tempDir, "new.txt");
-
-      const result = await executeWriteFile({ path: filePath, content: "New content" }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("New content");
-    });
-
-    it("should write with relative path", async () => {
-      const result = await executeWriteFile(
-        { path: "relative.txt", content: "Relative content" },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(path.join(tempDir, "relative.txt"), "utf-8");
-      expect(content).toBe("Relative content");
-    });
-
-    it("should overwrite existing file by default", async () => {
-      const filePath = path.join(tempDir, "existing.txt");
-      await fs.writeFile(filePath, "Original");
-
-      const result = await executeWriteFile({ path: filePath, content: "Overwritten" }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("Overwritten");
-    });
-
-    it("should include structuredPatch for overwrites", async () => {
-      const filePath = path.join(tempDir, "diff-write.txt");
-      await fs.writeFile(filePath, "line 1\nline 2\nline 3\n");
-
-      const result = await executeWriteFile(
-        { path: filePath, content: "line 1\nLINE TWO\nline 3\n" },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const data = result.data as Record<string, unknown>;
-      expect(data.structuredPatch).toBeDefined();
-      const hunks = data.structuredPatch as Array<{ lines: string[] }>;
-      expect(hunks.length).toBeGreaterThan(0);
-      const allLines = hunks.flatMap((h) => h.lines);
-      expect(allLines).toContain("-line 2");
-      expect(allLines).toContain("+LINE TWO");
-    });
-
-    it("should not include structuredPatch for new files", async () => {
-      const filePath = path.join(tempDir, "brand-new.txt");
-
-      const result = await executeWriteFile({ path: filePath, content: "new content" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as Record<string, unknown>;
-      expect(data.structuredPatch).toBeUndefined();
-    });
-
-    it("should append when append option is true", async () => {
-      const filePath = path.join(tempDir, "append.txt");
-      await fs.writeFile(filePath, "Original");
-
-      const result = await executeWriteFile(
-        { path: filePath, content: " appended", append: true },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("Original appended");
-    });
-
-    it("should create parent directories if needed", async () => {
-      const filePath = path.join(tempDir, "nested", "dir", "file.txt");
-
-      const result = await executeWriteFile({ path: filePath, content: "Nested content" }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("Nested content");
-    });
-
-    it("should enforce expectedHash optimistic concurrency", async () => {
-      const filePath = path.join(tempDir, "guarded.txt");
-      await fs.writeFile(filePath, "original");
-
-      const wrongHash = "a".repeat(64);
-      const rejected = await executeWriteFile(
-        { path: filePath, content: "new", expectedHash: wrongHash },
-        ctx,
-      );
-      expect(rejected.success).toBe(false);
-      expect(rejected.message).toContain("Hash mismatch");
-
-      const sha256 = createHash("sha256").update("original", "utf8").digest("hex");
-      const accepted = await executeWriteFile(
-        { path: filePath, content: "new", expectedHash: sha256 },
-        ctx,
-      );
-      expect(accepted.success).toBe(true);
-      expect((accepted.data as { currentHash: string }).currentHash).toHaveLength(64);
-    });
-  });
-
-  describe("executeEditFile", () => {
-    it("should replace content in a file", async () => {
-      const filePath = path.join(tempDir, "edit.txt");
-      await fs.writeFile(filePath, "Hello World");
-
-      const result = await executeEditFile(
-        { path: filePath, oldText: "World", newText: "Universe" },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("Hello Universe");
-    });
-
-    it("should include structuredPatch in result data", async () => {
-      const filePath = path.join(tempDir, "diff.txt");
-      await fs.writeFile(filePath, "line 1\nline 2\nline 3\nline 4\nline 5\n");
-
-      const result = await executeEditFile(
-        { path: filePath, oldText: "line 3", newText: "LINE THREE" },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const data = result.data as Record<string, unknown>;
-      expect(data.structuredPatch).toBeDefined();
-      expect(Array.isArray(data.structuredPatch)).toBe(true);
-      const hunks = data.structuredPatch as Array<{
-        oldStart: number;
-        newStart: number;
-        lines: string[];
-      }>;
-      expect(hunks.length).toBeGreaterThan(0);
-      // Verify the hunk contains the change
-      const allLines = hunks.flatMap((h) => h.lines);
-      expect(allLines).toContain("-line 3");
-      expect(allLines).toContain("+LINE THREE");
-    });
-
-    it("should replace all occurrences when replaceAll is true", async () => {
-      const filePath = path.join(tempDir, "multi.txt");
-      await fs.writeFile(filePath, "foo bar foo baz foo");
-
-      const result = await executeEditFile(
-        { path: filePath, oldText: "foo", newText: "qux", replaceAll: true },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("qux bar qux baz qux");
-    });
-
-    it("should replace only first occurrence by default", async () => {
-      const filePath = path.join(tempDir, "first.txt");
-      await fs.writeFile(filePath, "foo bar foo");
-
-      const result = await executeEditFile({ path: filePath, oldText: "foo", newText: "qux" }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("qux bar foo");
-    });
-
-    it("should return error if oldText not found", async () => {
-      const filePath = path.join(tempDir, "notfound.txt");
-      await fs.writeFile(filePath, "Hello World");
-
-      const result = await executeEditFile(
-        { path: filePath, oldText: "notexist", newText: "new" },
-        ctx,
-      );
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("not found");
-    });
-
-    it("should return error for non-existent file", async () => {
-      const result = await executeEditFile(
-        { path: "nonexistent.txt", oldText: "a", newText: "b" },
-        ctx,
-      );
-
-      expect(result.success).toBe(false);
-      expect(result.message).toBeDefined();
-    });
-
-    it("should return error for empty oldText", async () => {
-      const filePath = path.join(tempDir, "edit.txt");
-      await fs.writeFile(filePath, "Hello World");
-
-      const result = await executeEditFile({ path: filePath, oldText: "", newText: "new" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("empty");
-    });
-
-    it("should enforce expectedReplacements when replaceAll is true", async () => {
-      const filePath = path.join(tempDir, "counts.txt");
-      await fs.writeFile(filePath, "foo bar foo");
-
-      const mismatch = await executeEditFile(
-        {
-          path: filePath,
-          oldText: "foo",
-          newText: "qux",
-          replaceAll: true,
-          expectedReplacements: 3,
-        },
-        ctx,
-      );
-      expect(mismatch.success).toBe(false);
-      expect(mismatch.message).toContain("expected 3");
-
-      const accepted = await executeEditFile(
-        {
-          path: filePath,
-          oldText: "foo",
-          newText: "qux",
-          replaceAll: true,
-          expectedReplacements: 2,
-        },
-        ctx,
-      );
-      expect(accepted.success).toBe(true);
-    });
-
-    it("should reject expectedReplacements > 1 without replaceAll", async () => {
-      const filePath = path.join(tempDir, "strict.txt");
-      await fs.writeFile(filePath, "foo foo");
-
-      const result = await executeEditFile(
-        { path: filePath, oldText: "foo", newText: "bar", expectedReplacements: 2 },
-        ctx,
-      );
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("replaceAll=true");
-    });
-
-    it("should enforce expectedHash before applying edit", async () => {
-      const filePath = path.join(tempDir, "guarded-edit.txt");
-      await fs.writeFile(filePath, "const x = 1;\n");
-
-      const wrongHash = "b".repeat(64);
-      const rejected = await executeEditFile(
-        {
-          path: filePath,
-          oldText: "1",
-          newText: "2",
-          expectedHash: wrongHash,
-        },
-        ctx,
-      );
-      expect(rejected.success).toBe(false);
-      expect(rejected.message).toContain("Hash mismatch");
-
-      const hash = createHash("sha256").update("const x = 1;\n", "utf8").digest("hex");
-      const accepted = await executeEditFile(
-        {
-          path: filePath,
-          oldText: "1",
-          newText: "2",
-          expectedHash: hash,
-        },
-        ctx,
-      );
-      expect(accepted.success).toBe(true);
-    });
-
-    it("should use fallback strategy when exact match fails due whitespace drift", async () => {
-      const filePath = path.join(tempDir, "fallback.ts");
-      await fs.writeFile(filePath, ["function run() {", "  return 42;", "}", ""].join("\n"));
-
-      const result = await executeEditFile(
-        {
-          path: filePath,
-          oldText: "function run() {\nreturn 42;\n}",
-          newText: "function run() {\n  return 7;\n}",
-          replaceAll: false,
-        },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const data = result.data as { strategy: string };
-      expect(data.strategy).not.toBe("exact");
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toContain("return 7;");
-    });
-
-    it("should return canonical shape with filePath (not path)", async () => {
-      const filePath = path.join(tempDir, "canonical.txt");
-      await fs.writeFile(filePath, "line 1\nline 2\n");
-      const result = await executeEditFile(
-        { path: filePath, oldText: "line 1", newText: "LINE ONE" },
-        ctx,
-      );
-      expect(result.success).toBe(true);
-      const data = result.data as Record<string, unknown>;
-      // Use realpath to handle macOS /var → /private/var symlink
-      const realFilePath = await fs.realpath(filePath);
-      expect(data.filePath).toBe(realFilePath);
-      expect(data).not.toHaveProperty("path");
-      expect(data.structuredPatch).toBeDefined();
-    });
-  });
-
-  describe("executeLs", () => {
-    it("should list directory contents", async () => {
-      await fs.writeFile(path.join(tempDir, "file1.txt"), "content1");
-      await fs.writeFile(path.join(tempDir, "file2.txt"), "content2");
-      await fs.mkdir(path.join(tempDir, "subdir"));
-
-      const result = await executeLs({ path: tempDir }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { entries: Array<{ name: string; type: string }> };
-      expect(data.entries.map((e) => e.name).sort()).toEqual(["file1.txt", "file2.txt", "subdir"]);
-    });
-
-    it("should list with relative path", async () => {
-      await fs.writeFile(path.join(tempDir, "file.txt"), "content");
-
-      const result = await executeLs({ path: "." }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { entries: Array<{ name: string }> };
-      expect(data.entries.some((e) => e.name === "file.txt")).toBe(true);
-    });
-
-    it("should include file type information", async () => {
-      await fs.writeFile(path.join(tempDir, "file.txt"), "content");
-      await fs.mkdir(path.join(tempDir, "dir"));
-
-      const result = await executeLs({ path: tempDir }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { entries: Array<{ name: string; type: string }> };
-      const file = data.entries.find((e) => e.name === "file.txt");
-      const dir = data.entries.find((e) => e.name === "dir");
-      expect(file?.type).toBe("file");
-      expect(dir?.type).toBe("directory");
-    });
-
-    it("should return error for non-existent directory", async () => {
-      const result = await executeLs({ path: "/nonexistent/dir" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toBeDefined();
-    });
-  });
-
-  describe("executeLs — pagination", () => {
-    it("should return structured data with pagination metadata", async () => {
-      await fs.writeFile(path.join(tempDir, "alpha.txt"), "a");
-      await fs.mkdir(path.join(tempDir, "nested"), { recursive: true });
-      await fs.writeFile(path.join(tempDir, "nested", "beta.txt"), "b");
-      await fs.writeFile(path.join(tempDir, "nested", "skip.tmp"), "tmp");
-
-      const result = await executeLs(
-        {
-          path: ".",
-          depth: 2,
-          offset: 1,
-          limit: 1,
-          ignore: ["**/*.tmp"],
-        },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        depth: 2,
-        offset: 1,
-        limit: 1,
-        ignore: ["**/*.tmp"],
-        truncated: true,
-        total: expect.any(Number),
-        entries: expect.any(Array),
-      });
-      const data = result.data as {
-        entries: Array<{ path: string; depth: number }>;
-      };
-      expect(data.entries).toHaveLength(1);
-      expect(data.entries[0]).toMatchObject({
-        path: expect.any(String),
-        depth: expect.any(Number),
-      });
-    });
-
-    it("should only resolve types for paged entries", async () => {
-      for (let i = 0; i < 12; i++) {
-        await fs.writeFile(path.join(tempDir, `file-${i}.txt`), String(i));
-      }
-
-      const originalReadType = LS_INTERNALS.readType;
-      let readTypeCalls = 0;
-      LS_INTERNALS.readType = async (entryPath: string) => {
-        readTypeCalls++;
-        return originalReadType(entryPath);
-      };
-
-      try {
-        const result = await executeLs({ path: ".", offset: 5, limit: 2 }, ctx);
-        expect(result.success).toBe(true);
-        expect(result.data).toMatchObject({
-          offset: 5,
-          limit: 2,
-        });
-        expect(readTypeCalls).toBeLessThanOrEqual(2);
-      } finally {
-        LS_INTERNALS.readType = originalReadType;
-      }
-    });
-  });
-
-  // executeMkdir, executeRm, executeMv, executeCp tests removed — tools deleted in aria-c3x
-
-  describe("executeGlob", () => {
-    it("should match files with glob pattern", async () => {
-      await fs.writeFile(path.join(tempDir, "file1.ts"), "content1");
-      await fs.writeFile(path.join(tempDir, "file2.ts"), "content2");
-      await fs.writeFile(path.join(tempDir, "file3.txt"), "content3");
-
-      const result = await executeGlob({ pattern: "*.ts" }, ctx);
-
-      expect(result.success).toBe(true);
-      const files = result.data as string[];
-      expect(files).toHaveLength(2);
-      expect(files.every((f) => f.endsWith(".ts"))).toBe(true);
-    });
-
-    it("should match nested files with ** pattern", async () => {
-      await fs.mkdir(path.join(tempDir, "nested", "deep"), { recursive: true });
-      await fs.writeFile(path.join(tempDir, "root.ts"), "content");
-      await fs.writeFile(path.join(tempDir, "nested", "nested.ts"), "content");
-      await fs.writeFile(path.join(tempDir, "nested", "deep", "deep.ts"), "content");
-
-      const result = await executeGlob({ pattern: "**/*.ts" }, ctx);
-
-      expect(result.success).toBe(true);
-      const files = result.data as string[];
-      expect(files.length).toBeGreaterThanOrEqual(3);
-    });
-
-    it("should work with absolute path pattern", async () => {
-      await fs.writeFile(path.join(tempDir, "file.txt"), "content");
-
-      const result = await executeGlob({ pattern: path.join(tempDir, "*.txt") }, ctx);
-
-      expect(result.success).toBe(true);
-      const files = result.data as string[];
-      expect(files).toHaveLength(1);
-    });
-
-    it("should return empty array for no matches", async () => {
-      const result = await executeGlob({ pattern: "*.nonexistent" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual([]);
-    });
-
-    it("should support cwd option", async () => {
-      const subdir = path.join(tempDir, "subdir");
-      await fs.mkdir(subdir);
-      await fs.writeFile(path.join(subdir, "file.ts"), "content");
-
-      const result = await executeGlob({ pattern: "*.ts", cwd: subdir }, ctx);
-
-      expect(result.success).toBe(true);
-      const files = result.data as string[];
-      expect(files).toHaveLength(1);
-    });
-
-    it("should reject cwd prefix-collision paths outside working directory", async () => {
-      const siblingDir = `${tempDir}-evil`;
-      await fs.mkdir(siblingDir, { recursive: true });
-      await fs.writeFile(path.join(siblingDir, "outside.ts"), "content");
-
-      const result = await executeGlob({ pattern: "*.ts", cwd: siblingDir }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("outside working directory");
-    });
-
-    it("should cap glob output to hard limit", async () => {
-      const total = FILESYSTEM_OUTPUT_LIMITS.MAX_GLOB_RESULTS + 25;
-      const writes = Array.from({ length: total }, (_, i) =>
-        fs.writeFile(path.join(tempDir, `cap-${i}.txt`), "x"),
-      );
-      await Promise.all(writes);
-
-      const result = await executeGlob({ pattern: "cap-*.txt" }, ctx);
-
-      expect(result.success).toBe(true);
-      const files = result.data as string[];
-      expect(files).toHaveLength(FILESYSTEM_OUTPUT_LIMITS.MAX_GLOB_RESULTS);
-      expect(result.message).toContain("truncated");
-    });
-  });
-
-  describe("executeGrep", () => {
-    beforeEach(async () => {
-      await fs.writeFile(
-        path.join(tempDir, "file1.txt"),
-        "Hello World\nThis is a test\nHello again",
-      );
-      await fs.writeFile(path.join(tempDir, "file2.txt"), "Another file\nNo matches here");
-      await fs.writeFile(
-        path.join(tempDir, "file3.ts"),
-        'const hello = "Hello";\nfunction test() {}',
-      );
-    });
-
-    it("should find pattern in single file", async () => {
-      const filePath = path.join(tempDir, "file1.txt");
-
-      const result = await executeGrep({ pattern: "Hello", path: filePath }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as {
-        matches: Array<{ file: string; line: number; content: string }>;
-        errors?: string[];
-      };
-      expect(data.matches.length).toBe(2);
-      expect(data.matches[0].content).toContain("Hello");
-    });
-
-    it("should search directory recursively", async () => {
-      const result = await executeGrep({ pattern: "Hello", path: tempDir }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { matches: Array<{ file: string }>; errors?: string[] };
-      expect(data.matches.length).toBeGreaterThanOrEqual(3);
-    });
-
-    it("should support glob patterns", async () => {
-      const result = await executeGrep({ pattern: "Hello", path: tempDir, glob: "*.txt" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { matches: Array<{ file: string }>; errors?: string[] };
-      expect(data.matches.every((m) => m.file.endsWith(".txt"))).toBe(true);
-    });
-
-    it("should support case-insensitive search", async () => {
-      const result = await executeGrep({ pattern: "hello", path: tempDir, ignoreCase: true }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { matches: Array<{ content: string }>; errors?: string[] };
-      expect(data.matches.length).toBeGreaterThan(0);
-    });
-
-    it("should return empty array for no matches", async () => {
-      const result = await executeGrep({ pattern: "nomatchpattern123", path: tempDir }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { matches: Array<unknown>; errors?: string[] };
-      expect(data.matches).toEqual([]);
-    });
-
-    it("should return error for invalid regex", async () => {
-      const result = await executeGrep({ pattern: "[invalid(regex", path: tempDir }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toBeDefined();
-    });
-
-    it("should reject potentially catastrophic regex patterns", async () => {
-      const result = await executeGrep({ pattern: "(a+)+$", path: tempDir }, ctx);
-
-      expect(result.success).toBe(false);
-      expect((result.message ?? "").toLowerCase()).toContain("unsafe regular expression");
-    });
-
-    it("should reject ambiguous repeated alternation patterns prone to backtracking", async () => {
-      const result = await executeGrep({ pattern: "(a|aa)+$", path: tempDir }, ctx);
-
-      expect(result.success).toBe(false);
-      expect((result.message ?? "").toLowerCase()).toContain("unsafe regular expression");
-    });
-
-    it("should reject lookaround assertions for grep regex safety", async () => {
-      const result = await executeGrep({ pattern: "(?=a)a+", path: tempDir }, ctx);
-
-      expect(result.success).toBe(false);
-      expect((result.message ?? "").toLowerCase()).toContain("unsafe regular expression");
-    });
-
-    it("should work with relative path", async () => {
-      const result = await executeGrep({ pattern: "Hello", path: "." }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { matches: Array<{ file: string }>; errors?: string[] };
-      expect(data.matches.length).toBeGreaterThan(0);
-    });
-
-    it("should default path to current working directory when omitted", async () => {
-      const result = await executeGrep({ pattern: "Hello" }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as { matches: Array<{ file: string }>; errors?: string[] };
-      expect(data.matches.length).toBeGreaterThan(0);
-    });
-
-    it("should cap grep matches to hard limit and mark truncated", async () => {
-      const hits = FILESYSTEM_OUTPUT_LIMITS.MAX_GREP_MATCHES + 20;
-      await fs.writeFile(path.join(tempDir, "many-hits.txt"), Array(hits).fill("HIT").join("\n"));
-
-      const result = await executeGrep(
-        { pattern: "HIT", path: path.join(tempDir, "many-hits.txt") },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const data = result.data as {
-        matches: Array<{ file: string; line: number; content: string }>;
-        truncated?: boolean;
-      };
-      expect(data.matches).toHaveLength(FILESYSTEM_OUTPUT_LIMITS.MAX_GREP_MATCHES);
-      expect(data.truncated).toBe(true);
-      expect(result.message).toContain("truncated");
-    });
-
-    it("should skip oversized files instead of reading them fully", async () => {
-      const oversizedPath = path.join(tempDir, "oversized.txt");
-      await fs.writeFile(
-        oversizedPath,
-        "a".repeat(FILESYSTEM_OUTPUT_LIMITS.MAX_GREP_FILE_BYTES + 1024),
-      );
-
-      const result = await executeGrep({ pattern: "a+", path: oversizedPath }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as {
-        matches: Array<{ file: string; line: number; content: string }>;
-        errors?: string[];
-      };
-      expect(data.matches).toHaveLength(0);
-      expect(data.errors?.[0]).toContain("exceeds");
-    });
-
-    it("should skip extremely long lines to cap regex evaluation risk", async () => {
-      const longLinePath = path.join(tempDir, "long-line.txt");
-      await fs.writeFile(
-        longLinePath,
-        `${"a".repeat(FILESYSTEM_OUTPUT_LIMITS.MAX_GREP_LINE_BYTES + 1)}\nshort line`,
-      );
-
-      const result = await executeGrep({ pattern: "a+", path: longLinePath }, ctx);
-
-      expect(result.success).toBe(true);
-      const data = result.data as {
-        matches: Array<{ file: string; line: number; content: string }>;
-        errors?: string[];
-      };
-      expect(data.matches).toHaveLength(0);
-      expect(data.errors?.[0]).toContain("Skipped lines longer than");
-    });
-  });
-});