@aria-cli/tools 1.0.8 → 1.0.10

package/tests/registry/pseudo-tool-filtering.test.ts

@@ -1,258 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { ToolRegistry } from "../../src/registry/registry.js";
-
-/**
- * Regression test: discoverFromMemoria() must NOT register pseudo-tools.
- *
- * A pseudo-tool is a Memoria tool record that has valid metadata (name,
- * description, category, parameters, riskLevel) but lacks executable
- * content. Executable content is defined as having:
- *   - a non-empty `responseTemplate` string.
- *
- * Tools with neither field are metadata-only stubs and must be skipped
- * to prevent the registry from surfacing non-functional tools to the LLM.
- *
- * Covers: P1-20 (pseudo-tool filtering) and P1-23 (missing regression coverage)
- * from the unify-skill-types design doc.
- */
-describe("Pseudo-tool filtering in discoverFromMemoria", () => {
-  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 register a tool with responseTemplate", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-rt",
-        name: "template_tool",
-        description: "Tool with a response template",
-        category: "meta",
-        parameters: { type: "object", properties: { input: { type: "string" } } },
-        riskLevel: "safe",
-        responseTemplate: "Result: {{input}}",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(1);
-    expect(registry.has("template_tool")).toBe(true);
-
-    // Verify the tool is actually executable
-    const tool = registry.get("template_tool")!;
-    const result = await tool.execute(
-      { input: "hello" },
-      { workingDir: "/tmp", env: {}, confirm: vi.fn().mockResolvedValue(true) },
-    );
-    expect(result.success).toBe(true);
-    expect(result.data).toBe("Result: hello");
-  });
-
-  it("should skip a tool with only knowledge field (no responseTemplate)", async () => {
-    // After the knowledge->tool rename, only tools with responseTemplate
-    // are considered executable. Knowledge-only records are metadata stubs.
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-kn",
-        name: "knowledge_tool",
-        description: "Tool with knowledge content but no responseTemplate",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        knowledge:
-          "TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(0);
-    expect(registry.has("knowledge_tool")).toBe(false);
-  });
-
-  it("should skip a pseudo-tool with no responseTemplate", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-pseudo",
-        name: "pseudo_tool",
-        description: "Metadata-only entry with no executable content",
-        category: "meta",
-        parameters: { type: "object", properties: { query: { type: "string" } } },
-        riskLevel: "safe",
-        // No responseTemplate
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(0);
-    expect(registry.has("pseudo_tool")).toBe(false);
-  });
-
-  it("should register tools with responseTemplate and skip all others in a mixed batch", async () => {
-    // Only responseTemplate makes a tool executable. Knowledge-only
-    // and empty records are both treated as non-executable metadata.
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-1",
-        name: "with_template",
-        description: "Has a response template",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        responseTemplate: "template output",
-      },
-      {
-        id: "tool-2",
-        name: "with_knowledge",
-        description: "Has knowledge content only",
-        category: "data",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        knowledge: "Some domain knowledge about data processing.",
-      },
-      {
-        id: "tool-3",
-        name: "pseudo_no_content",
-        description: "Metadata stub, no executable content",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-      },
-      {
-        id: "tool-4",
-        name: "another_pseudo",
-        description: "Another metadata-only entry",
-        category: "web",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "moderate",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(1);
-    expect(registry.has("with_template")).toBe(true);
-    expect(registry.has("with_knowledge")).toBe(false);
-    expect(registry.has("pseudo_no_content")).toBe(false);
-    expect(registry.has("another_pseudo")).toBe(false);
-  });
-
-  it("should treat empty-string responseTemplate as pseudo-tool", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-empty-rt",
-        name: "empty_template",
-        description: "Has an empty responseTemplate",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        responseTemplate: "",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(0);
-    expect(registry.has("empty_template")).toBe(false);
-  });
-
-  it("should treat whitespace-only responseTemplate as pseudo-tool", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-ws-rt",
-        name: "whitespace_template",
-        description: "Has whitespace-only responseTemplate",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        responseTemplate: "   \n\t  ",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(0);
-    expect(registry.has("whitespace_template")).toBe(false);
-  });
-
-  it("should treat empty-string knowledge as pseudo-tool", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-empty-kn",
-        name: "empty_knowledge",
-        description: "Has an empty knowledge field",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        knowledge: "",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(0);
-    expect(registry.has("empty_knowledge")).toBe(false);
-  });
-
-  it("should treat whitespace-only knowledge as pseudo-tool", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-ws-kn",
-        name: "whitespace_knowledge",
-        description: "Has whitespace-only knowledge field",
-        category: "meta",
-        parameters: { type: "object", properties: {} },
-        riskLevel: "safe",
-        knowledge: "   \n\t  ",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(0);
-    expect(registry.has("whitespace_knowledge")).toBe(false);
-  });
-
-  it("should prefer responseTemplate over knowledge when both are present", async () => {
-    mockMemoria.recallTools.mockResolvedValue([
-      {
-        id: "tool-both",
-        name: "both_fields",
-        description: "Has both responseTemplate and knowledge",
-        category: "meta",
-        parameters: { type: "object", properties: { name: { type: "string" } } },
-        riskLevel: "safe",
-        responseTemplate: "Hello, {{name}}!",
-        knowledge: "This is the knowledge content.",
-      },
-    ]);
-
-    const count = await registry.discoverFromMemoria(mockMemoria);
-
-    expect(count).toBe(1);
-    expect(registry.has("both_fields")).toBe(true);
-
-    // responseTemplate takes precedence in the executor
-    const tool = registry.get("both_fields")!;
-    const result = await tool.execute(
-      { name: "World" },
-      { workingDir: "/tmp", env: {}, confirm: vi.fn().mockResolvedValue(true) },
-    );
-    expect(result.success).toBe(true);
-    expect(result.data).toBe("Hello, World!");
-  });
-});

package/tests/registry/registration-lifecycle.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { ToolRegistry } from "../../src/registry/registry.js";
-import type { Tool } from "../../src/types.js";
-
-describe("Tool Registry - Static Registration", () => {
-  let registry: ToolRegistry;
-
-  beforeEach(() => {
-    registry = new ToolRegistry();
-  });
-
-  it("should register a new tool", () => {
-    const mockTool: Tool = {
-      name: "test_tool",
-      description: "A test tool",
-      category: "meta",
-      parameters: {},
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(mockTool);
-
-    expect(registry.has("test_tool")).toBe(true);
-    expect(registry.get("test_tool")).toBe(mockTool);
-    expect(registry.size).toBe(1);
-  });
-
-  it("should throw error on duplicate registration without override", () => {
-    const mockTool: Tool = {
-      name: "duplicate_tool",
-      description: "Test",
-      category: "meta",
-      parameters: {},
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(mockTool);
-
-    expect(() => registry.register(mockTool)).toThrow(
-      /already registered|override/i,
-    );
-  });
-
-  it("should allow override with override flag", () => {
-    const mockTool1: Tool = {
-      name: "override_test",
-      description: "Version 1",
-      category: "meta",
-      parameters: {},
-      riskLevel: "safe",
-      execute: async () => ({
-        success: true,
-        message: "ok",
-        data: { version: 1 },
-      }),
-    };
-
-    const mockTool2: Tool = {
-      name: "override_test",
-      description: "Version 2",
-      category: "meta",
-      parameters: {},
-      riskLevel: "safe",
-      execute: async () => ({
-        success: true,
-        message: "ok",
-        data: { version: 2 },
-      }),
-    };
-
-    registry.register(mockTool1);
-    registry.register(mockTool2, { override: true });
-
-    const tool = registry.get("override_test");
-    expect(tool?.description).toBe("Version 2");
-  });
-
-  it("should unregister a tool", () => {
-    const mockTool: Tool = {
-      name: "removable",
-      description: "Test",
-      category: "meta",
-      parameters: {},
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(mockTool);
-    expect(registry.has("removable")).toBe(true);
-
-    const removed = registry.unregister("removable");
-    expect(removed).toBe(true);
-    expect(registry.has("removable")).toBe(false);
-    expect(registry.size).toBe(0);
-  });
-
-  it("should return false when unregistering non-existent tool", () => {
-    const removed = registry.unregister("nonexistent");
-    expect(removed).toBe(false);
-  });
-
-  it("should filter tools by category", () => {
-    const fileTool: Tool = {
-      name: "file_tool",
-      description: "File ops",
-      category: "filesystem",
-      parameters: {},
-      riskLevel: "safe",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    const shellTool: Tool = {
-      name: "shell_tool",
-      description: "Shell ops",
-      category: "shell",
-      parameters: {},
-      riskLevel: "moderate",
-      execute: async () => ({ success: true, message: "ok" }),
-    };
-
-    registry.register(fileTool);
-    registry.register(shellTool);
-
-    const fileTools = registry.list("filesystem");
-    expect(fileTools).toHaveLength(1);
-    expect(fileTools[0].name).toBe("file_tool");
-
-    const allTools = registry.list();
-    expect(allTools).toHaveLength(2);
-  });
-});