@aria-cli/tools 1.0.0

package/tests/definitions/outlook.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { getCoreTool } from "../../src/definitions/core.js";
+
+describe("Outlook tool definitions", () => {
+  it("registers the Outlook check, send, and reply tools in the core inventory", () => {
+    const checkOutlookMessages = getCoreTool("check_outlook_messages");
+    const sendOutlookMessage = getCoreTool("send_outlook_message");
+    const replyOutlookMessage = getCoreTool("reply_outlook_message");
+
+    expect(checkOutlookMessages).toBeDefined();
+    expect(sendOutlookMessage).toBeDefined();
+    expect(replyOutlookMessage).toBeDefined();
+  });
+
+  it("marks Outlook reads as read-only and sends/replies as confirmation-gated writes", () => {
+    const checkOutlookMessages = getCoreTool("check_outlook_messages");
+    const sendOutlookMessage = getCoreTool("send_outlook_message");
+    const replyOutlookMessage = getCoreTool("reply_outlook_message");
+
+    expect(checkOutlookMessages?.category).toBe("messaging");
+    expect(checkOutlookMessages?.isReadOnly).toBe(true);
+    expect(checkOutlookMessages?.riskLevel).toBe("safe");
+    expect(sendOutlookMessage?.category).toBe("messaging");
+    expect(sendOutlookMessage?.requiresConfirmation).toBe(true);
+    expect(sendOutlookMessage?.riskLevel).toBe("dangerous");
+    expect(replyOutlookMessage?.category).toBe("messaging");
+    expect(replyOutlookMessage?.requiresConfirmation).toBe(true);
+    expect(replyOutlookMessage?.riskLevel).toBe("dangerous");
+  });
+});

package/tests/definitions/process.test.ts

