@aria-cli/tools 1.0.0

package/tests/executors/meta-tools.test.ts

@@ -0,0 +1,411 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, rmSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  executeCreateSkill,
+  executeCreateTool,
+  executeLearnSkill,
+  executeUseSkill,
+} from "../../src/executors/learning-meta.js";
+import type { ToolContext } from "../../src/types.js";
+
+function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: overrides.workingDir ?? process.cwd(),
+    env: overrides.env ?? (process.env as Record<string, string>),
+    confirm: overrides.confirm ?? (async () => true),
+    memoria: overrides.memoria,
+    manager: overrides.manager,
+    arion: overrides.arion,
+    abortSignal: overrides.abortSignal,
+    context: overrides.context,
+    processRegistry: overrides.processRegistry,
+    ptySessionStore: overrides.ptySessionStore,
+    providerContext: overrides.providerContext,
+    delegationRegistry: overrides.delegationRegistry,
+    delegationExecutor: overrides.delegationExecutor,
+    nativeSearchAdapter: overrides.nativeSearchAdapter,
+    userInteraction: overrides.userInteraction,
+    questStore: overrides.questStore,
+    askUserCallCounter: overrides.askUserCallCounter,
+    router: overrides.router,
+    toolRegistry: overrides.toolRegistry,
+    mailbox: overrides.mailbox,
+    networkControl: overrides.networkControl,
+  };
+}
+
+describe("learning meta executors", () => {
+  let workdir: string;
+
+  beforeEach(() => {
+    workdir = mkdtempSync(join(tmpdir(), "meta-tools-test-"));
+  });
+
+  afterEach(() => {
+    if (existsSync(workdir)) {
+      rmSync(workdir, { recursive: true, force: true });
+    }
+  });
+
+  it("learn_skill stores inline skill content", async () => {
+    const rememberSkill = vi.fn().mockResolvedValue("skill-inline-1");
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberSkill } as unknown as ToolContext["memoria"],
+    });
+
+    const result = await executeLearnSkill(
+      {
+        name: "repo-rules",
+        description: "Repository-specific instructions",
+        content: "Always use pnpm",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(rememberSkill).toHaveBeenCalledTimes(1);
+    expect(rememberSkill).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "repo-rules",
+        content: "Always use pnpm",
+      }),
+    );
+  });
+
+  it("create_tool writes executable script and stores tool", async () => {
+    const rememberTool = vi.fn().mockResolvedValue("tool-1");
+    const recallTools = vi.fn().mockResolvedValue([]);
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberTool, recallTools } as unknown as ToolContext["memoria"],
+    });
+
+    const result = await executeCreateTool(
+      {
+        name: "lint-repo",
+        description: "Run lint in workspace",
+        script: "pnpm lint",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+    const data = result.data as { scriptPath: string };
+    expect(data.scriptPath).toMatch(/\.aria\/tools\/lint-repo\.sh$/);
+    expect(existsSync(data.scriptPath)).toBe(true);
+    expect(rememberTool).toHaveBeenCalledTimes(1);
+    expect(rememberTool).toHaveBeenCalledWith(
+      expect.objectContaining({
+        source: { type: "external", ref: `file:${data.scriptPath}`, format: "markdown" },
+        responseTemplate: `bash:${data.scriptPath} {{args}}`,
+        usageHint: `${data.scriptPath} ...`,
+      }),
+    );
+  });
+
+  it("create_tool refreshes the live tool registry after persistence", async () => {
+    const rememberTool = vi.fn().mockResolvedValue("tool-2");
+    const recallTools = vi.fn().mockResolvedValue([]);
+    const discoverFromMemoria = vi.fn().mockResolvedValue(1);
+    const memoria = { rememberTool, recallTools } as unknown as ToolContext["memoria"];
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria,
+      toolRegistry: { discoverFromMemoria } as unknown as ToolContext["toolRegistry"],
+    });
+
+    const result = await executeCreateTool(
+      {
+        name: "format-repo",
+        description: "Run formatter in workspace",
+        script: "pnpm format",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(discoverFromMemoria).toHaveBeenCalledWith(memoria);
+  });
+
+  it("create_tool stores adversarial review issues as failures and keeps dangerous risk", async () => {
+    const rememberTool = vi.fn().mockResolvedValue("tool-unsafe");
+    const recallTools = vi.fn().mockResolvedValue([]);
+    const router = {
+      chat: vi.fn().mockResolvedValue({
+        content: JSON.stringify({
+          safe: false,
+          issues: ["force-push can overwrite remote history", "no branch protection check"],
+        }),
+      }),
+    };
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberTool, recallTools } as unknown as ToolContext["memoria"],
+      router: router as unknown as ToolContext["router"],
+    });
+
+    const result = await executeCreateTool(
+      {
+        name: "git-force-push",
+        description: "Force push current branch",
+        script: "git push --force origin HEAD",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(rememberTool).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "git-force-push",
+        riskLevel: "dangerous",
+        failures: expect.arrayContaining([
+          expect.objectContaining({ error: "force-push can overwrite remote history" }),
+          expect.objectContaining({ error: "no branch protection check" }),
+        ]),
+      }),
+    );
+  });
+
+  it("create_tool marks tool moderate only for explicitly safe reviews with no issues", async () => {
+    const rememberTool = vi.fn().mockResolvedValue("tool-safe");
+    const recallTools = vi.fn().mockResolvedValue([]);
+    const router = {
+      chat: vi.fn().mockResolvedValue({
+        content: JSON.stringify({ safe: true, issues: [] }),
+      }),
+    };
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberTool, recallTools } as unknown as ToolContext["memoria"],
+      router: router as unknown as ToolContext["router"],
+    });
+
+    const result = await executeCreateTool(
+      {
+        name: "lint-repo-safe",
+        description: "Run lint",
+        script: "pnpm lint",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(rememberTool).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: "lint-repo-safe",
+        riskLevel: "moderate",
+      }),
+    );
+  });
+
+  it("create_tool rejects names that start with hyphens or sanitize to empty", async () => {
+    const rememberTool = vi.fn();
+    const recallTools = vi.fn().mockResolvedValue([]);
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberTool, recallTools } as unknown as ToolContext["memoria"],
+    });
+
+    const leadingHyphen = await executeCreateTool(
+      {
+        name: "--version",
+        description: "unsafe",
+        script: "echo test",
+      },
+      ctx,
+    );
+    expect(leadingHyphen.success).toBe(false);
+    expect(leadingHyphen.message).toMatch(/must not start with a hyphen/i);
+
+    const sanitizedEmpty = await executeCreateTool(
+      {
+        name: "...",
+        description: "unsafe",
+        script: "echo test",
+      },
+      ctx,
+    );
+    expect(sanitizedEmpty.success).toBe(false);
+    expect(sanitizedEmpty.message).toMatch(/contains no safe characters|letter or digit/i);
+    expect(rememberTool).not.toHaveBeenCalled();
+  });
+
+  it("create_tool enforces maximum tool count", async () => {
+    const rememberTool = vi.fn();
+    const recallTools = vi.fn().mockResolvedValue(
+      Array.from({ length: 50 }, (_, i) => ({
+        id: `tool-${i}`,
+        name: `tool-${i}`,
+        description: `Tool ${i}`,
+      })),
+    );
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberTool, recallTools } as unknown as ToolContext["memoria"],
+    });
+
+    const result = await executeCreateTool(
+      {
+        name: "overflow-tool",
+        description: "should fail when at max",
+        script: "echo test",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.message).toMatch(/tool limit reached/i);
+    expect(rememberTool).not.toHaveBeenCalled();
+  });
+
+  it("create_skill links skillId to active arion badge", async () => {
+    const rememberSkill = vi.fn().mockResolvedValue("skill-42");
+    const evolveSkills = vi.fn().mockResolvedValue({ id: "arion-1", name: "ARIA", emoji: "🌟" });
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberSkill } as unknown as ToolContext["memoria"],
+      manager: { evolveSkills } as unknown as ToolContext["manager"],
+      arion: { id: "arion-1", name: "ARIA", emoji: "🌟" },
+    });
+
+    const result = await executeCreateSkill(
+      {
+        name: "safe-rebase",
+        description: "Recoverable rebase workflow",
+        content: "git fetch --all && git rebase --rebase-merges",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+    expect(rememberSkill).toHaveBeenCalledTimes(1);
+    expect(evolveSkills).toHaveBeenCalledWith(
+      "ARIA",
+      expect.objectContaining({
+        addSkills: [
+          expect.objectContaining({
+            name: "safe-rebase",
+            skillId: "skill-42",
+          }),
+        ],
+      }),
+    );
+  });
+
+  it("create_skill broadcasts skill offer with questId and priority 2 (Fix 6)", async () => {
+    const rememberSkill = vi.fn().mockResolvedValue("skill-fix6");
+    const evolveSkills = vi.fn().mockResolvedValue({ id: "arion-1", name: "ARIA", emoji: "🌟" });
+    const sendMock = vi.fn().mockResolvedValue(undefined);
+
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { rememberSkill } as unknown as ToolContext["memoria"],
+      manager: { evolveSkills } as unknown as ToolContext["manager"],
+      arion: { id: "arion-1", name: "ARIA", emoji: "🌟" },
+      mailbox: {
+        sendBestEffort: sendMock,
+        sendDurable: vi
+          .fn()
+          .mockResolvedValue({ transport: "in_process", delivered: true, queued: false }),
+        has: () => true,
+        hasByName: () => true,
+      },
+      networkControl: {
+        status: () => ({
+          configured: true,
+          nodeId: "node-alpha",
+          transportPublicKey: "pubkey",
+          signingPublicKey: "c2lnbmluZy1rZXk=", // base64 "signing-key"
+          listenPort: 51820,
+          externalEndpoint: null,
+          activePeers: 1,
+          totalPeers: 1,
+        }),
+        listPeers: () => [
+          {
+            peerId: "peer-alpha",
+            nodeId: "peer-alpha",
+            transportPublicKey: "peer-pub",
+            displayNameSnapshot: "peer-alpha",
+            endpointHost: "10.0.0.2",
+            endpointPort: 51820,
+            endpointRevision: 1,
+            controlEndpoint: null,
+            signingPublicKey: "peer-signing",
+            status: "active",
+            lastHandshake: Date.now(),
+            createdAt: Date.now() - 60000,
+            updatedAt: Date.now(),
+          },
+        ],
+        invite: () => ({ token: "", psk: "" }),
+        revokePeer: () => true,
+      } as unknown as ToolContext["networkControl"],
+    });
+
+    const result = await executeCreateSkill(
+      {
+        name: "fix6-skill",
+        description: "Test skill for Fix 6",
+        content: "do something useful",
+      },
+      ctx,
+    );
+
+    expect(result.success).toBe(true);
+
+    // Verify mailbox.send was called with correct Fix 6 fields
+    expect(sendMock).toHaveBeenCalledTimes(1);
+    const sentMessage = sendMock.mock.calls[0]![0];
+
+    // Fix 6a: questId must be present in the content JSON
+    const content = JSON.parse(sentMessage.content);
+    expect(content.questId).toBeDefined();
+    expect(content.questId).toMatch(/^skill-offer-/);
+
+    // Fix 6a: delegationType and task must also be present
+    expect(content.delegationType).toBe("remote");
+    expect(content.task).toContain("fix6-skill");
+    expect(content.sourceNodeId).toBe("node-alpha");
+    expect(content.sourceDisplayName).toBe("ARIA");
+    expect("sourcePeer" in content).toBe(false);
+
+    // Fix 6b: priority must be 2 (not 1)
+    expect(sentMessage.priority).toBe(2);
+
+    // Message type should be "quest"
+    expect(sentMessage.type).toBe("quest");
+    expect(sentMessage.sender.id).toBe("node-alpha");
+  });
+
+  it("use_skill loads skill and records execution", async () => {
+    const skill = {
+      id: "skill-use-1",
+      name: "deploy-checklist",
+      description: "Release checklist",
+      content: "1. tests 2. build 3. deploy",
+    };
+    const getSkill = vi.fn().mockResolvedValue(skill);
+    const recordSkillExecution = vi.fn().mockResolvedValue(undefined);
+
+    const ctx = makeContext({
+      workingDir: workdir,
+      memoria: { getSkill, recordSkillExecution } as unknown as ToolContext["memoria"],
+    });
+
+    const result = await executeUseSkill({ skillId: "skill-use-1", success: true }, ctx);
+
+    expect(result.success).toBe(true);
+    expect(getSkill).toHaveBeenCalledWith("skill-use-1");
+    expect(recordSkillExecution).toHaveBeenCalledWith(
+      expect.objectContaining({
+        skillId: "skill-use-1",
+        success: true,
+      }),
+    );
+  });
+});