@aria-cli/tools 1.0.9 → 1.0.10

package/tests/registry/input-validation.test.ts

@@ -1,361 +0,0 @@
-/**
- * @aria/tools - ToolRegistry.execute() input validation tests
- *
- * Verifies that ToolRegistry.execute() validates input against the tool's
- * JSON Schema before delegating to the handler, and that tools without
- * schemas skip validation.
- */
-
-import { describe, it, expect, vi } from "vitest";
-import { ToolRegistry, validateToolInput } from "../../src/registry/index.js";
-import type { Tool, ToolContext, ToolResult } from "../../src/types.js";
-import type { JSONSchema7 } from "json-schema";
-
-// Helper to create a minimal ToolContext
-const createContext = (): ToolContext => ({
-  workingDir: "/tmp/test",
-  env: {},
-  confirm: async () => true,
-});
-
-/** Helper to build a simple tool with a JSON Schema */
-function makeTool(overrides: Partial<Tool> = {}): Tool {
-  return {
-    name: "test_tool",
-    description: "A test tool",
-    category: "meta",
-    parameters: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "The name" },
-        count: { type: "number", description: "A count" },
-      },
-      required: ["name"],
-    } as JSONSchema7,
-    riskLevel: "safe",
-    execute: vi.fn(async () => ({
-      success: true,
-      message: "executed",
-    })),
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// validateToolInput unit tests
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      name: { type: "string" },
-      count: { type: "number" },
-      active: { type: "boolean" },
-      tags: { type: "array" },
-      meta: { type: "object" },
-    },
-    required: ["name"],
-  };
-
-  it("returns null for valid input", () => {
-    expect(validateToolInput({ name: "hello" }, schema)).toBeNull();
-    expect(validateToolInput({ name: "hi", count: 5 }, schema)).toBeNull();
-  });
-
-  it("rejects non-object input", () => {
-    expect(validateToolInput("string", schema)).toMatch(/Expected an object/);
-    expect(validateToolInput(42, schema)).toMatch(/Expected an object/);
-    expect(validateToolInput(true, schema)).toMatch(/Expected an object/);
-    expect(validateToolInput([1, 2], schema)).toMatch(/Expected an object.*array/);
-  });
-
-  it("rejects null/undefined when required fields exist", () => {
-    expect(validateToolInput(null, schema)).toMatch(/required properties/);
-    expect(validateToolInput(undefined, schema)).toMatch(/required properties/);
-  });
-
-  it("allows null/undefined when no required fields", () => {
-    const noReqSchema = { type: "object", properties: { x: { type: "string" } } };
-    expect(validateToolInput(null, noReqSchema)).toBeNull();
-    expect(validateToolInput(undefined, noReqSchema)).toBeNull();
-  });
-
-  it("detects missing required properties", () => {
-    expect(validateToolInput({}, schema)).toMatch(/Missing required.*name/);
-    expect(validateToolInput({ count: 3 }, schema)).toMatch(/Missing required.*name/);
-  });
-
-  it("detects wrong property type (string vs number)", () => {
-    expect(validateToolInput({ name: 123 }, schema)).toMatch(
-      /Property "name" expected type string; got number/,
-    );
-  });
-
-  it("detects wrong property type (number vs string)", () => {
-    expect(validateToolInput({ name: "ok", count: "five" }, schema)).toMatch(
-      /Property "count" expected type number; got string/,
-    );
-  });
-
-  it("validates boolean type", () => {
-    expect(validateToolInput({ name: "ok", active: "yes" }, schema)).toMatch(
-      /Property "active" expected type boolean; got string/,
-    );
-    expect(validateToolInput({ name: "ok", active: true }, schema)).toBeNull();
-  });
-
-  it("validates array type", () => {
-    expect(validateToolInput({ name: "ok", tags: "not-array" }, schema)).toMatch(
-      /Property "tags" expected type array; got string/,
-    );
-    expect(validateToolInput({ name: "ok", tags: [1, 2] }, schema)).toBeNull();
-  });
-
-  it("validates object type (nested)", () => {
-    expect(validateToolInput({ name: "ok", meta: "nope" }, schema)).toMatch(
-      /Property "meta" expected type object; got string/,
-    );
-    expect(validateToolInput({ name: "ok", meta: { a: 1 } }, schema)).toBeNull();
-  });
-
-  it("handles integer type", () => {
-    const intSchema = {
-      type: "object",
-      properties: { n: { type: "integer" } },
-      required: ["n"],
-    };
-    expect(validateToolInput({ n: 5 }, intSchema)).toBeNull();
-    expect(validateToolInput({ n: 5.5 }, intSchema)).toMatch(
-      /Property "n" expected type integer; got number/,
-    );
-  });
-
-  it("handles union types (e.g. ['string', 'null'])", () => {
-    const unionSchema = {
-      type: "object",
-      properties: { val: { type: ["string", "null"] } },
-    };
-    expect(validateToolInput({ val: "hi" }, unionSchema)).toBeNull();
-    expect(validateToolInput({ val: null }, unionSchema)).toBeNull();
-    expect(validateToolInput({ val: 42 }, unionSchema)).toMatch(
-      /Property "val" expected type string \| null; got number/,
-    );
-  });
-
-  it("skips validation for non-object schemas", () => {
-    expect(validateToolInput("anything", { type: "string" })).toBeNull();
-    expect(validateToolInput(42, { type: "number" })).toBeNull();
-  });
-
-  it("skips property type check when schema has no type", () => {
-    const noTypeSchema = {
-      type: "object",
-      properties: { data: { description: "anything goes" } },
-      required: ["data"],
-    };
-    expect(validateToolInput({ data: 42 }, noTypeSchema)).toBeNull();
-    expect(validateToolInput({ data: "ok" }, noTypeSchema)).toBeNull();
-  });
-
-  it("ignores undeclared extra properties", () => {
-    expect(validateToolInput({ name: "ok", extra: true }, schema)).toBeNull();
-  });
-
-  it("validates enum constraints", () => {
-    const enumSchema = {
-      type: "object",
-      properties: {
-        topic: { type: "string", enum: ["general", "news"] },
-      },
-      required: ["topic"],
-    };
-
-    expect(validateToolInput({ topic: "general" }, enumSchema)).toBeNull();
-    expect(validateToolInput({ topic: "sports" }, enumSchema)).toMatch(
-      /Property "topic" must be one of: general, news/,
-    );
-  });
-
-  it("validates string pattern constraints", () => {
-    const patternSchema = {
-      type: "object",
-      properties: {
-        slug: { type: "string", pattern: "^[a-z0-9-]+$" },
-      },
-      required: ["slug"],
-    };
-
-    expect(validateToolInput({ slug: "hello-world-2" }, patternSchema)).toBeNull();
-    expect(validateToolInput({ slug: "Hello World" }, patternSchema)).toMatch(
-      /Property "slug" does not match required pattern/,
-    );
-  });
-
-  it("validates numeric minimum/maximum bounds", () => {
-    const boundsSchema = {
-      type: "object",
-      properties: {
-        limit: { type: "number", minimum: 1, maximum: 10 },
-      },
-      required: ["limit"],
-    };
-
-    expect(validateToolInput({ limit: 5 }, boundsSchema)).toBeNull();
-    expect(validateToolInput({ limit: 0 }, boundsSchema)).toMatch(
-      /Property "limit" must be >= 1/,
-    );
-    expect(validateToolInput({ limit: 11 }, boundsSchema)).toMatch(
-      /Property "limit" must be <= 10/,
-    );
-  });
-
-  it("validates string length bounds", () => {
-    const lengthSchema = {
-      type: "object",
-      properties: {
-        name: { type: "string", minLength: 2, maxLength: 5 },
-      },
-      required: ["name"],
-    };
-
-    expect(validateToolInput({ name: "aria" }, lengthSchema)).toBeNull();
-    expect(validateToolInput({ name: "a" }, lengthSchema)).toMatch(
-      /Property "name" must have length >= 2/,
-    );
-    expect(validateToolInput({ name: "tooling" }, lengthSchema)).toMatch(
-      /Property "name" must have length <= 5/,
-    );
-  });
-
-  it("validates additionalProperties schema value types", () => {
-    const mapSchema = {
-      type: "object",
-      properties: {
-        headers: {
-          type: "object",
-          additionalProperties: { type: "string" },
-        },
-      },
-      required: ["headers"],
-    };
-
-    expect(validateToolInput({ headers: { accept: "application/json" } }, mapSchema)).toBeNull();
-    expect(validateToolInput({ headers: { retries: 3 } }, mapSchema)).toMatch(
-      /Property "headers.retries" expected type string; got number/,
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// ToolRegistry.execute() integration tests
-// ---------------------------------------------------------------------------
-
-describe("ToolRegistry.execute()", () => {
-  it("passes valid input to the tool handler", async () => {
-    const registry = new ToolRegistry();
-    const tool = makeTool();
-    registry.register(tool);
-
-    const ctx = createContext();
-    const result = await registry.execute("test_tool", { name: "Alice" }, ctx);
-
-    expect(result.success).toBe(true);
-    expect(result.message).toBe("executed");
-    expect(tool.execute).toHaveBeenCalledWith({ name: "Alice" }, ctx);
-  });
-
-  it("returns error for unregistered tool", async () => {
-    const registry = new ToolRegistry();
-    const result = await registry.execute("nonexistent", {}, createContext());
-
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/not registered/);
-  });
-
-  it("returns validation error for missing required property", async () => {
-    const registry = new ToolRegistry();
-    const tool = makeTool();
-    registry.register(tool);
-
-    const result = await registry.execute("test_tool", {}, createContext());
-
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/Invalid input.*Missing required.*name/);
-    expect(tool.execute).not.toHaveBeenCalled();
-  });
-
-  it("returns validation error for wrong property type", async () => {
-    const registry = new ToolRegistry();
-    const tool = makeTool();
-    registry.register(tool);
-
-    const result = await registry.execute("test_tool", { name: 42 }, createContext());
-
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/Invalid input.*Property "name" expected type string/);
-    expect(tool.execute).not.toHaveBeenCalled();
-  });
-
-  it("returns validation error for non-object input when required fields exist", async () => {
-    const registry = new ToolRegistry();
-    const tool = makeTool();
-    registry.register(tool);
-
-    const result = await registry.execute("test_tool", "not an object", createContext());
-
-    expect(result.success).toBe(false);
-    expect(result.message).toMatch(/Invalid input.*Expected an object/);
-    expect(tool.execute).not.toHaveBeenCalled();
-  });
-
-  it("skips validation for tool without parameters schema", async () => {
-    const registry = new ToolRegistry();
-    const handler = vi.fn(
-      async (): Promise<ToolResult> => ({
-        success: true,
-        message: "no-schema ok",
-      }),
-    );
-    const tool: Tool = {
-      name: "no_schema_tool",
-      description: "Tool with empty schema",
-      category: "meta",
-      parameters: {} as JSONSchema7, // Empty schema (no type field)
-      riskLevel: "safe",
-      execute: handler,
-    };
-    registry.register(tool);
-
-    const result = await registry.execute("no_schema_tool", { anything: true }, createContext());
-
-    expect(result.success).toBe(true);
-    expect(handler).toHaveBeenCalledWith({ anything: true }, expect.any(Object));
-  });
-
-  it("passes optional properties correctly", async () => {
-    const registry = new ToolRegistry();
-    const tool = makeTool();
-    registry.register(tool);
-
-    const result = await registry.execute("test_tool", { name: "Bob", count: 10 }, createContext());
-
-    expect(result.success).toBe(true);
-    expect(tool.execute).toHaveBeenCalledWith({ name: "Bob", count: 10 }, expect.any(Object));
-  });
-
-  it("allows extra properties not in schema", async () => {
-    const registry = new ToolRegistry();
-    const tool = makeTool();
-    registry.register(tool);
-
-    const result = await registry.execute(
-      "test_tool",
-      { name: "ok", extraField: 999 },
-      createContext(),
-    );
-
-    expect(result.success).toBe(true);
-    expect(tool.execute).toHaveBeenCalled();
-  });
-});