@@ -0,0 +1,469 @@
+/**
+ * @aria/tools - process tool unit tests
+ *
+ * Tests for session slugs, PTY key encoding, and process registry.
+ * No real child processes are spawned.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { createSessionSlug } from "../../src/definitions/process/session-slug.js";
+import {
+  encodeKeySequence,
+  encodePaste,
+  BRACKETED_PASTE_START,
+  BRACKETED_PASTE_END,
+} from "../../src/definitions/process/pty-keys.js";
+import {
+  addSession,
+  getSession,
+  getFinishedSession,
+  appendOutput,
+  drainSession,
+  markExited,
+  markBackgrounded,
+  listRunningSessions,
+  listFinishedSessions,
+  resetProcessRegistryForTests,
+  tail,
+  trimWithCap,
+  type ProcessSession,
+} from "../../src/definitions/process/process-registry.js";
+
+// ── Session Slugs ────────────────────────────────────────────────────
+
+describe("process", () => {
+  describe("session-slug", () => {
+    it("generates human-readable slugs", () => {
+      const slug = createSessionSlug();
+
+      // Format: adjective-noun (two words joined by hyphen)
+      expect(slug).toMatch(/^[a-z]+-[a-z]+/);
+      expect(slug.length).toBeGreaterThan(3);
+    });
+
+    it("generates unique slugs on repeated calls", () => {
+      const slugs = new Set<string>();
+      // Generate many slugs; collisions are extremely unlikely
+      for (let i = 0; i < 50; i++) {
+        slugs.add(createSessionSlug());
+      }
+      // With 40+ adjectives * 50+ nouns = 2000+ combos, 50 should be mostly unique
+      expect(slugs.size).toBeGreaterThan(30);
+    });
+
+    it("avoids collisions with existing slugs", () => {
+      const taken = new Set<string>();
+
+      const slug1 = createSessionSlug((id) => taken.has(id));
+      taken.add(slug1);
+
+      const slug2 = createSessionSlug((id) => taken.has(id));
+      taken.add(slug2);
+
+      expect(slug1).not.toBe(slug2);
+    });
+
+    it("appends numeric suffix when base is taken", () => {
+      // Force collision by marking all base slugs as taken for first attempt,
+      // but allow the -2 suffix variant
+      let callCount = 0;
+      const slug = createSessionSlug((id) => {
+        callCount++;
+        // First call (base slug): taken. Subsequent calls with suffixes: not taken.
+        if (!id.includes("-") || id.split("-").length <= 2) {
+          // Base slug (e.g., "calm-harbor") is taken
+          return true;
+        }
+        return false;
+      });
+
+      // Should have a numeric suffix since all 2-word bases are "taken"
+      expect(slug).toMatch(/\d/);
+    });
+
+    it("falls back to 3-word slugs when 2-word exhausted", () => {
+      // Mark ALL 2-word and their suffixed variants as taken
+      // to force 3-word generation
+      let attemptCount = 0;
+      const slug = createSessionSlug((id) => {
+        attemptCount++;
+        // If attempt count is very high, allow it (safety valve)
+        if (attemptCount > 200) return false;
+        // Count word segments (excluding numeric suffixes)
+        const parts = id.split("-");
+        const wordCount = parts.filter((p) => !/^\d+$/.test(p)).length;
+        return wordCount <= 2; // All 2-word variants are taken
+      });
+
+      // The slug should exist and be non-empty
+      expect(slug).toBeTruthy();
+      expect(slug.length).toBeGreaterThan(0);
+    });
+  });
+
+  // ── PTY Keys ───────────────────────────────────────────────────────
+
+  describe("pty-keys", () => {
+    it("encodes Enter key", () => {
+      const result = encodeKeySequence({ keys: ["Enter"] });
+      expect(result.data).toBe("\r");
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it("encodes Return key (alias for Enter)", () => {
+      const result = encodeKeySequence({ keys: ["Return"] });
+      expect(result.data).toBe("\r");
+    });
+
+    it("encodes Ctrl+C", () => {
+      const result = encodeKeySequence({ keys: ["C-c"] });
+      expect(result.data).toBe("\x03"); // ETX (End of Text)
+      expect(result.warnings).toHaveLength(0);
+    });
+
+    it("encodes Ctrl+C with caret notation", () => {
+      const result = encodeKeySequence({ keys: ["^C"] });
+      expect(result.data).toBe("\x03");
+    });
+
+    it("encodes arrow keys", () => {
+      const up = encodeKeySequence({ keys: ["Up"] });
+      expect(up.data).toBe("\x1b[A");
+
+      const down = encodeKeySequence({ keys: ["Down"] });
+      expect(down.data).toBe("\x1b[B");
+
+      const right = encodeKeySequence({ keys: ["Right"] });
+      expect(right.data).toBe("\x1b[C");
+
+      const left = encodeKeySequence({ keys: ["Left"] });
+      expect(left.data).toBe("\x1b[D");
+    });
+
+    it("encodes Tab key", () => {
+      const result = encodeKeySequence({ keys: ["Tab"] });
+      expect(result.data).toBe("\t");
+    });
+
+    it("encodes Escape key", () => {
+      const result = encodeKeySequence({ keys: ["Escape"] });
+      expect(result.data).toBe("\x1b");
+    });
+
+    it("encodes Backspace key", () => {
+      const result = encodeKeySequence({ keys: ["Backspace"] });
+      expect(result.data).toBe("\x7f");
+    });
+
+    it("encodes function keys", () => {
+      const f1 = encodeKeySequence({ keys: ["F1"] });
+      expect(f1.data).toBe("\x1bOP");
+
+      const f5 = encodeKeySequence({ keys: ["F5"] });
+      expect(f5.data).toBe("\x1b[15~");
+    });
+
+    it("encodes Space key", () => {
+      const result = encodeKeySequence({ keys: ["Space"] });
+      expect(result.data).toBe(" ");
+    });
+
+    it("encodes Shift+Tab (back-tab)", () => {
+      const result = encodeKeySequence({ keys: ["S-Tab"] });
+      expect(result.data).toBe("\x1b[Z");
+    });
+
+    it("handles literal text", () => {
+      const result = encodeKeySequence({ literal: "hello" });
+      expect(result.data).toBe("hello");
+    });
+
+    it("handles hex byte encoding", () => {
+      const result = encodeKeySequence({ hex: ["0x0d"] });
+      expect(result.data).toBe("\r"); // 0x0d = carriage return
+    });
+
+    it("rejects invalid hex bytes with warning", () => {
+      const result = encodeKeySequence({ hex: ["zz"] });
+      expect(result.data).toBe("");
+      expect(result.warnings).toHaveLength(1);
+      expect(result.warnings[0]).toContain("Invalid hex byte");
+    });
+
+    it("handles unknown keys gracefully with warning", () => {
+      const result = encodeKeySequence({ keys: ["C-UnknownKey"] });
+      // Should produce warnings for unknown modified key
+      expect(result.warnings.length).toBeGreaterThanOrEqual(0);
+      // Should still produce some output (literal fallback)
+    });
+
+    it("encodes multiple keys in sequence", () => {
+      const result = encodeKeySequence({ keys: ["h", "i", "Enter"] });
+      expect(result.data).toBe("hi\r");
+    });
+
+    it("combines literal and keys", () => {
+      const result = encodeKeySequence({
+        literal: "hello",
+        keys: ["Enter"],
+      });
+      expect(result.data).toBe("hello\r");
+    });
+
+    it("encodes Alt modifier", () => {
+      const result = encodeKeySequence({ keys: ["M-x"] });
+      expect(result.data).toBe("\x1bx"); // ESC + x
+    });
+
+    it("encodes Ctrl+A to Ctrl+Z", () => {
+      const ctrlA = encodeKeySequence({ keys: ["C-a"] });
+      expect(ctrlA.data).toBe("\x01");
+
+      const ctrlZ = encodeKeySequence({ keys: ["C-z"] });
+      expect(ctrlZ.data).toBe("\x1a");
+    });
+
+    it("encodes modifiers on arrow keys", () => {
+      // Ctrl+Up
+      const result = encodeKeySequence({ keys: ["C-Up"] });
+      // Should be xterm modified sequence: ESC[1;5A (5 = ctrl modifier)
+      expect(result.data).toContain("\x1b[1;5A");
+    });
+
+    it("encodePaste wraps with bracketed paste markers", () => {
+      const result = encodePaste("hello world");
+      expect(result.startsWith(BRACKETED_PASTE_START)).toBe(true);
+      expect(result.endsWith(BRACKETED_PASTE_END)).toBe(true);
+      expect(result).toContain("hello world");
+    });
+
+    it("encodePaste without brackets returns raw text", () => {
+      const result = encodePaste("hello", false);
+      expect(result).toBe("hello");
+    });
+  });
+
+  // ── Process Registry ───────────────────────────────────────────────
+
+  describe("process-registry", () => {
+    beforeEach(() => {
+      resetProcessRegistryForTests();
+    });
+
+    afterEach(() => {
+      resetProcessRegistryForTests();
+    });
+
+    function createMockSession(overrides?: Partial<ProcessSession>): ProcessSession {
+      return {
+        id: "test-session",
+        command: "echo hello",
+        startedAt: Date.now(),
+        maxOutputChars: 200_000,
+        totalOutputChars: 0,
+        pendingStdout: [],
+        pendingStderr: [],
+        pendingStdoutChars: 0,
+        pendingStderrChars: 0,
+        aggregated: "",
+        tail: "",
+        exited: false,
+        truncated: false,
+        backgrounded: false,
+        ...overrides,
+      };
+    }
+
+    it("tracks spawned processes", () => {
+      const session = createMockSession({ id: "my-proc" });
+      addSession(session);
+
+      const found = getSession("my-proc");
+      expect(found).toBeDefined();
+      expect(found!.id).toBe("my-proc");
+      expect(found!.command).toBe("echo hello");
+    });
+
+    it("returns undefined for unknown session", () => {
+      expect(getSession("nonexistent")).toBeUndefined();
+      expect(getFinishedSession("nonexistent")).toBeUndefined();
+    });
+
+    it("appends output to stdout", () => {
+      const session = createMockSession();
+      addSession(session);
+
+      appendOutput(session, "stdout", "line 1\n");
+      appendOutput(session, "stdout", "line 2\n");
+
+      const drained = drainSession(session);
+      expect(drained.stdout).toBe("line 1\nline 2\n");
+      expect(drained.stderr).toBe("");
+    });
+
+    it("appends output to stderr", () => {
+      const session = createMockSession();
+      addSession(session);
+
+      appendOutput(session, "stderr", "error msg\n");
+
+      const drained = drainSession(session);
+      expect(drained.stdout).toBe("");
+      expect(drained.stderr).toBe("error msg\n");
+    });
+
+    it("drainSession clears pending buffers", () => {
+      const session = createMockSession();
+      addSession(session);
+
+      appendOutput(session, "stdout", "data");
+      const first = drainSession(session);
+      expect(first.stdout).toBe("data");
+
+      // Second drain should be empty
+      const second = drainSession(session);
+      expect(second.stdout).toBe("");
+    });
+
+    it("caps output at ring buffer limit", () => {
+      const session = createMockSession({
+        maxOutputChars: 100,
+      });
+      addSession(session);
+
+      // Write more than 100 chars
+      const bigChunk = "x".repeat(150);
+      appendOutput(session, "stdout", bigChunk);
+
+      expect(session.truncated).toBe(true);
+      expect(session.aggregated.length).toBeLessThanOrEqual(100);
+    });
+
+    it("marks finished processes", () => {
+      const session = createMockSession({
+        id: "finishing",
+        backgrounded: true,
+      });
+      addSession(session);
+      markBackgrounded(session);
+
+      appendOutput(session, "stdout", "done\n");
+      markExited(session, 0, null, "completed");
+
+      // Should be moved from running to finished
+      expect(getSession("finishing")).toBeUndefined();
+
+      const finished = getFinishedSession("finishing");
+      expect(finished).toBeDefined();
+      expect(finished!.status).toBe("completed");
+      expect(finished!.exitCode).toBe(0);
+    });
+
+    it("marks failed processes", () => {
+      const session = createMockSession({
+        id: "failing",
+        backgrounded: true,
+      });
+      addSession(session);
+      markBackgrounded(session);
+
+      markExited(session, 1, null, "failed");
+
+      const finished = getFinishedSession("failing");
+      expect(finished).toBeDefined();
+      expect(finished!.status).toBe("failed");
+      expect(finished!.exitCode).toBe(1);
+    });
+
+    it("marks killed processes", () => {
+      const session = createMockSession({
+        id: "killed",
+        backgrounded: true,
+      });
+      addSession(session);
+      markBackgrounded(session);
+
+      markExited(session, null, "SIGTERM", "killed");
+
+      const finished = getFinishedSession("killed");
+      expect(finished).toBeDefined();
+      expect(finished!.status).toBe("killed");
+      expect(finished!.exitSignal).toBe("SIGTERM");
+    });
+
+    it("lists running backgrounded sessions", () => {
+      const s1 = createMockSession({ id: "bg-1", backgrounded: true });
+      const s2 = createMockSession({ id: "bg-2", backgrounded: false });
+      const s3 = createMockSession({ id: "bg-3", backgrounded: true });
+
+      addSession(s1);
+      addSession(s2);
+      addSession(s3);
+
+      const running = listRunningSessions();
+      const ids = running.map((s) => s.id);
+      expect(ids).toContain("bg-1");
+      expect(ids).toContain("bg-3");
+      expect(ids).not.toContain("bg-2");
+    });
+
+    it("lists finished sessions", () => {
+      const session = createMockSession({ id: "done-1", backgrounded: true });
+      addSession(session);
+      markBackgrounded(session);
+      markExited(session, 0, null, "completed");
+
+      const finished = listFinishedSessions();
+      expect(finished).toHaveLength(1);
+      expect(finished[0]!.id).toBe("done-1");
+    });
+
+    it("non-backgrounded sessions are not preserved in finished", () => {
+      const session = createMockSession({ id: "fg-session", backgrounded: false });
+      addSession(session);
+
+      markExited(session, 0, null, "completed");
+
+      // Should not appear in finished since it was not backgrounded
+      expect(getFinishedSession("fg-session")).toBeUndefined();
+    });
+
+    it("tail utility caps output at max chars", () => {
+      expect(tail("hello world", 5)).toBe("world");
+      expect(tail("hi", 10)).toBe("hi");
+      expect(tail("", 5)).toBe("");
+    });
+
+    it("trimWithCap keeps last N characters", () => {
+      expect(trimWithCap("abcdef", 3)).toBe("def");
+      expect(trimWithCap("ab", 5)).toBe("ab");
+    });
+
+    it("tracks total output chars across appends", () => {
+      const session = createMockSession();
+      addSession(session);
+
+      appendOutput(session, "stdout", "12345");
+      appendOutput(session, "stderr", "67890");
+
+      expect(session.totalOutputChars).toBe(10);
+    });
+
+    it("resetProcessRegistryForTests clears all state", () => {
+      const s1 = createMockSession({ id: "s1" });
+      addSession(s1);
+
+      const s2 = createMockSession({ id: "s2", backgrounded: true });
+      addSession(s2);
+      markBackgrounded(s2);
+      markExited(s2, 0, null, "completed");
+
+      resetProcessRegistryForTests();
+
+      expect(getSession("s1")).toBeUndefined();
+      expect(getFinishedSession("s2")).toBeUndefined();
+      expect(listRunningSessions()).toHaveLength(0);
+      expect(listFinishedSessions()).toHaveLength(0);
+    });
+  });
+});

package/tests/definitions/slack.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { getCoreTool } from "../../src/definitions/core.js";
+
+describe("Slack tool definitions", () => {
+  it("registers the Slack read, write, and react tools in the core inventory", () => {
+    const checkSlackMessages = getCoreTool("check_slack_messages");
+    const sendSlackMessage = getCoreTool("send_slack_message");
+    const reactSlackMessage = getCoreTool("react_slack_message");
+
+    expect(checkSlackMessages).toBeDefined();
+    expect(sendSlackMessage).toBeDefined();
+    expect(reactSlackMessage).toBeDefined();
+  });
+
+  it("marks Slack reads as read-only and Slack sends/reacts as confirmation-gated writes", () => {
+    const checkSlackMessages = getCoreTool("check_slack_messages");
+    const sendSlackMessage = getCoreTool("send_slack_message");
+    const reactSlackMessage = getCoreTool("react_slack_message");
+
+    expect(checkSlackMessages?.category).toBe("messaging");
+    expect(checkSlackMessages?.isReadOnly).toBe(true);
+    expect(sendSlackMessage?.category).toBe("messaging");
+    expect(sendSlackMessage?.requiresConfirmation).toBe(true);
+    expect(reactSlackMessage?.category).toBe("messaging");
+    expect(reactSlackMessage?.requiresConfirmation).toBe(true);
+    expect(reactSlackMessage?.isReadOnly).toBe(false);
+  });
+});