@aria-cli/tools 1.0.0

package/tests/executors/filesystem-tools.test.ts

@@ -0,0 +1,357 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as filesystemExecutors from "../../src/executors/filesystem.js";
+import type { ToolContext } from "../../src/types.js";
+
+const { executeReadFile, executeWriteFile, executeGlob, executeLs } = filesystemExecutors;
+
+describe("Filesystem Tool Executors", () => {
+  let tempDir: string;
+  let mockContext: ToolContext;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "aria-fs-test-"));
+    mockContext = {
+      workingDir: tempDir,
+      env: {},
+      confirm: async () => true,
+    };
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  describe("executeReadFile", () => {
+    it("should read file successfully", async () => {
+      const filePath = path.join(tempDir, "test.txt");
+      await fs.writeFile(filePath, "Hello, World!");
+
+      const result = await executeReadFile({ path: "test.txt" }, mockContext);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe("Hello, World!");
+      expect(result.message).toMatch(/Read \d+ characters/);
+    });
+
+    it("should handle file not found", async () => {
+      const result = await executeReadFile({ path: "nonexistent.txt" }, mockContext);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toMatch(/ENOENT|no such file/i);
+    });
+
+    it("should reject reading directories", async () => {
+      const dirPath = path.join(tempDir, "testdir");
+      await fs.mkdir(dirPath);
+
+      const result = await executeReadFile({ path: "testdir" }, mockContext);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("directory");
+    });
+
+    it("should support explicit text encoding", async () => {
+      const filePath = path.join(tempDir, "utf16.txt");
+      const expected = "Hello µ";
+      await fs.writeFile(filePath, Buffer.from(expected, "utf16le"));
+
+      const result = await executeReadFile({ path: "utf16.txt", encoding: "utf16le" }, mockContext);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBe(expected);
+    });
+
+    it("should reject unsupported encodings", async () => {
+      const filePath = path.join(tempDir, "text.txt");
+      await fs.writeFile(filePath, "hello");
+
+      const result = await executeReadFile({ path: "text.txt", encoding: "utf32" }, mockContext);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("Unsupported encoding");
+    });
+
+    it("should enforce media size cap even with non-utf8 encoding", async () => {
+      const filePath = path.join(tempDir, "too-large.pdf");
+      await fs.writeFile(filePath, Buffer.alloc(10 * 1024 * 1024 + 1));
+
+      const result = await executeReadFile(
+        { path: "too-large.pdf", encoding: "latin1" },
+        mockContext,
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.message).toContain("File too large for media reading");
+    });
+  });
+
+  describe("executeWriteFile", () => {
+    it("should write file successfully", async () => {
+      const result = await executeWriteFile(
+        { path: "new.txt", content: "New content" },
+        mockContext,
+      );
+
+      expect(result.success).toBe(true);
+
+      const written = await fs.readFile(path.join(tempDir, "new.txt"), "utf-8");
+      expect(written).toBe("New content");
+    });
+
+    it("should overwrite existing file", async () => {
+      const filePath = path.join(tempDir, "existing.txt");
+      await fs.writeFile(filePath, "Old content");
+
+      const result = await executeWriteFile(
+        { path: "existing.txt", content: "New content" },
+        mockContext,
+      );
+
+      expect(result.success).toBe(true);
+
+      const written = await fs.readFile(filePath, "utf-8");
+      expect(written).toBe("New content");
+    });
+
+    it("should support explicit write encoding", async () => {
+      const expected = "Hello µ";
+      const result = await executeWriteFile(
+        { path: "utf16-write.txt", content: expected, encoding: "utf16le" },
+        mockContext,
+      );
+
+      expect(result.success).toBe(true);
+
+      const raw = await fs.readFile(path.join(tempDir, "utf16-write.txt"));
+      expect(raw.equals(Buffer.from(expected, "utf16le"))).toBe(true);
+    });
+  });
+
+  describe("executeGlob", () => {
+    it("should support ignore patterns", async () => {
+      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
+      await fs.mkdir(path.join(tempDir, "node_modules"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "src", "keep.ts"), "keep");
+      await fs.writeFile(path.join(tempDir, "node_modules", "skip.ts"), "skip");
+
+      const result = await executeGlob(
+        { pattern: "**/*.ts", ignore: ["node_modules/**"] },
+        mockContext,
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(["src/keep.ts"]);
+    });
+  });
+
+  describe("executeLs", () => {
+    it("should hide dotfiles unless all=true", async () => {
+      await fs.writeFile(path.join(tempDir, ".env"), "SECRET=1");
+      await fs.writeFile(path.join(tempDir, "visible.txt"), "ok");
+
+      const defaultResult = await executeLs({ path: "." }, mockContext);
+      expect(defaultResult.success).toBe(true);
+      const defaultEntries = (defaultResult.data as { entries: Array<{ name: string }> }).entries;
+      expect(defaultEntries.some((entry) => entry.name === ".env")).toBe(false);
+      expect(defaultEntries.some((entry) => entry.name === "visible.txt")).toBe(true);
+
+      const allResult = await executeLs({ path: ".", all: true }, mockContext);
+      expect(allResult.success).toBe(true);
+      const allEntries = (allResult.data as { entries: Array<{ name: string }> }).entries;
+      expect(allEntries.some((entry) => entry.name === ".env")).toBe(true);
+    });
+
+    it("should include long metadata when long=true", async () => {
+      await fs.writeFile(path.join(tempDir, "file.txt"), "abc");
+
+      const result = await executeLs({ path: ".", all: true, long: true }, mockContext);
+
+      expect(result.success).toBe(true);
+      const entries = (result.data as { entries: Array<Record<string, unknown>> }).entries;
+      const fileEntry = entries.find((entry) => entry.name === "file.txt");
+      expect(fileEntry).toBeDefined();
+      expect(typeof fileEntry?.size).toBe("number");
+      expect(typeof fileEntry?.mtimeMs).toBe("number");
+      expect(typeof fileEntry?.modifiedAt).toBe("string");
+    });
+
+    it("should return entries in deterministic name order", async () => {
+      await fs.writeFile(path.join(tempDir, "zeta.txt"), "z");
+      await fs.writeFile(path.join(tempDir, "alpha.txt"), "a");
+      await fs.mkdir(path.join(tempDir, "beta"));
+
+      const result = await executeLs({ path: ".", all: true }, mockContext);
+
+      expect(result.success).toBe(true);
+      const names = (result.data as { entries: Array<{ name: string }> }).entries.map(
+        (entry) => entry.name,
+      );
+      expect(names).toEqual(["alpha.txt", "beta", "zeta.txt"]);
+    });
+  });
+
+  describe("executeLs", () => {
+    it("should default to cwd and hide dotfiles", async () => {
+      await fs.writeFile(path.join(tempDir, "visible.txt"), "visible");
+      await fs.writeFile(path.join(tempDir, ".hidden.txt"), "hidden");
+
+      const result = await executeLs({}, mockContext);
+
+      expect(result.success).toBe(true);
+      const entries = (result.data as { entries: Array<{ name: string }> }).entries;
+      const names = entries.map((entry) => entry.name);
+      expect(names).toContain("visible.txt");
+      expect(names).not.toContain(".hidden.txt");
+    });
+
+    it("should include dotfiles when all is true", async () => {
+      await fs.writeFile(path.join(tempDir, "visible.txt"), "visible");
+      await fs.writeFile(path.join(tempDir, ".hidden.txt"), "hidden");
+
+      const result = await executeLs({ all: true, path: "." }, mockContext);
+
+      expect(result.success).toBe(true);
+      const entries = (result.data as { entries: Array<{ name: string }> }).entries;
+      const names = entries.map((entry) => entry.name);
+      expect(names).toContain("visible.txt");
+      expect(names).toContain(".hidden.txt");
+    });
+
+    it("should return long metadata when long is true", async () => {
+      await fs.writeFile(path.join(tempDir, "alpha.txt"), "a");
+      await fs.mkdir(path.join(tempDir, "beta-dir"));
+
+      const result = await executeLs({ path: ".", long: true }, mockContext);
+
+      expect(result.success).toBe(true);
+      const entries = (
+        result.data as {
+          entries: Array<{
+            name: string;
+            type: string;
+            size: number;
+            mode: string;
+            mtimeMs: number;
+          }>;
+        }
+      ).entries;
+      expect(entries.map((entry) => entry.name)).toEqual(["alpha.txt", "beta-dir"]);
+      expect(entries).toContainEqual(
+        expect.objectContaining({
+          name: "alpha.txt",
+          type: "file",
+          size: expect.any(Number),
+          mode: expect.any(String),
+          mtimeMs: expect.any(Number),
+        }),
+      );
+      expect(entries).toContainEqual(
+        expect.objectContaining({
+          name: "beta-dir",
+          type: "directory",
+          size: expect.any(Number),
+          mode: expect.any(String),
+          mtimeMs: expect.any(Number),
+        }),
+      );
+    });
+
+    it("should continue long listing when one metadata lookup fails", async () => {
+      await fs.writeFile(path.join(tempDir, "alpha.txt"), "a");
+      await fs.writeFile(path.join(tempDir, "beta.txt"), "b");
+
+      const realReadMetadata = filesystemExecutors.LS_INTERNALS.readMetadata;
+      const metadataSpy = vi
+        .spyOn(filesystemExecutors.LS_INTERNALS, "readMetadata")
+        .mockImplementation(async (targetPath) => {
+          if (String(targetPath).endsWith("beta.txt")) {
+            const err = new Error("Permission denied") as NodeJS.ErrnoException;
+            err.code = "EACCES";
+            throw err;
+          }
+          return realReadMetadata(targetPath);
+        });
+
+      try {
+        const result = await executeLs({ path: ".", long: true }, mockContext);
+
+        expect(result.success).toBe(true);
+        const entries = (
+          result.data as {
+            entries: Array<{
+              name: string;
+              size?: number;
+              mode?: string;
+              mtimeMs?: number;
+            }>;
+          }
+        ).entries;
+        expect(entries.map((entry) => entry.name)).toEqual(["alpha.txt", "beta.txt"]);
+        expect(entries.find((entry) => entry.name === "alpha.txt")).toEqual(
+          expect.objectContaining({
+            size: expect.any(Number),
+            mode: expect.any(String),
+            mtimeMs: expect.any(Number),
+          }),
+        );
+        expect(entries.find((entry) => entry.name === "beta.txt")).toEqual(
+          expect.objectContaining({
+            name: "beta.txt",
+          }),
+        );
+        expect(entries.find((entry) => entry.name === "beta.txt")?.size).toBeUndefined();
+      } finally {
+        metadataSpy.mockRestore();
+      }
+    });
+
+    it("should skip entries that disappear before metadata read", async () => {
+      await fs.writeFile(path.join(tempDir, "alpha.txt"), "a");
+      await fs.writeFile(path.join(tempDir, "gone.txt"), "gone");
+
+      const realReadMetadata = filesystemExecutors.LS_INTERNALS.readMetadata;
+      const metadataSpy = vi
+        .spyOn(filesystemExecutors.LS_INTERNALS, "readMetadata")
+        .mockImplementation(async (targetPath) => {
+          if (String(targetPath).endsWith("gone.txt")) {
+            const err = new Error("No such file or directory") as NodeJS.ErrnoException;
+            err.code = "ENOENT";
+            throw err;
+          }
+          return realReadMetadata(targetPath);
+        });
+
+      try {
+        const result = await executeLs({ path: ".", long: true }, mockContext);
+
+        expect(result.success).toBe(true);
+        const entries = (result.data as { entries: Array<{ name: string }> }).entries;
+        expect(entries.map((entry) => entry.name)).toEqual(["alpha.txt"]);
+      } finally {
+        metadataSpy.mockRestore();
+      }
+    });
+
+    it("ls should return structured contract with pagination metadata", async () => {
+      await fs.mkdir(path.join(tempDir, "nested"), { recursive: true });
+      await fs.writeFile(path.join(tempDir, "nested", "file.txt"), "x");
+
+      const result = await executeLs(
+        { path: ".", depth: 2, limit: 1, offset: 0, ignore: [] },
+        mockContext,
+      );
+      expect(result.success).toBe(true);
+      expect(result.data).toMatchObject({
+        depth: 2,
+        limit: 1,
+        offset: 0,
+        ignore: [],
+        truncated: expect.any(Boolean),
+        entries: expect.any(Array),
+      });
+    });
+  });
+});