@enrichlayer/el-linear 1.2.0

package/dist/utils/markdown-prosemirror.js

@@ -0,0 +1,325 @@
+/**
+ * Lightweight markdown → ProseMirror document converter.
+ *
+ * Handles the subset of markdown commonly used in Linear comments:
+ * headings, bullet/ordered lists, code blocks, blockquotes, horizontal rules,
+ * and inline marks (bold, italic, code, links).
+ */
+// ── Block parsing ────────────────────────────────────────────────────
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+const BULLET_RE = /^[\t ]*[-*]\s+(.+)$/;
+const ORDERED_RE = /^[\t ]*\d+[.)]\s+(.+)$/;
+const BLOCKQUOTE_RE = /^>\s?(.*)$/;
+const HR_RE = /^([-*_])\1{2,}\s*$/;
+const TABLE_ROW_RE = /^\|(.+)\|$/;
+const TABLE_SEP_RE = /^\|[\s:]*-{2,}[\s:]*(\|[\s:]*-{2,}[\s:]*)*\|$/;
+const FENCE_OPEN_RE = /^```(\w*)$/;
+const FENCE_CLOSE_RE = /^```\s*$/;
+// Inline patterns (top-level for performance)
+const INLINE_CODE_RE = /`([^`]+)`/;
+const INLINE_LINK_RE = /\[([^\]]+)\]\(([^)]+)\)/;
+const INLINE_BOLD_RE = /\*\*(.+?)\*\*|__(.+?)__/;
+const INLINE_ITALIC_RE = /(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)|(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/;
+export function markdownToProseMirror(text) {
+    const state = { lines: text.split("\n"), content: [], i: 0 };
+    while (state.i < state.lines.length) {
+        const line = state.lines[state.i];
+        if (line.trim() === "") {
+            state.i++;
+            continue;
+        }
+        if (parseFencedCodeBlock(state, line)) {
+            continue;
+        }
+        if (parseHorizontalRule(state, line)) {
+            continue;
+        }
+        if (parseHeading(state, line)) {
+            continue;
+        }
+        if (parseBulletList(state, line)) {
+            continue;
+        }
+        if (parseOrderedList(state, line)) {
+            continue;
+        }
+        if (parseBlockquote(state)) {
+            continue;
+        }
+        if (parseTable(state, line)) {
+            continue;
+        }
+        parseParagraph(state);
+    }
+    return { type: "doc", content: state.content };
+}
+function parseFencedCodeBlock(state, line) {
+    const fenceMatch = line.match(FENCE_OPEN_RE);
+    if (!fenceMatch) {
+        return false;
+    }
+    const language = fenceMatch[1] || undefined;
+    const codeLines = [];
+    state.i++;
+    while (state.i < state.lines.length &&
+        !FENCE_CLOSE_RE.test(state.lines[state.i])) {
+        codeLines.push(state.lines[state.i]);
+        state.i++;
+    }
+    state.i++; // skip closing fence
+    const attrs = {};
+    if (language) {
+        attrs.language = language;
+    }
+    state.content.push({
+        type: "codeBlock",
+        ...(Object.keys(attrs).length > 0 ? { attrs } : {}),
+        content: codeLines.length > 0
+            ? [{ type: "text", text: codeLines.join("\n") }]
+            : undefined,
+    });
+    return true;
+}
+function parseHorizontalRule(state, line) {
+    if (!HR_RE.test(line)) {
+        return false;
+    }
+    state.content.push({ type: "horizontalRule" });
+    state.i++;
+    return true;
+}
+function parseHeading(state, line) {
+    const headingMatch = line.match(HEADING_RE);
+    if (!headingMatch) {
+        return false;
+    }
+    state.content.push({
+        type: "heading",
+        attrs: { level: headingMatch[1].length },
+        content: parseInline(headingMatch[2]),
+    });
+    state.i++;
+    return true;
+}
+function parseBulletList(state, line) {
+    if (!BULLET_RE.test(line)) {
+        return false;
+    }
+    const items = [];
+    while (state.i < state.lines.length && BULLET_RE.test(state.lines[state.i])) {
+        const m = state.lines[state.i].match(BULLET_RE);
+        items.push({
+            type: "listItem",
+            content: [{ type: "paragraph", content: parseInline(m[1]) }],
+        });
+        state.i++;
+    }
+    state.content.push({ type: "bulletList", content: items });
+    return true;
+}
+function parseOrderedList(state, line) {
+    if (!ORDERED_RE.test(line)) {
+        return false;
+    }
+    const items = [];
+    while (state.i < state.lines.length &&
+        ORDERED_RE.test(state.lines[state.i])) {
+        const m = state.lines[state.i].match(ORDERED_RE);
+        items.push({
+            type: "listItem",
+            content: [{ type: "paragraph", content: parseInline(m[1]) }],
+        });
+        state.i++;
+    }
+    state.content.push({ type: "orderedList", content: items });
+    return true;
+}
+function parseBlockquote(state) {
+    if (!BLOCKQUOTE_RE.test(state.lines[state.i])) {
+        return false;
+    }
+    const quoteLines = [];
+    while (state.i < state.lines.length &&
+        BLOCKQUOTE_RE.test(state.lines[state.i])) {
+        const m = state.lines[state.i].match(BLOCKQUOTE_RE);
+        quoteLines.push(m[1]);
+        state.i++;
+    }
+    const inner = markdownToProseMirror(quoteLines.join("\n"));
+    state.content.push({
+        type: "blockquote",
+        content: inner.content && inner.content.length > 0
+            ? inner.content
+            : [{ type: "paragraph", content: [] }],
+    });
+    return true;
+}
+// Split a table row's inner content on unescaped `|`, preserving `\|` as a literal pipe.
+// Caller strips leading/trailing pipes before calling; each returned cell is trimmed.
+function splitTableRow(inner) {
+    const cells = [];
+    let current = "";
+    for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === "\\" && inner[i + 1] === "|") {
+            current += "|";
+            i++;
+        }
+        else if (inner[i] === "|") {
+            cells.push(current.trim());
+            current = "";
+        }
+        else {
+            current += inner[i];
+        }
+    }
+    cells.push(current.trim());
+    return cells;
+}
+// Build ProseMirror inline content for a cell, handling empty strings gracefully.
+function cellContent(cell) {
+    const inline = parseInline(cell);
+    return inline.length > 0 ? inline : [];
+}
+function parseTable(state, line) {
+    const rowMatch = line.match(TABLE_ROW_RE);
+    if (!rowMatch) {
+        return false;
+    }
+    // Peek ahead: a table needs at least a header row + separator row
+    if (state.i + 1 >= state.lines.length ||
+        !TABLE_SEP_RE.test(state.lines[state.i + 1].trim())) {
+        return false;
+    }
+    const rows = [];
+    const headerCells = splitTableRow(rowMatch[1]);
+    const cols = headerCells.length;
+    rows.push({
+        type: "tableRow",
+        content: headerCells.map((cell) => ({
+            type: "tableHeader",
+            content: [{ type: "paragraph", content: cellContent(cell) }],
+        })),
+    });
+    state.i++; // header row
+    state.i++; // separator row
+    // Parse body rows — pad/truncate to match header column count so Linear gets a
+    // rectangular table (ProseMirror tolerates uneven rows but Linear's validator may not).
+    while (state.i < state.lines.length) {
+        const bodyMatch = state.lines[state.i].trim().match(TABLE_ROW_RE);
+        if (!bodyMatch) {
+            break;
+        }
+        const cells = splitTableRow(bodyMatch[1]);
+        while (cells.length < cols) {
+            cells.push("");
+        }
+        cells.length = cols;
+        rows.push({
+            type: "tableRow",
+            content: cells.map((cell) => ({
+                type: "tableCell",
+                content: [{ type: "paragraph", content: cellContent(cell) }],
+            })),
+        });
+        state.i++;
+    }
+    state.content.push({ type: "table", content: rows });
+    return true;
+}
+function isBlockStart(line) {
+    return (HEADING_RE.test(line) ||
+        FENCE_OPEN_RE.test(line) ||
+        HR_RE.test(line) ||
+        BULLET_RE.test(line) ||
+        ORDERED_RE.test(line) ||
+        BLOCKQUOTE_RE.test(line) ||
+        TABLE_ROW_RE.test(line));
+}
+function parseParagraph(state) {
+    // Always consume the current line — the main loop has already determined no
+    // block parser handled it. Skipping the first-line block-start check avoids
+    // an infinite loop when a line looks like a block (e.g. table row) but fails
+    // the stricter block parser (e.g. table row with no separator line).
+    const paraLines = [state.lines[state.i]];
+    state.i++;
+    while (state.i < state.lines.length &&
+        state.lines[state.i].trim() !== "" &&
+        !isBlockStart(state.lines[state.i])) {
+        paraLines.push(state.lines[state.i]);
+        state.i++;
+    }
+    const inlineNodes = parseInline(paraLines.join("\n"));
+    if (inlineNodes.length > 0) {
+        state.content.push({ type: "paragraph", content: inlineNodes });
+    }
+}
+// ── Inline parsing ───────────────────────────────────────────────────
+/**
+ * Parse inline markdown (bold, italic, code, links) into ProseMirror nodes with marks.
+ */
+export function parseInline(text) {
+    const nodes = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        const candidate = findEarliestInlineMatch(remaining);
+        if (!candidate) {
+            nodes.push({ type: "text", text: remaining });
+            break;
+        }
+        if (candidate.index > 0) {
+            nodes.push({ type: "text", text: remaining.slice(0, candidate.index) });
+        }
+        nodes.push({
+            type: "text",
+            text: candidate.innerText,
+            marks: candidate.marks,
+        });
+        remaining = remaining.slice(candidate.index + candidate.length);
+    }
+    return nodes;
+}
+function findEarliestInlineMatch(text) {
+    const candidates = [];
+    const codeMatch = text.match(INLINE_CODE_RE);
+    if (codeMatch) {
+        candidates.push({
+            index: codeMatch.index,
+            length: codeMatch[0].length,
+            innerText: codeMatch[1],
+            marks: [{ type: "code" }],
+        });
+    }
+    const linkMatch = text.match(INLINE_LINK_RE);
+    if (linkMatch) {
+        candidates.push({
+            index: linkMatch.index,
+            length: linkMatch[0].length,
+            innerText: linkMatch[1],
+            marks: [{ type: "link", attrs: { href: linkMatch[2] } }],
+        });
+    }
+    const boldMatch = text.match(INLINE_BOLD_RE);
+    if (boldMatch) {
+        candidates.push({
+            index: boldMatch.index,
+            length: boldMatch[0].length,
+            innerText: boldMatch[1] ?? boldMatch[2],
+            marks: [{ type: "bold" }],
+        });
+    }
+    const italicMatch = text.match(INLINE_ITALIC_RE);
+    if (italicMatch) {
+        candidates.push({
+            index: italicMatch.index,
+            length: italicMatch[0].length,
+            innerText: italicMatch[1] ?? italicMatch[2],
+            marks: [{ type: "italic" }],
+        });
+    }
+    if (candidates.length === 0) {
+        return null;
+    }
+    // Return the earliest match; on tie, prefer the longer match (more specific)
+    candidates.sort((a, b) => a.index - b.index || b.length - a.length);
+    return candidates[0];
+}

package/dist/utils/mention-resolver.d.ts

@@ -0,0 +1,31 @@
+import type { LinearService } from "./linear-service.js";
+import type { ProseMirrorNode } from "./markdown-prosemirror.js";
+export interface ResolveMentionsOptions {
+    /**
+     * When true, bare capitalized-word references matching known config members
+     * are auto-converted to mentions. Default: true.
+     */
+    autoMention?: boolean;
+    /**
+     * UUID of the commenting user. Bare references that resolve to this UUID
+     * are skipped (you shouldn't @-mention yourself).
+     */
+    selfUserId?: string;
+}
+/**
+ * Resolve mentions in markdown body text to Linear user IDs.
+ *
+ * Explicit `@name` tokens are always resolved via config aliases, full names,
+ * and platform handles — falling back to the Linear API.
+ *
+ * When `autoMention` is true (default), bare capitalized-word references that
+ * match a known config member (alias or first-name/last-name of a fullName)
+ * are also converted to mentions — without requiring the `@` prefix. This
+ * catches cases like "Bob owns the design" → "@bob owns the design".
+ *
+ * Returns a ProseMirror `bodyData` doc with `suggestion_userMentions` nodes,
+ * or `null` if nothing was resolved.
+ */
+export declare function resolveMentions(body: string, linearService: LinearService, options?: ResolveMentionsOptions): Promise<{
+    bodyData: ProseMirrorNode;
+} | null>;

package/dist/utils/mention-resolver.js

@@ -0,0 +1,234 @@
+import { loadConfig } from "../config/config.js";
+import { resolveMember } from "../config/resolver.js";
+import { markdownToProseMirror } from "./markdown-prosemirror.js";
+import { isUuid } from "./uuid.js";
+const EXPLICIT_MENTION_REGEX = /@(\w+)/g;
+const WHITESPACE_SPLIT_REGEX = /\s+/;
+const FENCED_CODE_REGEX = /```[\s\S]*?```/g;
+const INLINE_CODE_REGEX = /`[^`]+`/g;
+const MARKDOWN_LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
+/**
+ * Resolve mentions in markdown body text to Linear user IDs.
+ *
+ * Explicit `@name` tokens are always resolved via config aliases, full names,
+ * and platform handles — falling back to the Linear API.
+ *
+ * When `autoMention` is true (default), bare capitalized-word references that
+ * match a known config member (alias or first-name/last-name of a fullName)
+ * are also converted to mentions — without requiring the `@` prefix. This
+ * catches cases like "Bob owns the design" → "@bob owns the design".
+ *
+ * Returns a ProseMirror `bodyData` doc with `suggestion_userMentions` nodes,
+ * or `null` if nothing was resolved.
+ */
+export async function resolveMentions(body, linearService, options = {}) {
+    const autoMention = options.autoMention !== false;
+    const selfUserId = options.selfUserId;
+    // 1. Resolve explicit @name mentions (existing behavior).
+    const explicit = new Map();
+    const explicitNames = [...body.matchAll(EXPLICIT_MENTION_REGEX)].map((m) => m[1]);
+    for (const name of new Set(explicitNames)) {
+        const userId = await resolveUserByName(name, linearService);
+        if (userId) {
+            explicit.set(name, { userId, label: name });
+        }
+    }
+    // 2. Bare-name mentions: scan for candidate names that actually appear as
+    //    standalone words in the body (outside code / link contexts).
+    //    Config-only — no API fallback — so false positives stay bounded.
+    const bare = new Map();
+    if (autoMention) {
+        const stripped = stripCodeAndLinks(body);
+        for (const candidate of getBareMentionCandidates()) {
+            const pattern = new RegExp(`\\b${escapeRegex(candidate)}\\b`);
+            if (!pattern.test(stripped)) {
+                continue;
+            }
+            const userId = resolveMemberLocal(candidate);
+            if (!userId) {
+                continue;
+            }
+            if (selfUserId && userId === selfUserId) {
+                continue;
+            }
+            bare.set(candidate, { userId, label: candidate });
+        }
+    }
+    if (explicit.size === 0 && bare.size === 0) {
+        return null;
+    }
+    const doc = markdownToProseMirror(body);
+    const bodyData = injectMentions(doc, explicit, bare);
+    return { bodyData };
+}
+async function resolveUserByName(name, linearService) {
+    const configResult = resolveMember(name);
+    if (isUuid(configResult)) {
+        return configResult;
+    }
+    try {
+        return await linearService.resolveUserId(name);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Config-only resolution (no API fallback). Used for bare-mention detection,
+ * where matching a random word against the API would risk false positives.
+ */
+function resolveMemberLocal(name) {
+    const result = resolveMember(name);
+    return isUuid(result) ? result : null;
+}
+/**
+ * Build the list of candidate names for bare-mention detection from config:
+ * - alias keys ("bob", "erin", "carol")
+ * - uuids keys (short display names like "Bob", "David")
+ * - every space-separated token of every fullName (so "Surkov" resolves too)
+ *
+ * Each candidate is returned capitalized (first letter upper, rest lower) —
+ * text matches use word boundaries and the capitalization is a proper-noun
+ * signal that filters out code/keyword matches.
+ */
+function getBareMentionCandidates() {
+    const config = loadConfig();
+    const candidates = new Set();
+    for (const alias of Object.keys(config.members.aliases)) {
+        candidates.add(capitalize(alias));
+    }
+    for (const name of Object.keys(config.members.uuids)) {
+        candidates.add(capitalize(name));
+    }
+    for (const fullName of Object.values(config.members.fullNames)) {
+        for (const part of fullName.split(WHITESPACE_SPLIT_REGEX)) {
+            if (part.length >= 3) {
+                candidates.add(capitalize(part));
+            }
+        }
+    }
+    return [...candidates];
+}
+function capitalize(s) {
+    if (s.length === 0) {
+        return s;
+    }
+    return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+}
+/**
+ * Remove fenced code blocks, inline code, and link text/URLs from the body
+ * so the bare-name scan doesn't match inside them. This is a conservative
+ * pre-filter — the ProseMirror-walk injection still skips these contexts at
+ * emit time, but pre-filtering keeps the bare map from recording candidates
+ * that wouldn't actually be converted.
+ */
+function stripCodeAndLinks(body) {
+    return body
+        .replace(FENCED_CODE_REGEX, "")
+        .replace(INLINE_CODE_REGEX, "")
+        .replace(MARKDOWN_LINK_REGEX, "");
+}
+/**
+ * Walk a ProseMirror document tree and replace @name + bare name references
+ * with mention nodes.
+ */
+function injectMentions(doc, explicit, bare) {
+    if (!doc.content) {
+        return doc;
+    }
+    return {
+        ...doc,
+        content: doc.content.map((node) => {
+            if (node.content && node.type !== "codeBlock") {
+                const processed = injectMentions(node, explicit, bare);
+                if (node.type === "paragraph" || node.type === "heading") {
+                    return {
+                        ...processed,
+                        content: processed.content?.flatMap((child) => splitMentions(child, explicit, bare)),
+                    };
+                }
+                return processed;
+            }
+            return node;
+        }),
+    };
+}
+/**
+ * Split a text node on mention matches. Non-text nodes and code/link-marked
+ * nodes pass through unchanged — link text like "[Dima's doc](url)" is an
+ * explicit label, not a team reference.
+ */
+function splitMentions(node, explicit, bare) {
+    if (node.type !== "text" || !node.text) {
+        return [node];
+    }
+    if (node.marks?.some((m) => m.type === "code" || m.type === "link")) {
+        return [node];
+    }
+    const combinedRegex = buildCombinedRegex(explicit, bare);
+    if (!combinedRegex) {
+        return [node];
+    }
+    const result = [];
+    let lastIndex = 0;
+    combinedRegex.lastIndex = 0;
+    let match = combinedRegex.exec(node.text);
+    while (match !== null) {
+        const raw = match[0];
+        const resolved = raw.startsWith("@")
+            ? explicit.get(raw.slice(1))
+            : bare.get(raw);
+        if (!resolved) {
+            match = combinedRegex.exec(node.text);
+            continue;
+        }
+        if (match.index > lastIndex) {
+            result.push({
+                type: "text",
+                text: node.text.slice(lastIndex, match.index),
+                ...(node.marks ? { marks: node.marks } : {}),
+            });
+        }
+        result.push({
+            type: "suggestion_userMentions",
+            attrs: { id: resolved.userId, label: resolved.label },
+        });
+        lastIndex = match.index + raw.length;
+        match = combinedRegex.exec(node.text);
+    }
+    if (lastIndex < node.text.length) {
+        result.push({
+            type: "text",
+            text: node.text.slice(lastIndex),
+            ...(node.marks ? { marks: node.marks } : {}),
+        });
+    }
+    return result.length > 0 ? result : [node];
+}
+/**
+ * Build a single regex that matches either an explicit `@name` or any bare
+ * candidate name as a whole word. Returns null when both maps are empty.
+ *
+ * Bare names are anchored with `\b` so "Dima" inside "Dimadex" doesn't match.
+ * Longest candidates come first so multi-word names win over prefixes.
+ */
+function buildCombinedRegex(explicit, bare) {
+    const parts = [];
+    if (explicit.size > 0) {
+        parts.push("@\\w+");
+    }
+    if (bare.size > 0) {
+        const alternation = [...bare.keys()]
+            .sort((a, b) => b.length - a.length)
+            .map(escapeRegex)
+            .join("|");
+        parts.push(`\\b(?:${alternation})\\b`);
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    return new RegExp(parts.join("|"), "g");
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/utils/output.d.ts

@@ -0,0 +1,7 @@
+export declare function setRawMode(enabled: boolean): void;
+export declare function setJqFilter(filter: string | null): void;
+export declare function setFieldsFilter(fields: string[] | null): void;
+export declare function outputSuccess(data: unknown): void;
+export declare function outputWarning(message: string | string[], _type?: string): void;
+export declare function resetWarnings(): void;
+export declare function handleAsyncCommand<TArgs extends unknown[]>(asyncFn: (...args: TArgs) => Promise<void>): (...args: TArgs) => Promise<void>;