@aria-cli/tools 1.0.8 → 1.0.10

package/tests/executors/arion.test.ts

@@ -1,309 +0,0 @@
-/**
- * @aria/tools - Arion executor tests
- */
-
-import { describe, it, expect, vi } from "vitest";
-import type { ToolContext } from "../../src/types.js";
-import {
-  executeHatchArion,
-  executeRestArion,
-  executeWakeArion,
-  executeRetireArion,
-} from "../../src/executors/arion.js";
-
-// Helper to create a mock context
-const createContext = (overrides: Partial<ToolContext> = {}): ToolContext => ({
-  workingDir: "/test/dir",
-  env: {},
-  confirm: vi.fn().mockResolvedValue(true),
-  ...overrides,
-});
-
-describe("Arion Executors", () => {
-  describe("executeHatchArion", () => {
-    it("should successfully hatch an arion with valid input", async () => {
-      const mockArion = { id: "arion-123", name: "TestArion", emoji: "🦅" };
-      const mockManager = {
-        hatch: vi.fn().mockResolvedValue(mockArion),
-        getMemoria: vi.fn(),
-      };
-      const ctx = createContext({
-        manager: mockManager as any,
-        arion: { id: "parent-1", name: "ParentArion", emoji: "🐣" },
-      });
-
-      const result = await executeHatchArion(
-        { name: "TestArion", traits: ["curious", "brave"], style: "casual" },
-        ctx,
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual({
-        arionId: "arion-123",
-        name: "TestArion",
-        emoji: "🦅",
-      });
-      expect(mockManager.hatch).toHaveBeenCalled();
-    });
-
-    it("should fail when name is missing", async () => {
-      const ctx = createContext({
-        manager: { hatch: vi.fn(), getMemoria: vi.fn() } as any,
-        arion: { id: "parent-1", name: "ParentArion", emoji: "🐣" },
-      });
-
-      const result = await executeHatchArion(
-        { name: "", traits: ["curious"], style: "casual" },
-        ctx,
-      );
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("name is required");
-    });
-
-    it("should fail when manager is not available", async () => {
-      const ctx = createContext({
-        arion: { id: "parent-1", name: "ParentArion", emoji: "🐣" },
-      });
-
-      const result = await executeHatchArion(
-        { name: "TestArion", traits: ["curious"], style: "casual" },
-        ctx,
-      );
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("ArionManager is not available");
-    });
-  });
-
-  // ==========================================================================
-  // executeRestArion
-  // ==========================================================================
-
-  describe("executeRestArion", () => {
-    it("should successfully rest an arion", async () => {
-      const mockManager = {
-        rest: vi.fn().mockResolvedValue(undefined),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRestArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain("Sage");
-      expect(result.message).toContain("resting");
-      expect(mockManager.rest).toHaveBeenCalledWith("Sage");
-    });
-
-    it("should fail when name is empty", async () => {
-      const mockManager = { rest: vi.fn() };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRestArion({ name: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("name is required");
-      expect(mockManager.rest).not.toHaveBeenCalled();
-    });
-
-    it("should fail when manager is not available", async () => {
-      const ctx = createContext();
-
-      const result = await executeRestArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("ArionManager is not available");
-    });
-
-    it("should propagate manager errors (e.g. already resting)", async () => {
-      const mockManager = {
-        rest: vi.fn().mockRejectedValue(new Error("Arion is already resting")),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRestArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Failed to rest arion");
-      expect(result.message).toContain("Arion is already resting");
-    });
-
-    it("should handle non-Error throw from manager", async () => {
-      const mockManager = {
-        rest: vi.fn().mockRejectedValue("unexpected string error"),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRestArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Failed to rest arion");
-      expect(result.message).toContain("unexpected string error");
-    });
-  });
-
-  // ==========================================================================
-  // executeWakeArion
-  // ==========================================================================
-
-  describe("executeWakeArion", () => {
-    it("should successfully wake an arion", async () => {
-      const mockManager = {
-        wake: vi.fn().mockResolvedValue(undefined),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeWakeArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain("Sage");
-      expect(result.message).toContain("awake");
-      expect(mockManager.wake).toHaveBeenCalledWith("Sage");
-    });
-
-    it("should fail when name is empty", async () => {
-      const mockManager = { wake: vi.fn() };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeWakeArion({ name: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("name is required");
-      expect(mockManager.wake).not.toHaveBeenCalled();
-    });
-
-    it("should fail when manager is not available", async () => {
-      const ctx = createContext();
-
-      const result = await executeWakeArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("ArionManager is not available");
-    });
-
-    it("should propagate manager errors (e.g. arion not resting)", async () => {
-      const mockManager = {
-        wake: vi.fn().mockRejectedValue(new Error("Arion is not resting")),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeWakeArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Failed to wake arion");
-      expect(result.message).toContain("Arion is not resting");
-    });
-
-    it("should handle non-Error throw from manager", async () => {
-      const mockManager = {
-        wake: vi.fn().mockRejectedValue(42),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeWakeArion({ name: "Sage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Failed to wake arion");
-      expect(result.message).toContain("42");
-    });
-  });
-
-  // ==========================================================================
-  // executeRetireArion
-  // ==========================================================================
-
-  describe("executeRetireArion", () => {
-    it("should successfully retire an arion when confirmed", async () => {
-      const mockManager = {
-        retire: vi.fn().mockResolvedValue(undefined),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRetireArion({ name: "OldSage" }, ctx);
-
-      expect(result.success).toBe(true);
-      expect(result.message).toContain("OldSage");
-      expect(result.message).toContain("retired");
-      expect(mockManager.retire).toHaveBeenCalledWith("OldSage", {
-        confirm: true,
-      });
-    });
-
-    it("should call confirm with a warning about permanence", async () => {
-      const confirmFn = vi.fn().mockResolvedValue(true);
-      const mockManager = {
-        retire: vi.fn().mockResolvedValue(undefined),
-      };
-      const ctx = createContext({
-        manager: mockManager as any,
-        confirm: confirmFn,
-      });
-
-      await executeRetireArion({ name: "OldSage" }, ctx);
-
-      expect(confirmFn).toHaveBeenCalledTimes(1);
-      const confirmMsg = confirmFn.mock.calls[0][0];
-      expect(confirmMsg).toContain("OldSage");
-      expect(confirmMsg).toContain("cannot be undone");
-    });
-
-    it("should fail when user declines confirmation", async () => {
-      const mockManager = { retire: vi.fn() };
-      const ctx = createContext({
-        manager: mockManager as any,
-        confirm: vi.fn().mockResolvedValue(false),
-      });
-
-      const result = await executeRetireArion({ name: "OldSage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("cancelled");
-      expect(mockManager.retire).not.toHaveBeenCalled();
-    });
-
-    it("should fail when name is empty", async () => {
-      const mockManager = { retire: vi.fn() };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRetireArion({ name: "" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("name is required");
-      expect(mockManager.retire).not.toHaveBeenCalled();
-    });
-
-    it("should fail when manager is not available", async () => {
-      const ctx = createContext();
-
-      const result = await executeRetireArion({ name: "OldSage" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("ArionManager is not available");
-    });
-
-    it("should propagate manager errors (e.g. arion not found)", async () => {
-      const mockManager = {
-        retire: vi.fn().mockRejectedValue(new Error("Arion 'Ghost' does not exist")),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRetireArion({ name: "Ghost" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Failed to retire arion");
-      expect(result.message).toContain("Arion 'Ghost' does not exist");
-    });
-
-    it("should handle non-Error throw from manager", async () => {
-      const mockManager = {
-        retire: vi.fn().mockRejectedValue({ code: "NOT_FOUND" }),
-      };
-      const ctx = createContext({ manager: mockManager as any });
-
-      const result = await executeRetireArion({ name: "Ghost" }, ctx);
-
-      expect(result.success).toBe(false);
-      expect(result.message).toContain("Failed to retire arion");
-    });
-  });
-});

package/tests/executors/conversation-primitives.test.ts

@@ -1,250 +0,0 @@
-/**
- * @aria/tools - Conversation primitives tests
- *
- * Tests for getConversationContext, getSessionTranscript, getSelfContext,
- * and the RecallToolContext interface.
- */
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  getConversationContext,
-  getSessionTranscript,
-  getSelfContext,
-} from "../../src/executors/memory.js";
-import type { RecallToolContext } from "../../src/executors/memory.js";
-
-describe("Conversation Primitives", () => {
-  describe("getConversationContext", () => {
-    const sampleMessages: Array<{ role: string; content: string }> = [
-      { role: "user", content: "Hello" },
-      { role: "assistant", content: "Hi there!" },
-      { role: "user", content: "What is 2+2?" },
-      { role: "assistant", content: "4" },
-      { role: "user", content: "And 3+3?" },
-      { role: "assistant", content: "6" },
-      { role: "user", content: "Thanks" },
-      { role: "assistant", content: "You're welcome!" },
-      { role: "user", content: "One more thing" },
-      { role: "assistant", content: "Sure, what is it?" },
-    ];
-
-    it("returns last N turns (default 5)", () => {
-      const result = getConversationContext(sampleMessages, {});
-      // Default 5 turns = 10 messages, which is all of our sample
-      expect(result).toHaveLength(10);
-      expect(result[0]).toEqual({ role: "user", content: "Hello" });
-    });
-
-    it("returns last 3 turns (6 messages)", () => {
-      const result = getConversationContext(sampleMessages, { turns: 3 });
-      expect(result).toHaveLength(6);
-      // 10 messages, slice(-6) starts at index 4
-      expect(result[0]).toEqual({ role: "user", content: "And 3+3?" });
-      expect(result[5]).toEqual({ role: "assistant", content: "Sure, what is it?" });
-    });
-
-    it("returns last 1 turn (2 messages)", () => {
-      const result = getConversationContext(sampleMessages, { turns: 1 });
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({ role: "user", content: "One more thing" });
-      expect(result[1]).toEqual({ role: "assistant", content: "Sure, what is it?" });
-    });
-
-    it("returns empty array when messages is undefined", () => {
-      const result = getConversationContext(undefined, { turns: 3 });
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array when messages is empty", () => {
-      const result = getConversationContext([], { turns: 3 });
-      expect(result).toEqual([]);
-    });
-
-    it("returns all messages when turns exceeds available messages", () => {
-      const result = getConversationContext(sampleMessages, { turns: 100 });
-      expect(result).toHaveLength(10);
-    });
-
-    it("handles single message", () => {
-      const single = [{ role: "user", content: "Hi" }];
-      const result = getConversationContext(single, { turns: 5 });
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({ role: "user", content: "Hi" });
-    });
-
-    it("handles turns=0 gracefully", () => {
-      const result = getConversationContext(sampleMessages, { turns: 0 });
-      // 0 turns = 0 messages
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("getSessionTranscript", () => {
-    let tmpDir: string;
-    let projectsDir: string;
-
-    beforeEach(() => {
-      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "aria-conversation-primitives-"));
-      projectsDir = path.join(tmpDir, ".claude", "projects");
-      fs.mkdirSync(projectsDir, { recursive: true });
-      vi.spyOn(os, "homedir").mockReturnValue(tmpDir);
-    });
-
-    afterEach(() => {
-      vi.restoreAllMocks();
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-
-    function writeSession(lines: string[]): void {
-      const projectDir = path.join(projectsDir, "test-project");
-      fs.mkdirSync(projectDir, { recursive: true });
-      fs.writeFileSync(path.join(projectDir, "session.jsonl"), lines.join("\n"), "utf8");
-    }
-
-    function makeEntry(role: "user" | "assistant", content: string): string {
-      return JSON.stringify({
-        type: role,
-        message: { role, content },
-      });
-    }
-
-    it("returns empty array when no session files exist at default path", async () => {
-      const result = await getSessionTranscript({});
-      expect(result).toBeInstanceOf(Array);
-      expect(result).toEqual([]);
-    });
-
-    it("returns empty array with non-matching sessionId", async () => {
-      writeSession([makeEntry("user", "Hello"), makeEntry("assistant", "Hi")]);
-      const result = await getSessionTranscript({ sessionId: "nonexistent-session-123" });
-      expect(result).toEqual([]);
-    });
-
-    it("returns an array with turns parameter", async () => {
-      writeSession([
-        makeEntry("user", "Question 1"),
-        makeEntry("assistant", "Answer 1"),
-        makeEntry("user", "Question 2"),
-        makeEntry("assistant", "Answer 2"),
-      ]);
-
-      const result = await getSessionTranscript({ turns: 5 });
-      expect(result).toBeInstanceOf(Array);
-      expect(result).toEqual([
-        { role: "user", content: "Question 1" },
-        { role: "assistant", content: "Answer 1" },
-        { role: "user", content: "Question 2" },
-        { role: "assistant", content: "Answer 2" },
-      ]);
-    });
-
-    it("returns empty array when turns is 0", async () => {
-      const result = await getSessionTranscript({ turns: 0 });
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("getSelfContext", () => {
-    const sections: Record<string, string> = {
-      memory: "Current task: Fix the bug\nSuggested response: Try running tests",
-      strategies: "Always write tests first\nUse TDD approach",
-      profile: "User: Tony, prefers TypeScript",
-      context: "Background: Working on ARIA project",
-    };
-
-    it("returns memory section", () => {
-      const result = getSelfContext(sections, { section: "memory" });
-      expect(result).toBe("Current task: Fix the bug\nSuggested response: Try running tests");
-    });
-
-    it("returns strategies section", () => {
-      const result = getSelfContext(sections, { section: "strategies" });
-      expect(result).toBe("Always write tests first\nUse TDD approach");
-    });
-
-    it("returns profile section", () => {
-      const result = getSelfContext(sections, { section: "profile" });
-      expect(result).toBe("User: Tony, prefers TypeScript");
-    });
-
-    it("returns context section", () => {
-      const result = getSelfContext(sections, { section: "context" });
-      expect(result).toBe("Background: Working on ARIA project");
-    });
-
-    it("returns null for unknown section name", () => {
-      const result = getSelfContext(sections, { section: "unknown" });
-      expect(result).toBeNull();
-    });
-
-    it("returns null when sections is undefined", () => {
-      const result = getSelfContext(undefined, { section: "memory" });
-      expect(result).toBeNull();
-    });
-
-    it("returns null for valid section name not present in sections", () => {
-      const partial: Record<string, string> = { memory: "Some content" };
-      const result = getSelfContext(partial, { section: "strategies" });
-      expect(result).toBeNull();
-    });
-
-    it("rejects invalid section names (SQL injection attempt)", () => {
-      const result = getSelfContext(sections, { section: "'; DROP TABLE --" });
-      expect(result).toBeNull();
-    });
-
-    it("rejects empty string section name", () => {
-      const result = getSelfContext(sections, { section: "" });
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("RecallToolContext integration", () => {
-    it("can be used to type ctx.context for memory executors", () => {
-      const recallCtx: RecallToolContext = {
-        conversationContext: [
-          { role: "user", content: "Hello" },
-          { role: "assistant", content: "Hi!" },
-        ],
-        systemPromptSections: {
-          memory: "Current task: testing",
-          strategies: "Write good tests",
-        },
-      };
-
-      // getConversationContext reads from conversationContext
-      const turns = getConversationContext(recallCtx.conversationContext, { turns: 1 });
-      expect(turns).toHaveLength(2);
-      expect(turns[0]!.content).toBe("Hello");
-
-      // getSelfContext reads from systemPromptSections
-      const memory = getSelfContext(recallCtx.systemPromptSections, { section: "memory" });
-      expect(memory).toBe("Current task: testing");
-    });
-
-    it("handles RecallToolContext with only conversationContext", () => {
-      const recallCtx: RecallToolContext = {
-        conversationContext: [{ role: "user", content: "Test" }],
-      };
-
-      const turns = getConversationContext(recallCtx.conversationContext, {});
-      expect(turns).toHaveLength(1);
-
-      const section = getSelfContext(recallCtx.systemPromptSections, { section: "memory" });
-      expect(section).toBeNull();
-    });
-
-    it("handles empty RecallToolContext", () => {
-      const recallCtx: RecallToolContext = {};
-
-      const turns = getConversationContext(recallCtx.conversationContext, {});
-      expect(turns).toEqual([]);
-
-      const section = getSelfContext(recallCtx.systemPromptSections, { section: "memory" });
-      expect(section).toBeNull();
-    });
-  });
-});