@aria-cli/tools 1.0.9 → 1.0.11

package/tests/registry/memoria-discovery.test.ts

@@ -1,390 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ToolRegistry } from "../../src/registry/registry.js";
-
-describe("Tool Registry - Memoria Discovery", () => {
-  let registry: ToolRegistry;
-  let mockMemoria: any;
-
-  beforeEach(() => {
-    registry = new ToolRegistry();
-    mockMemoria = {
-      recallTools: vi.fn(),
-      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() }),
-    };
-  });
-
-  it("should discover tools from Memoria", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-1",
-        name: "memoria_tool",
-        description: "A tool from Memoria",
-        category: "filesystem",
-        parameters: { type: "object", properties: { input: { type: "string" } } },
-        riskLevel: "safe",
-        responseTemplate: "result: {{input}}",
-      },
-    ]);
-
-    await registry.discoverFromMemoria(mockMemoria);
-
-    expect(mockMemoria.recallTools).toHaveBeenCalledWith({
-      query: "",
-      limit: 200,
-      offset: 0,
-      matchAll: true,
-      updateAccessStats: false,
-    });
-
-    expect(registry.has("memoria_tool")).toBe(true);
-    const tool = registry.get("memoria_tool");
-    expect(tool?.description).toBe("A tool from Memoria");
-    expect(tool?.loadingTier).toBe("deferred");
-  });
-
-  it("should map Memoria failures into discovered tool issues", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-risk",
-        name: "git_force_push",
-        description: "Force push helper",
-        category: "shell",
-        parameters: { type: "object", properties: { branch: { type: "string" } } },
-        riskLevel: "dangerous",
-        failures: [
-          { error: "force-push can overwrite remote history" },
-          { error: "no branch protection check" },
-          { error: "force-push can overwrite remote history" },
-        ],
-        responseTemplate: "force push {{branch}}",
-      },
-    ]);
-
-    await registry.discoverFromMemoria(mockMemoria);
-
-    const tool = registry.get("git_force_push");
-    expect(tool).toBeDefined();
-    expect(tool?.issues).toEqual([
-      "force-push can overwrite remote history",
-      "no branch protection check",
-    ]);
-  });
-
-  it("should handle empty Memoria results gracefully", async () => {
-    mockMemoria.recallTools.mockResolvedValue([]);
-
-    await registry.discoverFromMemoria(mockMemoria);
-
-    expect(registry.size).toBe(0);
-  });
-
-  it("should page through matchAll recall so discovery includes all tools", async () => {
-    const total = 250;
-    mockMemoria.recallTools.mockImplementation(
-      async (opts: { limit?: number; offset?: number }) => {
-        const limit = opts.limit ?? 200;
-        const offset = opts.offset ?? 0;
-        if (offset >= total) return [];
-        return Array.from({ length: Math.min(limit, total - offset) }, (_, i) => {
-          const index = offset + i + 1;
-          return {
-            id: `tool-${index}`,
-            name: `bulk_tool_${index}`,
-            description: `Bulk tool ${index}`,
-            category: "meta",
-            parameters: { type: "object", properties: {} },
-            riskLevel: "safe",
-            responseTemplate: `ok-${index}`,
-          };
-        });
-      },
-    );
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(total);
-    expect(mockMemoria.recallTools).toHaveBeenNthCalledWith(1, {
-      query: "",
-      limit: 200,
-      offset: 0,
-      matchAll: true,
-      updateAccessStats: false,
-    });
-    expect(mockMemoria.recallTools).toHaveBeenNthCalledWith(2, {
-      query: "",
-      limit: 200,
-      offset: 200,
-      matchAll: true,
-      updateAccessStats: false,
-    });
-    expect(registry.has("bulk_tool_250")).toBe(true);
-  });
-
-  it("should skip invalid or knowledge-only recalled tools and keep executable template tools", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-1",
-        name: "first_tool",
-        description: "First tool",
-      },
-      {
-        id: "tool-2",
-        name: "second_tool",
-        description: "Valid tool",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        responseTemplate: "second tool: {{input}}",
-      },
-      {
-        id: "tool-3",
-        name: "third_tool",
-        description: "Knowledge-only tool",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        knowledge: "third tool knowledge",
-      },
-    ]);
-
-    await registry.discoverFromMemoria(mockMemoria);
-
-    expect(registry.has("first_tool")).toBe(false);
-    expect(registry.has("second_tool")).toBe(true);
-    expect(registry.has("third_tool")).toBe(false);
-  });
-
-  it("should default missing parameters for template-backed tools", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-missing-params",
-        name: "templated_without_params",
-        description: "Template tool missing explicit schema",
-        category: "meta",
-        riskLevel: "safe",
-        responseTemplate: "Template result: {{input}}",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(1);
-    const tool = registry.get("templated_without_params");
-    expect(tool).toBeDefined();
-    expect(tool?.parameters).toEqual({
-      type: "object",
-      properties: {},
-      additionalProperties: true,
-    });
-  });
-
-  it("should persist tool to Memoria", async () => {
-    const mockTool = {
-      name: "persist_test",
-      description: "Tool to persist",
-      category: "meta" as const,
-      parameters: { arg: { type: "string" } },
-      riskLevel: "safe" as const,
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    // Register the tool first
-    registry.register(mockTool);
-
-    mockMemoria.rememberTool.mockResolvedValue("tool-123");
-
-    await registry.saveToMemoria("persist_test", mockMemoria);
-
-    expect(mockMemoria.rememberTool).toHaveBeenCalledWith({
-      name: "persist_test",
-      description: "Tool to persist",
-      category: "meta",
-      parameters: { arg: { type: "string" } },
-      riskLevel: "safe",
-    });
-  });
-
-  it("persists explicit non-shell responseTemplate fields", async () => {
-    const mockTool = {
-      name: "persist_with_template",
-      description: "Templated tool",
-      category: "meta" as const,
-      parameters: { type: "object", properties: { name: { type: "string" } } },
-      riskLevel: "safe" as const,
-      responseTemplate: "hello {{name}}",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(mockTool);
-    mockMemoria.rememberTool.mockResolvedValue("tool-template");
-
-    await registry.saveToMemoria("persist_with_template", mockMemoria);
-
-    expect(mockMemoria.rememberTool).toHaveBeenCalledWith(
-      expect.objectContaining({
-        name: "persist_with_template",
-        responseTemplate: "hello {{name}}",
-      }),
-    );
-  });
-
-  it("persists shell responseTemplate fields for executable discovery", async () => {
-    const mockTool = {
-      name: "persist_shell_template",
-      description: "Shell template should not be persisted",
-      category: "shell" as const,
-      parameters: { type: "object", properties: {} },
-      riskLevel: "dangerous" as const,
-      responseTemplate: "bash:echo hi",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(mockTool);
-    mockMemoria.rememberTool.mockResolvedValue("tool-shell-template");
-
-    await registry.saveToMemoria("persist_shell_template", mockMemoria);
-
-    expect(mockMemoria.rememberTool).toHaveBeenCalledWith(
-      expect.objectContaining({
-        name: "persist_shell_template",
-        responseTemplate: "bash:echo hi",
-      }),
-    );
-  });
-
-  it("persists discovered tool issues as failure records", async () => {
-    const mockTool = {
-      name: "persist_risky",
-      description: "Risky persisted tool",
-      category: "shell" as const,
-      parameters: { type: "object", properties: {} },
-      riskLevel: "dangerous" as const,
-      issues: ["force push may overwrite history", "no branch protection check"],
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(mockTool);
-    mockMemoria.rememberTool.mockResolvedValue("tool-risky");
-
-    await registry.saveToMemoria("persist_risky", mockMemoria);
-
-    expect(mockMemoria.rememberTool).toHaveBeenCalledWith(
-      expect.objectContaining({
-        name: "persist_risky",
-        riskLevel: "dangerous",
-        failures: expect.arrayContaining([
-          expect.objectContaining({ error: "force push may overwrite history" }),
-          expect.objectContaining({ error: "no branch protection check" }),
-        ]),
-      }),
-    );
-  });
-
-  it("uses structured fields, ignores legacy content field", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-legacy",
-        name: "legacy_tool",
-        description: "From structured field", // NEW format
-        content: JSON.stringify({ description: "From content field" }), // OLD format
-        category: "meta",
-        riskLevel: "safe",
-        parameters: { type: "object", properties: {} },
-        responseTemplate: "legacy: {{input}}",
-      },
-    ]);
-
-    await registry.discoverFromMemoria(mockMemoria);
-
-    expect(registry.has("legacy_tool")).toBe(true);
-    const tool = registry.get("legacy_tool");
-    expect(tool?.description).toBe("From structured field"); // Uses description, not parsed content
-  });
-
-  it("discovers Memoria shell templates and upgrades them to dangerous risk", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-bash-safe",
-        name: "safe_bash_echo",
-        description: "Echoes the provided value safely",
-        category: "shell",
-        parameters: {
-          type: "object",
-          properties: { value: { type: "string" } },
-          required: ["value"],
-        },
-        riskLevel: "moderate",
-        responseTemplate: "bash:printf '%s' {{value}}",
-      },
-      {
-        id: "tool-text-ok",
-        name: "safe_text_tool",
-        description: "Normal template should load",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        responseTemplate: "ok",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(2);
-    expect(registry.has("safe_bash_echo")).toBe(true);
-    expect(registry.has("safe_text_tool")).toBe(true);
-    expect(registry.get("safe_bash_echo")?.riskLevel).toBe("dangerous");
-  });
-
-  it("validates full schema constraints for discovered template tools", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-schema",
-        name: "strict_schema_tool",
-        description: "Validates strict schema",
-        category: "meta",
-        parameters: {
-          type: "object",
-          properties: {
-            slug: { type: "string", pattern: "^[a-z-]+$" },
-            limit: { type: "number", minimum: 1, maximum: 3 },
-          },
-          required: ["slug"],
-          additionalProperties: false,
-        },
-        riskLevel: "safe",
-        responseTemplate: "slug={{slug}} limit={{limit}}",
-      },
-    ]);
-
-    await registry.discoverFromMemoria(mockMemoria);
-
-    const tool = registry.get("strict_schema_tool");
-    expect(tool).toBeDefined();
-
-    const invalidInput = await tool!.execute(
-      { slug: "Hello World", limit: 0, extra: true },
-      {
-        workingDir: process.cwd(),
-        env: process.env as Record<string, string>,
-      },
-    );
-    expect(invalidInput.success).toBe(false);
-    expect(String(invalidInput.message ?? "")).toContain("Invalid input");
-
-    const validInput = await tool!.execute(
-      { slug: "release-notes", limit: 2 },
-      {
-        workingDir: process.cwd(),
-        env: process.env as Record<string, string>,
-      },
-    );
-    expect(validInput.success).toBe(true);
-    expect(String(validInput.data ?? "")).toContain("release-notes");
-  });
-});

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

