feat: Add Line plugin (#1630)

* feat: add LINE plugin (#1630) (thanks @plum-dawg) * feat: complete LINE plugin (#1630) (thanks @plum-dawg) * chore: drop line plugin node_modules (#1630) (thanks @plum-dawg) * test: mock /context report in commands test (#1630) (thanks @plum-dawg) * test: limit macOS CI workers to avoid OOM (#1630) (thanks @plum-dawg) * test: reduce macOS CI vitest workers (#1630) (thanks @plum-dawg) --------- Co-authored-by: Peter Steinberger <steipete@gmail.com>
2026-05-08 18:38:28 +00:00 · 2026-01-25 07:22:36 -05:00
parent 101d0f451f
commit c96ffa7186
85 changed files with 11365 additions and 60 deletions
--- a/src/line/markdown-to-line.test.ts
+++ b/src/line/markdown-to-line.test.ts
@@ -0,0 +1,449 @@
+import { describe, expect, it } from "vitest";
+import {
+  extractMarkdownTables,
+  extractCodeBlocks,
+  extractLinks,
+  stripMarkdown,
+  processLineMessage,
+  convertTableToFlexBubble,
+  convertCodeBlockToFlexBubble,
+  hasMarkdownToConvert,
+} from "./markdown-to-line.js";
+
+describe("extractMarkdownTables", () => {
+  it("extracts a simple 2-column table", () => {
+    const text = `Here is a table:
+
+| Name | Value |
+|------|-------|
+| foo  | 123   |
+| bar  | 456   |
+
+And some more text.`;
+
+    const { tables, textWithoutTables } = extractMarkdownTables(text);
+
+    expect(tables).toHaveLength(1);
+    expect(tables[0].headers).toEqual(["Name", "Value"]);
+    expect(tables[0].rows).toEqual([
+      ["foo", "123"],
+      ["bar", "456"],
+    ]);
+    expect(textWithoutTables).toContain("Here is a table:");
+    expect(textWithoutTables).toContain("And some more text.");
+    expect(textWithoutTables).not.toContain("|");
+  });
+
+  it("extracts a multi-column table", () => {
+    const text = `| Col A | Col B | Col C |
+|-------|-------|-------|
+| 1     | 2     | 3     |
+| a     | b     | c     |`;
+
+    const { tables } = extractMarkdownTables(text);
+
+    expect(tables).toHaveLength(1);
+    expect(tables[0].headers).toEqual(["Col A", "Col B", "Col C"]);
+    expect(tables[0].rows).toHaveLength(2);
+  });
+
+  it("extracts multiple tables", () => {
+    const text = `Table 1:
+
+| A | B |
+|---|---|
+| 1 | 2 |
+
+Table 2:
+
+| X | Y |
+|---|---|
+| 3 | 4 |`;
+
+    const { tables } = extractMarkdownTables(text);
+
+    expect(tables).toHaveLength(2);
+    expect(tables[0].headers).toEqual(["A", "B"]);
+    expect(tables[1].headers).toEqual(["X", "Y"]);
+  });
+
+  it("handles tables with alignment markers", () => {
+    const text = `| Left | Center | Right |
+|:-----|:------:|------:|
+| a    | b      | c     |`;
+
+    const { tables } = extractMarkdownTables(text);
+
+    expect(tables).toHaveLength(1);
+    expect(tables[0].headers).toEqual(["Left", "Center", "Right"]);
+    expect(tables[0].rows).toEqual([["a", "b", "c"]]);
+  });
+
+  it("returns empty when no tables present", () => {
+    const text = "Just some plain text without tables.";
+
+    const { tables, textWithoutTables } = extractMarkdownTables(text);
+
+    expect(tables).toHaveLength(0);
+    expect(textWithoutTables).toBe(text);
+  });
+});
+
+describe("extractCodeBlocks", () => {
+  it("extracts a code block with language", () => {
+    const text = `Here is some code:
+
+\`\`\`javascript
+const x = 1;
+console.log(x);
+\`\`\`
+
+And more text.`;
+
+    const { codeBlocks, textWithoutCode } = extractCodeBlocks(text);
+
+    expect(codeBlocks).toHaveLength(1);
+    expect(codeBlocks[0].language).toBe("javascript");
+    expect(codeBlocks[0].code).toBe("const x = 1;\nconsole.log(x);");
+    expect(textWithoutCode).toContain("Here is some code:");
+    expect(textWithoutCode).toContain("And more text.");
+    expect(textWithoutCode).not.toContain("```");
+  });
+
+  it("extracts a code block without language", () => {
+    const text = `\`\`\`
+plain code
+\`\`\``;
+
+    const { codeBlocks } = extractCodeBlocks(text);
+
+    expect(codeBlocks).toHaveLength(1);
+    expect(codeBlocks[0].language).toBeUndefined();
+    expect(codeBlocks[0].code).toBe("plain code");
+  });
+
+  it("extracts multiple code blocks", () => {
+    const text = `\`\`\`python
+print("hello")
+\`\`\`
+
+Some text
+
+\`\`\`bash
+echo "world"
+\`\`\``;
+
+    const { codeBlocks } = extractCodeBlocks(text);
+
+    expect(codeBlocks).toHaveLength(2);
+    expect(codeBlocks[0].language).toBe("python");
+    expect(codeBlocks[1].language).toBe("bash");
+  });
+
+  it("returns empty when no code blocks present", () => {
+    const text = "No code here, just text.";
+
+    const { codeBlocks, textWithoutCode } = extractCodeBlocks(text);
+
+    expect(codeBlocks).toHaveLength(0);
+    expect(textWithoutCode).toBe(text);
+  });
+});
+
+describe("extractLinks", () => {
+  it("extracts markdown links", () => {
+    const text = "Check out [Google](https://google.com) and [GitHub](https://github.com).";
+
+    const { links, textWithLinks } = extractLinks(text);
+
+    expect(links).toHaveLength(2);
+    expect(links[0]).toEqual({ text: "Google", url: "https://google.com" });
+    expect(links[1]).toEqual({ text: "GitHub", url: "https://github.com" });
+    expect(textWithLinks).toBe("Check out Google and GitHub.");
+  });
+
+  it("handles text without links", () => {
+    const text = "No links here.";
+
+    const { links, textWithLinks } = extractLinks(text);
+
+    expect(links).toHaveLength(0);
+    expect(textWithLinks).toBe(text);
+  });
+});
+
+describe("stripMarkdown", () => {
+  it("strips bold markers", () => {
+    expect(stripMarkdown("This is **bold** text")).toBe("This is bold text");
+    expect(stripMarkdown("This is __bold__ text")).toBe("This is bold text");
+  });
+
+  it("strips italic markers", () => {
+    expect(stripMarkdown("This is *italic* text")).toBe("This is italic text");
+    expect(stripMarkdown("This is _italic_ text")).toBe("This is italic text");
+  });
+
+  it("strips strikethrough markers", () => {
+    expect(stripMarkdown("This is ~~deleted~~ text")).toBe("This is deleted text");
+  });
+
+  it("strips headers", () => {
+    expect(stripMarkdown("# Heading 1")).toBe("Heading 1");
+    expect(stripMarkdown("## Heading 2")).toBe("Heading 2");
+    expect(stripMarkdown("### Heading 3")).toBe("Heading 3");
+  });
+
+  it("strips blockquotes", () => {
+    expect(stripMarkdown("> This is a quote")).toBe("This is a quote");
+    expect(stripMarkdown(">This is also a quote")).toBe("This is also a quote");
+  });
+
+  it("removes horizontal rules", () => {
+    expect(stripMarkdown("Above\n---\nBelow")).toBe("Above\n\nBelow");
+    expect(stripMarkdown("Above\n***\nBelow")).toBe("Above\n\nBelow");
+  });
+
+  it("strips inline code markers", () => {
+    expect(stripMarkdown("Use `const` keyword")).toBe("Use const keyword");
+  });
+
+  it("handles complex markdown", () => {
+    const input = `# Title
+
+This is **bold** and *italic* text.
+
+> A quote
+
+Some ~~deleted~~ content.`;
+
+    const result = stripMarkdown(input);
+
+    expect(result).toContain("Title");
+    expect(result).toContain("This is bold and italic text.");
+    expect(result).toContain("A quote");
+    expect(result).toContain("Some deleted content.");
+    expect(result).not.toContain("#");
+    expect(result).not.toContain("**");
+    expect(result).not.toContain("~~");
+    expect(result).not.toContain(">");
+  });
+});
+
+describe("convertTableToFlexBubble", () => {
+  it("creates a receipt-style card for 2-column tables", () => {
+    const table = {
+      headers: ["Item", "Price"],
+      rows: [
+        ["Apple", "$1"],
+        ["Banana", "$2"],
+      ],
+    };
+
+    const bubble = convertTableToFlexBubble(table);
+
+    expect(bubble.type).toBe("bubble");
+    expect(bubble.body).toBeDefined();
+  });
+
+  it("creates a multi-column layout for 3+ column tables", () => {
+    const table = {
+      headers: ["A", "B", "C"],
+      rows: [["1", "2", "3"]],
+    };
+
+    const bubble = convertTableToFlexBubble(table);
+
+    expect(bubble.type).toBe("bubble");
+    expect(bubble.body).toBeDefined();
+  });
+
+  it("replaces empty cells with placeholders", () => {
+    const table = {
+      headers: ["A", "B"],
+      rows: [["", ""]],
+    };
+
+    const bubble = convertTableToFlexBubble(table);
+    const body = bubble.body as {
+      contents: Array<{ contents?: Array<{ contents?: Array<{ text: string }> }> }>;
+    };
+    const rowsBox = body.contents[2] as { contents: Array<{ contents: Array<{ text: string }> }> };
+
+    expect(rowsBox.contents[0].contents[0].text).toBe("-");
+    expect(rowsBox.contents[0].contents[1].text).toBe("-");
+  });
+
+  it("strips bold markers and applies weight for fully bold cells", () => {
+    const table = {
+      headers: ["**Name**", "Status"],
+      rows: [["**Alpha**", "OK"]],
+    };
+
+    const bubble = convertTableToFlexBubble(table);
+    const body = bubble.body as {
+      contents: Array<{ contents?: Array<{ text: string; weight?: string }> }>;
+    };
+    const headerRow = body.contents[0] as { contents: Array<{ text: string; weight?: string }> };
+    const dataRow = body.contents[2] as { contents: Array<{ text: string; weight?: string }> };
+
+    expect(headerRow.contents[0].text).toBe("Name");
+    expect(headerRow.contents[0].weight).toBe("bold");
+    expect(dataRow.contents[0].text).toBe("Alpha");
+    expect(dataRow.contents[0].weight).toBe("bold");
+  });
+});
+
+describe("convertCodeBlockToFlexBubble", () => {
+  it("creates a code card with language label", () => {
+    const block = { language: "typescript", code: "const x = 1;" };
+
+    const bubble = convertCodeBlockToFlexBubble(block);
+
+    expect(bubble.type).toBe("bubble");
+    expect(bubble.body).toBeDefined();
+
+    const body = bubble.body as { contents: Array<{ text: string }> };
+    expect(body.contents[0].text).toBe("Code (typescript)");
+  });
+
+  it("creates a code card without language", () => {
+    const block = { code: "plain code" };
+
+    const bubble = convertCodeBlockToFlexBubble(block);
+
+    const body = bubble.body as { contents: Array<{ text: string }> };
+    expect(body.contents[0].text).toBe("Code");
+  });
+
+  it("truncates very long code", () => {
+    const longCode = "x".repeat(3000);
+    const block = { code: longCode };
+
+    const bubble = convertCodeBlockToFlexBubble(block);
+
+    const body = bubble.body as { contents: Array<{ contents: Array<{ text: string }> }> };
+    const codeText = body.contents[1].contents[0].text;
+    expect(codeText.length).toBeLessThan(longCode.length);
+    expect(codeText).toContain("...");
+  });
+});
+
+describe("processLineMessage", () => {
+  it("processes text with tables", () => {
+    const text = `Here's the data:
+
+| Key | Value |
+|-----|-------|
+| a   | 1     |
+
+Done.`;
+
+    const result = processLineMessage(text);
+
+    expect(result.flexMessages).toHaveLength(1);
+    expect(result.flexMessages[0].type).toBe("flex");
+    expect(result.text).toContain("Here's the data:");
+    expect(result.text).toContain("Done.");
+    expect(result.text).not.toContain("|");
+  });
+
+  it("processes text with code blocks", () => {
+    const text = `Check this code:
+
+\`\`\`js
+console.log("hi");
+\`\`\`
+
+That's it.`;
+
+    const result = processLineMessage(text);
+
+    expect(result.flexMessages).toHaveLength(1);
+    expect(result.text).toContain("Check this code:");
+    expect(result.text).toContain("That's it.");
+    expect(result.text).not.toContain("```");
+  });
+
+  it("processes text with markdown formatting", () => {
+    const text = "This is **bold** and *italic* text.";
+
+    const result = processLineMessage(text);
+
+    expect(result.text).toBe("This is bold and italic text.");
+    expect(result.flexMessages).toHaveLength(0);
+  });
+
+  it("handles mixed content", () => {
+    const text = `# Summary
+
+Here's **important** info:
+
+| Item | Count |
+|------|-------|
+| A    | 5     |
+
+\`\`\`python
+print("done")
+\`\`\`
+
+> Note: Check the link [here](https://example.com).`;
+
+    const result = processLineMessage(text);
+
+    // Should have 2 flex messages (table + code)
+    expect(result.flexMessages).toHaveLength(2);
+
+    // Text should be cleaned
+    expect(result.text).toContain("Summary");
+    expect(result.text).toContain("important");
+    expect(result.text).toContain("Note: Check the link here.");
+    expect(result.text).not.toContain("#");
+    expect(result.text).not.toContain("**");
+    expect(result.text).not.toContain("|");
+    expect(result.text).not.toContain("```");
+    expect(result.text).not.toContain("[here]");
+  });
+
+  it("handles plain text unchanged", () => {
+    const text = "Just plain text with no markdown.";
+
+    const result = processLineMessage(text);
+
+    expect(result.text).toBe(text);
+    expect(result.flexMessages).toHaveLength(0);
+  });
+});
+
+describe("hasMarkdownToConvert", () => {
+  it("detects tables", () => {
+    const text = `| A | B |
+|---|---|
+| 1 | 2 |`;
+    expect(hasMarkdownToConvert(text)).toBe(true);
+  });
+
+  it("detects code blocks", () => {
+    const text = "```js\ncode\n```";
+    expect(hasMarkdownToConvert(text)).toBe(true);
+  });
+
+  it("detects bold", () => {
+    expect(hasMarkdownToConvert("**bold**")).toBe(true);
+  });
+
+  it("detects strikethrough", () => {
+    expect(hasMarkdownToConvert("~~deleted~~")).toBe(true);
+  });
+
+  it("detects headers", () => {
+    expect(hasMarkdownToConvert("# Title")).toBe(true);
+  });
+
+  it("detects blockquotes", () => {
+    expect(hasMarkdownToConvert("> quote")).toBe(true);
+  });
+
+  it("returns false for plain text", () => {
+    expect(hasMarkdownToConvert("Just plain text.")).toBe(false);
+  });
+});