@aria-cli/tools 1.0.0

package/tests/executors/arion.test.ts

@@ -0,0 +1,309 @@
+/**
+ * @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

@@ -0,0 +1,250 @@
+/**
+ * @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();
+    });
+  });
+});