@aria-cli/tools 1.0.8 → 1.0.10

package/tests/definitions/execution.test.ts

@@ -1,671 +0,0 @@
-/**
- * @aria/tools - Tool execution integration tests
- *
- * Tests that tool definitions are wired to their executors correctly.
- * Verifies that tools actually execute (not just that they exist).
- */
-
-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 type { ToolContext, Tool } from "../../src/types.js";
-import {
-  CORE_TOOL_DEFINITIONS,
-  getCoreTool,
-  getCoreToolsByCategory,
-} from "../../src/definitions/core.js";
-import * as executorsBarrel from "../../src/executors/index.js";
-import * as toolsBarrel from "../../src/index.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-exec-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: {},
-});
-
-describe("Tool Definition Execution", () => {
-  let tempDir: string;
-  let ctx: ToolContext;
-
-  beforeEach(async () => {
-    tempDir = await createTempDir();
-    ctx = createContext(tempDir);
-  });
-
-  afterEach(async () => {
-    await cleanupTempDir(tempDir);
-  });
-
-  describe("All tools have execute functions", () => {
-    it("should have 56 core tools", () => {
-      expect(CORE_TOOL_DEFINITIONS).toHaveLength(56);
-    });
-
-    it("should have execute function for every tool", () => {
-      for (const tool of CORE_TOOL_DEFINITIONS) {
-        expect(tool.execute).toBeDefined();
-        expect(typeof tool.execute).toBe("function");
-      }
-    });
-
-    it("should not have any notImplemented stubs", async () => {
-      // Test a few non-meta tools to ensure they don't throw "not implemented"
-      const toolsToCheck = ["read_file", "bash", "remember", "web_fetch"];
-
-      for (const toolName of toolsToCheck) {
-        const tool = getCoreTool(toolName);
-        expect(tool).toBeDefined();
-
-        // Try to execute with minimal/empty input - should not throw "not implemented"
-        try {
-          await tool!.execute({}, ctx);
-        } catch (error) {
-          const message = (error as Error).message;
-          expect(message).not.toContain("not implemented");
-        }
-      }
-    });
-  });
-
-  describe("Filesystem tools execute", () => {
-    it("read_file should read actual files", async () => {
-      const filePath = path.join(tempDir, "test.txt");
-      await fs.writeFile(filePath, "Hello from test");
-
-      const tool = getCoreTool("read_file");
-      const result = await tool!.execute({ path: filePath }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe("Hello from test");
-    });
-
-    it("write_file should write actual files", async () => {
-      const filePath = path.join(tempDir, "output.txt");
-
-      const tool = getCoreTool("write_file");
-      const result = await tool!.execute({ path: filePath, content: "Written content" }, ctx);
-
-      expect(result.success).toBe(true);
-      const content = await fs.readFile(filePath, "utf-8");
-      expect(content).toBe("Written content");
-    });
-
-    it("read_file should honor encoding input", async () => {
-      const filePath = path.join(tempDir, "utf16.txt");
-      const expected = "Hello µ";
-      await fs.writeFile(filePath, Buffer.from(expected, "utf16le"));
-
-      const tool = getCoreTool("read_file");
-      const result = await tool!.execute({ path: filePath, encoding: "utf16le" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBe(expected);
-    });
-
-    it("write_file should honor encoding input", async () => {
-      const filePath = path.join(tempDir, "utf16-write.txt");
-      const expected = "Hello µ";
-
-      const tool = getCoreTool("write_file");
-      const result = await tool!.execute(
-        { path: filePath, content: expected, encoding: "utf16le" },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      const raw = await fs.readFile(filePath);
-      expect(raw.equals(Buffer.from(expected, "utf16le"))).toBe(true);
-    });
-
-    it("ls should list directory contents", async () => {
-      await fs.writeFile(path.join(tempDir, "file1.txt"), "");
-      await fs.writeFile(path.join(tempDir, "file2.txt"), "");
-      await fs.writeFile(path.join(tempDir, ".hidden.txt"), "");
-
-      const tool = getCoreTool("ls");
-      const result = await tool!.execute({ path: tempDir }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBeDefined();
-      const data = result.data as { entries: Array<{ name: string }> };
-      expect(data.entries).toContainEqual(expect.objectContaining({ name: "file1.txt" }));
-      expect(data.entries).toContainEqual(expect.objectContaining({ name: "file2.txt" }));
-      expect(data.entries).not.toContainEqual(expect.objectContaining({ name: ".hidden.txt" }));
-    });
-
-    it("ls should default to cwd and support all+long options", async () => {
-      await fs.writeFile(path.join(tempDir, "alpha.txt"), "a");
-      await fs.writeFile(path.join(tempDir, ".hidden.txt"), "h");
-
-      const tool = getCoreTool("ls");
-      const result = await tool!.execute({ all: true, long: true }, ctx);
-
-      expect(result.success).toBe(true);
-      const entries = (
-        result.data as {
-          entries: Array<{
-            name: string;
-            type: string;
-            size: number;
-            mode: string;
-            mtimeMs: number;
-          }>;
-        }
-      ).entries;
-      const names = entries.map((entry) => entry.name);
-      expect(names).toContain(".hidden.txt");
-      expect(names).toContain("alpha.txt");
-      expect(entries).toContainEqual(
-        expect.objectContaining({
-          name: "alpha.txt",
-          type: "file",
-          size: expect.any(Number),
-          mode: expect.any(String),
-          mtimeMs: expect.any(Number),
-        }),
-      );
-    });
-
-    it("ls should support all/long options", async () => {
-      await fs.writeFile(path.join(tempDir, ".hidden"), "secret");
-      await fs.writeFile(path.join(tempDir, "visible.txt"), "abc");
-
-      const tool = getCoreTool("ls");
-
-      const defaultResult = await tool!.execute({ path: tempDir }, ctx);
-      expect(defaultResult.success).toBe(true);
-      const defaultEntries = (defaultResult.data as { entries: Array<{ name: string }> }).entries;
-      expect(defaultEntries.some((entry) => entry.name === ".hidden")).toBe(false);
-
-      const longAllResult = await tool!.execute({ path: tempDir, all: true, long: true }, ctx);
-      expect(longAllResult.success).toBe(true);
-      const longEntries = (longAllResult.data as { entries: Array<Record<string, unknown>> })
-        .entries;
-      const hidden = longEntries.find((entry) => entry.name === ".hidden");
-      expect(hidden).toBeDefined();
-      expect(typeof hidden?.size).toBe("number");
-      expect(typeof hidden?.mtimeMs).toBe("number");
-      expect(typeof hidden?.modifiedAt).toBe("string");
-    });
-
-    it("ls should return structured depth/limit/offset/ignore contract", async () => {
-      await fs.mkdir(path.join(tempDir, "nested"), { recursive: true });
-      await fs.writeFile(path.join(tempDir, "nested", "a.txt"), "a");
-
-      const tool = getCoreTool("ls");
-      const result = await tool!.execute({ path: ".", depth: 2, limit: 1, offset: 0 }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data).toMatchObject({
-        depth: 2,
-        limit: 1,
-        offset: 0,
-        ignore: [],
-        truncated: expect.any(Boolean),
-        entries: expect.any(Array),
-      });
-    });
-
-    it("glob should find files", async () => {
-      await fs.writeFile(path.join(tempDir, "test1.ts"), "");
-      await fs.writeFile(path.join(tempDir, "test2.ts"), "");
-      await fs.writeFile(path.join(tempDir, "test.js"), "");
-
-      const tool = getCoreTool("glob");
-      const result = await tool!.execute({ pattern: "*.ts", cwd: tempDir }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(Array.isArray(result.data)).toBe(true);
-      expect(result.data).toHaveLength(2);
-    });
-
-    it("glob should support ignore patterns", async () => {
-      await fs.mkdir(path.join(tempDir, "src"), { recursive: true });
-      await fs.mkdir(path.join(tempDir, "vendor"), { recursive: true });
-      await fs.writeFile(path.join(tempDir, "src", "keep.ts"), "");
-      await fs.writeFile(path.join(tempDir, "vendor", "skip.ts"), "");
-
-      const tool = getCoreTool("glob");
-      const result = await tool!.execute(
-        { pattern: "**/*.ts", cwd: tempDir, ignore: ["vendor/**"] },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual(["src/keep.ts"]);
-    });
-
-    it("grep schema should expose glob (not recursive) for directory filtering", () => {
-      const tool = getCoreTool("grep") as Tool;
-      expect(tool).toBeDefined();
-
-      const schema = tool.parameters as {
-        properties?: Record<string, unknown>;
-      };
-      const properties = schema.properties ?? {};
-
-      expect(properties).toHaveProperty("glob");
-      expect(properties).not.toHaveProperty("recursive");
-    });
-
-    it("read_file/write_file schema should constrain encoding values", () => {
-      const readFile = getCoreTool("read_file");
-      const writeFile = getCoreTool("write_file");
-
-      const readEncoding = (readFile!.parameters as any).properties.encoding;
-      const writeEncoding = (writeFile!.parameters as any).properties.encoding;
-
-      expect(readEncoding.enum).toEqual(
-        expect.arrayContaining(["utf-8", "utf8", "latin1", "ascii", "base64"]),
-      );
-      expect(writeEncoding.enum).toEqual(
-        expect.arrayContaining(["utf-8", "utf8", "latin1", "ascii", "base64"]),
-      );
-    });
-  });
-
-  describe("Shell tools execute", () => {
-    it("shell observability executors should be exported from barrel files", () => {
-      expect(typeof executorsBarrel.executeListProcesses).toBe("function");
-      expect(typeof executorsBarrel.executeWaitProcess).toBe("function");
-      expect(typeof toolsBarrel.executeListProcesses).toBe("function");
-      expect(typeof toolsBarrel.executeWaitProcess).toBe("function");
-    });
-
-    it("arion lifecycle executors should be exported from root barrel", () => {
-      expect(typeof executorsBarrel.executeHatchArion).toBe("function");
-      expect(typeof executorsBarrel.executeRestArion).toBe("function");
-      expect(typeof executorsBarrel.executeWakeArion).toBe("function");
-      expect(typeof executorsBarrel.executeRetireArion).toBe("function");
-
-      expect(typeof toolsBarrel.executeHatchArion).toBe("function");
-      expect(typeof toolsBarrel.executeRestArion).toBe("function");
-      expect(typeof toolsBarrel.executeWakeArion).toBe("function");
-      expect(typeof toolsBarrel.executeRetireArion).toBe("function");
-    });
-
-    it("wait_process schema should expose timeoutMs", () => {
-      const tool = getCoreTool("wait_process");
-      expect(tool).toBeDefined();
-
-      const properties = (tool!.parameters as any).properties;
-      expect(properties.pid).toMatchObject({ type: "number" });
-      expect(properties.timeoutMs).toMatchObject({ type: "number" });
-    });
-
-    it("bash should execute commands", async () => {
-      const tool = getCoreTool("bash");
-      const result = await tool!.execute({ command: 'echo "hello world"' }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data.stdout.trim()).toBe("hello world");
-    });
-
-    it("exec should execute programs", async () => {
-      const tool = getCoreTool("exec");
-      const result = await tool!.execute({ program: "echo", args: ["test", "output"] }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.data.stdout.trim()).toBe("test output");
-    });
-
-    it("kill should handle non-existent process gracefully", async () => {
-      const tool = getCoreTool("kill");
-      // Use a PID that doesn't exist
-      const result = await tool!.execute({ pid: 999999999 }, ctx);
-
-      // Should fail gracefully, not throw
-      expect(result.success).toBe(false);
-      expect(result.message).toBeDefined();
-    });
-
-    it("list_processes should fail gracefully without registry in context", async () => {
-      const tool = getCoreTool("list_processes");
-      const result = await tool!.execute({}, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Process registry not available");
-    });
-
-    it("wait_process should fail gracefully without registry in context", async () => {
-      const tool = getCoreTool("wait_process");
-      const result = await tool!.execute({ pid: 1234 }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Process registry not available");
-    });
-  });
-
-  describe("Memory tools execute", () => {
-    it("remember should require memoria in context", async () => {
-      const tool = getCoreTool("remember");
-      const result = await tool!.execute({ content: "Test memory content", tags: ["test"] }, ctx);
-
-      // Without memoria in context, should fail gracefully
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria is not available");
-    });
-
-    it("recall should require memoria in context", async () => {
-      const tool = getCoreTool("recall");
-      const result = await tool!.execute({ query: "test query" }, ctx);
-
-      // Without memoria in context, should fail gracefully
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria is not available");
-    });
-
-    it("recall_knowledge should require memoria in context", async () => {
-      const tool = getCoreTool("recall_knowledge");
-      const result = await tool!.execute({ topic: "test topic" }, ctx);
-
-      // Without memoria in context, should fail gracefully (delegates to search)
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Memoria");
-    });
-
-    it("remember with memoria mock should work", async () => {
-      // Create a context with mock memoria
-      const mockMemoria = {
-        remember: async (content: string) => ({ id: `mem-${Date.now()}` }),
-        recall: async () => [],
-        recallTools: async () => [],
-        deleteMemory: async () => true,
-      };
-      const ctxWithMemoria: ToolContext = {
-        ...ctx,
-        memoria: mockMemoria,
-      };
-
-      const tool = getCoreTool("remember");
-      const result = await tool!.execute(
-        { content: "Test memory content", tags: ["test"] },
-        ctxWithMemoria,
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data).toBeDefined();
-      expect(result.data.id).toBeDefined();
-    });
-  });
-
-  describe("Web tools execute", () => {
-    const mockDuckDuckGoHtml = `
-      <a class="result__a" href="https://example.com">Example Result</a>
-      <a class="result__snippet">Example snippet content</a>
-    `;
-
-    beforeEach(() => {
-      vi.stubGlobal(
-        "fetch",
-        vi.fn().mockResolvedValue(
-          new Response(mockDuckDuckGoHtml, {
-            status: 200,
-            headers: { "Content-Type": "text/html" },
-          }),
-        ),
-      );
-    });
-
-    afterEach(() => {
-      vi.unstubAllGlobals();
-    });
-
-    it("web_search should work without TAVILY_API_KEY (DuckDuckGo fallback)", async () => {
-      const savedKey = process.env.TAVILY_API_KEY;
-      delete process.env.TAVILY_API_KEY;
-      try {
-        const tool = getCoreTool("web_search");
-        const result = await tool!.execute({ query: "test search" }, ctx);
-
-        // SearchProviderRouter falls back to DuckDuckGo when no API keys are set.
-        // The result depends on whether the DDG fetch succeeds or fails in test env.
-        // Either way, it should NOT fail with "TAVILY_API_KEY" error.
-        if (result.success) {
-          expect(result.data).toHaveProperty("query");
-        } else {
-          expect(result.message).not.toContain("TAVILY_API_KEY");
-        }
-      } finally {
-        if (savedKey !== undefined) {
-          process.env.TAVILY_API_KEY = savedKey;
-        }
-      }
-    });
-
-    it("web_fetch should handle invalid URLs", async () => {
-      const tool = getCoreTool("web_fetch");
-      const result = await tool!.execute({ url: "not-a-valid-url" }, ctx);
-
-      // Should fail gracefully with error
-      expect(result.success).toBe(false);
-      expect(result.message).toBeDefined();
-    });
-
-    it("web_search should expose advanced search options and aligned defaults", () => {
-      const tool = getCoreTool("web_search");
-      expect(tool).toBeDefined();
-
-      const properties = (tool!.parameters as any).properties;
-      expect(properties.limit.default).toBe(10);
-      expect(properties.domains).toMatchObject({ type: "array" });
-      expect(properties.excludeDomains).toMatchObject({ type: "array" });
-      expect(properties.topic).toMatchObject({
-        type: "string",
-        enum: ["general", "news"],
-      });
-      expect(properties.timeRange).toMatchObject({
-        type: "string",
-        enum: ["day", "week", "month", "year"],
-      });
-    });
-
-    it("web_fetch should expose request tuning options", () => {
-      const tool = getCoreTool("web_fetch");
-      expect(tool).toBeDefined();
-
-      const properties = (tool!.parameters as any).properties;
-      expect(properties.headers).toMatchObject({ type: "object" });
-      expect(properties.timeoutMs).toMatchObject({ type: "number" });
-      expect(properties.maxSizeBytes).toMatchObject({ type: "number" });
-    });
-
-    it("browse schema should expose timeout and remove screenshot", () => {
-      const tool = getCoreTool("browse");
-      expect(tool).toBeDefined();
-
-      const properties = (tool!.parameters as any).properties;
-      expect(properties.timeoutMs).toMatchObject({ type: "number" });
-      expect(properties.screenshot).toBeUndefined();
-    });
-  });
-
-  // Meta tools (search, learn) moved to @aria/aria — tests moved there too.
-
-  describe("Tool categories are properly wired", () => {
-    it('all filesystem tools should execute without "not implemented" error', async () => {
-      const filesystemTools = getCoreToolsByCategory("filesystem");
-      expect(filesystemTools).toHaveLength(7);
-
-      for (const tool of filesystemTools) {
-        try {
-          // Execute with minimal input - we just want to verify it doesn't throw "not implemented"
-          await tool.execute({}, ctx);
-        } catch (error) {
-          const message = (error as Error).message;
-          expect(message).not.toContain("not implemented");
-        }
-      }
-    });
-
-    it('all shell tools should execute without "not implemented" error', async () => {
-      const shellTools = getCoreToolsByCategory("shell");
-      expect(shellTools).toHaveLength(8);
-
-      for (const tool of shellTools) {
-        try {
-          await tool.execute({}, ctx);
-        } catch (error) {
-          const message = (error as Error).message;
-          expect(message).not.toContain("not implemented");
-        }
-      }
-    });
-
-    it('all memory tools should execute without "not implemented" error', async () => {
-      const memoryTools = getCoreToolsByCategory("memory");
-      expect(memoryTools).toHaveLength(5);
-
-      for (const tool of memoryTools) {
-        try {
-          await tool.execute({}, ctx);
-        } catch (error) {
-          const message = (error as Error).message;
-          expect(message).not.toContain("not implemented");
-        }
-      }
-    });
-
-    it('all web tools should execute without "not implemented" error', async () => {
-      const webTools = getCoreToolsByCategory("web");
-      expect(webTools).toHaveLength(4);
-
-      const mockDuckDuckGoHtml = `
-        <a class="result__a" href="https://example.com">Example Result</a>
-        <a class="result__snippet">Example snippet content</a>
-      `;
-      vi.stubGlobal(
-        "fetch",
-        vi.fn().mockResolvedValue(
-          new Response(mockDuckDuckGoHtml, {
-            status: 200,
-            headers: { "Content-Type": "text/html" },
-          }),
-        ),
-      );
-
-      const inputByToolName: Record<string, Record<string, unknown>> = {
-        web_search: { query: "test search" },
-        web_fetch: { url: "not-a-valid-url" },
-        browse: { url: "not-a-valid-url" },
-      };
-
-      try {
-        for (const tool of webTools) {
-          try {
-            await tool.execute(inputByToolName[tool.name] ?? {}, ctx);
-          } catch (error) {
-            const message = (error as Error).message;
-            expect(message).not.toContain("not implemented");
-          }
-        }
-      } finally {
-        vi.unstubAllGlobals();
-      }
-    });
-
-    it("meta tools include ask_user, quest tools, delegation helpers, and self-improving tools", () => {
-      const metaTools = getCoreToolsByCategory("meta");
-      expect(metaTools).toHaveLength(16);
-      const names = new Set(metaTools.map((t) => t.name));
-      // Core meta
-      expect(names.has("ask_user")).toBe(true);
-      expect(names.has("quest_update")).toBe(true);
-      expect(names.has("quest_list")).toBe(true);
-      // Delegation (meta category)
-      expect(names.has("spawn_worker")).toBe(true);
-      expect(names.has("check_delegation")).toBe(true);
-      // Self-improving agent tools
-      expect(names.has("search")).toBe(true);
-      expect(names.has("learn")).toBe(true);
-      expect(names.has("learn_tool")).toBe(true);
-      expect(names.has("learn_skill")).toBe(true);
-      expect(names.has("create_tool")).toBe(true);
-      expect(names.has("create_skill")).toBe(true);
-      expect(names.has("use_skill")).toBe(true);
-    });
-  });
-
-  describe("Delegation tool routing", () => {
-    it("spawn_worker routes type='cli_agent' to delegationExecutor.spawnCliAgent", async () => {
-      const spawnCliAgent = vi.fn().mockResolvedValue("del_cli_123");
-      const spawnWorker = vi.fn().mockResolvedValue("del_worker_456");
-      const delegationExecutor = {
-        delegateToArion: vi.fn(),
-        spawnWorker,
-        spawnCliAgent,
-      };
-
-      const tool = getCoreTool("spawn_worker");
-      expect(tool).toBeDefined();
-
-      const result = await tool!.execute(
-        {
-          task: "Implement auth middleware",
-          type: "cli_agent",
-          driver: "claude-code",
-          workspace: "tempdir",
-          timeout: 15_000,
-        },
-        {
-          ...ctx,
-          delegationExecutor,
-        },
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual({ id: "del_cli_123" });
-      expect(spawnCliAgent).toHaveBeenCalledWith({
-        task: "Implement auth middleware",
-        driver: "claude-code",
-        workspace: "tempdir",
-        model: undefined,
-        resume: undefined,
-        timeout: 15_000,
-      });
-      expect(spawnWorker).not.toHaveBeenCalled();
-    });
-
-    it("spawn_worker routes default worker path to delegationExecutor.spawnWorker", async () => {
-      const spawnCliAgent = vi.fn().mockResolvedValue("del_cli_123");
-      const spawnWorker = vi.fn().mockResolvedValue("del_worker_456");
-      const delegationExecutor = {
-        delegateToArion: vi.fn(),
-        spawnWorker,
-        spawnCliAgent,
-      };
-
-      const tool = getCoreTool("spawn_worker");
-      expect(tool).toBeDefined();
-
-      const result = await tool!.execute(
-        {
-          task: "Read recent logs",
-          tools: ["read_file"],
-          tier: "fast",
-        },
-        {
-          ...ctx,
-          delegationExecutor,
-        },
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual({ id: "del_worker_456" });
-      expect(spawnWorker).toHaveBeenCalledWith("Read recent logs", ["read_file"], "fast");
-      expect(spawnCliAgent).not.toHaveBeenCalled();
-    });
-  });
-});