package/tests/registry/interface-completeness.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type {
-  ToolRegistry as ToolRegistryInterface,
-  Tool,
-  ToolCategory,
-} from "../../src/types.js";
-import { ToolRegistry as ToolRegistryClass } from "../../src/registry/registry.js";
-
-/**
- * Verify that the ToolRegistry interface declares all methods
- * that the concrete class and executors rely on.
- */
-describe("ToolRegistry interface completeness", () => {
-  it("ToolRegistry interface should declare a list() method", () => {
-    // Use a type assertion to verify the interface shape.
-    // Create a type helper that extracts the 'list' key from the interface.
-    // If 'list' is not on the interface, this will be 'never' at compile time
-    // and the runtime assertion will fail.
-    type HasList = ToolRegistryInterface extends {
-      list: (...args: any[]) => any;
-    }
-      ? true
-      : false;
-
-    // This const is typed as `true` if the interface has list(), `false` otherwise.
-    // At runtime, we force-evaluate it.
-    const hasListMethod: HasList = true as HasList;
-    expect(hasListMethod).toBe(true);
-
-    // Also verify at runtime by checking the concrete class,
-    // which implements the interface
-    const concrete = new ToolRegistryClass();
-    expect(typeof concrete.list).toBe("function");
-  });
-
-  it("concrete ToolRegistry class should be assignable to ToolRegistry interface", () => {
-    // This assignment verifies structural compatibility.
-    // If the interface requires list() but class doesn't have it (or vice versa),
-    // TypeScript would flag it.
-    const concrete = new ToolRegistryClass();
-    const asInterface: ToolRegistryInterface = concrete;
-
-    // Verify all expected methods exist
-    expect(typeof asInterface.get).toBe("function");
-    expect(typeof asInterface.getAll).toBe("function");
-    expect(typeof asInterface.getToolInfos).toBe("function");
-    expect(typeof asInterface.register).toBe("function");
-    expect(typeof asInterface.has).toBe("function");
-
-    // This is the critical check — list() should be on the interface
-    // After the fix, this should be typed and callable
-    expect(typeof (asInterface as any).list).toBe("function");
-  });
-
-  it("list() should accept optional category filter and return Tool[]", () => {
-    const concrete = new ToolRegistryClass();
-
-    // Register some tools
-    concrete.register({
-      name: "tool_a",
-      description: "Tool A",
-      category: "filesystem" as ToolCategory,
-      parameters: { type: "object", properties: {} },
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    });
-    concrete.register({
-      name: "tool_b",
-      description: "Tool B",
-      category: "shell" as ToolCategory,
-      parameters: { type: "object", properties: {} },
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    });
-
-    // list() without category returns all tools
-    const all = concrete.list();
-    expect(all).toHaveLength(2);
-
-    // list() with category filters
-    const fsTools = concrete.list("filesystem" as ToolCategory);
-    expect(fsTools).toHaveLength(1);
-    expect(fsTools[0].name).toBe("tool_a");
-  });
-});

