@enrichlayer/el-linear 1.43.0 → 1.43.1

package/dist/commands/issues.js

@@ -1341,6 +1341,14 @@ async function handleMarkBranch(issueId, options, command) {
                 `Pass one explicitly: 'el-linear issues mark-branch DEV-123'.`);
         }
     }
+    const branchIdentifier = extractIssueIdentifierFromBranch(branch);
+    if (issueId &&
+        branchIdentifier &&
+        branchIdentifier !== identifier &&
+        options.allowBranchMismatch !== true) {
+        throw new Error(`Branch '${branch}' implies ${branchIdentifier}, but the requested marker is ${identifier}. ` +
+            "Run this command from the matching branch, or pass --allow-branch-mismatch for deliberate recovery.");
+    }
     const previous = getBranchLinearIssue(branch);
     setBranchLinearIssue(branch, identifier);
     let claim;
@@ -1620,5 +1628,6 @@ export function setupIssuesCommands(program) {
         "Accepts a bare identifier (DEV-123), a branch-style token, or a Linear URL.\n" +
         "By default, also claims the issue (assignee = current Linear user; status = first started state). Pass --no-claim to only write git metadata.")
         .option("--no-claim", "only record git metadata; skip assigning the issue to the current Linear user and moving it to the first started state")
+        .option("--allow-branch-mismatch", "allow an explicit issue identifier that conflicts with the current branch name")
         .action(handleAsyncCommand(handleMarkBranch));
 }

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

@@ -436,7 +436,7 @@ export class GraphQLIssuesService {
             updateResult = await this.graphQLService.rawRequest(UPDATE_ISSUE_MUTATION, {
                 id: resolvedIssueId,
                 input: updateInput,
-            });
+            }, { retrySafeMutation: true });
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);

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

@@ -1,6 +1,21 @@
 import type { LinearCredential } from "../auth/linear-credential.js";
 import type { GraphQLResponseData, GraphQLVariables } from "../types/linear.js";
 import type { AuthOptions } from "./auth.js";
