@aria-cli/tools 1.0.8 → 1.0.10

package/tests/definitions/outlook.test.ts

@@ -1,30 +0,0 @@
-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

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

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