package/tests/registry/mcp-integration.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ToolRegistry } from "../../src/registry/registry.js";
-import type { MCPServerConfig } from "../../src/mcp/types.js";
-
-describe("Tool Registry - MCP Integration", () => {
-  let registry: ToolRegistry;
-
-  beforeEach(() => {
-    registry = new ToolRegistry();
-  });
-
-  it("should connect to MCP server and discover tools", async () => {
-    const mockServerConfig: MCPServerConfig = {
-      name: "test-server",
-      command: "node",
-      args: ["server.js"],
-    };
-
-    // Mock the MCPClient internally by testing the actual registry method
-    // This test validates that connectMCP accepts config and attempts connection
-    const result = await registry.connectMCP([mockServerConfig]);
-
-    // Should return counts even if no actual server connected
-    expect(result).toHaveProperty("tools");
-    expect(result).toHaveProperty("resources");
-    expect(result).toHaveProperty("prompts");
-    expect(typeof result.tools).toBe("number");
-    expect(typeof result.resources).toBe("number");
-    expect(typeof result.prompts).toBe("number");
-  });
-
-  it("should handle MCP toolsChanged events", async () => {
-    // Create a mock MCP client that simulates tool changes
-    const mockMCPClient = {
-      connect: vi.fn().mockResolvedValue(undefined),
-      listAllTools: vi.fn().mockResolvedValue([
-        {
-          name: "dynamic_tool",
-          description: "Dynamically added",
-          inputSchema: { type: "object", properties: {} },
-          server: "test-server",
-        },
-      ]),
-      listAllResources: vi.fn().mockResolvedValue([]),
-      listAllPrompts: vi.fn().mockResolvedValue([]),
-      on: vi.fn((event: string, handler: Function) => {
-        // Store handler for manual triggering
-        if (event === "toolsChanged") {
-          // Simulate toolsChanged event after a delay
-          setTimeout(() => handler("test-server"), 10);
-        }
-      }),
-      disconnectAll: vi.fn(),
-    };
-
-    // Create registry with mocked client
-    const testRegistry = new ToolRegistry();
-
-    // Replace the internal MCP client creation with our mock
-    // Since we can't easily inject the mock, we test the event handling logic
-    // by verifying the registry's behavior after tool changes
-
-    const mockConfig: MCPServerConfig = {
-      name: "test-server",
-      command: "node",
-      args: ["test.js"],
-    };
-
-    // Connect and verify initial state
-    await testRegistry.connectMCP([mockConfig]);
-
-    // Wait for any async event handling
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    // The registry should handle toolsChanged events by refreshing tools
-    // We can verify this by checking if the registry maintains tool consistency
-    expect(testRegistry).toBeDefined();
-  });
-
-  it("should clean up MCP tools on disconnect", async () => {
-    const mockConfig: MCPServerConfig = {
-      name: "test-server",
-      command: "node",
-      args: ["test.js"],
-    };
-
-    // Connect to MCP server
-    await registry.connectMCP([mockConfig]);
-
-    // Check initial state - even if connection failed, registry should be clean
-    const sizeBefore = registry.size;
-
-    // Disconnect should remove all MCP tools
-    await registry.disconnectMCP();
-
-    // After disconnect, all mcp__ prefixed tools should be removed
-    const toolsAfter = registry.list();
-    const mcpTools = toolsAfter.filter((t) => t.name.startsWith("mcp__"));
-
-    expect(mcpTools).toHaveLength(0);
-    expect(registry.getMCPClient()).toBeUndefined();
-  });
-});

