@enrichlayer/el-linear 1.7.0 → 1.9.0

package/dist/utils/graphql-issues-service.d.ts

@@ -1,19 +1,122 @@
 import type { GraphQLResponseData, LinearIssue } from "../types/linear.js";
 import type { GraphQLService } from "./graphql-service.js";
 import type { LinearService } from "./linear-service.js";
+/**
+ * Arguments accepted by `GraphQLIssuesService.searchIssues`. Two
+ * modes:
+ *   - When `query` is set, runs Linear's full-text search and
+ *     post-filters the results with the structured filters below.
+ *   - When `query` is unset, runs a structured filter directly.
+ */
+export interface SearchIssueArgs {
+    /** Free-text search term. When set, `searchIssues` uses Linear's
+     * native full-text search. */
+    query?: string;
+    /** Team key, name, or UUID. */
+    teamId?: string;
+    /** Project name or UUID. */
+    projectId?: string;
+    /** Set true to match only issues with NO project. Mutually
+     * exclusive with `projectId`. */
+    noProject?: boolean;
+    /** Assignee name, email, alias, or UUID. */
+    assigneeId?: string;
+    /** Issue states to include (e.g. `["Todo", "In Progress"]`). */
+    status?: string[];
+    /** Label names to require (intersection). */
+    labelNames?: string[];
+    /** Priority values (0-4) to include. */
+    priority?: number[];
+    /** Result cap; defaults to 10 when not set. */
+    limit?: number;
+    /** Linear orderBy enum (`createdAt` / `updatedAt`). */
+    orderBy?: string;
+}
+/**
+ * Arguments accepted by `GraphQLIssuesService.updateIssue`. Same
+ * field shapes as `CreateIssueArgs` (UUID-or-name where applicable),
+ * but with `id` required (the issue to update) and `subscriberIds` /
+ * `templateId` omitted (not valid on update).
+ */
+export interface UpdateIssueArgs {
+    /** Issue identifier (e.g. `DEV-3592`) or UUID. Required. */
+    id: string;
+    title?: string;
+    description?: string;
+    /** Assignee name, email, alias, or UUID. */
+    assigneeId?: string;
+    priority?: number;
+    projectId?: string;
+    statusId?: string;
+    /**
+     * Hint for the team-aware label resolver when the issue is being
+     * moved between teams.
+     */
+    teamId?: string;
+    labelIds?: string[];
+    parentId?: string;
+    milestoneId?: string;
+    cycleId?: string | null;
+    dueDate?: string;
+    estimate?: number;
+}
+/**
+ * Arguments accepted by `GraphQLIssuesService.createIssue`. Most fields
+ * may be passed as a Linear UUID OR a name/identifier — the service
+ * resolves names to UUIDs against the workspace before issuing the
+ * mutation. The few fields that must already be UUIDs are noted on
+ * the property docstring.
+ *
+ * Pre-fix this was `Record<string, unknown>` and every command-side
+ * caller built up a free-form object. A typo in `assigeeId` vs
+ * `assigneeId` compiled cleanly and silently dropped the field. With
+ * the typed shape, `tsc` catches the typo.
+ */
+export interface CreateIssueArgs {
+    title?: string;
+    /** Team key, name, or UUID. Required unless `templateId` is set. */
+    teamId?: string;
+    /** Original team token (key or name) — used in label resolution error messages. */
+    teamInput?: string;
+    description?: string;
+    /** Assignee name, email, alias, or UUID. */
+    assigneeId?: string;
+    /** Linear priority: 0 (none), 1 (urgent), 2 (high), 3 (medium), 4 (low). */
+    priority?: number;
+    /** Project name or UUID. */
+    projectId?: string;
+    /** Status name or UUID — resolved per team. */
+    statusId?: string;
+    /** Label names or UUIDs — auto-created on the team if missing. */
+    labelIds?: string[];
+    /** Parent issue identifier or UUID. */
+    parentId?: string;
+    /** Project milestone name or UUID — resolved within the project. */
+    milestoneId?: string;
+    /** Cycle number, name, or UUID — resolved per team. */
+    cycleId?: string;
+    /** Subscriber names, emails, aliases, or UUIDs. */
+    subscriberIds?: string[];
+    /** Due date, ISO 8601. */
+    dueDate?: string;
+    /** Story-points / estimate. */
+    estimate?: number;
+    /** Linear server-side template UUID for `--from-template`. */
+    templateId?: string;
+}
 export declare class GraphQLIssuesService {
     private readonly graphQLService;
     private readonly linearService;
     constructor(graphQLService: GraphQLService, linearService: LinearService);
     getIssues(limit?: number): Promise<LinearIssue[]>;
     getIssueById(issueId: string): Promise<LinearIssue>;
-    updateIssue(args: Record<string, unknown>, labelMode?: string): Promise<LinearIssue>;
+    updateIssue(args: UpdateIssueArgs, labelMode?: string): Promise<LinearIssue>;
     private extractMilestoneNodes;
     private executeUpdateMutation;
-    createIssue(args: Record<string, unknown>): Promise<LinearIssue>;
+    createIssue(args: CreateIssueArgs): Promise<LinearIssue>;
     private resolveCreateFields;
     private executeCreateMutation;
-    searchIssues(args: Record<string, unknown>): Promise<LinearIssue[]>;
+    searchIssues(args: SearchIssueArgs): Promise<LinearIssue[]>;
     private resolveTeamId;
     private resolveProjectId;
     /**

package/dist/utils/graphql-issues-service.js

@@ -5,6 +5,7 @@ import { toISOStringOrNow } from "./date-format.js";
 import { extractEmbeds } from "./embed-parser.js";
 import { notFoundError } from "./error-messages.js";
 import { parseIssueIdentifier, tryParseIssueIdentifier, } from "./identifier-parser.js";
+import { logger } from "./logger.js";
 import { isUuid } from "./uuid.js";
 const TEAM_KEY_REGEX = /^[A-Z0-9]+$/i;
 function extractSummaryText(summary) {
@@ -76,15 +77,18 @@ export class GraphQLIssuesService {
         const finalLabelIds = await this.resolveLabelsWithMode(args.labelIds, resolveResult, labelMode, currentIssueLabels, teamIdForLabels, args.teamId);
         const finalProjectId = args.projectId
             ? this.resolveProjectId(args.projectId, resolveResult)
-            : args.projectId;
+            : undefined;
         const { projectMilestoneNodes, issueProjectMilestoneNodes } = this.extractMilestoneNodes(args, resolveResult);
         const finalMilestoneId = this.resolveMilestoneId(args.milestoneId, resolveResult, projectMilestoneNodes, issueProjectMilestoneNodes);
         const finalCycleId = await this.resolveCycleIdForUpdate(args, resolveResult, resolvedIssueId);
         const resolvedStatusId = await this.resolveStatusIdForUpdate(args, resolvedIssueId);
-        if (args.assigneeId && !isUuid(args.assigneeId)) {
-            args.assigneeId = await this.linearService.resolveUserId(args.assigneeId);
+        // Resolve assignee in place — `buildUpdateInput` reads it
+        // directly. Match the createIssue pattern.
+        let assigneeId = args.assigneeId;
+        if (assigneeId && !isUuid(assigneeId)) {
+            assigneeId = await this.linearService.resolveUserId(assigneeId);
         }
-        const updateInput = this.buildUpdateInput(args, {
+        const updateInput = this.buildUpdateInput({ ...args, assigneeId }, {
             statusId: resolvedStatusId,
             projectId: finalProjectId,
             labelIds: finalLabelIds,
@@ -150,35 +154,37 @@ export class GraphQLIssuesService {
             }
         }
         const resolved = await this.resolveCreateFields(args, resolveResult);
-        if (args.assigneeId && !isUuid(args.assigneeId)) {
-            args.assigneeId = await this.linearService.resolveUserId(args.assigneeId);
-        }
-        const createInput = this.buildCreateInput(args, resolved);
+        // Mutate-the-input feels gross but matches the existing pattern
+        // — `resolved` doesn't carry assigneeId, so the buildCreateInput
+        // step reads `args.assigneeId` directly. Resolve in place.
+        let assigneeId = args.assigneeId;
+        if (assigneeId && !isUuid(assigneeId)) {
+            assigneeId = await this.linearService.resolveUserId(assigneeId);
+        }
+        const createInput = this.buildCreateInput({ ...args, assigneeId }, resolved);
         return this.executeCreateMutation(createInput);
     }
     async resolveCreateFields(args, resolveResult) {
         let teamId = args.teamId
             ? await this.resolveTeamId(args.teamId, resolveResult)
-            : args.teamId;
+            : undefined;
         const projectId = args.projectId
             ? this.resolveProjectId(args.projectId, resolveResult)
-            : args.projectId;
+            : undefined;
         // Validate team-project compatibility and auto-correct when possible
-        if (projectId && teamId) {
+        if (projectId && teamId && args.projectId) {
             teamId = this.validateProjectTeam(teamId, args.projectId, resolveResult);
         }
         const labelIds = await this.resolveLabels(args.labelIds, resolveResult, teamId, args.teamInput);
         const parentId = this.resolveParentId(args.parentId, resolveResult);
         const milestoneId = this.resolveMilestoneIdForCreate(args.milestoneId, resolveResult, projectId);
         let cycleId = args.cycleId;
-        if (args.cycleId &&
-            typeof args.cycleId === "string" &&
-            !isUuid(args.cycleId)) {
-            cycleId = await this.linearService.resolveCycleId(args.cycleId, teamId);
+        if (cycleId && !isUuid(cycleId)) {
+            cycleId = await this.linearService.resolveCycleId(cycleId, teamId);
         }
         let statusId = args.statusId;
-        if (args.statusId && !isUuid(args.statusId)) {
-            statusId = await this.linearService.resolveStatusId(args.statusId, teamId);
+        if (statusId && !isUuid(statusId)) {
+            statusId = await this.linearService.resolveStatusId(statusId, teamId);
         }
         return {
             teamId,
@@ -229,15 +235,16 @@ export class GraphQLIssuesService {
         }
         const finalTeamId = args.teamId
             ? await this.resolveTeamId(args.teamId, resolveResult)
-            : args.teamId;
+            : undefined;
         const finalProjectId = args.projectId
             ? this.resolveProjectId(args.projectId, resolveResult)
-            : args.projectId;
+            : undefined;
         const finalAssigneeId = this.resolveAssigneeId(args.assigneeId, resolveResult);
+        const limit = args.limit ?? 10;
         if (args.query) {
             const searchResult = await this.graphQLService.rawRequest(SEARCH_ISSUES_QUERY, {
                 term: args.query,
-                first: args.limit || 10,
+                first: limit,
             });
             const searchIssues = searchResult.searchIssues;
             if (!searchIssues?.nodes) {
@@ -263,9 +270,9 @@ export class GraphQLIssuesService {
             priority: args.priority,
         });
         const searchResult = await this.graphQLService.rawRequest(FILTERED_SEARCH_ISSUES_QUERY, {
-            first: args.limit || 10,
+            first: limit,
             filter: Object.keys(filter).length > 0 ? filter : undefined,
-            orderBy: args.orderBy || "updatedAt",
+            orderBy: args.orderBy ?? "updatedAt",
         });
         const filteredIssues = searchResult.issues;
         if (!filteredIssues?.nodes) {
@@ -324,7 +331,7 @@ export class GraphQLIssuesService {
         if (teamNodes.length === 1) {
             const correctTeamId = teamNodes[0].id;
             const correctKey = teamKeys[0];
-            process.stderr.write(`Auto-switched team to ${correctKey} (the only team associated with project "${projectName}").\n`);
+            logger.error(`Auto-switched team to ${correctKey} (the only team associated with project "${projectName}").`);
             return correctTeamId;
         }
         throw new Error(`Project "${projectName}" is not associated with the specified team.\n` +
@@ -399,7 +406,7 @@ export class GraphQLIssuesService {
                 const labelData = created.issueLabel;
                 const teamInfo = labelData.team;
                 const teamKey = teamInfo?.key ?? "";
-                process.stderr.write(`Auto-created label "${name}" on team ${teamKey}\n`);
+                logger.error(`Auto-created label "${name}" on team ${teamKey}`);
                 return labelData.id;
             }
             return null;
@@ -529,7 +536,14 @@ export class GraphQLIssuesService {
         return fetchedTeam?.id;
     }
     buildCreateInput(args, resolved) {
-        const input = { title: args.title };
+        const input = {};
+        // Title is required by Linear's API unless --from-template is set,
+        // in which case Linear copies the template's title. We only include
+        // the field when explicitly set so a missing title with templateId
+        // works as the API documents.
+        if (args.title) {
+            input.title = args.title;
+        }
         if (resolved.teamId) {
             input.teamId = resolved.teamId;
         }
@@ -548,9 +562,7 @@ export class GraphQLIssuesService {
         if (resolved.statusId) {
             input.stateId = resolved.statusId;
         }
-        if (resolved.labelIds &&
-            Array.isArray(resolved.labelIds) &&
-            resolved.labelIds.length > 0) {
+        if (resolved.labelIds && resolved.labelIds.length > 0) {
             input.labelIds = resolved.labelIds;
         }
         if (args.estimate !== undefined) {
@@ -565,14 +577,18 @@ export class GraphQLIssuesService {
         if (resolved.cycleId) {
             input.cycleId = resolved.cycleId;
         }
-        if (args.subscriberIds &&
-            Array.isArray(args.subscriberIds) &&
-            args.subscriberIds.length > 0) {
+        if (args.subscriberIds && args.subscriberIds.length > 0) {
             input.subscriberIds = args.subscriberIds;
         }
         if (args.dueDate !== undefined) {
             input.dueDate = args.dueDate;
         }
+        if (args.templateId !== undefined && args.templateId !== null) {
+            // Server-side template instantiation: Linear copies the
+            // template's title/description/labels/priority onto the
+            // new issue. Any explicit field above wins by override.
+            input.templateId = args.templateId;
+        }
         return input;
     }
     buildUpdateInput(args, resolved) {
@@ -705,7 +721,7 @@ export class GraphQLIssuesService {
             resolveVariables.teamKey = teamKey;
             resolveVariables.issueNumber = issueNumber;
         }
-        if (args.labelIds && Array.isArray(args.labelIds)) {
+        if (args.labelIds && args.labelIds.length > 0) {
             const nonUuidLabels = args.labelIds.filter((id) => !isUuid(id));
             if (nonUuidLabels.length > 0) {
                 resolveVariables.__labelNames = nonUuidLabels;
@@ -714,9 +730,7 @@ export class GraphQLIssuesService {
         if (args.projectId && !isUuid(args.projectId)) {
             resolveVariables.projectName = args.projectId;
         }
-        if (args.milestoneId &&
-            typeof args.milestoneId === "string" &&
-            !isUuid(args.milestoneId)) {
+        if (args.milestoneId && !isUuid(args.milestoneId)) {
             resolveVariables.milestoneName = args.milestoneId;
         }
         const { __labelNames, ...updateQueryVars } = resolveVariables;
@@ -750,7 +764,7 @@ export class GraphQLIssuesService {
         if (args.cycleId === undefined || args.cycleId === null) {
             return args.cycleId;
         }
-        if (typeof args.cycleId !== "string" || isUuid(args.cycleId)) {
+        if (isUuid(args.cycleId)) {
             return args.cycleId;
         }
         let teamIdForCycle = resolveResult.issues?.nodes?.[0]?.team?.id;
@@ -780,7 +794,7 @@ export class GraphQLIssuesService {
         if (args.milestoneId && !isUuid(args.milestoneId)) {
             resolveVariables.milestoneName = args.milestoneId;
         }
-        if (args.labelIds && Array.isArray(args.labelIds)) {
+        if (args.labelIds && args.labelIds.length > 0) {
             const nonUuidLabels = args.labelIds.filter((id) => !isUuid(id));
             if (nonUuidLabels.length > 0) {
                 resolveVariables.__labelNames = nonUuidLabels;

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,11 @@
+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;
+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;
+export declare function resetOutputFormat(): void;
 export declare function handleAsyncCommand<TArgs extends unknown[]>(asyncFn: (...args: TArgs) => Promise<void>): (...args: TArgs) => Promise<void>;