+export interface GraphQLRequestOptions {
+    /**
+     * Retry only an operation whose mutation is safe to repeat. Callers must
+     * opt in; creates and comment writes intentionally retain one-shot
+     * semantics because a transport failure can leave their server-side result
+     * unknown.
+     */
+    retrySafeMutation?: boolean;
+}
+interface GraphQLServiceRuntimeOptions {
+    retryDelaysMs?: readonly number[];
+    sleep?: (ms: number) => Promise<void>;
+}
+/** True only for failures where retrying a known-idempotent request is useful. */
+export declare function isTransientGraphQLError(error: unknown): boolean;
 /**
  * Constructor arg for `GraphQLService`. Re-exported alias of the shared
  * `LinearCredential` union (`{ apiKey } | { oauthToken }`). Kept as a
@@ -15,7 +30,10 @@ import type { AuthOptions } from "./auth.js";
 export type GraphQLServiceAuth = LinearCredential;
 export declare class GraphQLService {
     private readonly graphQLClient;
-    constructor(auth: GraphQLServiceAuth);
-    rawRequest<T = GraphQLResponseData>(query: string, variables?: GraphQLVariables): Promise<T>;
+    private readonly retryDelaysMs;
+    private readonly sleep;
+    constructor(auth: GraphQLServiceAuth, options?: GraphQLServiceRuntimeOptions);
+    rawRequest<T = GraphQLResponseData>(query: string, variables?: GraphQLVariables, options?: GraphQLRequestOptions): Promise<T>;
 }
 export declare function createGraphQLService(options: AuthOptions): Promise<GraphQLService>;
+export {};

package/dist/utils/graphql-service.js

@@ -1,5 +1,20 @@
 import { LinearClient } from "@linear/sdk";
 import { getActiveAuth } from "../auth/token-resolver.js";
+const DEFAULT_SAFE_MUTATION_RETRY_DELAYS_MS = [150, 400];
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** True only for failures where retrying a known-idempotent request is useful. */
+export function isTransientGraphQLError(error) {
+    const detail = error;
+    const status = detail.response?.status ?? detail.response?.statusCode;
+    if (status === 408 ||
+        status === 429 ||
+        (status !== undefined && status >= 500)) {
+        return true;
+    }
+    return /\b(?:408|429|500|502|503|504)\b|(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|fetch failed|network error|connection termination)/i.test(errorMessage(error));
+}
 function buildLinearClient(auth) {
     const baseHeaders = { "public-file-urls-expire-in": "3600" };
     if ("oauthToken" in auth) {
@@ -16,17 +31,38 @@ function buildLinearClient(auth) {
 }
 export class GraphQLService {
     graphQLClient;
-    constructor(auth) {
+    retryDelaysMs;
+    sleep;
+    constructor(auth, options = {}) {
         const client = buildLinearClient(auth);
         // LinearClient stores a private graphql-request client — access via escape hatch
         this.graphQLClient = client.client;
+        this.retryDelaysMs =
+            options.retryDelaysMs ?? DEFAULT_SAFE_MUTATION_RETRY_DELAYS_MS;
+        this.sleep =
+            options.sleep ??
+                ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     }
     // Default type allows property access on raw GraphQL responses.
     // Callers can narrow with explicit type parameter: rawRequest<{ issues: { nodes: T[] } }>(...)
-    async rawRequest(query, variables) {
+    async rawRequest(query, variables, options = {}) {
+        let attempt = 0;
         try {
-            const response = await this.graphQLClient.rawRequest(query, variables);
-            return response.data;
+            while (true) {
+                try {
+                    const response = await this.graphQLClient.rawRequest(query, variables);
+                    return response.data;
+                }
+                catch (error) {
+                    if (!options.retrySafeMutation ||
+                        attempt >= this.retryDelaysMs.length ||
+                        !isTransientGraphQLError(error)) {
+                        throw error;
+                    }
+                    await this.sleep(this.retryDelaysMs[attempt]);
+                    attempt += 1;
+                }
+            }
         }
         catch (error) {
             const err = error;

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

@@ -37,8 +37,8 @@ export interface ProtectedRange {
 }
 /**
  * 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.
+ * Covered: fenced code, inline backticks, HTML comments, 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.

package/dist/utils/protected-ranges.js

@@ -22,6 +22,12 @@ const FENCED_CODE_BLOCK_REGEX = /(?:^|\n)([ \t]*)(?:```|~~~)[^\n]*\n[\s\S]*?\n\1
 // for spans containing backticks; we keep it simple and match
 // single-backtick spans, which covers the common case.
 const INLINE_CODE_REGEX = /`[^`\n]+?`/g;
+// HTML comments carry machine-readable metadata in Markdown documents (for
+// example, el-git's signed review and nit-disposition markers). They are not
+// rendered prose, so identifiers inside them must remain byte-for-byte stable.
+// Treat an unterminated comment as extending to EOF: preserving a malformed
+// marker is safer than inserting Markdown into its payload.
+const HTML_COMMENT_REGEX = /<!--[\s\S]*?(?:-->|$)/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;
@@ -116,8 +122,8 @@ function trimBareUrlTrailingPunct(url) {
 }
 /**
  * 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.
+ * Covered: fenced code, inline backticks, HTML comments, 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.
@@ -127,6 +133,7 @@ export function findProtectedRanges(text) {
     for (const re of [
         FENCED_CODE_BLOCK_REGEX,
         INLINE_CODE_REGEX,
+        HTML_COMMENT_REGEX,
         MARKDOWN_LINK_REGEX,
         // Slack links must be considered before generic angle-bracket
         // autolinks — the autolink regex doesn't know about the `|label`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enrichlayer/el-linear",
-  "version": "1.43.0",
+  "version": "1.43.1",
   "description": "A pragmatic CLI for Linear.app — deterministic team/label/member resolution, structured issue validation, configurable term enforcement, and a GraphQL escape hatch.",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",