@aria-cli/tools 1.0.9 → 1.0.11

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

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