@andocorp/cli 0.1.0

package/src/components/transcript-pane.ts

@@ -0,0 +1,457 @@
+import {
+  formatDateSeparator,
+  formatMessageFooter,
+  formatMessageHeaderParts,
+  getMessageBody,
+  getMessageBodyLines,
+  getVisibleTextLength,
+  LINK_END_MARKER,
+  LINK_SEPARATOR_MARKER,
+  LINK_START_MARKER,
+  renderCodeBlockText,
+  renderTerminalText,
+  truncate,
+} from "../format.js";
+import { Message } from "../types.js";
+
+const ANSI_RESET = "\u001b[0m";
+const ANSI_MESSAGE_HEADER = "\u001b[38;5;248m";
+const ANSI_SELECTION_MARKER = "\u001b[38;2;255;215;0m";
+
+type InlineSegment = {
+  text: string;
+  url?: string;
+};
+
+type InlineToken = {
+  text: string;
+  visibleLength: number;
+  url?: string;
+};
+
+function getSelectedItemPrefix(params: {
+  isFocusedPane: boolean;
+  isSelected: boolean;
+}) {
+  if (!params.isSelected) {
+    return " ";
+  }
+
+  return `${ANSI_SELECTION_MARKER}${params.isFocusedPane ? ">" : "-"}${ANSI_RESET}`;
+}
+
+function formatLinkedText(url: string, text: string) {
+  return `${LINK_START_MARKER}${url}${LINK_SEPARATOR_MARKER}${text}${LINK_END_MARKER}`;
+}
+
+function parseInlineSegments(text: string): InlineSegment[] {
+  const segments: InlineSegment[] = [];
+  let buffer = "";
+  let index = 0;
+
+  const flushBuffer = () => {
+    if (buffer === "") {
+      return;
+    }
+
+    segments.push({ text: buffer });
+    buffer = "";
+  };
+
+  while (index < text.length) {
+    const character = text[index];
+    if (character == null) {
+      break;
+    }
+
+    if (character !== LINK_START_MARKER) {
+      buffer += character;
+      index += 1;
+      continue;
+    }
+
+    flushBuffer();
+    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;
+    }
+
+    let label = "";
+    while (index < text.length && text[index] !== LINK_END_MARKER) {
+      const labelCharacter = text[index];
+      if (labelCharacter != null) {
+        label += labelCharacter;
+      }
+      index += 1;
+    }
+
+    if (text[index] === LINK_END_MARKER) {
+      index += 1;
+    }
+
+    segments.push({ text: label, url });
+  }
+
+  flushBuffer();
+  return segments;
+}
+
+function splitToken(token: InlineToken, width: number) {
+  const chunks: InlineToken[] = [];
+  for (let index = 0; index < token.text.length; index += width) {
+    const chunkText = token.text.slice(index, index + width);
+    chunks.push({
+      text: chunkText,
+      visibleLength: chunkText.length,
+      url: token.url,
+    });
+  }
+
+  return chunks;
+}
+
+function tokenizeInlineSegments(text: string): InlineToken[] {
+  const tokens: InlineToken[] = [];
+
+  for (const segment of parseInlineSegments(text)) {
+    let buffer = "";
+    for (const character of segment.text) {
+      if (character === " ") {
+        if (buffer !== "") {
+          tokens.push({
+            text: buffer,
+            visibleLength: buffer.length,
+            url: segment.url,
+          });
+          buffer = "";
+        }
+
+        tokens.push({
+          text: " ",
+          visibleLength: 1,
+        });
+        continue;
+      }
+
+      buffer += character;
+    }
+
+    if (buffer !== "") {
+      tokens.push({
+        text: buffer,
+        visibleLength: buffer.length,
+        url: segment.url,
+      });
+    }
+  }
+
+  return tokens;
+}
+
+function renderInlineTokens(tokens: InlineToken[]) {
+  return tokens
+    .map((token) =>
+      token.url == null ? token.text : formatLinkedText(token.url, token.text)
+    )
+    .join("");
+}
+
+function wrapLine(text: string, width: number) {
+  if (width <= 0) {
+    return [];
+  }
+
+  const tokens = tokenizeInlineSegments(text);
+  const lines: string[] = [];
+  let currentTokens: InlineToken[] = [];
+  let currentLength = 0;
+
+  const pushCurrentLine = () => {
+    while (currentTokens[0]?.text === " ") {
+      currentTokens.shift();
+    }
+
+    while (currentTokens[currentTokens.length - 1]?.text === " ") {
+      currentTokens.pop();
+    }
+
+    if (currentTokens.length === 0) {
+      return;
+    }
+
+    lines.push(renderInlineTokens(currentTokens));
+    currentTokens = [];
+    currentLength = 0;
+  };
+
+  for (const token of tokens) {
+    if (token.text === " ") {
+      if (currentLength === 0) {
+        continue;
+      }
+
+      if (currentLength + 1 <= width) {
+        currentTokens.push(token);
+        currentLength += 1;
+      } else {
+        pushCurrentLine();
+      }
+      continue;
+    }
+
+    if (token.visibleLength <= width - currentLength) {
+      currentTokens.push(token);
+      currentLength += token.visibleLength;
+      continue;
+    }
+
+    if (currentLength > 0) {
+      pushCurrentLine();
+    }
+
+    if (token.visibleLength <= width) {
+      currentTokens.push(token);
+      currentLength = token.visibleLength;
+      continue;
+    }
+
+    for (const chunk of splitToken(token, width)) {
+      lines.push(renderInlineTokens([chunk]));
+    }
+  }
+
+  pushCurrentLine();
+  return lines;
+}
+
+function wrapPreformattedLine(text: string, width: number) {
+  if (width <= 0) {
+    return [];
+  }
+
+  if (getVisibleTextLength(text) <= width) {
+    return [text];
+  }
+
+  const lines: string[] = [];
+  for (const segment of parseInlineSegments(text)) {
+    if (segment.text === "") {
+      continue;
+    }
+
+    for (let index = 0; index < segment.text.length; index += width) {
+      const chunk = segment.text.slice(index, index + width);
+      lines.push(
+        segment.url == null ? chunk : formatLinkedText(segment.url, chunk)
+      );
+    }
+  }
+
+  return lines;
+}
+
+function centerText(text: string, width: number) {
+  if (width <= 0) {
+    return "";
+  }
+
+  if (text.length >= width) {
+    return truncate(text, width);
+  }
+
+  const leftPadding = Math.floor((width - text.length) / 2);
+  return `${" ".repeat(leftPadding)}${text}`;
+}
+
+function colorMessageHeader(text: string) {
+  return `${ANSI_MESSAGE_HEADER}${text}${ANSI_RESET}`;
+}
+
+function getMessageDateKey(value: Date | string | number | null | undefined) {
+  if (value == null) {
+    return "";
+  }
+
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+
+  return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
+}
+
+export function renderTranscriptLines(params: {
+  items: Message[];
+  selectedIndex: number;
+  width: number;
+  bodyRows: number;
+  isFocusedPane: boolean;
+  currentMemberId?: string | null;
+}) {
+  const {
+    items,
+    selectedIndex,
+    width,
+    bodyRows,
+    isFocusedPane,
+    currentMemberId,
+  } = params;
+
+  if (width <= 0 || bodyRows <= 0) {
+    return {
+      lines: [],
+      hasAbove: false,
+      hasBelow: false,
+    };
+  }
+
+  const blocks = items.map((message, index) => {
+    const previousMessage = index > 0 ? items[index - 1] : null;
+    const showDateSeparator =
+      previousMessage == null ||
+      getMessageDateKey(previousMessage.created_at) !==
+        getMessageDateKey(message.created_at);
+
+    const prefix = getSelectedItemPrefix({
+      isFocusedPane,
+      isSelected: index === selectedIndex,
+    });
+    const contentWidth = Math.max(8, width - 4);
+    const bodyLines = getMessageBodyLines(message).flatMap((line) => {
+      const wrappedLine = line.preserveWhitespace
+        ? wrapPreformattedLine(line.text, contentWidth)
+        : wrapLine(line.text, contentWidth);
+
+      if (wrappedLine.length > 0) {
+        return wrappedLine.map((text) => ({
+          text,
+          isCodeBlock: line.isCodeBlock === true,
+        }));
+      }
+
+      return [{ text: line.text, isCodeBlock: line.isCodeBlock === true }];
+    });
+    const renderedBodyLines =
+      bodyLines.length > 0
+        ? bodyLines
+        : [{ text: getMessageBody(message), isCodeBlock: false }];
+    const footer = formatMessageFooter(message);
+
+    const lines: { text: string; isCodeBlock?: boolean; isHeader: boolean }[] = [];
+    if (showDateSeparator) {
+      lines.push({
+        text: centerText(formatDateSeparator(message.created_at), width),
+        isHeader: false,
+      });
+    }
+
+    lines.push({
+      text: (() => {
+        const header = formatMessageHeaderParts(message, { currentMemberId });
+        return `${prefix} ${colorMessageHeader(header.timestamp)} ${header.author}`;
+      })(),
+      isHeader: true,
+    });
+
+    for (let bodyLineIndex = 0; bodyLineIndex < renderedBodyLines.length; bodyLineIndex += 1) {
+      const line = renderedBodyLines[bodyLineIndex];
+      if (line == null) {
+        continue;
+      }
+
+      if (line.isCodeBlock === true) {
+        const codeBlockLines = [line.text];
+        let nextIndex = bodyLineIndex + 1;
+        while (nextIndex < renderedBodyLines.length) {
+          const nextLine = renderedBodyLines[nextIndex];
+          if (nextLine?.isCodeBlock !== true) {
+            break;
+          }
+
+          codeBlockLines.push(nextLine.text);
+          nextIndex += 1;
+        }
+
+        const codeBlockWidth = Math.max(
+          1,
+          ...codeBlockLines.map((codeLine) => getVisibleTextLength(codeLine))
+        );
+
+        lines.push({
+          text: `  ┌${"─".repeat(codeBlockWidth + 2)}┐`,
+          isHeader: false,
+        });
+
+        for (const codeLine of codeBlockLines) {
+          const visibleLength = getVisibleTextLength(codeLine);
+          lines.push({
+            text: `  │ ${renderCodeBlockText(codeLine)}${" ".repeat(codeBlockWidth - visibleLength)} │`,
+            isHeader: false,
+          });
+        }
+
+        lines.push({
+          text: `  └${"─".repeat(codeBlockWidth + 2)}┘`,
+          isHeader: false,
+        });
+
+        bodyLineIndex = nextIndex - 1;
+        continue;
+      }
+
+      lines.push({
+        text: `  ${line.text}`,
+        isHeader: false,
+      });
+    }
+
+    if (footer !== "") {
+      lines.push({ text: `  ${footer}`, isHeader: false });
+    }
+
+    return { index, lines };
+  });
+
+  const selectedBlockIndex = blocks.findIndex((block) => block.index === selectedIndex);
+  const safeSelectedBlockIndex = selectedBlockIndex === -1 ? 0 : selectedBlockIndex;
+
+  let visibleStart = 0;
+  let visibleEnd = blocks.length;
+  let visibleLineCount = blocks.reduce((sum, block) => sum + block.lines.length, 0);
+
+  while (visibleLineCount > bodyRows && visibleStart < safeSelectedBlockIndex) {
+    visibleLineCount -= blocks[visibleStart]?.lines.length ?? 0;
+    visibleStart += 1;
+  }
+
+  while (visibleLineCount > bodyRows && visibleEnd - 1 > safeSelectedBlockIndex) {
+    visibleEnd -= 1;
+    visibleLineCount -= blocks[visibleEnd]?.lines.length ?? 0;
+  }
+
+  const renderedLines = blocks
+    .slice(visibleStart, visibleEnd)
+    .flatMap((block) => block.lines)
+    .slice(0, bodyRows)
+    .map((line) => {
+      const truncatedText = truncate(line.text, width);
+      const coloredText = renderTerminalText(truncatedText);
+      return line.isHeader ? colorMessageHeader(coloredText) : coloredText;
+    });
+
+  return {
+    lines: renderedLines,
+    hasAbove: visibleStart > 0,
+    hasBelow: visibleEnd < blocks.length,
+  };
+}

