@enrichlayer/el-linear 1.30.0 → 1.32.1

package/README.md

@@ -662,9 +662,9 @@ Mutually exclusive with `--field` / `--sections` / `--with`.
 
 ### One-line write confirmations: `-q, --quiet`
 
-`issues create|update` and `comments create|update` accept `-q, --quiet`,
-printing a single confirmation line instead of the full JSON envelope so
-you don't have to `grep` the result:
+`issues create|update`, `issues relate`, and `comments create|update` accept
+`-q, --quiet`, printing a single confirmation line instead of the full JSON
+envelope so you don't have to `grep` the result:
 
 ```bash
 el-linear issues update DEV-123 --status "In Review" --quiet
@@ -672,6 +672,24 @@ el-linear issues update DEV-123 --status "In Review" --quiet
 
 el-linear comments create DEV-123 --body "..." --quiet
 # comment 6f1c…
+
+el-linear issues relate DEV-123 --related-to "DEV-456,DEV-789" --quiet
+# DEV-123  related DEV-456,DEV-789  (2)
+```
+
+For `issues relate` the line is source-oriented — relations are grouped by
+type from the source issue's perspective, so a `--blocked-by` reads back as
+`blockedBy`. `--format summary` renders the same source-oriented view as a
+`TYPE / TARGET / TITLE` table (TARGET is the peer issue; the source isn't
+repeated as a column):
+
+```bash
+el-linear issues relate DEV-1 --blocked-by DEV-9 --format summary
+# TYPE        TARGET   TITLE
+# ------------------------------------
+# blockedBy   DEV-9    Add IP ban system
+#
+# 1 relation
 ```
 
 `--quiet` overrides `--format` and is independent of `--fields` / `--jq`.

package/claude-skills/linear-operations/SKILL.md