package/tests/registry/mcp-read-only-hint.test.ts

@@ -1,60 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ToolRegistry } from "../../src/registry/registry.js";
-
-const mockConnect = vi.fn();
-const mockListAllTools = vi.fn();
-const mockListAllResources = vi.fn();
-const mockListAllPrompts = vi.fn();
-const mockOn = vi.fn();
-const mockDisconnectAll = vi.fn();
-
-vi.mock("../../src/mcp/client.js", () => ({
-  MCPClient: class MockMCPClient {
-    connect = mockConnect;
-    listAllTools = mockListAllTools;
-    listAllResources = mockListAllResources;
-    listAllPrompts = mockListAllPrompts;
-    on = mockOn;
-    disconnectAll = mockDisconnectAll;
-  },
-}));
-
-describe("MCP read-only classification", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockConnect.mockResolvedValue(undefined);
-    mockListAllResources.mockResolvedValue([]);
-    mockListAllPrompts.mockResolvedValue([]);
-    mockOn.mockImplementation(() => undefined);
-  });
-
-  it("trusts MCP readOnlyHint annotation instead of tool-name prefixes", async () => {
-    mockListAllTools.mockResolvedValue([
-      {
-        server: "test",
-        name: "list_users",
-        description: "Can write despite list_ prefix",
-        inputSchema: { type: "object", properties: {} },
-        annotations: { readOnlyHint: false },
-      },
-      {
-        server: "test",
-        name: "mutate_safely",
-        description: "Actually read only",
-        inputSchema: { type: "object", properties: {} },
-        annotations: { readOnlyHint: true },
-      },
-    ]);
-
-    const registry = new ToolRegistry();
-    await registry.connectMCP([{ name: "test", command: "node", args: ["server.js"] }]);
-
-    const prefixedTool = registry.get("mcp__test__list_users");
-    const hintedTool = registry.get("mcp__test__mutate_safely");
-
-    expect(prefixedTool).toBeDefined();
-    expect(prefixedTool?.isReadOnly).toBe(false);
-    expect(hintedTool).toBeDefined();
-    expect(hintedTool?.isReadOnly).toBe(true);
-  });
-});