@@ -1,283 +0,0 @@
-/**
- * @aria/tools - Nested object validation tests for validateToolInput
- *
- * Verifies that validateToolInput recursively validates nested object schemas,
- * catching missing required fields and type mismatches at arbitrary depth.
- */
-
-import { describe, it, expect } from "vitest";
-import { validateToolInput } from "../../src/registry/index.js";
-
-// ---------------------------------------------------------------------------
-// Single-level nesting
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput - nested objects", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      config: {
-        type: "object",
-        required: ["host"],
-        properties: {
-          host: { type: "string" },
-          port: { type: "number" },
-        },
-      },
-    },
-    required: ["config"],
-  };
-
-  it("accepts valid nested object", () => {
-    expect(validateToolInput({ config: { host: "localhost", port: 8080 } }, schema)).toBeNull();
-  });
-
-  it("accepts nested object with only required fields", () => {
-    expect(validateToolInput({ config: { host: "localhost" } }, schema)).toBeNull();
-  });
-
-  it("rejects missing required nested property", () => {
-    const err = validateToolInput({ config: { port: 8080 } }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Missing required properties.*host/);
-    // Error should include the path to the nested property
-    expect(err).toMatch(/config/);
-  });
-
-  it("rejects wrong type in nested property", () => {
-    const err = validateToolInput({ config: { host: 123 } }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "config\.host" expected type string; got number/);
-  });
-
-  it("rejects non-object value for nested object schema", () => {
-    const err = validateToolInput({ config: "not-an-object" }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "config" expected type object; got string/);
-  });
-
-  it("rejects null value for nested object with required fields", () => {
-    const err = validateToolInput({ config: null }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "config" expected type object; got null/);
-  });
-
-  it("rejects array value for nested object schema", () => {
-    const err = validateToolInput({ config: [1, 2] }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "config" expected type object; got array/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Multi-level nesting (two levels deep)
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput - deeply nested objects", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      outer: {
-        type: "object",
-        required: ["inner"],
-        properties: {
-          inner: {
-            type: "object",
-            required: ["x"],
-            properties: {
-              x: { type: "string" },
-              y: { type: "number" },
-            },
-          },
-        },
-      },
-    },
-    required: ["outer"],
-  };
-
-  it("accepts valid deeply nested object", () => {
-    expect(validateToolInput({ outer: { inner: { x: "hello", y: 42 } } }, schema)).toBeNull();
-  });
-
-  it("accepts deeply nested object with only required fields", () => {
-    expect(validateToolInput({ outer: { inner: { x: "hello" } } }, schema)).toBeNull();
-  });
-
-  it("rejects missing required property at depth 2", () => {
-    const err = validateToolInput({ outer: { inner: {} } }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Missing required properties.*x/);
-    // Path should indicate full nesting
-    expect(err).toMatch(/outer\.inner/);
-  });
-
-  it("rejects missing required property at depth 1", () => {
-    const err = validateToolInput({ outer: {} }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Missing required properties.*inner/);
-    expect(err).toMatch(/outer/);
-  });
-
-  it("rejects wrong type at depth 2", () => {
-    const err = validateToolInput({ outer: { inner: { x: 999 } } }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "outer\.inner\.x" expected type string; got number/);
-  });
-
-  it("rejects non-object at depth 1", () => {
-    const err = validateToolInput({ outer: { inner: "flat" } }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "outer\.inner" expected type object; got string/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Nested with additionalProperties: false
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput - nested additionalProperties", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      settings: {
-        type: "object",
-        properties: {
-          verbose: { type: "boolean" },
-        },
-        additionalProperties: false,
-      },
-    },
-  };
-
-  it("accepts valid nested object without extra properties", () => {
-    expect(validateToolInput({ settings: { verbose: true } }, schema)).toBeNull();
-  });
-
-  it("rejects unknown properties in nested object", () => {
-    const err = validateToolInput({ settings: { verbose: true, debug: true } }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Unknown properties.*debug/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Optional nested objects (no required on the outer)
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput - optional nested objects", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      metadata: {
-        type: "object",
-        required: ["version"],
-        properties: {
-          version: { type: "string" },
-        },
-      },
-    },
-    // metadata is NOT required at the top level
-  };
-
-  it("accepts when optional nested object is absent", () => {
-    expect(validateToolInput({}, schema)).toBeNull();
-  });
-
-  it("validates nested object when present", () => {
-    const err = validateToolInput({ metadata: {} }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Missing required properties.*version/);
-  });
-
-  it("accepts valid optional nested object", () => {
-    expect(validateToolInput({ metadata: { version: "1.0" } }, schema)).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Nested object with no properties/required (just type: "object")
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput - nested object without constraints", () => {
-  const schema = {
-    type: "object",
-    properties: {
-      data: { type: "object" },
-    },
-  };
-
-  it("accepts any object when nested schema has no properties/required", () => {
-    expect(validateToolInput({ data: { anything: "goes" } }, schema)).toBeNull();
-    expect(validateToolInput({ data: {} }, schema)).toBeNull();
-  });
-
-  it("still rejects non-object types", () => {
-    const err = validateToolInput({ data: "string" }, schema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "data" expected type object; got string/);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Realistic shell/filesystem tool schema (the motivating use case)
-// ---------------------------------------------------------------------------
-
-describe("validateToolInput - realistic nested schema", () => {
-  const shellToolSchema = {
-    type: "object",
-    properties: {
-      command: { type: "string" },
-      options: {
-        type: "object",
-        required: ["cwd"],
-        properties: {
-          cwd: { type: "string" },
-          env: {
-            type: "object",
-            properties: {
-              PATH: { type: "string" },
-              HOME: { type: "string" },
-            },
-          },
-          timeout: { type: "number" },
-        },
-      },
-    },
-    required: ["command", "options"],
-  };
-
-  it("accepts fully valid shell tool input", () => {
-    const input = {
-      command: "ls -la",
-      options: {
-        cwd: "/home/user",
-        env: { PATH: "/usr/bin", HOME: "/home/user" },
-        timeout: 5000,
-      },
-    };
-    expect(validateToolInput(input, shellToolSchema)).toBeNull();
-  });
-
-  it("rejects missing nested required cwd", () => {
-    const input = {
-      command: "ls",
-      options: { timeout: 3000 },
-    };
-    const err = validateToolInput(input, shellToolSchema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Missing required properties.*cwd/);
-  });
-
-  it("rejects wrong type in deeply nested env property", () => {
-    const input = {
-      command: "ls",
-      options: {
-        cwd: "/tmp",
-        env: { PATH: 123 },
-      },
-    };
-    const err = validateToolInput(input, shellToolSchema);
-    expect(err).not.toBeNull();
-    expect(err).toMatch(/Property "options\.env\.PATH" expected type string; got number/);
-  });
-});