@andocorp/cli 0.1.0

package/src/format.ts

@@ -0,0 +1,611 @@
+import * as Shared from "@ando/shared";
+import { Membership, Message } from "./types.js";
+
+type DateInput = Date | string | number | null | undefined;
+
+export const LINK_START_MARKER = "\u0000";
+export const LINK_END_MARKER = "\u0001";
+export const LINK_SEPARATOR_MARKER = "\u0002";
+const ANSI_RESET = "\u001b[0m";
+const ANSI_LINK = "\u001b[34m";
+const ANSI_CURRENT_MEMBER = "\u001b[38;2;0;224;224m";
+const ANSI_OTHER_MEMBER = "\u001b[38;2;221;221;221m";
+const ANSI_CODE_BLOCK_FOREGROUND = "\u001b[38;2;21;128;61m";
+const ANSI_ESCAPE_PATTERN = new RegExp(`${ANSI_RESET[0]}\\[[0-9;]*m`, "g");
+const ANSI_ESCAPE_AT_START_PATTERN = new RegExp(
+  `^${ANSI_RESET[0]}\\[[0-9;]*m`
+);
+
+type MessageBodyLine = {
+  text: string;
+  isCodeBlock?: boolean;
+  preserveWhitespace?: boolean;
+};
+
+function pad(value: number) {
+  return value.toString().padStart(2, "0");
+}
+
+function getMonthName(monthIndex: number) {
+  return new Intl.DateTimeFormat("en-US", {
+    month: "long",
+  }).format(new Date(2020, monthIndex, 1));
+}
+
+function stripLinkMarkers(text: string) {
+  let result = "";
+  let index = 0;
+
+  while (index < text.length) {
+    const character = text[index];
+    if (character == null) {
+      break;
+    }
+
+    if (character === LINK_START_MARKER) {
+      index += 1;
+      while (index < text.length && text[index] !== LINK_SEPARATOR_MARKER) {
+        index += 1;
+      }
+
+      if (text[index] === LINK_SEPARATOR_MARKER) {
+        index += 1;
+      }
+
+      while (index < text.length && text[index] !== LINK_END_MARKER) {
+        const linkCharacter = text[index];
+        if (linkCharacter != null) {
+          result += linkCharacter;
+        }
+        index += 1;
+      }
+
+      if (text[index] === LINK_END_MARKER) {
+        index += 1;
+      }
+
+      continue;
+    }
+
+    if (character !== LINK_END_MARKER && character !== LINK_SEPARATOR_MARKER) {
+      result += character;
+    }
+
+    index += 1;
+  }
+
+  return result;
+}
+
+export function stripAnsi(text: string) {
+  return text.replace(ANSI_ESCAPE_PATTERN, "");
+}
+
+export function getVisibleText(text: string) {
+  return stripAnsi(stripLinkMarkers(text));
+}
+
+export function getVisibleTextLength(text: string) {
+  return getVisibleText(text).length;
+}
+
+export function renderTerminalText(text: string) {
+  let rendered = "";
+  let index = 0;
+
+  while (index < text.length) {
+    const character = text[index];
+    if (character == null) {
+      break;
+    }
+
+    if (character === LINK_START_MARKER) {
+      index += 1;
+      let url = "";
+      while (index < text.length && text[index] !== LINK_SEPARATOR_MARKER) {
+        const urlCharacter = text[index];
+        if (urlCharacter != null) {
+          url += urlCharacter;
+        }
+        index += 1;
+      }
+
+      if (text[index] === LINK_SEPARATOR_MARKER) {
+        index += 1;
+      }
+
+      rendered += ANSI_LINK;
+      continue;
+    }
+
+    if (character === LINK_END_MARKER) {
+      rendered += ANSI_RESET;
+      index += 1;
+      continue;
+    }
+
+    if (character !== LINK_SEPARATOR_MARKER) {
+      rendered += character;
+    }
+
+    index += 1;
+  }
+
+  return rendered;
+}
+
+function formatLink(url: string, label: string) {
+  return `${LINK_START_MARKER}${url}${LINK_SEPARATOR_MARKER}${label}${LINK_END_MARKER}`;
+}
+
+function isUrlLikeText(text: string) {
+  try {
+    const url = new URL(text);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function getLinkLabel(part: Shared.Markup.LinkPart) {
+  const childText = part.children
+    .map((child) => (child.type === "text" ? child.value : "\n"))
+    .join("")
+    .trim();
+
+  if (childText === "") {
+    return part.url;
+  }
+
+  if (childText === part.url || isUrlLikeText(childText)) {
+    return childText;
+  }
+
+  return childText;
+}
+
+function getMessageBodyText(markdown: string) {
+  return Shared.Markup.parseParts(markdown)
+    .map((part) => {
+      if (part.type === "text") {
+        return part.value;
+      }
+
+      if (part.type === "linebreak") {
+        return "\n";
+      }
+
+      if (part.type === "mention") {
+        return `@${part.displayName}`;
+      }
+
+      if (part.type === "channel") {
+        return `#${part.displayName}`;
+      }
+
+      if (part.type === "image") {
+        return part.alt || "Image";
+      }
+
+      if (part.type === "link") {
+        return formatLink(part.url, getLinkLabel(part));
+      }
+
+      return "";
+    })
+    .join("");
+}
+
+function pushCurrentLine(lines: MessageBodyLine[], currentLine: string) {
+  lines.push({ text: currentLine });
+}
+
+export function renderCodeBlockText(text: string) {
+  return `${ANSI_CODE_BLOCK_FOREGROUND}${text}${ANSI_RESET}`;
+}
+
+function isCodeLikeLine(text: string) {
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return false;
+  }
+
+  return (
+    /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|URIError|EvalError|AggregateError):/.test(
+      trimmed
+    ) ||
+    /^at\s+\S+/.test(trimmed) ||
+    /^Caused by:/.test(trimmed) ||
+    /^Traceback \(most recent call last\):/.test(trimmed) ||
+    /:[0-9]+(?::[0-9]+)?\)?$/.test(trimmed)
+  );
+}
+
+function startsImplicitCodeBlock(lines: string[], index: number) {
+  if (!isCodeLikeLine(lines[index] ?? "")) {
+    return false;
+  }
+
+  return isCodeLikeLine(lines[index + 1] ?? "");
+}
+
+function getRenderedLinesFromMarkdownSegment(markdown: string): MessageBodyLine[] {
+  const parts = Shared.Markup.parseParts(markdown);
+  const lines: MessageBodyLine[] = [];
+  let currentLine = "";
+
+  for (const part of parts) {
+    if (part.type === "text") {
+      currentLine += part.value;
+      continue;
+    }
+
+    if (part.type === "linebreak") {
+      pushCurrentLine(lines, currentLine);
+      currentLine = "";
+      continue;
+    }
+
+    if (part.type === "mention") {
+      currentLine += `@${part.displayName}`;
+      continue;
+    }
+
+    if (part.type === "channel") {
+      currentLine += `#${part.displayName}`;
+      continue;
+    }
+
+    if (part.type === "image") {
+      currentLine += part.alt || "Image";
+      continue;
+    }
+
+    if (part.type === "link") {
+      currentLine += formatLink(part.url, getLinkLabel(part));
+    }
+  }
+
+  pushCurrentLine(lines, currentLine);
+  return lines;
+}
+
+function parseMessageBodyLines(markdown: string): MessageBodyLine[] {
+  const normalizedMarkdown = markdown.replace(/\r\n/g, "\n");
+  const lines = normalizedMarkdown.split("\n");
+  const renderedLines: MessageBodyLine[] = [];
+  const markdownBuffer: string[] = [];
+  let codeFenceLanguage: string | null = null;
+  let codeBuffer: string[] = [];
+
+  const flushMarkdownBuffer = () => {
+    if (markdownBuffer.length === 0) {
+      return;
+    }
+
+    renderedLines.push(
+      ...getRenderedLinesFromMarkdownSegment(markdownBuffer.join("\n"))
+    );
+    markdownBuffer.length = 0;
+  };
+
+  const flushCodeBuffer = () => {
+    if (codeBuffer.length === 0) {
+      renderedLines.push({
+        text: "",
+        isCodeBlock: true,
+        preserveWhitespace: true,
+      });
+    } else {
+      for (const line of codeBuffer) {
+        renderedLines.push({
+          text: line,
+          isCodeBlock: true,
+          preserveWhitespace: true,
+        });
+      }
+    }
+
+    codeBuffer = [];
+    codeFenceLanguage = null;
+  };
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const fenceMatch = /^```(.*)$/.exec(line);
+    if (fenceMatch) {
+      if (codeFenceLanguage == null) {
+        flushMarkdownBuffer();
+        codeFenceLanguage = fenceMatch[1]?.trim() || null;
+        codeBuffer = [];
+      } else {
+        flushCodeBuffer();
+      }
+      continue;
+    }
+
+    if (codeFenceLanguage != null) {
+      codeBuffer.push(line);
+      continue;
+    }
+
+    if (startsImplicitCodeBlock(lines, index)) {
+      flushMarkdownBuffer();
+      codeBuffer = [line];
+
+      let nextIndex = index + 1;
+      while (nextIndex < lines.length) {
+        const nextLine = lines[nextIndex] ?? "";
+        if (!isCodeLikeLine(nextLine)) {
+          break;
+        }
+
+        codeBuffer.push(nextLine);
+        nextIndex += 1;
+      }
+
+      flushCodeBuffer();
+      index = nextIndex - 1;
+      continue;
+    }
+
+    markdownBuffer.push(line);
+  }
+
+  flushMarkdownBuffer();
+  if (codeFenceLanguage != null) {
+    flushCodeBuffer();
+  }
+
+  return renderedLines;
+}
+
+export function formatDateTime(value: DateInput) {
+  if (value == null) {
+    return "";
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  return `${pad(date.getDate())}/${pad(date.getMonth() + 1)} ${pad(
+    date.getHours()
+  )}:${pad(date.getMinutes())}`;
+}
+
+export function formatTime(value: DateInput) {
+  if (value == null) {
+    return "";
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+
+export function formatDateSeparator(value: DateInput) {
+  if (value == null) {
+    return "";
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  const baseLabel = `${getMonthName(date.getMonth())} ${date.getDate()}`;
+  const currentYear = new Date().getFullYear();
+
+  if (date.getFullYear() === currentYear) {
+    return baseLabel;
+  }
+
+  return `${baseLabel} '${date.getFullYear().toString().slice(-2)}`;
+}
+
+export function truncate(text: string, width: number) {
+  if (width <= 0) {
+    return "";
+  }
+
+  const visibleText = getVisibleText(text);
+  if (visibleText.length <= width) {
+    return text;
+  }
+
+  if (width <= 1) {
+    return visibleText.slice(0, width);
+  }
+
+  let visibleCount = 0;
+  let result = "";
+
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (character == null) {
+      break;
+    }
+
+    if (character === "\u001b") {
+      const ansiMatch = ANSI_ESCAPE_AT_START_PATTERN.exec(text.slice(index));
+      if (ansiMatch != null) {
+        result += ansiMatch[0];
+        index += ansiMatch[0].length - 1;
+        continue;
+      }
+    }
+
+    if (character === LINK_START_MARKER || character === LINK_END_MARKER) {
+      result += character;
+      if (character === LINK_START_MARKER) {
+        index += 1;
+        while (index < text.length) {
+          const linkCharacter = text[index];
+          if (linkCharacter == null) {
+            break;
+          }
+
+          result += linkCharacter;
+          if (linkCharacter === LINK_SEPARATOR_MARKER) {
+            break;
+          }
+          index += 1;
+        }
+      }
+      continue;
+    }
+
+    if (visibleCount >= width - 1) {
+      break;
+    }
+
+    result += character;
+    visibleCount += 1;
+  }
+
+  return `${result}…`;
+}
+
+export function padVisibleEnd(text: string, width: number) {
+  const visibleLength = getVisibleTextLength(text);
+  if (visibleLength >= width) {
+    return text;
+  }
+
+  return `${text}${" ".repeat(width - visibleLength)}`;
+}
+
+export function getConversationLabel(membership: Membership) {
+  const prefix =
+    membership.conversation.type === Shared.Models.ConversationType.CHANNEL
+      ? "#"
+      : "@";
+
+  return `${prefix}${membership.conversation.name || membership.conversation.id}`;
+}
+
+export function getMessageBody(message: Message) {
+  const body = message.markdown_content?.trim();
+  if (body) {
+    return getMessageBodyText(body).replace(/\s+/g, " ").trim();
+  }
+
+  if (message.image_urls.length > 0) {
+    return `[${message.image_urls.length} image attachment${message.image_urls.length === 1 ? "" : "s"}]`;
+  }
+
+  if (message.files.length > 0) {
+    return `[${message.files.length} file attachment${message.files.length === 1 ? "" : "s"}]`;
+  }
+
+  if (message.call_id != null) {
+    return "[Jam started]";
+  }
+
+  return "[empty message]";
+}
+
+export function getMessageBodyLines(message: Message) {
+  const body = message.markdown_content?.trim();
+  if (body) {
+    return parseMessageBodyLines(body);
+  }
+
+  return [{ text: getMessageBody(message) }];
+}
+
+export function formatReactionSummary(message: Message) {
+  if (message.message_reactions.length === 0) {
+    return "";
+  }
+
+  const groupedEmojis: string[] = [];
+  let currentEmoji = "";
+  let currentCount = 0;
+
+  const pushCurrentEmoji = () => {
+    if (currentCount === 0) {
+      return;
+    }
+
+    groupedEmojis.push(currentEmoji.repeat(currentCount));
+  };
+
+  for (const reaction of message.message_reactions) {
+    if (reaction.emoji_text === currentEmoji) {
+      currentCount += 1;
+      continue;
+    }
+
+    pushCurrentEmoji();
+    currentEmoji = reaction.emoji_text;
+    currentCount = 1;
+  }
+
+  pushCurrentEmoji();
+
+  return groupedEmojis.join(" ");
+}
+
+export function formatMessageFooter(message: Message) {
+  const parts: string[] = [];
+  const reactions = formatReactionSummary(message);
+
+  if (message.replies_count > 0) {
+    parts.push(
+      `[${message.replies_count} ${message.replies_count === 1 ? "reply" : "replies"}]`
+    );
+  }
+
+  if (reactions !== "") {
+    parts.push(reactions);
+  }
+
+  return parts.join(" ");
+}
+
+export function formatMessageHeaderParts(
+  message: Message,
+  options?: {
+    currentMemberId?: string | null;
+  }
+) {
+  const timestamp = formatTime(message.created_at);
+  const author = message.author.display_name ?? message.author.email ?? "Unknown";
+  const renderedAuthor =
+    options?.currentMemberId != null && message.author.id === options.currentMemberId
+      ? `${ANSI_CURRENT_MEMBER}${author}${ANSI_RESET}`
+      : `${ANSI_OTHER_MEMBER}${author}${ANSI_RESET}`;
+
+  return {
+    timestamp,
+    author: renderedAuthor,
+  };
+}
+
+export function formatMessageLine(
+  message: Message,
+  options?: {
+    currentMemberId?: string | null;
+  }
+) {
+  const parts = [
+    formatDateTime(message.created_at),
+    options?.currentMemberId != null && message.author.id === options.currentMemberId
+      ? `${ANSI_CURRENT_MEMBER}${truncate(
+          message.author.display_name ?? message.author.email ?? "Unknown",
+          20
+        )}${ANSI_RESET}`
+      : truncate(message.author.display_name ?? message.author.email ?? "Unknown", 20),
+    getMessageBody(message),
+  ];
+  const footer = formatMessageFooter(message);
+  const footerSuffix = footer === "" ? "" : ` | ${footer}`;
+
+  return renderTerminalText(`${parts.filter(Boolean).join(" | ")}${footerSuffix}`);
+}

package/src/help.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { buildHelpText } from "./help.js";
+
+describe("help", () => {
+  it("describes interactive mode and command surface", () => {
+    const helpText = buildHelpText();
+
+    expect(helpText).toContain("Interactive Mode:");
+    expect(helpText).toContain("ando list-channels");
+    expect(helpText).toContain("[u] Older");
+    expect(helpText).toContain("--convex-url <url>");
+  });
+});

package/src/help.ts

@@ -0,0 +1,48 @@
+import { getConfigPath } from "./config.js";
+
+export function buildHelpText() {
+  return `
+ando
+
+Usage:
+  ando                                 Open the interactive terminal UI
+  ando login [--email <email>] [--workspace <id|slug|name>] [--convex-url <url>]
+  ando list-channels [--json]
+  ando list-dms [--json]
+  ando list-messages (--channel <query> | --dm <query> | --conversation <id>) [--limit <n>] [--json]
+  ando thread --message-id <id> [--json]
+  ando post-message (--channel <query> | --dm <query> | --conversation <id>) --text <markdown> [--json]
+  ando reply --message-id <id> --text <markdown> [--json]
+  ando react --message-id <id> --emoji <emoji> [--json]
+
+Authentication:
+  login runs the same email-OTP + workspace-selection flow the web app uses,
+  then stores the selected workspace session in:
+    ${getConfigPath()}
+
+Environment:
+  ANDO_CONVEX_URL        Convex deployment URL
+  VITE_CONVEX_URL        Fallback Convex URL
+  NEXT_PUBLIC_CONVEX_URL Fallback Convex URL
+  ANDO_SESSION_JWT       Override saved session token for one run
+
+Interactive Mode:
+  Running plain "ando" opens a keyboard-driven terminal client for browsing
+  channels and DMs, reading messages and threads, paging older and newer
+  history, posting messages, replying in threads, and adding reactions.
+
+Interactive Keys:
+  [c] Channels   [d] DMs   [/] Search   [Tab] Focus panes
+  [Enter] Open   [t] Thread   [u] Older   [n] Newer
+  [p] Post       [r] Reply    [a] React   [b] Back   [q] Quit
+
+Examples:
+  ando login --email alex@ando.so
+  ando list-channels
+  ando list-messages -c engineering -n 20
+  ando thread -m <message-id>
+  ando post-message -c engineering -t "hello"
+  ando reply -m <message-id> -t "on it"
+  ando react -m <message-id> -e 👍
+`.trim();
+}