@aria-cli/tools 1.0.0

package/tests/definitions/execution.test.ts

@@ -0,0 +1,671 @@
+/**
+ * @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();
+    });
+  });
+});