@enrichlayer/el-linear 1.5.0 → 1.6.0

package/dist/commands/teams.js

@@ -1,5 +1,6 @@
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 export function setupTeamsCommands(program) {
     const teams = program
         .command("teams")
@@ -11,8 +12,8 @@ export function setupTeamsCommands(program) {
         .description("List all teams")
         .option("-l, --limit <number>", "limit results", "100")
         .action(handleAsyncCommand(async (options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const service = createLinearService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const service = await createLinearService(rootOpts);
         const result = await service.getTeams(Number.parseInt(options.limit, 10));
         outputSuccess({ data: result, meta: { count: result.length } });
     }));

package/dist/commands/templates.js

@@ -1,6 +1,7 @@
 import { TEMPLATE_BY_ID_QUERY, TEMPLATES_LIST_QUERY, } from "../queries/templates.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 import { parsePositiveInt } from "../utils/validators.js";
 function formatTemplateSummary(t) {
     return {
@@ -25,8 +26,8 @@ export function setupTemplatesCommands(program) {
         .option("--type <type>", "filter by type (issue, document, project, recurringIssue)")
         .option("-l, --limit <number>", "limit results", "50")
         .action(handleAsyncCommand(async (options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const graphQLService = createGraphQLService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const graphQLService = await createGraphQLService(rootOpts);
         const limit = parsePositiveInt(options.limit, "--limit");
         const result = await graphQLService.rawRequest(TEMPLATES_LIST_QUERY);
         let items = result.templates ?? [];
@@ -44,8 +45,8 @@ export function setupTemplatesCommands(program) {
         .command("read <templateId>")
         .description("Read a template including its full content (templateData)")
         .action(handleAsyncCommand(async (templateId, _options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const graphQLService = createGraphQLService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest(TEMPLATE_BY_ID_QUERY, {
             id: templateId,
         });

package/dist/commands/users.js

@@ -1,5 +1,6 @@
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
 export function setupUsersCommands(program) {
     const users = program.command("users").description("User operations");
     users.action(() => users.help());
@@ -9,8 +10,8 @@ export function setupUsersCommands(program) {
         .option("--active", "Only show active users")
         .option("-l, --limit <number>", "limit results", "100")
         .action(handleAsyncCommand(async (options, command) => {
-        const rootOpts = command.parent.parent.opts();
-        const service = createLinearService(rootOpts);
+        const rootOpts = getRootOpts(command);
+        const service = await createLinearService(rootOpts);
         const result = await service.getUsers(options.active, Number.parseInt(options.limit, 10));
         outputSuccess({ data: result, meta: { count: result.length } });
     }));

package/dist/config/config.d.ts

@@ -39,6 +39,24 @@ export interface ElLinearConfig {
      * once per session and caches the result.
      */
     workspaceUrlKey?: string;
+    /**
+     * Text appended to issue descriptions and comment bodies on the `create`
+     * paths. Treated as a literal string — include any `\n\n---\n` separator
+     * yourself if you want a horizontal rule. CLI flags `--footer <text>` and
+     * `--no-footer` override this per-invocation.
+     */
+    messageFooter?: string;
+    /**
+     * Named description boilerplates for `el-linear issues create --template <name>`.
+     * The template's value is used as the description body when `--template` is
+     * provided and neither `--description` nor `--description-file` is set.
+     *
+     * Example:
+     *   "descriptionTemplates": {
+     *     "bug": "## Steps to reproduce\n\n1. ...\n\n## Expected\n\n...\n\n## Actual\n\n..."
+     *   }
+     */
+    descriptionTemplates?: Record<string, string>;
 }
 /** Test seam — resets the cache between test cases. */
 export declare function _resetConfigCacheForTests(): void;

package/dist/config/issue-validation.js

@@ -210,7 +210,7 @@ function checkTitleVerbAlignment(title, typeLabel, result) {
         for (const verb of typeVerbs) {
             if (!verb.includes(" "))
                 continue;
-            if (title.toLowerCase().startsWith(verb.toLowerCase() + " ") ||
+            if (title.toLowerCase().startsWith(`${verb.toLowerCase()} `) ||
                 title.toLowerCase() === verb.toLowerCase()) {
                 if (type === typeLabel)
                     return; // match — all good

package/dist/config/resolver.js

@@ -91,7 +91,7 @@ export function resolveMember(input) {
  */
 export async function resolveAssignee(input, rootOpts) {
     if (input.toLowerCase() === "me") {
-        const graphQLService = createGraphQLService(rootOpts);
+        const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest("{ viewer { id } }");
         const viewer = result.viewer;
         if (!viewer?.id) {

package/dist/main.js

@@ -30,7 +30,7 @@ import { splitList } from "./utils/validators.js";
 program
     .name("el-linear")
     .description("A pragmatic CLI for Linear.app — deterministic resolution, structured validation, GraphQL escape hatch.")
-    .version("1.5.0")
+    .version("1.6.0")
     .option("--api-token <token>", "Linear API token")
     .option("--profile <name>", "named profile (under ~/.config/el-linear/profiles/<name>/) for this invocation. Overrides EL_LINEAR_PROFILE env + the on-disk active-profile marker.")
     .option("--json", "output as JSON (default, accepted for compatibility)")

package/dist/utils/download-uploads.d.ts

@@ -1,7 +1,8 @@
 import type { LinearIssue } from "../types/linear.js";
+import type { FileService } from "./file-service.js";
 /**
  * Downloads all uploads.linear.app URLs found in an issue's description
  * and comments, replacing them with local file paths so Claude Code
  * can read the images directly.
  */
-export declare function downloadLinearUploads(issue: LinearIssue, apiToken: string): Promise<LinearIssue>;
+export declare function downloadLinearUploads(issue: LinearIssue, fileService: FileService): Promise<LinearIssue>;

package/dist/utils/download-uploads.js

@@ -1,7 +1,6 @@
 import { mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { FileService } from "./file-service.js";
 const DOWNLOAD_DIR = join(tmpdir(), "el-linear-downloads");
 const UPLOAD_URL_REGEX = /https:\/\/uploads\.linear\.app\/[^\s)>\]"]+/g;
 function collectUploadUrls(text) {
@@ -20,7 +19,7 @@ function replaceUrls(text, urlMap) {
  * and comments, replacing them with local file paths so Claude Code
  * can read the images directly.
  */
-export async function downloadLinearUploads(issue, apiToken) {
+export async function downloadLinearUploads(issue, fileService) {
     const allUrls = new Set();
     if (issue.description) {
         for (const url of collectUploadUrls(issue.description)) {
@@ -38,7 +37,6 @@ export async function downloadLinearUploads(issue, apiToken) {
         return issue;
     }
     await mkdir(DOWNLOAD_DIR, { recursive: true });
-    const fileService = new FileService(apiToken);
     const urlMap = new Map();
     await Promise.all([...allUrls].map(async (url) => {
         const filename = extractUniqueFilename(url);
@@ -78,7 +76,7 @@ function extractUniqueFilename(url) {
         // Path like /workspace-id/uuid1/uuid2/filename.png — take last two parts for uniqueness
         const parts = urlObj.pathname.split("/").filter(Boolean);
         if (parts.length >= 2) {
-            return `${parts.at(-2).slice(0, 8)}-${parts.at(-1)}`;
+            return `${parts.at(-2)?.slice(0, 8)}-${parts.at(-1) ?? ""}`;
         }
         return parts.at(-1) || "download";
     }

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

@@ -1,7 +1,22 @@
 import type { FileDownloadResult, FileUploadResult } from "../types/linear.js";
+/**
+ * Constructor arg shapes for `FileService`:
+ *   - `string` → personal API token (legacy; sent as `Authorization: <token>`).
+ *   - `{apiKey: string}` → personal API token (explicit).
+ *   - `{oauthToken: string}` → OAuth access token (sent as
+ *     `Authorization: Bearer <token>`).
+ *
+ * The string variant exists because dozens of tests construct `FileService`
+ * with a plain string. We continue to support it indefinitely.
+ */
+export type FileServiceAuth = string | {
+    apiKey: string;
+} | {
+    oauthToken: string;
+};
 export declare class FileService {
-    private readonly apiToken;
-    constructor(apiToken: string);
+    private readonly authHeader;
+    constructor(auth: FileServiceAuth);
     downloadFile(url: string, options?: {
         output?: string;
         overwrite?: boolean;
@@ -11,3 +26,12 @@ export declare class FileService {
     private requestUploadUrl;
     private putFileToUrl;
 }
+import type { AuthOptions } from "./auth.js";
+/**
+ * OAuth-aware factory: resolves the active credential (with auto-refresh
+ * for OAuth tokens) and returns a `FileService` configured with the right
+ * `Authorization` header shape. Personal tokens use `Authorization:
+ * <token>` (no Bearer prefix); OAuth tokens use `Authorization: Bearer
+ * <token>`.
+ */
+export declare function createFileService(options: AuthOptions): Promise<FileService>;

package/dist/utils/file-service.js

@@ -37,10 +37,17 @@ function getMimeType(filePath) {
     const ext = extname(filePath).toLowerCase();
     return MIME_TYPES[ext] || "application/octet-stream";
 }
+function buildAuthHeader(auth) {
+    if (typeof auth === "string")
+        return auth;
+    if ("oauthToken" in auth)
+        return `Bearer ${auth.oauthToken}`;
+    return auth.apiKey;
+}
 export class FileService {
-    apiToken;
-    constructor(apiToken) {
-        this.apiToken = apiToken;
+    authHeader;
+    constructor(auth) {
+        this.authHeader = buildAuthHeader(auth);
     }
     async downloadFile(url, options = {}) {
         if (!isLinearUploadUrl(url)) {
@@ -67,7 +74,7 @@ export class FileService {
             const isSignedUrl = urlObj.searchParams.has("signature");
             const headers = {};
             if (!isSignedUrl) {
-                headers.Authorization = this.apiToken;
+                headers.Authorization = this.authHeader;
             }
             const response = await fetch(url, { method: "GET", headers });
             if (!response.ok) {
@@ -162,7 +169,7 @@ export class FileService {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                Authorization: this.apiToken,
+                Authorization: this.authHeader,
             },
             body: JSON.stringify({
                 query,
@@ -237,3 +244,18 @@ export class FileService {
         return { success: true, assetUrl: meta.assetUrl, filename };
     }
 }
+import { getActiveAuth } from "../auth/token-resolver.js";
+/**
+ * OAuth-aware factory: resolves the active credential (with auto-refresh
+ * for OAuth tokens) and returns a `FileService` configured with the right
+ * `Authorization` header shape. Personal tokens use `Authorization:
+ * <token>` (no Bearer prefix); OAuth tokens use `Authorization: Bearer
+ * <token>`.
+ */
+export async function createFileService(options) {
+    const auth = await getActiveAuth(options);
+    if (auth.kind === "oauth") {
+        return new FileService({ oauthToken: auth.token });
+    }
+    return new FileService({ apiKey: auth.token });
+}

package/dist/utils/footer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Append a footer to a body string.
+ *
+ * Resolution order:
+ *   1. `--no-footer` flag → return body unchanged
+ *   2. `--footer <text>` flag → use the explicit value
+ *   3. `config.messageFooter` → use the configured value
+ *   4. nothing set → return body unchanged
+ *
+ * The footer is treated as a literal string — callers who want a horizontal
+ * rule or blank line before it must include the separator in the value.
+ *
+ * Used on `create` paths only (issues create, comments create). Update paths
+ * take an explicit body the user has already authored, so we don't auto-inject.
+ */
+export declare function applyFooter(body: string | undefined, options: {
+    footer?: string;
+    noFooter?: boolean;
+}): string | undefined;

package/dist/utils/footer.js

@@ -0,0 +1,27 @@
+import { loadConfig } from "../config/config.js";
+/**
+ * Append a footer to a body string.
+ *
+ * Resolution order:
+ *   1. `--no-footer` flag → return body unchanged
+ *   2. `--footer <text>` flag → use the explicit value
+ *   3. `config.messageFooter` → use the configured value
+ *   4. nothing set → return body unchanged
+ *
+ * The footer is treated as a literal string — callers who want a horizontal
+ * rule or blank line before it must include the separator in the value.
+ *
+ * Used on `create` paths only (issues create, comments create). Update paths
+ * take an explicit body the user has already authored, so we don't auto-inject.
+ */
+export function applyFooter(body, options) {
+    if (options.noFooter) {
+        return body;
+    }
+    const explicit = options.footer;
+    const footer = explicit ?? loadConfig().messageFooter;
+    if (!footer) {
+        return body;
+    }
+    return body ? `${body}${footer}` : footer;
+}

package/dist/utils/gdoc-parser.js

@@ -82,7 +82,7 @@ export function parseGoogleDoc(doc) {
                         .filter((c) => c.paragraph)
                         .map((c) => {
                         let text = "";
-                        for (const el of c.paragraph.elements) {
+                        for (const el of c.paragraph?.elements ?? []) {
                             text += formatTextRun(el);
                         }
                         return text.replace(TRAILING_NEWLINE_RE, "");

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

@@ -8,5 +8,5 @@ declare class GraphQLAttachmentsService {
     deleteAttachment(id: string): Promise<boolean>;
     listAttachments(issueId: string): Promise<LinearAttachment[]>;
 }
-export declare function createGraphQLAttachmentsService(options: AuthOptions): GraphQLAttachmentsService;
+export declare function createGraphQLAttachmentsService(options: AuthOptions): Promise<GraphQLAttachmentsService>;
 export {};

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

@@ -40,7 +40,7 @@ class GraphQLAttachmentsService {
         return attachments.nodes.map(transformAttachment);
     }
 }
-export function createGraphQLAttachmentsService(options) {
-    const graphqlService = createGraphQLService(options);
+export async function createGraphQLAttachmentsService(options) {
+    const graphqlService = await createGraphQLService(options);
     return new GraphQLAttachmentsService(graphqlService);
 }

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

@@ -14,5 +14,5 @@ declare class GraphQLDocumentsService {
     deleteDocument(id: string): Promise<boolean>;
     listDocumentsBySlugIds(slugIds: string[], limit?: number): Promise<LinearDocument[]>;
 }
-export declare function createGraphQLDocumentsService(options: AuthOptions): GraphQLDocumentsService;
+export declare function createGraphQLDocumentsService(options: AuthOptions): Promise<GraphQLDocumentsService>;
 export {};

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

@@ -91,7 +91,7 @@ class GraphQLDocumentsService {
         return result.documents.nodes.map(transformDocument);
     }
 }
-export function createGraphQLDocumentsService(options) {
-    const graphqlService = createGraphQLService(options);
+export async function createGraphQLDocumentsService(options) {
+    const graphqlService = await createGraphQLService(options);
     return new GraphQLDocumentsService(graphqlService);
 }

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

@@ -1,5 +1,5 @@
 import type { GraphQLResponseData, GraphQLVariables } from "../types/linear.js";
-import { type AuthOptions } from "./auth.js";
+import type { AuthOptions } from "./auth.js";
 /**
  * Constructor arg shapes for `GraphQLService`. Three variants:
  *   - `string` → personal API token (legacy; sent without `Bearer` prefix).
@@ -20,4 +20,4 @@ export declare class GraphQLService {
     constructor(auth: GraphQLServiceAuth);
     rawRequest<T = GraphQLResponseData>(query: string, variables?: GraphQLVariables): Promise<T>;
 }
-export declare function createGraphQLService(options: AuthOptions): GraphQLService;
+export declare function createGraphQLService(options: AuthOptions): Promise<GraphQLService>;

package/dist/utils/graphql-service.js

@@ -1,5 +1,5 @@
 import { LinearClient } from "@linear/sdk";
-import { getApiToken } from "./auth.js";
+import { getActiveAuth } from "../auth/token-resolver.js";
 function buildLinearClient(auth) {
     const baseHeaders = { "public-file-urls-expire-in": "3600" };
     if (typeof auth === "string") {
@@ -41,7 +41,10 @@ export class GraphQLService {
         }
     }
 }
-export function createGraphQLService(options) {
-    const apiToken = getApiToken(options);
-    return new GraphQLService(apiToken);
+export async function createGraphQLService(options) {
+    const auth = await getActiveAuth(options);
+    if (auth.kind === "oauth") {
+        return new GraphQLService({ oauthToken: auth.token });
+    }
+    return new GraphQLService({ apiKey: auth.token });
 }

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

@@ -1,8 +1,23 @@
 import type { LinearComment, LinearCycleDetail, LinearCycleSummary, LinearLabel, LinearProject, LinearTeam, LinearUser } from "../types/linear.js";
-import { type AuthOptions } from "./auth.js";
+import type { AuthOptions } from "./auth.js";
+/**
+ * Constructor arg shapes for `LinearService`. Three variants:
+ *   - `string` → personal API token (legacy; sent without `Bearer` prefix).
+ *   - `{apiKey: string}` → personal API token (explicit).
+ *   - `{oauthToken: string}` → OAuth access token (sent as
+ *     `Authorization: Bearer <token>` via the SDK's accessToken option).
+ *
+ * The string variant exists because hundreds of call sites and tests pass
+ * a plain string. We continue to support it indefinitely.
+ */
+export type LinearServiceAuth = string | {
+    apiKey: string;
+} | {
+    oauthToken: string;
+};
 export declare class LinearService {
     private readonly client;
-    constructor(apiToken: string);
+    constructor(auth: LinearServiceAuth);
     resolveIssueId(issueId: string): Promise<string>;
     getTeams(limit?: number): Promise<LinearTeam[]>;
     resolveUserId(nameOrEmailOrId: string): Promise<string>;
@@ -23,4 +38,4 @@ export declare class LinearService {
     resolveCycleId(cycleNameOrId: string, teamFilter?: string): Promise<string>;
     resolveProjectId(projectNameOrId: string): Promise<string>;
 }
-export declare function createLinearService(options: AuthOptions): LinearService;
+export declare function createLinearService(options: AuthOptions): Promise<LinearService>;

package/dist/utils/linear-service.js

@@ -1,6 +1,6 @@
 import { LinearClient } from "@linear/sdk";
+import { getActiveAuth } from "../auth/token-resolver.js";
 import { resolveUserDisplayName } from "../config/resolver.js";
-import { getApiToken } from "./auth.js";
 import { toISOStringOrNow, toISOStringOrUndefined } from "./date-format.js";
 import { multipleMatchesError, notFoundError } from "./error-messages.js";
 import { parseIssueIdentifier } from "./identifier-parser.js";
@@ -21,10 +21,22 @@ function teamIdFilter(teamId) {
 function nonEmptyFilter(filter) {
     return Object.keys(filter).length > 0 ? filter : undefined;
 }
+function buildLinearClient(auth) {
+    if (typeof auth === "string") {
+        return new LinearClient({ apiKey: auth });
+    }
+    if ("oauthToken" in auth) {
+        // Linear's SDK natively supports OAuth via the `accessToken` option,
+        // which causes the underlying transport to send
+        // `Authorization: Bearer <token>` instead of the personal-token shape.
+        return new LinearClient({ accessToken: auth.oauthToken });
+    }
+    return new LinearClient({ apiKey: auth.apiKey });
+}
 export class LinearService {
     client;
-    constructor(apiToken) {
-        this.client = new LinearClient({ apiKey: apiToken });
+    constructor(auth) {
+        this.client = buildLinearClient(auth);
     }
     async resolveIssueId(issueId) {
         if (isUuid(issueId)) {
@@ -436,7 +448,10 @@ export class LinearService {
         return projectsConnection.nodes[0].id;
     }
 }
-export function createLinearService(options) {
-    const apiToken = getApiToken(options);
-    return new LinearService(apiToken);
+export async function createLinearService(options) {
+    const auth = await getActiveAuth(options);
+    if (auth.kind === "oauth") {
+        return new LinearService({ oauthToken: auth.token });
+    }
+    return new LinearService({ apiKey: auth.token });
 }

package/dist/utils/markdown-prosemirror.js

@@ -106,8 +106,11 @@ function parseBulletList(state, line) {
         return false;
     }
     const items = [];
-    while (state.i < state.lines.length && BULLET_RE.test(state.lines[state.i])) {
+    while (state.i < state.lines.length) {
         const m = state.lines[state.i].match(BULLET_RE);
+        if (!m) {
+            break;
+        }
         items.push({
             type: "listItem",
             content: [{ type: "paragraph", content: parseInline(m[1]) }],
@@ -122,9 +125,11 @@ function parseOrderedList(state, line) {
         return false;
     }
     const items = [];
-    while (state.i < state.lines.length &&
-        ORDERED_RE.test(state.lines[state.i])) {
+    while (state.i < state.lines.length) {
         const m = state.lines[state.i].match(ORDERED_RE);
+        if (!m) {
+            break;
+        }
         items.push({
             type: "listItem",
             content: [{ type: "paragraph", content: parseInline(m[1]) }],
@@ -139,9 +144,11 @@ function parseBlockquote(state) {
         return false;
     }
     const quoteLines = [];
-    while (state.i < state.lines.length &&
-        BLOCKQUOTE_RE.test(state.lines[state.i])) {
+    while (state.i < state.lines.length) {
         const m = state.lines[state.i].match(BLOCKQUOTE_RE);
+        if (!m) {
+            break;
+        }
         quoteLines.push(m[1]);
         state.i++;
     }
@@ -283,7 +290,7 @@ function findEarliestInlineMatch(text) {
     const codeMatch = text.match(INLINE_CODE_RE);
     if (codeMatch) {
         candidates.push({
-            index: codeMatch.index,
+            index: codeMatch.index ?? 0,
             length: codeMatch[0].length,
             innerText: codeMatch[1],
             marks: [{ type: "code" }],
@@ -292,7 +299,7 @@ function findEarliestInlineMatch(text) {
     const linkMatch = text.match(INLINE_LINK_RE);
     if (linkMatch) {
         candidates.push({
-            index: linkMatch.index,
+            index: linkMatch.index ?? 0,
             length: linkMatch[0].length,
             innerText: linkMatch[1],
             marks: [{ type: "link", attrs: { href: linkMatch[2] } }],
@@ -301,7 +308,7 @@ function findEarliestInlineMatch(text) {
     const boldMatch = text.match(INLINE_BOLD_RE);
     if (boldMatch) {
         candidates.push({
-            index: boldMatch.index,
+            index: boldMatch.index ?? 0,
             length: boldMatch[0].length,
             innerText: boldMatch[1] ?? boldMatch[2],
             marks: [{ type: "bold" }],
@@ -310,7 +317,7 @@ function findEarliestInlineMatch(text) {
     const italicMatch = text.match(INLINE_ITALIC_RE);
     if (italicMatch) {
         candidates.push({
-            index: italicMatch.index,
+            index: italicMatch.index ?? 0,
             length: italicMatch[0].length,
             innerText: italicMatch[1] ?? italicMatch[2],
             marks: [{ type: "italic" }],

package/dist/utils/root-opts.d.ts

@@ -0,0 +1,11 @@
+import type { Command, OptionValues } from "commander";
+/**
+ * Extract root command options from inside a subcommand action handler.
+ *
+ * Commander guarantees `command.parent` exists inside any subcommand action,
+ * and `command.parent.parent` exists inside a nested subcommand action
+ * (e.g. `el-linear comments create` — the `create` command is nested under
+ * `comments`, which is nested under the root program). The non-null
+ * assertions live here so call sites can stay clean and typed.
+ */
+export declare function getRootOpts(command: Command): OptionValues;

package/dist/utils/root-opts.js

@@ -0,0 +1,13 @@
+/**
+ * Extract root command options from inside a subcommand action handler.
+ *
+ * Commander guarantees `command.parent` exists inside any subcommand action,
+ * and `command.parent.parent` exists inside a nested subcommand action
+ * (e.g. `el-linear comments create` — the `create` command is nested under
+ * `comments`, which is nested under the root program). The non-null
+ * assertions live here so call sites can stay clean and typed.
+ */
+export function getRootOpts(command) {
+    // biome-ignore lint/style/noNonNullAssertion: command.parent / .parent.parent are guaranteed by commander inside subcommand actions; see docstring
+    return (command.parent?.parent ?? command.parent).opts();
+}

package/dist/utils/validators.d.ts

@@ -1,4 +1,11 @@
 export declare function parsePositiveInt(value: string, flagName: string): number;
+/**
+ * Parse a single priority value (for `issues create --priority`, `issues update --priority`).
+ *
+ * Accepts:
+ *   - keywords:  none | urgent | high | medium | normal | low
+ *   - numbers:   0 (no priority), 1 (urgent), 2 (high), 3 (medium), 4 (low)
+ */
 export declare function validatePriority(value: string): number;
 export declare function validateHexColor(value: string): string;
 export declare function validateIsoDate(value: string): string;

package/dist/utils/validators.js

@@ -8,14 +8,21 @@ export function parsePositiveInt(value, flagName) {
     }
     return n;
 }
+/**
+ * Parse a single priority value (for `issues create --priority`, `issues update --priority`).
+ *
+ * Accepts:
+ *   - keywords:  none | urgent | high | medium | normal | low
+ *   - numbers:   0 (no priority), 1 (urgent), 2 (high), 3 (medium), 4 (low)
+ */
 export function validatePriority(value) {
     const asName = PRIORITY_NAMES[value.toLowerCase()];
-    if (asName !== undefined && asName >= 1) {
+    if (asName !== undefined) {
         return asName;
     }
     const n = Number.parseInt(value, 10);
-    if (Number.isNaN(n) || n < 1 || n > 4) {
-        throw invalidParameterError("--priority", `"${value}" is not valid. Use names (urgent, high, medium/normal, low) or numbers (1-4).`);
+    if (Number.isNaN(n) || n < 0 || n > 4) {
+        throw invalidParameterError("--priority", `"${value}" is not valid. Use names (none, urgent, high, medium/normal, low) or numbers (0-4).`);
     }
     return n;
 }
@@ -41,6 +48,9 @@ export function splitList(value) {
         .map((s) => s.trim())
         .filter((s) => s.length > 0);
 }
+// Shared keyword → Linear priority number map. `none` and `0` mean "No priority"
+// (Linear stores it as a real state, not absence). `1..4` are the rated priorities,
+// `urgent` (1) being the highest.
 const PRIORITY_NAMES = {
     none: 0,
     urgent: 1,
@@ -50,17 +60,7 @@ const PRIORITY_NAMES = {
     low: 4,
 };
 export function parsePriorityFilter(value) {
-    return splitList(value).map((item) => {
-        const asName = PRIORITY_NAMES[item.toLowerCase()];
-        if (asName !== undefined) {
-            return asName;
-        }
-        const n = Number.parseInt(item, 10);
-        if (Number.isNaN(n) || n < 0 || n > 4) {
-            throw invalidParameterError("--priority", `"${item}" is not valid. Use names (urgent, high, medium, low, none) or numbers (0-4).`);
-        }
-        return n;
-    });
+    return splitList(value).map((item) => validatePriority(item));
 }
 export const PRIORITY_LABELS = {
     0: "No priority",