agent-messenger 1.15.0 → 2.0.0

package/src/tui/utils.test.ts

@@ -0,0 +1,149 @@
+import { describe, test, expect } from "bun:test";
+import { formatTimestamp, truncate, fuzzyMatch, stripHtml } from "./utils";
+
+describe("formatTimestamp", () => {
+  test("today's date returns HH:MM", () => {
+    const now = new Date();
+    const epochSeconds = (now.getTime() / 1000).toFixed(6);
+    const result = formatTimestamp(epochSeconds);
+    expect(result).toMatch(/^\d{2}:\d{2}$/);
+  });
+
+  test("yesterday's date returns MM/DD HH:MM", () => {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    const epochSeconds = (yesterday.getTime() / 1000).toFixed(6);
+    const result = formatTimestamp(epochSeconds);
+    expect(result).toMatch(/^\d{2}\/\d{2} \d{2}:\d{2}$/);
+  });
+
+  test("ISO 8601 string for today returns HH:MM", () => {
+    const now = new Date();
+    const iso = now.toISOString();
+    const result = formatTimestamp(iso);
+    expect(result).toMatch(/^\d{2}:\d{2}$/);
+  });
+
+  test("ISO 8601 string for past date returns MM/DD HH:MM", () => {
+    const result = formatTimestamp("2024-03-15T10:30:00Z");
+    expect(result).toMatch(/^\d{2}\/\d{2} \d{2}:\d{2}$/);
+  });
+
+  test("invalid string returns original", () => {
+    expect(formatTimestamp("not-a-date")).toBe("not-a-date");
+    expect(formatTimestamp("abc123")).toBe("abc123");
+  });
+
+  test("Slack-style epoch with microseconds", () => {
+    const now = new Date();
+    const slackTs = `${Math.floor(now.getTime() / 1000)}.123456`;
+    const result = formatTimestamp(slackTs);
+    expect(result).toMatch(/^\d{2}:\d{2}$/);
+  });
+});
+
+describe("truncate", () => {
+  test("short string returned unchanged", () => {
+    expect(truncate("hello", 10)).toBe("hello");
+  });
+
+  test("exact length returned unchanged", () => {
+    expect(truncate("hello", 5)).toBe("hello");
+  });
+
+  test("long string gets truncated with ellipsis", () => {
+    expect(truncate("hello world", 8)).toBe("hello...");
+  });
+
+  test("maxLen of 3 truncates without ellipsis", () => {
+    expect(truncate("hello", 3)).toBe("hel");
+  });
+
+  test("maxLen of 1 truncates without ellipsis", () => {
+    expect(truncate("hello", 1)).toBe("h");
+  });
+
+  test("maxLen of 0 returns empty string", () => {
+    expect(truncate("hello", 0)).toBe("");
+  });
+
+  test("maxLen of 4 adds ellipsis", () => {
+    expect(truncate("hello", 4)).toBe("h...");
+  });
+});
+
+describe("fuzzyMatch", () => {
+  test("exact match returns true", () => {
+    expect(fuzzyMatch("general", "general")).toBe(true);
+  });
+
+  test("partial match in order returns true", () => {
+    expect(fuzzyMatch("gnrl", "general")).toBe(true);
+  });
+
+  test("case insensitive match", () => {
+    expect(fuzzyMatch("GNRL", "general")).toBe(true);
+    expect(fuzzyMatch("gnrl", "GENERAL")).toBe(true);
+  });
+
+  test("empty query returns true", () => {
+    expect(fuzzyMatch("", "anything")).toBe(true);
+    expect(fuzzyMatch("", "")).toBe(true);
+  });
+
+  test("no match returns false", () => {
+    expect(fuzzyMatch("xyz", "general")).toBe(false);
+  });
+
+  test("characters out of order returns false", () => {
+    expect(fuzzyMatch("lrng", "general")).toBe(false);
+  });
+
+  test("query longer than text returns false", () => {
+    expect(fuzzyMatch("generalgeneral", "general")).toBe(false);
+  });
+});
+
+describe("stripHtml", () => {
+  test("removes simple tags", () => {
+    expect(stripHtml("<p>hello</p>")).toBe("hello");
+  });
+
+  test("removes nested tags", () => {
+    expect(stripHtml("<div><p><strong>hello</strong></p></div>")).toBe("hello");
+  });
+
+  test("decodes &amp;", () => {
+    expect(stripHtml("a &amp; b")).toBe("a & b");
+  });
+
+  test("decodes &lt; and &gt;", () => {
+    expect(stripHtml("&lt;tag&gt;")).toBe("<tag>");
+  });
+
+  test("decodes &quot;", () => {
+    expect(stripHtml('say &quot;hello&quot;')).toBe('say "hello"');
+  });
+
+  test("decodes &#39;", () => {
+    expect(stripHtml("it&#39;s")).toBe("it's");
+  });
+
+  test("collapses multiple whitespace", () => {
+    expect(stripHtml("hello   world")).toBe("hello world");
+  });
+
+  test("trims leading and trailing whitespace", () => {
+    expect(stripHtml("  hello  ")).toBe("hello");
+  });
+
+  test("handles multiple entities and tags together", () => {
+    expect(stripHtml("<p>Hello &amp; <strong>World</strong></p>")).toBe(
+      "Hello & World",
+    );
+  });
+
+  test("whitespace from tag removal is collapsed", () => {
+    expect(stripHtml("<p>hello</p> <p>world</p>")).toBe("hello world");
+  });
+});

