@aria-cli/tools 1.0.0

package/tests/registry/discovery.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ToolRegistry } from "../../src/registry/index.js";
+import type { Tool } from "../../src/types.js";
+
+// Mock Memoria
+const mockRecallKnowledge = vi.fn();
+
+const mockMemoria = {
+  recallTools: mockRecallKnowledge,
+  rememberTool: vi.fn(),
+  rememberSkill: vi.fn().mockResolvedValue("skill-id"),
+  recallSkills: vi.fn().mockResolvedValue([]),
+  getSkill: vi.fn().mockResolvedValue(null),
+  recordSkillExecution: vi
+    .fn()
+    .mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
+};
+
+describe("Tool Discovery", () => {
+  let registry: ToolRegistry;
+
+  const createMockTool = (name: string, description: string): Tool => ({
+    name,
+    description,
+    category: "meta",
+    parameters: { type: "object", properties: {} },
+    riskLevel: "safe",
+    execute: async () => ({ success: true, message: "ok" }),
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    registry = new ToolRegistry();
+  });
+
+  describe("search", () => {
+    it("should search registered tools by name", () => {
+      registry.register(createMockTool("file_reader", "Read files from disk"));
+      registry.register(createMockTool("file_writer", "Write files to disk"));
+      registry.register(createMockTool("http_client", "Make HTTP requests"));
+
+      const results = registry.search("file");
+
+      expect(results).toHaveLength(2);
+      expect(results.map((t) => t.name)).toContain("file_reader");
+      expect(results.map((t) => t.name)).toContain("file_writer");
+    });
+
+    it("should search tools by description", () => {
+      registry.register(createMockTool("reader", "Read files from disk"));
+      registry.register(createMockTool("writer", "Write files to disk"));
+      registry.register(createMockTool("fetcher", "Fetch data from API"));
+
+      const results = registry.search("disk");
+
+      expect(results).toHaveLength(2);
+    });
+
+    it("should return empty array for no matches", () => {
+      registry.register(createMockTool("tool1", "Description"));
+
+      const results = registry.search("nonexistent");
+
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe("discoverFromMemoria", () => {
+    it("should load tools from Memoria knowledge", async () => {
+      mockRecallKnowledge.mockResolvedValue([
+        {
+          id: "k1",
+          name: "custom_tool",
+          description: "A custom learned tool",
+          category: "meta",
+          parameters: { type: "object", properties: { input: { type: "string" } } },
+          riskLevel: "safe",
+          responseTemplate: "Result: {{input}}",
+        },
+      ]);
+
+      const count = await registry.discoverFromMemoria(mockMemoria as any);
+
+      expect(count).toBe(1);
+      expect(registry.has("custom_tool")).toBe(true);
+
+      const tool = registry.get("custom_tool");
+      expect(tool?.description).toBe("A custom learned tool");
+    });
+
+    it("should register only recalled tools with responseTemplate content", async () => {
+      mockRecallKnowledge.mockResolvedValue([
+        {
+          id: "k1",
+          name: "valid_tool",
+          description: "Valid",
+          category: "meta",
+          parameters: { type: "object" },
+          riskLevel: "safe",
+          responseTemplate: "Result: ok",
+        },
+        {
+          id: "k2",
+          name: "also_a_tool",
+          description: "Knowledge-only metadata should be skipped",
+          category: "meta",
+          parameters: { type: "object", properties: {} },
+          riskLevel: "safe",
+          knowledge: "This tool does useful things",
+        },
+      ]);
+
+      const count = await registry.discoverFromMemoria(mockMemoria as any);
+
+      expect(count).toBe(1);
+      expect(registry.has("valid_tool")).toBe(true);
+      expect(registry.has("also_a_tool")).toBe(false);
+    });
+
+    it("should return 0 when recallTools fails", async () => {
+      mockRecallKnowledge.mockRejectedValue(new Error("Network error"));
+
+      const count = await registry.discoverFromMemoria(mockMemoria as any);
+
+      expect(count).toBe(0);
+    });
+  });
+
+  describe("saveToMemoria", () => {
+    it("should save tool definition to Memoria", async () => {
+      const rememberMock = vi.fn().mockResolvedValue("k1");
+      const memoria = { rememberTool: rememberMock } as any;
+
+      const tool = createMockTool("my_tool", "My tool description");
+      registry.register(tool);
+
+      await registry.saveToMemoria("my_tool", memoria);
+
+      expect(rememberMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my_tool",
+          description: "My tool description",
+        }),
+      );
+    });
+
+    it("should throw error if tool not found", async () => {
+      const memoria = { rememberTool: vi.fn() } as any;
+      await expect(registry.saveToMemoria("nonexistent", memoria)).rejects.toThrow(
+        'Tool "nonexistent" not found',
+      );
+    });
+  });
+});

package/tests/registry/injectable-logger.test.ts

@@ -0,0 +1,230 @@
+/**
+ * @aria/tools - Injectable Logger Tests for ToolRegistry
+ *
+ * Verifies that ToolRegistry uses an injectable logger instead of hardcoded
+ * console.warn/error, and that the default behavior (using console) is preserved.
+ *
+ * aria-rfu.17: Debug cleanup + injectable logger
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ToolRegistry } from "../../src/registry/registry.js";
+import type { Logger, Tool, ToolContext } from "../../src/types.js";
+
+function createMockLogger(): Logger & {
+  warn: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+} {
+  return {
+    warn: vi.fn(),
+    error: vi.fn(),
+  };
+}
+
+function createDummyTool(name: string): Tool {
+  return {
+    name,
+    description: `Tool ${name}`,
+    category: "meta",
+    parameters: { type: "object", properties: {} },
+    riskLevel: "safe",
+    execute: async () => ({ success: true, message: "ok" }),
+  };
+}
+
+describe("ToolRegistry — injectable logger", () => {
+  describe("constructor", () => {
+    it("accepts a custom logger via options", () => {
+      const logger = createMockLogger();
+      const registry = new ToolRegistry({ logger });
+
+      // Registry should be created successfully
+      expect(registry.size).toBe(0);
+    });
+
+    it("defaults to console when no logger is provided", () => {
+      // Should not throw
+      const registry = new ToolRegistry();
+      expect(registry.size).toBe(0);
+    });
+
+    it("defaults to console when options is empty object", () => {
+      const registry = new ToolRegistry({});
+      expect(registry.size).toBe(0);
+    });
+  });
+
+  describe("discoverFromMemoria — uses logger.warn on invalid tool definitions", () => {
+    it("calls logger.warn when a tool definition throws during creation", async () => {
+      const logger = createMockLogger();
+      const registry = new ToolRegistry({ logger });
+
+      // Create a knowledge item with a description getter that throws —
+      // simulates a corrupt entry. name is a normal string so the warn
+      // message in the catch block can still access k.name safely.
+      const badItem = {
+        id: "bad-tool",
+        name: "broken-tool",
+        get description(): string {
+          throw new Error("corrupt entry");
+        },
+      };
+
+      const mockMemoria = {
+        recallTools: vi.fn().mockResolvedValue([badItem]),
+        rememberTool: vi.fn(),
+        rememberSkill: vi.fn().mockResolvedValue("skill-id"),
+        recallSkills: vi.fn().mockResolvedValue([]),
+        getSkill: vi.fn().mockResolvedValue(null),
+        recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
+      };
+
+      await registry.discoverFromMemoria(mockMemoria);
+
+      // logger.warn should be called for the invalid tool
+      expect(logger.warn).toHaveBeenCalledTimes(1);
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining("Invalid tool definition in Memoria: broken-tool"),
+      );
+
+      // Verify the corrupt tool was not registered
+      expect(registry.has("broken-tool")).toBe(false);
+    });
+
+    it("calls logger.error when Memoria query itself fails", async () => {
+      const logger = createMockLogger();
+      const registry = new ToolRegistry({ logger });
+
+      const mockMemoria = {
+        recallTools: vi.fn().mockRejectedValue(new Error("DB connection lost")),
+        rememberTool: vi.fn(),
+        rememberSkill: vi.fn().mockResolvedValue("skill-id"),
+        recallSkills: vi.fn().mockResolvedValue([]),
+        getSkill: vi.fn().mockResolvedValue(null),
+        recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
+      };
+
+      await registry.discoverFromMemoria(mockMemoria);
+
+      // logger.error should be called for the Memoria error
+      expect(logger.error).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledWith(
+        expect.stringContaining("Error discovering tools from Memoria"),
+        expect.any(Error),
+      );
+    });
+
+    it("does NOT call console.warn/error when custom logger is provided", async () => {
+      const logger = createMockLogger();
+      const registry = new ToolRegistry({ logger });
+
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      // Create a knowledge item with a description getter that throws
+      const badItem = {
+        id: "bad-tool",
+        name: "broken-tool",
+        get description(): string {
+          throw new Error("corrupt entry");
+        },
+      };
+
+      const mockMemoria = {
+        recallTools: vi.fn().mockResolvedValue([badItem]),
+        rememberTool: vi.fn(),
+        rememberSkill: vi.fn().mockResolvedValue("skill-id"),
+        recallSkills: vi.fn().mockResolvedValue([]),
+        getSkill: vi.fn().mockResolvedValue(null),
+        recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
+      };
+
+      await registry.discoverFromMemoria(mockMemoria);
+
+      // console.warn/error should NOT be called (custom logger handles it)
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+
+      // Verify the corrupt tool was not registered
+      expect(registry.has("broken-tool")).toBe(false);
+
+      consoleWarnSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe("connectMCP — logger flows to MCPClient", () => {
+    it("logger is available on registry (verified via discoverFromMemoria path)", async () => {
+      // We verify that the same logger is used across all registry operations.
+      // connectMCP spawns real processes, so we verify logger flow through
+      // discoverFromMemoria which is fully in-process.
+      const logger = createMockLogger();
+      const registry = new ToolRegistry({ logger });
+
+      // First verify logger works via discoverFromMemoria
+      const mockMemoria = {
+        recallTools: vi.fn().mockRejectedValue(new Error("DB error")),
+        rememberTool: vi.fn(),
+        rememberSkill: vi.fn().mockResolvedValue("skill-id"),
+        recallSkills: vi.fn().mockResolvedValue([]),
+        getSkill: vi.fn().mockResolvedValue(null),
+        recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
+      };
+
+      await registry.discoverFromMemoria(mockMemoria);
+
+      // Logger.error should have been called
+      expect(logger.error).toHaveBeenCalled();
+
+      // And console.error should NOT have been called
+      const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      logger.error.mockClear();
+
+      await registry.discoverFromMemoria(mockMemoria);
+
+      expect(logger.error).toHaveBeenCalled();
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe("default logger (console) is used when no custom logger provided", () => {
+    it("uses console.warn for invalid tool definitions in discoverFromMemoria", async () => {
+      const registry = new ToolRegistry(); // no custom logger
+
+      const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+      // Create a knowledge item with a description getter that throws
+      const badItem = {
+        id: "bad-tool",
+        name: "broken-tool",
+        get description(): string {
+          throw new Error("corrupt entry");
+        },
+      };
+
+      const mockMemoria = {
+        recallTools: vi.fn().mockResolvedValue([badItem]),
+        rememberTool: vi.fn(),
+        rememberSkill: vi.fn().mockResolvedValue("skill-id"),
+        recallSkills: vi.fn().mockResolvedValue([]),
+        getSkill: vi.fn().mockResolvedValue(null),
+        recordSkillExecution: vi.fn().mockResolvedValue({ id: "exec-1", skillId: "s1", success: true, timestamp: new Date() }),
+      };
+
+      await registry.discoverFromMemoria(mockMemoria);
+
+      // console.warn should be called since no custom logger was set
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Invalid tool definition"),
+      );
+
+      // Verify the corrupt tool was not registered
+      expect(registry.has("broken-tool")).toBe(false);
+
+      consoleWarnSpy.mockRestore();
+    });
+  });
+});