@aria-cli/tools 1.0.0

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

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

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