@@ -197,7 +197,15 @@ el-linear issues search "keywords from proposed title" --include-closed 2>&1
    el-linear issues create "Title" --team ENG --related-to "ENG-456,ENG-789" ... 2>&1
    ```
 
-### Surfacing relation candidates — explicit user reply required ([DEV-4494](https://linear.app/verticalint/issue/DEV-4494/))
+### Existence check — before an "add capability X" issue ([DEV-5097](https://linear.app/verticalint/issue/DEV-5097/))
+
+The dup-check above guards against duplicating an *issue*. This guards against duplicating *reality*: before filing an issue to **add** a flag / guard / command / subcommand, confirm it doesn't **already exist**.
+
+- `<cli> <subcommand> --help` (the flag may be a global option absent from the subcommand's help — check `<cli> --help` too).
+- `el-catalog commands --search "<intent>"` / `el-catalog clis --search` (the snapshot likely already lists it).
+- For a hook/guard, grep the source — e.g. `cli/el-hook/src/checks`.
+
+Skipping it cost two needless branch+MR cycles in one session: a "feature" issue to add a hook guard that already existed and was firing, and one to add `--jq`/`--fields` flags that already worked — both premises only caught at implementation.
 
 When `el-linear issues search` (or the cross-resource `search`) returns rows
 carrying issue identifiers, the JSON envelope embeds a `_warnings` line

package/dist/commands/branch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `el-linear branch validate [branch]` — validate that a branch name carries a
+ * **real** Linear team prefix, checked against the workspace's actual teams
+ * (cached `teams list`) rather than a hand-maintained allowlist.
+ *
+ * Built so the tools-repo pre-commit gate (`check-linear-branch.sh`) can
+ * delegate team-validity here instead of hardcoding a bash regex that drifts
+ * (it already did: phantom `CS`, missing `CUS/EMW/NIC/PYT`). Branch *parsing*
+ * already lives in `issue-id`/`parseBranchName`; this adds team *validity*.
+ *
+ * Exit codes (so a caller can distinguish "block" from "fall back"):
+ *   0 — valid: a real team, or an exempt branch (main/master/detached/empty)
+ *   1 — invalid: parsed a team that isn't a real workspace team, or no Linear ID
+ *   2 — indeterminate: the team set couldn't be loaded (offline + cold cache);
+ *       lets the caller fall back to its own check rather than hard-block
+ *
+ * `--exit-zero` reports the JSON verdict but always exits 0 (report-only).
+ */
+import type { Command } from "commander";
+export declare function setupBranchCommands(program: Command): void;

package/dist/commands/branch.js

@@ -0,0 +1,101 @@
+/**
+ * `el-linear branch validate [branch]` — validate that a branch name carries a
+ * **real** Linear team prefix, checked against the workspace's actual teams
+ * (cached `teams list`) rather than a hand-maintained allowlist.
+ *
+ * Built so the tools-repo pre-commit gate (`check-linear-branch.sh`) can
+ * delegate team-validity here instead of hardcoding a bash regex that drifts
+ * (it already did: phantom `CS`, missing `CUS/EMW/NIC/PYT`). Branch *parsing*
+ * already lives in `issue-id`/`parseBranchName`; this adds team *validity*.
+ *
+ * Exit codes (so a caller can distinguish "block" from "fall back"):
+ *   0 — valid: a real team, or an exempt branch (main/master/detached/empty)
+ *   1 — invalid: parsed a team that isn't a real workspace team, or no Linear ID
+ *   2 — indeterminate: the team set couldn't be loaded (offline + cold cache);
+ *       lets the caller fall back to its own check rather than hard-block
+ *
+ * `--exit-zero` reports the JSON verdict but always exits 0 (report-only).
+ */
+import { loadConfig } from "../config/config.js";
+import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
+import { getCurrentBranch, parseBranchName } from "./issue-id.js";
+import { TEAMS_LIST_DEFAULT_LIMIT } from "./teams.js";
+// Branches that never carry a Linear ID and must not be blocked. Mirrors the
+// exemptions in the tools-repo gate (main/master/detached HEAD/empty).
+const EXEMPT_BRANCHES = new Set(["main", "master", "HEAD", ""]);
+export function setupBranchCommands(program) {
+    const branch = program.command("branch").description("Branch-name helpers");
+    branch.action(() => branch.help());
+    branch
+        .command("validate [branch]")
+        .description("Validate a branch's team prefix against real workspace teams. Exit 0 valid, 1 invalid, 2 indeterminate.")
+        .option("--exit-zero", "report the verdict as JSON but always exit 0 (report-only)", false)
+        .action(handleAsyncCommand(async (branchArg, options, command) => {
+        const branchName = branchArg ?? getCurrentBranch();
+        if (EXEMPT_BRANCHES.has(branchName)) {
+            outputSuccess({
+                branch: branchName,
+                valid: true,
+                team: null,
+                issueId: null,
+                reason: "exempt",
+            });
+            return;
+        }
+        const parsed = parseBranchName(branchName);
+        if (!(parsed.issueId && parsed.team)) {
+            outputSuccess({
+                branch: branchName,
+                valid: false,
+                team: null,
+                issueId: null,
+                reason: "no-linear-id",
+            });
+            if (!options.exitZero)
+                process.exitCode = 1;
+            return;
+        }
+        let teamKeys;
+        try {
+            const rootOpts = getRootOpts(command);
+            const ttl = resolveCacheTTL({
+                configTTL: loadConfig().cacheTTLSeconds,
+                noCacheFlag: rootOpts.cache === false,
+            });
+            // Same cache key and limit as `teams list` default — share the entry.
+            const teams = await cached(`teams-list-limit:${TEAMS_LIST_DEFAULT_LIMIT}`, ttl, async () => {
+                const service = await createLinearService(rootOpts);
+                return service.getTeams(TEAMS_LIST_DEFAULT_LIMIT);
+            });
+            teamKeys = teams.map((t) => t.key);
+        }
+        catch {
+            // Couldn't load the team set (offline + cold cache). Signal
+            // indeterminate so the caller can fall back instead of blocking.
+            outputSuccess({
+                branch: branchName,
+                valid: null,
+                team: parsed.team,
+                issueId: parsed.issueId,
+                reason: "teams-unavailable",
+            });
+            if (!options.exitZero)
+                process.exitCode = 2;
+            return;
+        }
+        const valid = teamKeys.includes(parsed.team);
+        outputSuccess({
+            branch: branchName,
+            valid,
+            team: parsed.team,
+            issueId: parsed.issueId,
+            reason: valid ? "ok" : "unknown-team",
+            ...(valid ? {} : { knownTeams: teamKeys }),
+        });
+        if (!(valid || options.exitZero))
+            process.exitCode = 1;
+    }));
+}

package/dist/commands/issue-id.d.ts

@@ -24,5 +24,6 @@ interface ParsedBranch {
     team: string | null;
 }
 export declare function parseBranchName(branch: string): ParsedBranch;
+export declare function getCurrentBranch(): string;
 export declare function setupIssueIdCommand(program: Command): void;
 export {};

package/dist/commands/issue-id.js

@@ -50,7 +50,7 @@ export function parseBranchName(branch) {
         slug: m[3] ?? null,
     };
 }
-function getCurrentBranch() {
+export function getCurrentBranch() {
     const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
         encoding: "utf8",
     });

package/dist/commands/issues.js

@@ -1233,6 +1233,7 @@ export function setupIssuesCommands(program) {
         .option("--blocks <issues>", "issues this blocks (comma-separated)")
         .option("--blocked-by <issues>", "issues blocking this (comma-separated)")
         .option("--duplicate-of <issue>", "mark as duplicate of another issue")
+        .option("-q, --quiet", "print one confirmation line (SOURCE  type targets  (count)) instead of the full JSON")
         .action(handleAsyncCommand(handleRelateIssue));
     issues
         .command("related <issueId>")

package/dist/commands/teams.d.ts

@@ -1,2 +1,3 @@
 import type { Command } from "commander";
+export declare const TEAMS_LIST_DEFAULT_LIMIT = 100;
 export declare function setupTeamsCommands(program: Command): void;

package/dist/commands/teams.js

@@ -4,6 +4,7 @@ import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { parsePositiveInt } from "../utils/validators.js";
+export const TEAMS_LIST_DEFAULT_LIMIT = 100;
 export function setupTeamsCommands(program) {
     const teams = program
         .command("teams")
@@ -13,7 +14,7 @@ export function setupTeamsCommands(program) {
     teams
         .command("list")
         .description("List all teams")
-        .option("-l, --limit <number>", "limit results", "100")
+        .option("-l, --limit <number>", "limit results", String(TEAMS_LIST_DEFAULT_LIMIT))
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
         const limit = parsePositiveInt(options.limit, "--limit");

package/dist/main.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "node:url";
 import { program } from "commander";
 import { setupAttachmentsCommands } from "./commands/attachments.js";
 import { setupBatchCommands } from "./commands/batch.js";
+import { setupBranchCommands } from "./commands/branch.js";
 import { setupCommentsCommands } from "./commands/comments.js";
 import { setupConfigCommands } from "./commands/config.js";
 import { setupCyclesCommands } from "./commands/cycles.js";
@@ -132,6 +133,7 @@ program.action(() => {
 });
 setupAttachmentsCommands(program);
 setupBatchCommands(program);
+setupBranchCommands(program);
 setupSearchCommands(program);
 setupIssuesCommands(program);
 setupIssueIdCommand(program);

package/dist/utils/formatters/summary.d.ts

@@ -32,6 +32,16 @@ export declare function formatMilestoneSummary(milestone: Record<string, unknown
 export declare function formatMilestoneList(milestones: unknown[]): string;
 export declare function formatTeamList(teams: unknown[]): string;
 export declare function formatLabelList(labels: unknown[]): string;
+/**
+ * Table render for an `issues relate` result — the `{ data: IssueRelation[] }`
+ * envelope where each entry is `{ type, issue, relatedIssue }`. Rendered
+ * **source-oriented** (`TYPE  TARGET  TITLE`) to match the `--quiet` line: the
+ * type is normalized from the source's perspective (a `--blocked-by` reads as
+ * `blockedBy`) and TARGET is the peer (non-source) issue. `sourceRef` comes
+ * from the envelope's `meta.source` via `dispatch`; absent it (a bare array),
+ * the row falls back to the stored direction.
+ */
+export declare function formatRelationList(relations: unknown[], sourceRef?: string): string;
 export declare function formatUserSummary(user: Record<string, unknown>): string;
 export declare function formatUserList(users: unknown[]): string;
 export declare function formatDocumentSummary(doc: Record<string, unknown>): string;
@@ -49,7 +59,7 @@ export declare function formatSearchResultList(results: unknown[]): string;
  * the full payload. Lists fall back to a simple bulleted list.
  */
 export declare function formatGenericSummary(value: unknown): string;
-export type ResourceKind = "issue" | "issue-list" | "project" | "project-list" | "comment" | "comment-list" | "cycle" | "cycle-list" | "milestone" | "milestone-list" | "team-list" | "label-list" | "user" | "user-list" | "document" | "document-list" | "template" | "template-list" | "attachment-list" | "release" | "release-list" | "search-result-list" | "empty-list" | "generic";
+export type ResourceKind = "issue" | "issue-list" | "project" | "project-list" | "comment" | "comment-list" | "cycle" | "cycle-list" | "milestone" | "milestone-list" | "team-list" | "label-list" | "user" | "user-list" | "document" | "document-list" | "template" | "template-list" | "attachment-list" | "release" | "release-list" | "search-result-list" | "relation-list" | "empty-list" | "generic";
 /**
  * Heuristic — used by the central `outputSuccess` path which doesn't know
  * which command produced the payload. Looks at the shape of the data to

package/dist/utils/formatters/summary.js

@@ -689,6 +689,64 @@ export function formatLabelList(labels) {
         { header: "COLOR", minWidth: 5, extract: (l) => s(l.color) },
     ], { emptyText: "(no labels)", itemNoun: "label" });
 }
+// ── relations ──────────────────────────────────────────────────
+/**
+ * Re-frame a stored relation row from the source issue's perspective: returns
+ * the normalized relation `type` (a reverse `blocks` becomes `blockedBy`) and
+ * the `peer` — the non-source issue node. `createRelations` stores a
+ * `--blocked-by X` row reversed (`{ type:"blocks", issue:X, relatedIssue:source }`),
+ * so the source can sit on either side; we orient by `sourceRef`.
+ *
+ * `sourceRef` is the raw arg the user passed — a canonical `TEAM-NUM`
+ * identifier or a UUID, the only two forms `resolveIssueId` admits — matched
+ * against either node's `identifier` or `id`. (Coupling note: if that resolver
+ * is ever widened to accept Linear URLs / slug-ids, as `--project` already
+ * does, this match would need the resolved `sourceId` instead.) With no source
+ * (`"—"`, e.g. a bare array with no `meta`), nothing matches, so it falls back
+ * to the stored direction: peer = `relatedIssue`, type uninverted.
+ */
+function relationFromSource(rel, sourceRef) {
+    const matchesSource = (node) => !!node &&
+        sourceRef !== "—" &&
+        (s(node.identifier) === sourceRef || s(node.id) === sourceRef);
+    const issue = asObj(rel.issue);
+    const related = asObj(rel.relatedIssue);
+    // Source on the relatedIssue side ⇒ this is the inverse direction.
+    const sourceIsRelated = matchesSource(related) && !matchesSource(issue);
+    const peer = sourceIsRelated ? issue : related;
+    const rawType = s(rel.type);
+    const type = sourceIsRelated && rawType === "blocks" ? "blockedBy" : rawType;
+    return { type, peer };
+}
+/**
+ * Table render for an `issues relate` result — the `{ data: IssueRelation[] }`
+ * envelope where each entry is `{ type, issue, relatedIssue }`. Rendered
+ * **source-oriented** (`TYPE  TARGET  TITLE`) to match the `--quiet` line: the
+ * type is normalized from the source's perspective (a `--blocked-by` reads as
+ * `blockedBy`) and TARGET is the peer (non-source) issue. `sourceRef` comes
+ * from the envelope's `meta.source` via `dispatch`; absent it (a bare array),
+ * the row falls back to the stored direction.
+ */
+export function formatRelationList(relations, sourceRef = "—") {
+    const rows = relations.map((raw) => {
+        const { type, peer } = relationFromSource(asObj(raw) ?? {}, sourceRef);
+        return {
+            type,
+            target: s(peer?.identifier ?? peer?.id),
+            title: s(peer?.title),
+        };
+    });
+    return renderTable(rows, [
+        { header: "TYPE", minWidth: 4, extract: (r) => r.type },
+        { header: "TARGET", minWidth: 6, extract: (r) => r.target },
+        {
+            header: "TITLE",
+            minWidth: 5,
+            maxWidth: TITLE_TRUNC,
+            extract: (r) => r.title,
+        },
+    ], { emptyText: "(no relations)", itemNoun: "relation" });
+}
 // ── users ──────────────────────────────────────────────────────
 export function formatUserSummary(user) {
     const name = s(user.name);
@@ -968,6 +1026,10 @@ function inferListKind(items) {
         return "empty-list";
     }
     const sample = asObj(items[0]) ?? {};
+    // IssueRelation rows ({ type, issue, relatedIssue }) carry no top-level
+    // identifier/title, so this must precede the issue-list check below.
+    if ("relatedIssue" in sample && "issue" in sample && "type" in sample)
+        return "relation-list";
     if ("identifier" in sample && "title" in sample) {
         // could be issue or search result
         if ("type" in sample && !("templateData" in sample)) {
@@ -1088,6 +1150,8 @@ export function dispatch(kind, payload, fields) {
             return formatReleaseList(list ?? []);
         case "search-result-list":
             return formatSearchResultList(list ?? []);
+        case "relation-list":
+            return formatRelationList(list ?? [], s(asObj(obj?.meta)?.source));
         case "empty-list":
             return "(no results)";
         case "generic":
@@ -1122,5 +1186,44 @@ export function formatLine(payload) {
     if (kind === "comment" && obj) {
         return `comment ${s(obj.id)}`;
     }
+    if (kind === "relation-list") {
+        return formatRelationLine(payload);
+    }
     return JSON.stringify(payload);
 }
+/**
+ * `--quiet` render for an `issues relate` result: one source-oriented line
+ * grouping the created relations by type from the source issue's perspective.
+ *
+ *   EMW-331  related EMW-339,EMW-340  (2)
+ *   EMW-331  blockedBy EMW-400; related EMW-339  (2)
+ *
+ * The per-row reframing (peer + type inversion for reverse `--blocked-by`)
+ * is shared with the summary table via `relationFromSource`; see its doc for
+ * the direction and source-matching rules.
+ */
+function formatRelationLine(payload) {
+    const obj = asObj(payload);
+    const relations = Array.isArray(payload)
+        ? payload
+        : Array.isArray(obj?.data)
+            ? obj.data
+            : [];
+    const sourceRef = s(asObj(obj?.meta)?.source);
+    // Preserve first-seen type order for a stable line.
+    const byType = new Map();
+    for (const raw of relations) {
+        const rel = asObj(raw);
+        if (!rel)
+            continue;
+        const { type, peer } = relationFromSource(rel, sourceRef);
+        const targetId = s(peer?.identifier ?? peer?.id);
+        const bucket = byType.get(type);
+        if (bucket)
+            bucket.push(targetId);
+        else
+            byType.set(type, [targetId]);
+    }
+    const segments = [...byType.entries()].map(([type, ids]) => `${type} ${ids.join(",")}`);
+    return `${sourceRef}  ${segments.join("; ")}  (${relations.length})`;
+}

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

@@ -188,8 +188,10 @@ export declare class GraphQLIssuesService {
     /**
      * Batch-fetches N issues in a single GraphQL round-trip (DEV-4477).
      *
-     * Replaces `Promise.all(refs.map(getIssueById))` — that pattern issues N
-     * concurrent queries; this one issues exactly one. Useful for
+     * Replaces `Promise.all(refs.map(getIssueById))` as the primary path. The
+     * batch response is still order-restored locally; if Linear omits an input
+     * ref from that response, the missing ref falls back to the single-issue
+     * lookup path so valid issues are not misreported as missing. Useful for
      * `el-linear issues read <id...>`, the only caller today.
      *
      * Identifier shapes accepted (mirrors `getIssueById`):

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

@@ -66,8 +66,10 @@ export class GraphQLIssuesService {
     /**
      * Batch-fetches N issues in a single GraphQL round-trip (DEV-4477).
      *
-     * Replaces `Promise.all(refs.map(getIssueById))` — that pattern issues N
-     * concurrent queries; this one issues exactly one. Useful for
+     * Replaces `Promise.all(refs.map(getIssueById))` as the primary path. The
+     * batch response is still order-restored locally; if Linear omits an input
+     * ref from that response, the missing ref falls back to the single-issue
+     * lookup path so valid issues are not misreported as missing. Useful for
      * `el-linear issues read <id...>`, the only caller today.
      *
      * Identifier shapes accepted (mirrors `getIssueById`):
@@ -146,11 +148,12 @@ export class GraphQLIssuesService {
         for (const ref of refs) {
             const node = isUuid(ref) ? byUuid.get(ref) : byIdentifier.get(ref);
             if (!node) {
-                throw notFoundError("Issue", ref);
+                ordered.push(await this.getIssueById(ref));
+                continue;
             }
-            ordered.push(node);
+            ordered.push(this.transformIssueData(node));
         }
-        return ordered.map((issue) => this.transformIssueData(issue));
+        return ordered;
     }
     async getFirstStartedStatus(team) {
         const statuses = await this.graphQLService.rawRequest(TEAM_STARTED_STATUSES_QUERY, { teamId: team.id });

package/dist/utils/mention-resolver.js

@@ -5,7 +5,8 @@ import { isUuid } from "./uuid.js";
 // 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 MENTION_NAME_CHARS = "\\p{L}\\p{N}_\\-";
+const EXPLICIT_MENTION_REGEX = new RegExp(`(?<![${MENTION_NAME_CHARS}])@([${MENTION_NAME_CHARS}]+)(?![${MENTION_NAME_CHARS}/])`, "gu");
 const WHITESPACE_SPLIT_REGEX = /\s+/;
 const FENCED_CODE_REGEX = /```[\s\S]*?```/g;
 const INLINE_CODE_REGEX = /`[^`]+`/g;
@@ -31,7 +32,10 @@ export async function resolveMentions(body, linearService, options = {}) {
     // 1. Resolve explicit @name mentions (existing behavior).
     const explicit = new Map();
     const unresolvedExplicit = [];
-    const explicitNames = [...body.matchAll(EXPLICIT_MENTION_REGEX)].map((m) => m[1]);
+    const explicitScanBody = stripCodeAndLinks(body);
+    const explicitNames = [
+        ...explicitScanBody.matchAll(EXPLICIT_MENTION_REGEX),
+    ].map((m) => m[1]);
     for (const name of new Set(explicitNames)) {
         const userId = await resolveUserByName(name, linearService);
         if (userId) {
@@ -253,7 +257,7 @@ function buildCombinedRegex(explicit, bare) {
         // 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}_]+");
+        parts.push(`(?<![${MENTION_NAME_CHARS}])@[${MENTION_NAME_CHARS}]+(?![${MENTION_NAME_CHARS}/])`);
     }
     if (bare.size > 0) {
         const alternation = [...bare.keys()]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enrichlayer/el-linear",
-  "version": "1.30.0",
+  "version": "1.32.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",
@@ -53,7 +53,7 @@
   "dependencies": {
     "@inquirer/prompts": "^8.4.2",
     "@linear/sdk": "^86.0.0",
-    "commander": "^14.0.0",
+    "commander": "^15.0.0",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {