@aria-cli/tools 1.0.8 → 1.0.10

package/tests/integration/meta-tools-round-trip.integration.test.ts

@@ -1,506 +0,0 @@
-/**
- * Meta-tools round-trip integration tests
- *
- * Tests the full lifecycle of the 6 meta-tools (search, learn_tool, learn_skill,
- * create_tool, create_skill, use_skill) using mock IMemoria instances to verify
- * that executors correctly call the Memoria API and that data flows through
- * the system as expected.
- *
- * All tests use vi.fn() mocks to isolate the executor logic from real storage.
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { mkdtempSync, rmSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir, homedir } from "node:os";
-import {
-  executeLearnTool,
-  executeLearnSkill,
-  executeCreateTool,
-  executeCreateSkill,
-  executeUseSkill,
-  executeSearchKnowledge,
-} from "../../src/executors/learning-meta.js";
-import { ToolRegistry } from "../../src/registry/registry.js";
-import type { ToolContext } from "../../src/types.js";
-
-// ===========================================================================
-// Shared Helpers
-// ===========================================================================
-
-/** Create a mock IMemoria with all methods needed by meta-tool executors */
-function createMockMemoria() {
-  return {
-    remember: vi.fn().mockResolvedValue({ id: "mem-001" }),
-    recall: vi.fn().mockResolvedValue({ memories: [] }),
-    recallTools: vi.fn().mockResolvedValue([]),
-    rememberTool: vi.fn().mockResolvedValue("tool-id-001"),
-    rememberSkill: vi.fn().mockResolvedValue("skill-id-001"),
-    recallSkills: vi.fn().mockResolvedValue([]),
-    getSkill: vi.fn().mockResolvedValue(null),
-    recordSkillExecution: vi.fn().mockResolvedValue({
-      id: "exec-001",
-      skillId: "skill-id-001",
-      success: true,
-      timestamp: new Date(),
-    }),
-    deleteMemory: vi.fn().mockResolvedValue(true),
-  };
-}
-
-/** Create a ToolContext with the given workingDir and memoria mock */
-function createContext(
-  workDir: string,
-  memoria: ReturnType<typeof createMockMemoria>,
-): ToolContext {
-  return {
-    workingDir: workDir,
-    env: {},
-    confirm: vi.fn().mockResolvedValue(true),
-    memoria: memoria as any,
-  };
-}
-
-// ===========================================================================
-// Tests
-// ===========================================================================
-
-describe("Meta-tools round-trip integration", () => {
-  let workDir: string;
-
-  beforeEach(() => {
-    workDir = mkdtempSync(join(tmpdir(), "meta-tools-rt-"));
-  });
-
-  // -----------------------------------------------------------------------
-  // 1. learn_tool -> discoverFromMemoria round-trip
-  // -----------------------------------------------------------------------
-  describe("learn_tool -> discoverFromMemoria round-trip", () => {
-    it("should learn a CLI tool via --help and store it in Memoria, then discover it in a fresh registry", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.rememberTool.mockResolvedValue("learned-tool-id-42");
-      const ctx = createContext(workDir, mockMemoria);
-
-      // Step 1: Learn a tool from its --help output (use "git" which reliably supports --help)
-      const result = await executeLearnTool({ command: "git" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect((result.data as any).toolId).toBe("learned-tool-id-42");
-      expect((result.data as any).name).toBe("git");
-
-      // Verify rememberTool was called with correct shape
-      expect(mockMemoria.rememberTool).toHaveBeenCalledTimes(1);
-      const storedTool = mockMemoria.rememberTool.mock.calls[0][0];
-      expect(storedTool.name).toBe("git");
-      expect(storedTool.description).toBeDefined();
-      expect(storedTool.source).toEqual({
-        type: "external",
-        ref: "cli:git",
-        format: "markdown",
-      });
-      expect(storedTool.category).toBe("shell");
-      expect(storedTool.riskLevel).toBe("moderate");
-      expect(storedTool.parameters).toBeDefined();
-      expect(storedTool.responseTemplate).toContain("git");
-      expect(storedTool.knowledge).toBeDefined();
-      expect(storedTool.tags).toEqual(expect.arrayContaining(["cli", "learned"]));
-      expect(storedTool.confidence).toBe(0.7);
-      expect(storedTool.importance).toBe(0.6);
-
-      // Step 2: Verify a fresh ToolRegistry's discoverFromMemoria would find it.
-      // Set up recallTools to return the tool that was just "stored".
-      const discoveryMemoria = {
-        recallTools: vi.fn().mockResolvedValue([
-          {
-            id: "learned-tool-id-42",
-            name: storedTool.name,
-            description: storedTool.description,
-            category: storedTool.category,
-            parameters: storedTool.parameters,
-            riskLevel: storedTool.riskLevel,
-            responseTemplate: storedTool.responseTemplate,
-          },
-        ]),
-        rememberTool: vi.fn().mockResolvedValue("unused"),
-      };
-
-      const registry = new ToolRegistry();
-      const count = await registry.discoverFromMemoria(discoveryMemoria as any);
-
-      expect(count).toBe(1);
-      const discovered = registry.get("git");
-      expect(discovered).toBeDefined();
-      expect(discovered!.name).toBe("git");
-      expect(discovered!.category).toBe("shell");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // 2. create_skill -> recall round-trip
-  // -----------------------------------------------------------------------
-  describe("create_skill -> recall round-trip", () => {
-    it("should create a skill and verify rememberSkill was called, then verify recallSkills would return it", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.rememberSkill.mockResolvedValue("skill-deploy-001");
-      const ctx = createContext(workDir, mockMemoria);
-
-      // Step 1: Create a skill
-      const result = await executeCreateSkill(
-        {
-          name: "deploy-pipeline",
-          description: "Standard deploy procedure for production",
-          content:
-            "1. Run tests\n2. Build artifacts\n3. Push to staging\n4. Smoke test\n5. Promote to prod",
-          tags: ["deploy", "production"],
-          toolIds: ["bash-tool", "test-runner"],
-        },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect((result.data as any).skillId).toBe("skill-deploy-001");
-      expect((result.data as any).name).toBe("deploy-pipeline");
-
-      // Verify rememberSkill was called with correct shape
-      expect(mockMemoria.rememberSkill).toHaveBeenCalledTimes(1);
-      const storedSkill = mockMemoria.rememberSkill.mock.calls[0][0];
-      expect(storedSkill.name).toBe("deploy-pipeline");
-      expect(storedSkill.description).toBe("Standard deploy procedure for production");
-      expect(storedSkill.content).toContain("Run tests");
-      expect(storedSkill.source).toEqual({ type: "user", ref: "create_skill" });
-      expect(storedSkill.tags).toEqual(["deploy", "production"]);
-      expect(storedSkill.toolIds).toEqual(["bash-tool", "test-runner"]);
-      expect(storedSkill.importance).toBe(0.75);
-      expect(storedSkill.confidence).toBe(0.8);
-
-      // Step 2: Verify recallSkills({ query: name }) would return it
-      mockMemoria.recallSkills.mockResolvedValue([
-        {
-          id: "skill-deploy-001",
-          name: "deploy-pipeline",
-          description: "Standard deploy procedure for production",
-          content: storedSkill.content,
-          toolIds: ["bash-tool", "test-runner"],
-          triggers: [],
-          tags: ["deploy", "production"],
-          source: { type: "user", ref: "create_skill" },
-          executionCount: 0,
-          successCount: 0,
-          lastExecuted: null,
-          averageDurationMs: null,
-          confidence: 0.8,
-          importance: 0.75,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          accessedAt: new Date(),
-          accessCount: 0,
-        },
-      ]);
-
-      const recalled = await mockMemoria.recallSkills({ query: "deploy-pipeline" });
-      expect(recalled).toHaveLength(1);
-      expect(recalled[0].name).toBe("deploy-pipeline");
-      expect(recalled[0].id).toBe("skill-deploy-001");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // 3. use_skill -> recordSkillExecution tracking
-  // -----------------------------------------------------------------------
-  describe("use_skill -> recordSkillExecution tracking", () => {
-    it("should look up a skill via getSkill and then record execution via recordSkillExecution", async () => {
-      const mockMemoria = createMockMemoria();
-
-      // Set up getSkill to return a known skill
-      const fakeSkill = {
-        id: "skill-lint-007",
-        name: "lint-check",
-        description: "Run all linters",
-        content: "eslint . && prettier --check .",
-        toolIds: ["bash"],
-        triggers: [],
-        tags: ["lint"],
-        source: { type: "user" as const, ref: "create_skill" },
-        executionCount: 3,
-        successCount: 2,
-        lastExecuted: new Date("2026-02-15"),
-        averageDurationMs: 500,
-        confidence: 0.85,
-        importance: 0.7,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        accessedAt: new Date(),
-        accessCount: 3,
-      };
-      mockMemoria.getSkill.mockResolvedValue(fakeSkill);
-      mockMemoria.recordSkillExecution.mockResolvedValue({
-        id: "exec-lint-001",
-        skillId: "skill-lint-007",
-        success: true,
-        durationMs: 320,
-        timestamp: new Date(),
-      });
-
-      const ctx = createContext(workDir, mockMemoria);
-
-      // Execute use_skill
-      const result = await executeUseSkill(
-        {
-          name: "lint-check",
-          success: true,
-          durationMs: 320,
-          notes: "All checks passed",
-        },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain("lint-check");
-
-      // Verify getSkill was called with the skill name
-      expect(mockMemoria.getSkill).toHaveBeenCalledTimes(1);
-      expect(mockMemoria.getSkill).toHaveBeenCalledWith("lint-check");
-
-      // Verify recordSkillExecution was called with the skill's ID
-      expect(mockMemoria.recordSkillExecution).toHaveBeenCalledTimes(1);
-      expect(mockMemoria.recordSkillExecution).toHaveBeenCalledWith({
-        skillId: "skill-lint-007",
-        success: true,
-        durationMs: 320,
-        notes: "All checks passed",
-      });
-
-      // Verify the returned data contains the skill
-      expect((result.data as any).skill).toEqual(fakeSkill);
-    });
-
-    it("should return failure when skill is not found", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.getSkill.mockResolvedValue(null);
-      const ctx = createContext(workDir, mockMemoria);
-
-      const result = await executeUseSkill({ name: "nonexistent-skill" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("not found");
-      expect(mockMemoria.recordSkillExecution).not.toHaveBeenCalled();
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // 4. learn_skill (file) -> search round-trip
-  // -----------------------------------------------------------------------
-  describe("learn_skill (file) -> search round-trip", () => {
-    it("should read a SKILL.md file, parse frontmatter, and store it via rememberSkill", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.rememberSkill.mockResolvedValue("skill-file-001");
-      const ctx = createContext(workDir, mockMemoria);
-
-      // Create a SKILL.md file with frontmatter
-      const skillDir = join(workDir, "skills", "code-review");
-      mkdirSync(skillDir, { recursive: true });
-      const skillPath = join(skillDir, "SKILL.md");
-      writeFileSync(
-        skillPath,
-        [
-          "---",
-          "name: code-review-checklist",
-          "description: Systematic code review procedure",
-          "---",
-          "## Code Review Checklist",
-          "",
-          "1. Check for security vulnerabilities",
-          "2. Verify error handling completeness",
-          "3. Review test coverage",
-          "4. Check naming conventions",
-        ].join("\n"),
-        "utf-8",
-      );
-
-      // Execute learn_skill with file path
-      const result = await executeLearnSkill(
-        {
-          path: "skills/code-review/SKILL.md",
-          tags: ["review", "quality"],
-        },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect((result.data as any).skillId).toBe("skill-file-001");
-      expect((result.data as any).name).toBe("code-review-checklist");
-
-      // Verify rememberSkill was called with parsed frontmatter
-      expect(mockMemoria.rememberSkill).toHaveBeenCalledTimes(1);
-      const stored = mockMemoria.rememberSkill.mock.calls[0][0];
-      expect(stored.name).toBe("code-review-checklist");
-      expect(stored.description).toBe("Systematic code review procedure");
-      expect(stored.content).toContain("Check for security vulnerabilities");
-      expect(stored.content).toContain("Review test coverage");
-      expect(stored.source).toEqual({
-        type: "file",
-        path: skillPath,
-        format: "skill-file",
-      });
-      expect(stored.tags).toEqual(["review", "quality"]);
-      expect(stored.toolIds).toEqual([]);
-      expect(stored.importance).toBe(0.65);
-      expect(stored.confidence).toBe(0.7);
-    });
-
-    it("should fall back to directory name when frontmatter has no name", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.rememberSkill.mockResolvedValue("skill-fallback-001");
-      const ctx = createContext(workDir, mockMemoria);
-
-      // Create a SKILL.md without a name in frontmatter
-      const skillDir = join(workDir, "skills", "my-custom-skill");
-      mkdirSync(skillDir, { recursive: true });
-      writeFileSync(
-        join(skillDir, "SKILL.md"),
-        [
-          "---",
-          "description: A skill without explicit name",
-          "---",
-          "Do the thing step by step",
-        ].join("\n"),
-        "utf-8",
-      );
-
-      const result = await executeLearnSkill({ path: "skills/my-custom-skill/SKILL.md" }, ctx);
-
-      expect(result.success).toBe(true);
-      const stored = mockMemoria.rememberSkill.mock.calls[0][0];
-      // Should fall back to directory name
-      expect(stored.name).toBe("my-custom-skill");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // 5. create_tool upsert
-  // -----------------------------------------------------------------------
-  describe("create_tool upsert", () => {
-    it("should call rememberTool twice when creating a tool with the same name but different script (upsert)", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.rememberTool.mockResolvedValueOnce("tool-v1").mockResolvedValueOnce("tool-v2");
-      const ctx = createContext(workDir, mockMemoria);
-
-      // First creation
-      const result1 = await executeCreateTool(
-        {
-          name: "formatter",
-          description: "Format source code",
-          script: "prettier --write .",
-          tags: ["format"],
-        },
-        ctx,
-      );
-
-      expect(result1.success).toBe(true);
-      expect((result1.data as any).toolId).toBe("tool-v1");
-
-      // Second creation with same name but different script (upsert)
-      const result2 = await executeCreateTool(
-        {
-          name: "formatter",
-          description: "Format source code v2",
-          script: "biome format --write .",
-          tags: ["format", "v2"],
-        },
-        ctx,
-      );
-
-      expect(result2.success).toBe(true);
-      expect((result2.data as any).toolId).toBe("tool-v2");
-
-      // Verify rememberTool was called twice (upsert behavior -- second call overwrites)
-      expect(mockMemoria.rememberTool).toHaveBeenCalledTimes(2);
-
-      // Verify first call had the original script details
-      const firstCall = mockMemoria.rememberTool.mock.calls[0][0];
-      expect(firstCall.name).toBe("formatter");
-      expect(firstCall.description).toBe("Format source code");
-      expect(firstCall.tags).toEqual(expect.arrayContaining(["format", "created"]));
-
-      // Verify second call had the updated script details
-      const secondCall = mockMemoria.rememberTool.mock.calls[1][0];
-      expect(secondCall.name).toBe("formatter");
-      expect(secondCall.description).toBe("Format source code v2");
-      expect(secondCall.tags).toEqual(expect.arrayContaining(["format", "v2", "created"]));
-
-      // Verify the script file on disk was overwritten
-      // (both calls write to ~/.aria/tools/formatter.sh)
-      const { readFileSync } = await import("node:fs");
-      const scriptContent = readFileSync(join(homedir(), ".aria", "tools", "formatter.sh"), "utf-8");
-      expect(scriptContent).toContain("biome format --write .");
-      expect(scriptContent).not.toContain("prettier --write .");
-    });
-  });
-
-  // -----------------------------------------------------------------------
-  // 6. search (executeSearchKnowledge) — recallTools + recallSkills merge
-  // -----------------------------------------------------------------------
-  describe("executeSearchKnowledge — recallTools + recallSkills merge", () => {
-    it("should call both recallTools and recallSkills and merge results", async () => {
-      const mockMemoria = createMockMemoria();
-      mockMemoria.recallTools.mockResolvedValue([
-        {
-          id: "tool-grep-001",
-          name: "grep-helper",
-          description: "Smart grep wrapper",
-          category: "shell",
-          parameters: [],
-          riskLevel: "low",
-        },
-      ]);
-      mockMemoria.recallSkills.mockResolvedValue([
-        {
-          id: "skill-review-001",
-          name: "code-review",
-          description: "Systematic code review procedure",
-          content: "1. Check errors 2. Check tests",
-          toolIds: [],
-          triggers: [],
-          tags: ["review"],
-          source: { type: "user", ref: "create_skill" },
-          executionCount: 5,
-          successCount: 4,
-          lastExecuted: null,
-          averageDurationMs: null,
-          confidence: 0.8,
-          importance: 0.7,
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          accessedAt: new Date(),
-          accessCount: 3,
-        },
-      ]);
-      const ctx = createContext(workDir, mockMemoria);
-
-      const result = await executeSearchKnowledge(
-        { query: "code review grep", sources: ["memoria"] },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-
-      // Verify both recall methods were called
-      expect(mockMemoria.recallTools).toHaveBeenCalledWith(
-        expect.objectContaining({ query: "code review grep" }),
-      );
-      expect(mockMemoria.recallSkills).toHaveBeenCalledWith(
-        expect.objectContaining({ query: "code review grep" }),
-      );
-
-      // Verify merged results contain both tool and skill
-      const data = result.data as { results: Array<Record<string, unknown>> };
-      expect(data.results).toHaveLength(2);
-      expect(data.results).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({ kind: "tool", name: "grep-helper" }),
-          expect.objectContaining({ kind: "skill", name: "code-review" }),
-        ]),
-      );
-    });
-  });
-});