@aria-cli/tools 1.0.8 → 1.0.10

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

@@ -1,357 +0,0 @@
-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),
-      });
-    });
-  });
-});