@enrichlayer/el-linear 1.7.0 → 1.10.0

package/dist/utils/issue-reference-extractor.d.ts

@@ -7,7 +7,15 @@ export interface IssueReference {
 }
 /**
  * Extract issue identifiers from text along with the inferred relation type.
- * Strips fenced code blocks before scanning to avoid false positives in pasted logs.
+ *
+ * Identifiers inside protected ranges are skipped — fenced code blocks,
+ * inline backticks, existing markdown links, Slack links, angle-bracket
+ * autolinks, and bare URLs. This is the same protection set used by
+ * `wrapIssueReferencesAsLinks`, so the two stay symmetric: a wrapped
+ * `[label](https://x/DEV-100)` won't have DEV-100 re-extracted as a
+ * phantom reference, and a bare URL like
+ * `https://github.com/org/repo/DEV-100.md` won't either. (See
+ * `protected-ranges.ts` for the shared scanner.)
  *
  * The relation type is inferred from prose keywords immediately before the identifier
  * (e.g. "blocked by DEV-100" → blocks/reverse=true). Default is `related`.

package/dist/utils/issue-reference-extractor.js

@@ -1,5 +1,4 @@
-const IDENTIFIER_REGEX = /\b([A-Z][A-Z0-9]*-\d+)\b/g;
-const FENCED_CODE_BLOCK_REGEX = /(?:^|\n)([ \t]*)(?:```|~~~)[^\n]*\n[\s\S]*?\n\1?(?:```|~~~)(?=\n|$)/g;
+import { findProtectedRanges, IDENTIFIER_REGEX, isProtected, } from "./protected-ranges.js";
 /**
  * Window of text immediately before an identifier where we look for relation keywords.
  * 30 chars covers phrases like "is a prerequisite of" comfortably.
@@ -36,9 +35,6 @@ const PHRASE_PATTERNS = [
         reverse: false,
     },
 ];
-function stripFencedCodeBlocks(text) {
-    return text.replace(FENCED_CODE_BLOCK_REGEX, "");
-}
 function inferRelation(textBefore) {
     const window = textBefore.slice(-KEYWORD_WINDOW);
     for (const { regex, type, reverse } of PHRASE_PATTERNS) {
@@ -63,7 +59,15 @@ function specificity(ref) {
 }
 /**
  * Extract issue identifiers from text along with the inferred relation type.
- * Strips fenced code blocks before scanning to avoid false positives in pasted logs.
+ *
+ * Identifiers inside protected ranges are skipped — fenced code blocks,
+ * inline backticks, existing markdown links, Slack links, angle-bracket
+ * autolinks, and bare URLs. This is the same protection set used by
+ * `wrapIssueReferencesAsLinks`, so the two stay symmetric: a wrapped
+ * `[label](https://x/DEV-100)` won't have DEV-100 re-extracted as a
+ * phantom reference, and a bare URL like
+ * `https://github.com/org/repo/DEV-100.md` won't either. (See
+ * `protected-ranges.ts` for the shared scanner.)
  *
  * The relation type is inferred from prose keywords immediately before the identifier
  * (e.g. "blocked by DEV-100" → blocks/reverse=true). Default is `related`.
@@ -75,15 +79,18 @@ export function extractIssueReferences(text, selfIdentifier) {
     if (!text) {
         return [];
     }
-    const stripped = stripFencedCodeBlocks(text);
+    const ranges = findProtectedRanges(text);
     const byIdentifier = new Map();
-    for (const match of stripped.matchAll(IDENTIFIER_REGEX)) {
+    for (const match of text.matchAll(IDENTIFIER_REGEX)) {
         const id = match[1];
         if (selfIdentifier && id === selfIdentifier) {
             continue;
         }
         const matchIndex = match.index ?? 0;
-        const textBefore = stripped.slice(0, matchIndex);
+        if (isProtected(matchIndex, ranges)) {
+            continue;
+        }
+        const textBefore = text.slice(0, matchIndex);
         const { type, reverse } = inferRelation(textBefore);
         const candidate = { identifier: id, type, reverse };
         const existing = byIdentifier.get(id);

package/dist/utils/issue-reference-wrapper.js

@@ -2,60 +2,7 @@
 // `getWorkspaceUrlKey(graphQLService)` to obtain it before invoking
 // `wrapIssueReferencesAsLinks`. Linear URLs look like
 // `https://linear.app/<urlKey>/issue/<identifier>/`.
-const IDENTIFIER_REGEX = /\b([A-Z][A-Z0-9]*-\d+)\b/g;
-const FENCED_CODE_BLOCK_REGEX = /(?:^|\n)([ \t]*)(?:```|~~~)[^\n]*\n[\s\S]*?\n\1?(?:```|~~~)(?=\n|$)/g;
-// Inline backtick spans — `EMW-258`. Markdown allows multiple backticks for spans containing
-// backticks; we keep it simple and match single-backtick spans.
-const INLINE_CODE_REGEX = /`[^`\n]+?`/g;
-// Existing markdown links: [text](url). We protect both the text and the url.
-const MARKDOWN_LINK_REGEX = /\[([^\]]*)\]\(([^)]*)\)/g;
-// Existing Slack mrkdwn links: <url|text>. We protect both halves so identifiers
-// inside an already-wrapped Slack link aren't double-wrapped.
-const SLACK_LINK_REGEX = /<https?:\/\/[^|>\s]+\|[^>]*>/g;
-// Angle-bracket autolinks: <https://...>
-const ANGLE_AUTOLINK_REGEX = /<[^>\s]+>/g;
-// Bare URLs in prose. We protect these so identifiers inside paths
-// (e.g. "https://github.com/foo/DEV-100") don't get split by wrapping.
-const BARE_URL_REGEX = /https?:\/\/\S+/g;
-/**
- * Find ranges of `text` that should NOT have identifiers wrapped:
- * - Fenced code blocks (``` or ~~~)
- * - Inline backtick code spans
- * - Existing markdown links — both `[text]` and `(url)`
- * - Angle-bracket autolinks
- *
- * The returned ranges may overlap; callers only need to test "is this position
- * inside any protected range" so overlap is fine.
- */
-function findProtectedRanges(text) {
-    const ranges = [];
-    for (const re of [
-        FENCED_CODE_BLOCK_REGEX,
-        INLINE_CODE_REGEX,
-        MARKDOWN_LINK_REGEX,
-        // Slack links must be protected before generic angle-bracket autolinks,
-        // otherwise the autolink regex would still match `<https://…|label>` because
-        // it doesn't include the pipe boundary. matchAll resets per regex so order
-        // in this list is irrelevant for correctness — both ranges still cover the span.
-        SLACK_LINK_REGEX,
-        ANGLE_AUTOLINK_REGEX,
-        BARE_URL_REGEX,
-    ]) {
-        for (const m of text.matchAll(re)) {
-            const start = m.index ?? 0;
-            ranges.push({ start, end: start + m[0].length });
-        }
-    }
-    return ranges;
-}
-function isProtected(pos, ranges) {
-    for (const r of ranges) {
-        if (pos >= r.start && pos < r.end) {
-            return true;
-        }
-    }
-    return false;
-}
+import { findProtectedRanges, IDENTIFIER_REGEX, isProtected, } from "./protected-ranges.js";
 function buildIssueUrl(identifier, workspaceUrlKey) {
     return `https://linear.app/${workspaceUrlKey}/issue/${identifier}/`;
 }