package/src/tui/utils.ts

@@ -0,0 +1,58 @@
+export function formatTimestamp(ts: string): string {
+  let date: Date;
+
+  if (/^\d+(\.\d+)?$/.test(ts)) {
+    date = new Date(parseFloat(ts) * 1000);
+  } else {
+    date = new Date(ts);
+  }
+
+  if (isNaN(date.getTime())) {
+    return ts;
+  }
+
+  const now = new Date();
+  const isToday =
+    date.getFullYear() === now.getFullYear() &&
+    date.getMonth() === now.getMonth() &&
+    date.getDate() === now.getDate();
+
+  const hh = String(date.getHours()).padStart(2, "0");
+  const mm = String(date.getMinutes()).padStart(2, "0");
+
+  if (isToday) {
+    return `${hh}:${mm}`;
+  }
+
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${month}/${day} ${hh}:${mm}`;
+}
+
+export function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  if (maxLen < 4) return text.slice(0, maxLen);
+  return text.slice(0, maxLen - 3) + "...";
+}
+
+export function fuzzyMatch(query: string, text: string): boolean {
+  if (query.length === 0) return true;
+  const lowerQuery = query.toLowerCase();
+  const lowerText = text.toLowerCase();
+  let qi = 0;
+  for (let ti = 0; ti < lowerText.length && qi < lowerQuery.length; ti++) {
+    if (lowerText[ti] === lowerQuery[qi]) qi++;
+  }
+  return qi === lowerQuery.length;
+}
+
+export function stripHtml(content: string): string {
+  const stripped = content.replace(/<[^>]*>/g, "");
+  const decoded = stripped
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+  return decoded.replace(/\s+/g, " ").trim();
+}

package/src/tui/views/channel-picker.ts

@@ -0,0 +1,146 @@
+import blessed from 'blessed'
+
+import { fuzzyMatch } from '../utils'
+import type { UnifiedChannel } from '../adapters/types'
+
+export class ChannelPicker {
+  private screen: blessed.Widgets.Screen
+  private overlay: blessed.Widgets.BoxElement
+  private searchInput: blessed.Widgets.TextboxElement
+  private resultsList: blessed.Widgets.ListElement
+  private allChannels: UnifiedChannel[] = []
+  private filteredChannels: UnifiedChannel[] = []
+  private onSelectCallback: ((channel: UnifiedChannel) => void) | null = null
+  private active = false
+
+  constructor(screen: blessed.Widgets.Screen) {
+    this.screen = screen
+
+    this.overlay = blessed.box({
+      parent: screen,
+      top: 'center',
+      left: 'center',
+      width: '60%',
+      height: '60%',
+      border: { type: 'line' },
+      style: {
+        border: { fg: 'blue' },
+        bg: 'black',
+      },
+      hidden: true,
+      label: ' Switch Channel (Ctrl+K) ',
+    })
+
+    this.searchInput = blessed.textbox({
+      parent: this.overlay,
+      top: 0,
+      left: 0,
+      right: 0,
+      height: 3,
+      border: { type: 'line' },
+      style: {
+        border: { fg: 'gray' },
+        fg: 'white',
+        focus: { border: { fg: 'blue' } },
+      },
+      inputOnFocus: true,
+      label: ' Search ',
+    })
+
+    this.resultsList = blessed.list({
+      parent: this.overlay,
+      top: 3,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      style: {
+        selected: { bg: 'blue', fg: 'white', bold: true },
+        item: { fg: 'white' },
+      },
+      keys: true,
+      vi: true,
+      mouse: true,
+    })
+
+    this.searchInput.on('keypress', (_ch: string, key: blessed.Widgets.Events.IKeyEventArg) => {
+      if (key.name === 'escape') {
+        this.close()
+        return
+      }
+      if (key.name === 'down' || (key.ctrl && key.name === 'n')) {
+        this.resultsList.down(1)
+        this.screen.render()
+        return
+      }
+      if (key.name === 'up' || (key.ctrl && key.name === 'p')) {
+        this.resultsList.up(1)
+        this.screen.render()
+        return
+      }
+      if (key.name === 'enter' || key.name === 'return') {
+        const selectedIndex = (this.resultsList as any).selected as number
+        const channel = this.filteredChannels[selectedIndex]
+        if (channel && this.onSelectCallback) {
+          this.onSelectCallback(channel)
+        }
+        this.close()
+        return
+      }
+
+      process.nextTick(() => {
+        const query = this.searchInput.getValue()
+        this.filterChannels(query)
+      })
+    })
+
+    this.resultsList.on('select', (_item: blessed.Widgets.BlessedElement, index: number) => {
+      const channel = this.filteredChannels[index]
+      if (channel && this.onSelectCallback) {
+        this.onSelectCallback(channel)
+      }
+      this.close()
+    })
+
+    this.resultsList.key(['escape'], () => {
+      this.close()
+    })
+  }
+
+  open(channels: UnifiedChannel[], onSelect: (channel: UnifiedChannel) => void): void {
+    this.allChannels = channels
+    this.filteredChannels = [...channels]
+    this.onSelectCallback = onSelect
+    this.active = true
+
+    this.searchInput.clearValue()
+    this.resultsList.setItems(channels.map((ch) => ch.name) as any)
+    this.resultsList.select(0)
+
+    this.overlay.show()
+    this.overlay.setFront()
+    this.searchInput.focus()
+    this.screen.render()
+  }
+
+  close(): void {
+    this.active = false
+    this.overlay.hide()
+    this.onSelectCallback = null
+    this.screen.render()
+  }
+
+  isActive(): boolean {
+    return this.active
+  }
+
+  private filterChannels(query: string): void {
+    if (!query) {
+      this.filteredChannels = [...this.allChannels]
+    } else {
+      this.filteredChannels = this.allChannels.filter((ch) => fuzzyMatch(query, ch.name))
+    }
+    this.resultsList.setItems(this.filteredChannels.map((ch) => ch.name) as any)
+    this.resultsList.select(0)
+    this.screen.render()
+  }
+}

package/src/tui/views/workspace-picker.ts

@@ -0,0 +1,146 @@
+import blessed from 'blessed'
+
+import { fuzzyMatch } from '../utils'
+import type { Workspace } from '../adapters/types'
+
+export class WorkspacePicker {
+  private screen: blessed.Widgets.Screen
+  private overlay: blessed.Widgets.BoxElement
+  private searchInput: blessed.Widgets.TextboxElement
+  private resultsList: blessed.Widgets.ListElement
+  private allWorkspaces: Workspace[] = []
+  private filteredWorkspaces: Workspace[] = []
+  private onSelectCallback: ((workspace: Workspace) => void) | null = null
+  private active = false
+
+  constructor(screen: blessed.Widgets.Screen) {
+    this.screen = screen
+
+    this.overlay = blessed.box({
+      parent: screen,
+      top: 'center',
+      left: 'center',
+      width: '60%',
+      height: '60%',
+      border: { type: 'line' },
+      style: {
+        border: { fg: 'yellow' },
+        bg: 'black',
+      },
+      hidden: true,
+      label: ' Switch Workspace (Ctrl+W) ',
+    })
+
+    this.searchInput = blessed.textbox({
+      parent: this.overlay,
+      top: 0,
+      left: 0,
+      right: 0,
+      height: 3,
+      border: { type: 'line' },
+      style: {
+        border: { fg: 'gray' },
+        fg: 'white',
+        focus: { border: { fg: 'yellow' } },
+      },
+      inputOnFocus: true,
+      label: ' Search ',
+    })
+
+    this.resultsList = blessed.list({
+      parent: this.overlay,
+      top: 3,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      style: {
+        selected: { bg: 'yellow', fg: 'black', bold: true },
+        item: { fg: 'white' },
+      },
+      keys: true,
+      vi: true,
+      mouse: true,
+    })
+
+    this.searchInput.on('keypress', (_ch: string, key: blessed.Widgets.Events.IKeyEventArg) => {
+      if (key.name === 'escape') {
+        this.close()
+        return
+      }
+      if (key.name === 'down' || (key.ctrl && key.name === 'n')) {
+        this.resultsList.down(1)
+        this.screen.render()
+        return
+      }
+      if (key.name === 'up' || (key.ctrl && key.name === 'p')) {
+        this.resultsList.up(1)
+        this.screen.render()
+        return
+      }
+      if (key.name === 'enter' || key.name === 'return') {
+        const selectedIndex = (this.resultsList as any).selected as number
+        const workspace = this.filteredWorkspaces[selectedIndex]
+        if (workspace && this.onSelectCallback) {
+          this.onSelectCallback(workspace)
+        }
+        this.close()
+        return
+      }
+
+      process.nextTick(() => {
+        const query = this.searchInput.getValue()
+        this.filterWorkspaces(query)
+      })
+    })
+
+    this.resultsList.on('select', (_item: blessed.Widgets.BlessedElement, index: number) => {
+      const workspace = this.filteredWorkspaces[index]
+      if (workspace && this.onSelectCallback) {
+        this.onSelectCallback(workspace)
+      }
+      this.close()
+    })
+
+    this.resultsList.key(['escape'], () => {
+      this.close()
+    })
+  }
+
+  open(workspaces: Workspace[], onSelect: (workspace: Workspace) => void): void {
+    this.allWorkspaces = workspaces
+    this.filteredWorkspaces = [...workspaces]
+    this.onSelectCallback = onSelect
+    this.active = true
+
+    this.searchInput.clearValue()
+    this.resultsList.setItems(workspaces.map((ws) => ws.name) as any)
+    this.resultsList.select(0)
+
+    this.overlay.show()
+    this.overlay.setFront()
+    this.searchInput.focus()
+    this.screen.render()
+  }
+
+  close(): void {
+    this.active = false
+    this.overlay.hide()
+    this.onSelectCallback = null
+    this.screen.render()
+  }
+
+  isActive(): boolean {
+    return this.active
+  }
+
+  private filterWorkspaces(query: string): void {
+    if (!query) {
+      this.filteredWorkspaces = [...this.allWorkspaces]
+    } else {
+      this.filteredWorkspaces = this.allWorkspaces.filter((ws) => fuzzyMatch(query, ws.name))
+    }
+    this.resultsList.setItems(this.filteredWorkspaces.map((ws) => ws.name) as any)
+    this.resultsList.select(0)
+    this.screen.render()
+  }
+}

package/docs/content/docs/integrations/meta.json

@@ -1,5 +0,0 @@
-{
-  "title": "Integrations",
-  "icon": "Plug",
-  "pages": ["slack", "slackbot", "discord", "discordbot", "teams", "channeltalk", "channeltalkbot"]
-}