package/src/config.ts

@@ -0,0 +1,53 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SavedConfig } from "./types.js";
+
+type SavedConfigFile = SavedConfig & {
+  savedAt: string;
+};
+
+export function getConfigPath() {
+  return path.join(os.homedir(), ".config", "ando", "config.json");
+}
+
+export async function readSavedConfig(): Promise<SavedConfig | null> {
+  try {
+    const raw = await readFile(getConfigPath(), "utf8");
+    const parsed = JSON.parse(raw) as Partial<SavedConfigFile>;
+    if (
+      typeof parsed.sessionToken !== "string" ||
+      parsed.sessionToken.trim() === "" ||
+      typeof parsed.convexUrl !== "string" ||
+      parsed.convexUrl.trim() === ""
+    ) {
+      return null;
+    }
+
+    return {
+      sessionToken: parsed.sessionToken,
+      convexUrl: parsed.convexUrl,
+    };
+  } catch (error) {
+    const errorCode =
+      error instanceof Error && "code" in error ? error.code : undefined;
+    if (errorCode === "ENOENT") {
+      return null;
+    }
+
+    throw error;
+  }
+}
+
+export async function saveConfig(config: SavedConfig) {
+  const configPath = getConfigPath();
+  await mkdir(path.dirname(configPath), { recursive: true });
+  const payload: SavedConfigFile = {
+    ...config,
+    savedAt: new Date().toISOString(),
+  };
+
+  await writeFile(configPath, JSON.stringify(payload, null, 2), {
+    mode: 0o600,
+  });
+}

