@aria-cli/tools 1.0.8 → 1.0.10

package/tests/registry/discovery.test.ts

@@ -1,154 +0,0 @@
-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

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