package/dist/utils/linear-service.d.ts

@@ -21,12 +21,16 @@ export declare class LinearService {
     resolveIssueId(issueId: string): Promise<string>;
     getTeams(limit?: number): Promise<LinearTeam[]>;
     resolveUserId(nameOrEmailOrId: string): Promise<string>;
-    getUsers(activeOnly?: boolean, limit?: number): Promise<LinearUser[]>;
-    getProjects(limit?: number): Promise<LinearProject[]>;
+    getUsers(activeOnly?: boolean, limit?: number, nameFilter?: string): Promise<LinearUser[]>;
+    getProjects(limit?: number, options?: {
+        nameFilter?: string;
+        states?: string[];
+        excludeStates?: string[];
+    }): Promise<LinearProject[]>;
     resolveTeamId(teamKeyOrNameOrId: string): Promise<string>;
     resolveStatusId(statusName: string, teamId?: string): Promise<string>;
     private buildLabelData;
-    getLabels(teamFilter?: string, limit?: number): Promise<{
+    getLabels(teamFilter?: string, limit?: number, nameFilter?: string): Promise<{
         labels: LinearLabel[];
     }>;
     createComment(args: {

package/dist/utils/linear-service.js

@@ -101,11 +101,14 @@ export class LinearService {
         }
         throw notFoundError("User", nameOrEmailOrId);
     }
-    async getUsers(activeOnly, limit = 100) {
+    async getUsers(activeOnly, limit = 100, nameFilter) {
         const filter = {};
         if (activeOnly) {
             filter.active = eqFilter(true);
         }
+        if (nameFilter) {
+            filter.name = { containsIgnoreCase: nameFilter };
+        }
         const usersConnection = await this.client.users({
             filter: nonEmptyFilter(filter),
             first: limit,
@@ -119,8 +122,19 @@ export class LinearService {
         }));
         return users.sort((a, b) => a.name.localeCompare(b.name));
     }
-    async getProjects(limit = 100) {
+    async getProjects(limit = 100, options = {}) {
+        const filter = {};
+        if (options.nameFilter) {
+            filter.name = { containsIgnoreCase: options.nameFilter };
+        }
+        if (options.states && options.states.length > 0) {
+            filter.state = { in: options.states };
+        }
+        else if (options.excludeStates && options.excludeStates.length > 0) {
+            filter.state = { nin: options.excludeStates };
+        }
         const projects = await this.client.projects({
+            filter: nonEmptyFilter(filter),
             first: limit,
             orderBy: sdkOrderBy("updatedAt"),
             includeArchived: false,
@@ -235,13 +249,18 @@ export class LinearService {
         }
         return labelData;
     }
-    async getLabels(teamFilter, limit = 100) {
+    async getLabels(teamFilter, limit = 100, nameFilter) {
         const labels = [];
+        const labelFilter = {};
+        if (nameFilter) {
+            labelFilter.name = { containsIgnoreCase: nameFilter };
+        }
         if (teamFilter) {
             const teamId = await this.resolveTeamId(teamFilter);
             const team = await this.client.team(teamId);
+            labelFilter.team = teamIdFilter(teamId);
             const teamLabels = await this.client.issueLabels({
-                filter: { team: teamIdFilter(teamId) },
+                filter: labelFilter,
                 first: limit,
             });
             const teamRef = { id: team.id, key: team.key, name: team.name };
@@ -253,7 +272,10 @@ export class LinearService {
             }
         }
         else {
-            const allLabels = await this.client.issueLabels({ first: limit });
+            const allLabels = await this.client.issueLabels({
+                filter: nonEmptyFilter(labelFilter),
+                first: limit,
+            });
             for (const label of allLabels.nodes) {
                 if (label.isGroup) {
                     continue;

package/dist/utils/markdown-prosemirror.js

@@ -20,6 +20,22 @@ const INLINE_CODE_RE = /`([^`]+)`/;
 const INLINE_LINK_RE = /\[([^\]]+)\]\(([^)]+)\)/;
 const INLINE_BOLD_RE = /\*\*(.+?)\*\*|__(.+?)__/;
 const INLINE_ITALIC_RE = /(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)|(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/;
+/**
+ * Allowlist of URL schemes accepted on link marks. Anything else
+ * (`javascript:`, `data:`, `vbscript:`, `file:`) is silently dropped
+ * so we don't ship XSS-shaped ProseMirror docs into Linear comments
+ * or issue descriptions. Schemeless / relative links pass through —
+ * those resolve against the document base.
+ */
+const SAFE_LINK_SCHEMES = new Set(["http:", "https:", "mailto:", "linear:"]);
+function isSafeLinkScheme(href) {
+    const trimmed = href.trim();
+    if (!/^[a-z][a-z0-9+.-]*:/i.test(trimmed))
+        return true;
+    const colon = trimmed.indexOf(":");
+    const scheme = trimmed.slice(0, colon + 1).toLowerCase();
+    return SAFE_LINK_SCHEMES.has(scheme);
+}
 export function markdownToProseMirror(text) {
     const state = { lines: text.split("\n"), content: [], i: 0 };
     while (state.i < state.lines.length) {
@@ -297,7 +313,7 @@ function findEarliestInlineMatch(text) {
         });
     }
     const linkMatch = text.match(INLINE_LINK_RE);
-    if (linkMatch) {
+    if (linkMatch && isSafeLinkScheme(linkMatch[2])) {
         candidates.push({
             index: linkMatch.index ?? 0,
             length: linkMatch[0].length,

package/dist/utils/mention-resolver.js

@@ -2,7 +2,10 @@ 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;
+// Unicode-aware mention regex: ASCII-only `\w` would silently fail to
+// match Cyrillic / accented Latin / CJK names (`@Юрий`, `@Niño`).
+// `\p{L}` covers all Unicode letters; `\p{N}` covers all numerics.
+const EXPLICIT_MENTION_REGEX = /@([\p{L}\p{N}_]+)/gu;
 const WHITESPACE_SPLIT_REGEX = /\s+/;
 const FENCED_CODE_REGEX = /```[\s\S]*?```/g;
 const INLINE_CODE_REGEX = /`[^`]+`/g;
@@ -40,7 +43,11 @@ export async function resolveMentions(body, linearService, options = {}) {
     if (autoMention) {
         const stripped = stripCodeAndLinks(body);
         for (const candidate of getBareMentionCandidates()) {
-            const pattern = new RegExp(`\\b${escapeRegex(candidate)}\\b`);
+            // Unicode-aware "word boundary": ASCII `\b` doesn't fire on
+            // Cyrillic / accented Latin / CJK chars, so a candidate like
+            // `Юрий` would silently fail to match. Lookarounds against
+            // the same letter+number+underscore class behave correctly.
+            const pattern = new RegExp(`(?<![\\p{L}\\p{N}_])${escapeRegex(candidate)}(?![\\p{L}\\p{N}_])`, "u");
             if (!pattern.test(stripped)) {
                 continue;
             }
@@ -215,19 +222,24 @@ function splitMentions(node, explicit, bare) {
 function buildCombinedRegex(explicit, bare) {
     const parts = [];
     if (explicit.size > 0) {
-        parts.push("@\\w+");
+        // Same Unicode-aware character class as EXPLICIT_MENTION_REGEX
+        // at module top so the splitter and the resolver agree on
+        // what counts as a name char.
+        parts.push("@[\\p{L}\\p{N}_]+");
     }
     if (bare.size > 0) {
         const alternation = [...bare.keys()]
             .sort((a, b) => b.length - a.length)
             .map(escapeRegex)
             .join("|");
-        parts.push(`\\b(?:${alternation})\\b`);
+        // Unicode-aware "word boundary": no `\b` (ASCII-only); use
+        // lookarounds against the same letter+number+underscore class.
+        parts.push(`(?<![\\p{L}\\p{N}_])(?:${alternation})(?![\\p{L}\\p{N}_])`);
     }
     if (parts.length === 0) {
         return null;
     }
-    return new RegExp(parts.join("|"), "g");
+    return new RegExp(parts.join("|"), "gu");
 }
 function escapeRegex(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/utils/output.d.ts

@@ -1,7 +1,13 @@
+export type OutputFormat = "json" | "summary";
 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 setOutputFormat(format: OutputFormat): void;
+/** @internal Test seam — consumers should not depend on the format state. */
+export declare function getOutputFormat(): OutputFormat;
 export declare function outputSuccess(data: unknown): void;
-export declare function outputWarning(message: string | string[], _type?: string): void;
+export declare function outputWarning(message: string | string[]): void;
 export declare function resetWarnings(): void;
+/** @internal Test seam — call between tests that toggle `setOutputFormat`. */
+export declare function resetOutputFormat(): void;
 export declare function handleAsyncCommand<TArgs extends unknown[]>(asyncFn: (...args: TArgs) => Promise<void>): (...args: TArgs) => Promise<void>;

package/dist/utils/output.js

@@ -1,9 +1,11 @@
 import { execFileSync } from "node:child_process";
+import { dispatch as dispatchSummary, inferKindFromPayload, } from "./formatters/summary.js";
 import { logger } from "./logger.js";
 const warningBuffer = [];
 let rawMode = false;
 let jqFilter = null;
 let fieldsFilter = null;
+let outputFormat = "json";
 export function setRawMode(enabled) {
     rawMode = enabled;
 }
@@ -13,6 +15,13 @@ export function setJqFilter(filter) {
 export function setFieldsFilter(fields) {
     fieldsFilter = fields;
 }
+export function setOutputFormat(format) {
+    outputFormat = format;
+}
+/** @internal Test seam — consumers should not depend on the format state. */
+export function getOutputFormat() {
+    return outputFormat;
+}
 function filterFields(obj, fields) {
     if (Array.isArray(obj)) {
         return obj.map((item) => filterFields(item, fields));
@@ -29,6 +38,18 @@ function filterFields(obj, fields) {
     }
     return obj;
 }
+/**
+ * Emit a summary-format render to stdout for the given payload.
+ *
+ * `kind` is captured upstream from the **pre-filter** payload — if we
+ * inferred here, `--fields identifier,url` would strip `title` and
+ * the heuristic would fall through to "generic", silently breaking
+ * the issue-list table. Caching the pre-filter shape keeps the
+ * formatter accurate regardless of how the user pared the JSON.
+ */
+function emitSummary(payload, kind) {
+    logger.info(dispatchSummary(kind, payload));
+}
 export function outputSuccess(data) {
     const warnings = drainWarnings();
     let output;
@@ -41,6 +62,11 @@ export function outputSuccess(data) {
     else {
         output = data;
     }
+    // Capture the kind from the original envelope shape BEFORE --raw /
+    // --fields stripping. Otherwise filtering away signature fields (e.g.
+    // `title` on an issue) breaks shape inference and the summary
+    // formatter falls back to the generic key-value dump.
+    const inferredKind = outputFormat === "summary" ? inferKindFromPayload(output) : "generic";
     // --raw: unwrap { data: [...] } to just the array
     if (rawMode &&
         output !== null &&
@@ -66,6 +92,13 @@ export function outputSuccess(data) {
             }
         }
     }
+    // summary format takes the post-raw / post-fields value and renders it
+    // as a human-readable block. We bypass the jq path because jq is a
+    // JSON-shape filter — it doesn't compose with text output.
+    if (outputFormat === "summary") {
+        emitSummary(output, inferredKind);
+        return;
+    }
     if (jqFilter) {
         const json = JSON.stringify(output);
         // Normalize common shell-escape artifacts (zsh history expansion)
@@ -87,7 +120,7 @@ export function outputSuccess(data) {
         logger.info(JSON.stringify(output, null, 2));
     }
 }
-export function outputWarning(message, _type) {
+export function outputWarning(message) {
     const messages = Array.isArray(message) ? message : [message];
     for (const msg of messages) {
         warningBuffer.push(msg);
@@ -103,6 +136,10 @@ function drainWarnings() {
 export function resetWarnings() {
     warningBuffer.length = 0;
 }
+/** @internal Test seam — call between tests that toggle `setOutputFormat`. */
+export function resetOutputFormat() {
+    outputFormat = "json";
+}
 function outputError(error) {
     const payload = JSON.stringify({ error: error.message }, null, 2);
     // Write to stdout (same channel as success) so machine callers always

package/dist/utils/protected-ranges.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Shared "protected ranges" scanner — used by both
+ * `issue-reference-wrapper` and `issue-reference-extractor` so they
+ * agree on which spans of input text should be excluded from
+ * identifier processing.
+ *
+ * Why this exists: a transform/consumer pair that disagree about what
+ * counts as "protected" silently produces phantom relations or
+ * double-wrapped links. Concretely, the wrapper protects fenced code,
+ * inline code, markdown links, Slack links, angle-bracket autolinks,
+ * AND bare URLs; the extractor used to only strip fenced code, so
+ * `[click](https://x/DEV-100)` would wrap correctly but the auto-link
+ * extractor would still detect DEV-100 inside the URL and create a
+ * phantom relation. Same for `https://github.com/org/repo/DEV-100.md`.
+ *
+ * Centralising the scanner makes both consumers agree by construction.
+ */
+/** Linear identifier shape: ABC-123, EMW-1, DEV-3592. */
+export declare const IDENTIFIER_REGEX: RegExp;
+export interface ProtectedRange {
+    end: number;
+    start: number;
+}
+/**
+ * Find ranges of `text` that should NOT have identifiers processed.
+ * Covered: fenced code, inline backticks, existing markdown links,
+ * Slack links, angle-bracket autolinks, bare URLs.
+ *
+ * The returned ranges may overlap; callers only test "is this position
+ * inside any protected range" so overlap is harmless.
+ */
+export declare function findProtectedRanges(text: string): ProtectedRange[];
+export declare function isProtected(pos: number, ranges: ProtectedRange[]): boolean;

package/dist/utils/protected-ranges.js

@@ -0,0 +1,73 @@
+/**
+ * Shared "protected ranges" scanner — used by both
+ * `issue-reference-wrapper` and `issue-reference-extractor` so they
+ * agree on which spans of input text should be excluded from
+ * identifier processing.
+ *
+ * Why this exists: a transform/consumer pair that disagree about what
+ * counts as "protected" silently produces phantom relations or
+ * double-wrapped links. Concretely, the wrapper protects fenced code,
+ * inline code, markdown links, Slack links, angle-bracket autolinks,
+ * AND bare URLs; the extractor used to only strip fenced code, so
+ * `[click](https://x/DEV-100)` would wrap correctly but the auto-link
+ * extractor would still detect DEV-100 inside the URL and create a
+ * phantom relation. Same for `https://github.com/org/repo/DEV-100.md`.
+ *
+ * Centralising the scanner makes both consumers agree by construction.
+ */
+/** Linear identifier shape: ABC-123, EMW-1, DEV-3592. */
+export const IDENTIFIER_REGEX = /\b([A-Z][A-Z0-9]*-\d+)\b/g;
+const FENCED_CODE_BLOCK_REGEX = /(?:^|\n)([ \t]*)(?:```|~~~)[^\n]*\n[\s\S]*?\n\1?(?:```|~~~)(?=\n|$)/g;
+// Inline backtick spans — `EMW-258`. Markdown allows multiple backticks
+// for spans containing backticks; we keep it simple and match
+// single-backtick spans, which covers the common case.
+const INLINE_CODE_REGEX = /`[^`\n]+?`/g;
+// Existing markdown links: [text](url). Both halves protected so
+// identifiers inside the URL or the text aren't reprocessed.
+const MARKDOWN_LINK_REGEX = /\[([^\]]*)\]\(([^)]*)\)/g;
+// Existing Slack mrkdwn links: <url|text>. Both halves protected for
+// the same reason as markdown links.
+const SLACK_LINK_REGEX = /<https?:\/\/[^|>\s]+\|[^>]*>/g;
+// Angle-bracket autolinks: <https://...>
+const ANGLE_AUTOLINK_REGEX = /<[^>\s]+>/g;
+// Bare URLs in prose. We protect these so identifiers inside path
+// components (e.g. "https://github.com/foo/DEV-100") don't get
+// processed.
+const BARE_URL_REGEX = /https?:\/\/\S+/g;
+/**
+ * Find ranges of `text` that should NOT have identifiers processed.
+ * Covered: fenced code, inline backticks, existing markdown links,
+ * Slack links, angle-bracket autolinks, bare URLs.
+ *
+ * The returned ranges may overlap; callers only test "is this position
+ * inside any protected range" so overlap is harmless.
+ */
+export function findProtectedRanges(text) {
+    const ranges = [];
+    for (const re of [
+        FENCED_CODE_BLOCK_REGEX,
+        INLINE_CODE_REGEX,
+        MARKDOWN_LINK_REGEX,
+        // Slack links must be considered before generic angle-bracket
+        // autolinks — the autolink regex doesn't know about the `|label`
+        // boundary, but matchAll resets per regex so order is just for
+        // clarity here.
+        SLACK_LINK_REGEX,
+        ANGLE_AUTOLINK_REGEX,
+        BARE_URL_REGEX,
+    ]) {
+        for (const m of text.matchAll(re)) {
+            const start = m.index ?? 0;
+            ranges.push({ start, end: start + m[0].length });
+        }
+    }
+    return ranges;
+}
+export function isProtected(pos, ranges) {
+    for (const r of ranges) {
+        if (pos >= r.start && pos < r.end) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/utils/table-formatter.d.ts

@@ -1,4 +1,40 @@
 import type { LinearIssue } from "../types/linear.js";
+/**
+ * Column definition for the fixed-width text and CSV renderers.
+ * Generic over the row type `T` so the same renderers serve issues,
+ * projects, and any future resource that wants table output. The
+ * `colorize` hook receives the row so it can branch on entity-
+ * specific fields (e.g. the issue's priority or status); pass
+ * undefined to skip color.
+ */
+export interface ColumnDef<T> {
+    colorize?: (value: string, row: T) => string;
+    extract: (row: T) => string;
+    header: string;
+    key: string;
+    width: number;
+}
+/**
+ * Render `rows` as a fixed-width text table using `columns`. Generic
+ * over the row type `T` so issues, projects, and other resources
+ * share the same width-padding + colorize machinery.
+ */
+export declare function renderFixedWidthTable<T>(rows: T[], columns: ColumnDef<T>[]): string;
+/**
+ * Render `rows` as CSV using `columns`. Quotes any value containing
+ * `,` or `"` (RFC 4180-style escaping). Generic over the row type.
+ */
+export declare function renderCsv<T>(rows: T[], columns: ColumnDef<T>[]): string;
 export declare function formatTable(issues: LinearIssue[], fieldNames?: string[]): string;
 export declare function formatCsv(issues: LinearIssue[], fieldNames?: string[]): string;
+export interface MarkdownColumnDef<T> {
+    align?: "left" | "right";
+    extract: (row: T) => string;
+    header: string;
+}
+/**
+ * Render `rows` as a markdown table using `columns`. Generic over
+ * the row type. Escapes `|` and newlines in cell values.
+ */
+export declare function renderMarkdownTable<T>(rows: T[], columns: MarkdownColumnDef<T>[]): string;
 export declare function formatMarkdown(issues: LinearIssue[], fieldNames?: string[]): string;