package/src/emoji-suggestions.ts

@@ -0,0 +1,152 @@
+import emojiData from "emojibase-data/en/data.json" with { type: "json" };
+import shortcodeData from "emojibase-data/en/shortcodes/cldr.json" with { type: "json" };
+
+type EmojiSuggestion = {
+  emoji: string;
+  label: string;
+  shortcode: string;
+  keywords: string[];
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function getString(value: unknown): string | null {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+
+function getStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value.filter((item): item is string => typeof item === "string" && item !== "");
+}
+
+function getPrimaryShortcode(value: unknown): string | null {
+  if (typeof value === "string" && value !== "") {
+    return value;
+  }
+
+  if (!Array.isArray(value)) {
+    return null;
+  }
+
+  return (
+    value.find(
+      (item): item is string => typeof item === "string" && item !== ""
+    ) ?? null
+  );
+}
+
+function buildEmojiSuggestions(): EmojiSuggestion[] {
+  const suggestions: EmojiSuggestion[] = [];
+  const rawShortcodes: Record<string, unknown> = isRecord(shortcodeData)
+    ? shortcodeData
+    : {};
+
+  for (const entry of emojiData) {
+    if (!isRecord(entry)) {
+      continue;
+    }
+
+    const emoji = getString(entry.emoji);
+    const label = getString(entry.label);
+    const hexcode = getString(entry.hexcode);
+    if (emoji == null || label == null || hexcode == null) {
+      continue;
+    }
+
+    const shortcode = getPrimaryShortcode(rawShortcodes[hexcode]);
+    if (shortcode == null) {
+      continue;
+    }
+
+    const keywords = Array.from(
+      new Set(
+        [...getStringArray(entry.tags), ...label.toLowerCase().split(/\s+/)]
+          .map((word) => word.trim())
+          .filter((word) => word !== "")
+      )
+    );
+
+    suggestions.push({
+      emoji,
+      label,
+      shortcode,
+      keywords,
+    });
+  }
+
+  return suggestions;
+}
+
+const emojiSuggestions = buildEmojiSuggestions();
+
+function scoreSuggestion(suggestion: EmojiSuggestion, query: string) {
+  let score = 0;
+  const normalizedLabel = suggestion.label.toLowerCase();
+
+  if (suggestion.shortcode === query) {
+    score = 1000;
+  } else if (suggestion.shortcode.startsWith(query)) {
+    score = 500;
+  } else if (suggestion.shortcode.includes(query)) {
+    score = 120;
+  }
+
+  if (normalizedLabel === query) {
+    score = Math.max(score, 800);
+  } else if (normalizedLabel.startsWith(query)) {
+    score = Math.max(score, 350);
+  } else if (normalizedLabel.includes(query)) {
+    score = Math.max(score, 80);
+  }
+
+  for (const keyword of suggestion.keywords) {
+    if (keyword === query) {
+      score = Math.max(score, 250);
+      continue;
+    }
+
+    if (keyword.startsWith(query)) {
+      score = Math.max(score, 150);
+      continue;
+    }
+
+    if (keyword.includes(query)) {
+      score = Math.max(score, 40);
+    }
+  }
+
+  return score;
+}
+
+function getSuggestionQuery(value: string) {
+  const match = value.toLowerCase().match(/(?:^|[\s:])([a-z][a-z0-9_+-]{0,31})$/);
+  return match?.[1] ?? "";
+}
+
+export function getEmojiSuggestions(value: string, limit = 5): EmojiSuggestion[] {
+  const query = getSuggestionQuery(value);
+  if (query === "") {
+    return [];
+  }
+
+  return emojiSuggestions
+    .map((suggestion) => ({
+      suggestion,
+      score: scoreSuggestion(suggestion, query),
+    }))
+    .filter((entry) => entry.score > 0)
+    .sort((left, right) => {
+      if (right.score !== left.score) {
+        return right.score - left.score;
+      }
+
+      return left.suggestion.shortcode.localeCompare(right.suggestion.shortcode);
+    })
+    .slice(0, limit)
+    .map((entry) => entry.suggestion);
+}

package/src/format.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { createMessage, createReaction } from "./test-helpers.js";
+import {
+  formatReactionSummary,
+  getMessageBody,
+  getVisibleText,
+  getVisibleTextLength,
+  renderTerminalText,
+} from "./format.js";
+
+describe("format", () => {
+  it("renders markdown links as visible link labels", () => {
+    const message = createMessage({
+      markdown_content:
+        "to leave comments in figma: [https://www.figma.com/design/file](https://www.figma.com/design/file)",
+    });
+
+    expect(getVisibleText(getMessageBody(message))).toBe(
+      "to leave comments in figma: https://www.figma.com/design/file"
+    );
+  });
+
+  it("renders markdown links in blue without hyperlink escapes", () => {
+    const message = createMessage({
+      markdown_content: "[Figma file](https://www.figma.com/design/file)",
+    });
+
+    expect(renderTerminalText(getMessageBody(message))).toBe(
+      "\u001b[34mFigma file\u001b[0m"
+    );
+  });
+
+  it("treats terminal color escape sequences as zero-width", () => {
+    const message = createMessage({
+      markdown_content: "[Figma file](https://www.figma.com/design/file)",
+    });
+
+    expect(getVisibleTextLength(renderTerminalText(getMessageBody(message)))).toBe(
+      "Figma file".length
+    );
+  });
+
+  it("renders identical reactions without spacing them apart", () => {
+    const message = createMessage({
+      message_reactions: [
+        createReaction({ id: "reaction-1", emoji_text: "🔥" }),
+        createReaction({ id: "reaction-2", emoji_text: "🔥" }),
+        createReaction({ id: "reaction-3", emoji_text: "🔥" }),
+      ],
+    });
+
+    expect(formatReactionSummary(message)).toBe("🔥🔥🔥");
+  });
+});