@enrichlayer/el-linear 1.9.0 → 1.10.0

package/dist/commands/issues.js

@@ -4,22 +4,22 @@ import { enforceValidation, validateIssueCreation, } from "../config/issue-valid
 import { resolveAssignee, resolveLabels, resolveMember, resolveTeam, } from "../config/resolver.js";
 import { resolveDefaultStatus } from "../config/status-defaults.js";
 import { enforceTerms } from "../config/term-enforcer.js";
-import { LIST_COMMENTS_QUERY } from "../queries/comments.js";
-import { GET_ISSUE_RELATIONS_QUERY, GET_ISSUE_STATE_HISTORY_QUERY, ISSUE_RELATION_CREATE_MUTATION, SCAN_ISSUES_QUERY, } from "../queries/issues.js";
-import { autoLinkReferences, } from "../utils/auto-link-references.js";
+import { GET_ISSUE_RELATIONS_QUERY, GET_ISSUE_STATE_HISTORY_QUERY, } from "../queries/issues.js";
 import { createFileService } from "../utils/file-service.js";
 import { applyFooter } from "../utils/footer.js";
 import { createGraphQLAttachmentsService } from "../utils/graphql-attachments-service.js";
 import { GraphQLIssuesService, } from "../utils/graphql-issues-service.js";
-import { createGraphQLService, } from "../utils/graphql-service.js";
-import { createLinearService, } from "../utils/linear-service.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { createLinearService } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { formatCsv, formatMarkdown, formatTable, } from "../utils/table-formatter.js";
-import { parsePriorityFilter, splitList, validatePriority, } from "../utils/validators.js";
+import { parsePositiveInt, parsePriorityFilter, splitList, validatePriority, } from "../utils/validators.js";
 import { gitCheckoutBranch, toBranchName } from "./issues/branch.js";
-import { maybeAutoLink, prepareAutoLinkedDescription, prepareDescriptionRewrite, pushDescriptionUpdate, readDescriptionFile, resolveDescription, } from "./issues/description.js";
+import { maybeAutoLink, prepareAutoLinkedDescription, readDescriptionFile, resolveDescription, } from "./issues/description.js";
+import { handleLinkReferencesIssue } from "./issues/link-references.js";
+import { buildIncomingRelationEntries, buildOutgoingRelationEntries, createRelations, } from "./issues/relations.js";
 import { readIssues } from "./read-shortcut.js";
 const IMAGE_EXTENSIONS = new Set([
     ".png",
@@ -35,53 +35,6 @@ function isImageFile(filename) {
     const ext = filename.lastIndexOf(".");
     return ext !== -1 && IMAGE_EXTENSIONS.has(filename.slice(ext).toLowerCase());
 }
-function transformIssueRelation(rel) {
-    const issue = rel.issue;
-    const relatedIssue = rel.relatedIssue;
-    return {
-        id: rel.id,
-        type: rel.type,
-        issue: {
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title,
-        },
-        relatedIssue: {
-            id: relatedIssue.id,
-            identifier: relatedIssue.identifier,
-            title: relatedIssue.title,
-        },
-    };
-}
-async function createRelations(sourceId, options, graphQLService, linearService) {
-    const relations = [];
-    const relationSpecs = [
-        { option: "relatedTo", type: "related" },
-        { option: "blocks", type: "blocks" },
-        { option: "blockedBy", type: "blocks", reverse: true },
-        { option: "duplicateOf", type: "duplicate" },
-    ];
-    for (const spec of relationSpecs) {
-        const value = options[spec.option];
-        if (!value) {
-            continue;
-        }
-        for (const id of splitList(value)) {
-            const targetId = await linearService.resolveIssueId(id);
-            const rel = await graphQLService.rawRequest(ISSUE_RELATION_CREATE_MUTATION, {
-                input: {
-                    issueId: spec.reverse ? targetId : sourceId,
-                    relatedIssueId: spec.reverse ? sourceId : targetId,
-                    type: spec.type,
-                },
-            });
-            const create = rel.issueRelationCreate;
-            const issueRelation = create?.issueRelation;
-            relations.push(transformIssueRelation(issueRelation));
-        }
-    }
-    return relations;
-}
 function validateUpdateOptions(options) {
     if (options.parentTicket && options.clearParentTicket) {
         throw new Error("Cannot use --parent-ticket and --clear-parent-ticket together");
@@ -212,7 +165,7 @@ async function handleListIssues(options, command) {
                 ? parsePriorityFilter(options.priority)
                 : undefined,
             orderBy: options.sort === "created" ? "createdAt" : "updatedAt",
-            limit: Number.parseInt(options.limit, 10),
+            limit: parsePositiveInt(options.limit, "--limit"),
         };
         const result = sortIssues(await issuesService.searchIssues(searchArgs), options.sort);
         outputIssues(result, options.format, options.fields, {
@@ -220,7 +173,7 @@ async function handleListIssues(options, command) {
         });
     }
     else {
-        const result = sortIssues(await issuesService.getIssues(Number.parseInt(options.limit, 10)), options.sort);
+        const result = sortIssues(await issuesService.getIssues(parsePositiveInt(options.limit, "--limit")), options.sort);
         outputIssues(result, options.format, options.fields, {});
     }
 }
@@ -245,7 +198,7 @@ async function handleSearchIssues(query, options, command) {
         priority: options.priority
             ? parsePriorityFilter(options.priority)
             : undefined,
-        limit: Number.parseInt(options.limit, 10),
+        limit: parsePositiveInt(options.limit, "--limit"),
     };
     const result = sortIssues(await issuesService.searchIssues(searchArgs), options.sort);
     outputIssues(result, options.format, options.fields, { query });
@@ -460,22 +413,19 @@ async function handleHistoryIssue(issueId, _options, command) {
     const graphQLService = await createGraphQLService(rootOpts);
     const linearService = await createLinearService(rootOpts);
     const resolvedId = await linearService.resolveIssueId(issueId);
-    const result = await graphQLService.rawRequest(GET_ISSUE_STATE_HISTORY_QUERY, {
-        id: resolvedId,
-    });
+    const result = await graphQLService.rawRequest(GET_ISSUE_STATE_HISTORY_QUERY, { id: resolvedId });
     if (!result.issue) {
         throw new Error(`Issue "${issueId}" not found`);
     }
     const issue = result.issue;
-    const stateHistory = issue.stateHistory;
-    const spans = (stateHistory?.nodes ?? []).map((span) => ({
+    const spans = issue.stateHistory.nodes.map((span) => ({
         state: {
             id: span.state.id,
             name: span.state.name,
             type: span.state.type,
         },
         startedAt: span.startedAt,
-        endedAt: span.endedAt || undefined,
+        endedAt: span.endedAt ?? undefined,
     }));
     outputSuccess({
         id: issue.id,
@@ -499,82 +449,19 @@ async function handleRelateIssue(issueId, options, command) {
         meta: { count: relations.length, source: issueId },
     });
 }
-/**
- * Invert relation type for incoming (inverse) relations so the output
- * reads naturally from the perspective of the queried issue.
- * e.g. if DEV-100 "blocks" DEV-200, and we query DEV-200,
- * the inverse relation type is "blocks" but direction is incoming → "blockedBy".
- */
-function normalizeInverseType(type) {
-    if (type === "blocks") {
-        return "blockedBy";
-    }
-    return type;
-}
-function buildRelatedIssueSummary(peer) {
-    const state = peer.state;
-    const assignee = peer.assignee;
-    const team = peer.team;
-    return {
-        id: peer.id,
-        identifier: peer.identifier,
-        title: peer.title,
-        ...(state
-            ? { state: { id: state.id, name: state.name } }
-            : {}),
-        ...(peer.priority == null ? {} : { priority: peer.priority }),
-        ...(assignee
-            ? {
-                assignee: {
-                    id: assignee.id,
-                    name: assignee.name,
-                },
-            }
-            : {}),
-        ...(team
-            ? {
-                team: {
-                    id: team.id,
-                    key: team.key,
-                    name: team.name,
-                },
-            }
-            : {}),
-    };
-}
-function buildRelationEntries(nodes, peerKey, direction, normalizeType) {
-    const entries = [];
-    for (const rel of nodes ?? []) {
-        const peer = rel[peerKey];
-        if (!peer) {
-            continue;
-        }
-        entries.push({
-            id: rel.id,
-            type: normalizeType(rel.type),
-            direction,
-            issue: buildRelatedIssueSummary(peer),
-        });
-    }
-    return entries;
-}
 async function handleRelatedIssues(issueId, _options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     const linearService = await createLinearService(rootOpts);
     const resolvedId = await linearService.resolveIssueId(issueId);
-    const result = await graphQLService.rawRequest(GET_ISSUE_RELATIONS_QUERY, {
-        id: resolvedId,
-    });
+    const result = await graphQLService.rawRequest(GET_ISSUE_RELATIONS_QUERY, { id: resolvedId });
     if (!result.issue) {
         throw new Error(`Issue "${issueId}" not found`);
     }
     const issue = result.issue;
-    const relations = issue.relations;
-    const inverseRelations = issue.inverseRelations;
     const entries = [
-        ...buildRelationEntries(relations?.nodes, "relatedIssue", "outgoing", (raw) => raw),
-        ...buildRelationEntries(inverseRelations?.nodes, "issue", "incoming", normalizeInverseType),
+        ...buildOutgoingRelationEntries(issue.relations.nodes),
+        ...buildIncomingRelationEntries(issue.inverseRelations.nodes),
     ];
     outputSuccess({
         id: issue.id,
@@ -584,158 +471,6 @@ async function handleRelatedIssues(issueId, _options, command) {
         meta: { count: entries.length },
     });
 }
-async function fetchCommentBodies(issueUuid, graphQLService) {
-    const result = await graphQLService.rawRequest(LIST_COMMENTS_QUERY, {
-        issueId: issueUuid,
-        first: 250,
-    });
-    const issue = result.issue;
-    const comments = issue?.comments;
-    const nodes = comments?.nodes ?? [];
-    return nodes
-        .map((c) => c.body)
-        .filter((b) => typeof b === "string" && b.length > 0);
-}
-async function linkReferencesForIssue(args) {
-    const comments = args.includeComments
-        ? await fetchCommentBodies(args.issueUuid, args.graphQLService)
-        : undefined;
-    return autoLinkReferences({
-        issueId: args.issueUuid,
-        identifier: args.identifier,
-        description: args.description,
-        comments,
-        dryRun: args.dryRun,
-        graphQLService: args.graphQLService,
-        linearService: args.linearService,
-        preResolved: args.preResolved,
-    });
-}
-async function handleLinkReferencesSingle(issueId, options, graphQLService, linearService) {
-    const resolvedId = await linearService.resolveIssueId(issueId);
-    // GET_ISSUE_RELATIONS_QUERY also returns description, so this single call gives us everything
-    // we need for the description-only path. Comments are fetched separately on demand.
-    const issueResult = await graphQLService.rawRequest(GET_ISSUE_RELATIONS_QUERY, {
-        id: resolvedId,
-    });
-    if (!issueResult.issue) {
-        throw new Error(`Issue "${issueId}" not found`);
-    }
-    const issue = issueResult.issue;
-    const identifier = issue.identifier;
-    const description = issue.description ?? "";
-    const dryRun = Boolean(options.dryRun);
-    const includeComments = Boolean(options.includeComments);
-    const rewriteDescription = Boolean(options.rewriteDescription);
-    // If rewriting, validate refs once up front so we can both wrap the description and
-    // pass the resolved map down to autoLink — avoids a second resolve round trip.
-    const rewrite = rewriteDescription
-        ? await prepareDescriptionRewrite(description, identifier, linearService, graphQLService)
-        : { preResolved: undefined, wrapped: undefined };
-    const autoLinked = await linkReferencesForIssue({
-        issueUuid: resolvedId,
-        identifier,
-        description,
-        includeComments,
-        dryRun,
-        graphQLService,
-        linearService,
-        preResolved: rewrite.preResolved,
-    });
-    let descriptionRewritten = false;
-    if (rewriteDescription && rewrite.wrapped && !dryRun) {
-        await pushDescriptionUpdate(resolvedId, rewrite.wrapped, graphQLService);
-        descriptionRewritten = true;
-    }
-    outputSuccess({
-        id: resolvedId,
-        identifier,
-        title: issue.title,
-        autoLinked,
-        ...(rewriteDescription
-            ? {
-                descriptionRewritten,
-                ...(dryRun && rewrite.wrapped
-                    ? { descriptionPreview: rewrite.wrapped }
-                    : {}),
-            }
-            : {}),
-        meta: {
-            dryRun,
-            includeComments,
-            ...(rewriteDescription ? { rewriteDescription: true } : {}),
-        },
-    });
-}
-async function handleLinkReferencesBatch(teamInput, options, graphQLService, linearService) {
-    const teamId = resolveTeam(teamInput);
-    const limit = options.limit
-        ? Number.parseInt(options.limit, 10)
-        : 100;
-    if (!Number.isFinite(limit) || limit <= 0) {
-        throw new Error(`--limit must be a positive integer, got: ${options.limit}`);
-    }
-    const dryRun = Boolean(options.dryRun);
-    const includeComments = Boolean(options.includeComments);
-    const scan = await graphQLService.rawRequest(SCAN_ISSUES_QUERY, {
-        filter: { team: { id: { eq: teamId } } },
-        first: limit,
-    });
-    const issues = scan.issues?.nodes;
-    const nodes = issues ?? [];
-    const entries = [];
-    for (const node of nodes) {
-        const issueUuid = node.id;
-        const identifier = node.identifier;
-        const description = node.description ?? "";
-        const autoLinked = await linkReferencesForIssue({
-            issueUuid,
-            identifier,
-            description,
-            includeComments,
-            dryRun,
-            graphQLService,
-            linearService,
-        });
-        entries.push({ identifier, autoLinked });
-    }
-    // Summary counts across the batch
-    const totalLinked = entries.reduce((n, e) => n + e.autoLinked.linked.length, 0);
-    const totalSkipped = entries.reduce((n, e) => n + e.autoLinked.skipped.length, 0);
-    const totalFailed = entries.reduce((n, e) => n + e.autoLinked.failed.length, 0);
-    outputSuccess({
-        data: entries,
-        meta: {
-            count: entries.length,
-            team: teamInput,
-            dryRun,
-            includeComments,
-            totals: {
-                linked: totalLinked,
-                skipped: totalSkipped,
-                failed: totalFailed,
-            },
-        },
-    });
-}
-async function handleLinkReferencesIssue(issueIdOrTeamFlag, options, command) {
-    const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    if (options.team) {
-        if (issueIdOrTeamFlag) {
-            throw new Error("Provide either an issueId positional argument OR --team, not both. With --team, omit the issueId.");
-        }
-        if (options.rewriteDescription) {
-            throw new Error("--rewrite-description is single-issue only. Use it case by case (one issueId per invocation) — bulk description rewrites bot-author the whole team's history.");
-        }
-        return handleLinkReferencesBatch(options.team, options, graphQLService, linearService);
-    }
-    if (!issueIdOrTeamFlag) {
-        throw new Error("issueId is required (or use --team <key> to scan a whole team)");
-    }
-    return handleLinkReferencesSingle(issueIdOrTeamFlag, options, graphQLService, linearService);
-}
 async function handleUpdateIssue(issueId, options, command) {
     // Normalize aliases
     if (options.state && !options.status) {
@@ -754,9 +489,10 @@ async function handleUpdateIssue(issueId, options, command) {
     const linearService = await createLinearService(rootOpts);
     if (options.appendDescription) {
         const resolved = await linearService.resolveIssueId(issueId);
-        const current = await graphQLService.rawRequest("query($id: String!) { issue(id: $id) { description } }", { id: resolved });
-        const issue = current.issue;
-        const existing = issue?.description ?? "";
+        const current = await graphQLService.rawRequest("query($id: String!) { issue(id: $id) { description } }", {
+            id: resolved,
+        });
+        const existing = current.issue?.description ?? "";
         options.description = `${existing}\n${options.appendDescription}`;
     }
     if (options.title || options.description) {
@@ -799,6 +535,34 @@ async function handleUpdateIssue(issueId, options, command) {
         : undefined;
     outputSuccess(autoLinked ? { ...result, autoLinked } : result);
 }
+async function handleArchiveIssue(issueId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const result = await issuesService.archiveIssue(issueId);
+    outputSuccess({
+        success: true,
+        archived: true,
+        ...result,
+    });
+}
+async function handleDeleteIssue(issueId, options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const permanentlyDelete = Boolean(options.permanentlyDelete || options.hard);
+    const result = await issuesService.deleteIssue(issueId, {
+        permanentlyDelete,
+    });
+    outputSuccess({
+        success: true,
+        deleted: true,
+        permanentlyDeleted: permanentlyDelete,
+        ...result,
+    });
+}
 async function handleRetrolink(options, command) {
     // 1. Read current branch
     let currentBranch;
@@ -1000,6 +764,23 @@ export function setupIssuesCommands(program) {
         .option("--strict", "strict brand validation")
         .option("--no-auto-link", "skip auto-linking issue references found in the description")
         .action(handleAsyncCommand(handleUpdateIssue));
+    issues
+        .command("archive <issueId>")
+        .description("Archive an issue.")
+        .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.")
+        .action(handleAsyncCommand(handleArchiveIssue));
+    issues
+        .command("delete <issueId>")
+        .description("Delete (trash) an issue.")
+        .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported. Use --permanently-delete only when you intend to skip Linear's grace period; Linear requires admin permissions.")
+        .option("--permanently-delete", "skip Linear's 30-day grace period (admin only)")
+        .option("--hard", "alias for --permanently-delete")
+        .action(handleAsyncCommand(handleDeleteIssue));
+    issues
+        .command("hard-delete <issueId>")
+        .description("Permanently delete an issue immediately (admin only).")
+        .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.")
+        .action(handleAsyncCommand((issueId, options, command) => handleDeleteIssue(issueId, { ...options, permanentlyDelete: true }, command)));
     issues
         .command("history <issueId>")
         .description("Show issue state transition history (time in each status).")

package/dist/commands/labels.js

@@ -6,7 +6,7 @@ import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
-import { validateHexColor } from "../utils/validators.js";
+import { parsePositiveInt, validateHexColor } from "../utils/validators.js";
 async function handleCreateLabel(name, options, command) {
     const rootOpts = getRootOpts(command);
     const teamId = resolveTeam(options.team);
@@ -23,45 +23,35 @@ async function handleCreateLabel(name, options, command) {
             name: options.parent,
             teamId,
         });
-        const issueLabels = parentResult.issueLabels;
-        const nodes = issueLabels?.nodes;
-        const parentLabel = nodes?.[0];
+        const parentLabel = parentResult.issueLabels.nodes[0];
         if (parentLabel) {
             input.parentId = parentLabel.id;
         }
     }
-    const result = await graphQLService.rawRequest(CREATE_LABEL_MUTATION, {
-        input,
-    });
-    const createResult = result.issueLabelCreate;
-    if (!createResult?.success) {
+    const result = await graphQLService.rawRequest(CREATE_LABEL_MUTATION, { input });
+    if (!result.issueLabelCreate.success || !result.issueLabelCreate.issueLabel) {
         throw new Error(`Failed to create label "${name}"`);
     }
-    outputSuccess(createResult.issueLabel);
+    outputSuccess(result.issueLabelCreate.issueLabel);
 }
 async function handleRetireLabel(labelId, _options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
-    const result = await graphQLService.rawRequest(RETIRE_LABEL_MUTATION, {
-        id: labelId,
-    });
-    const retireResult = result.issueLabelRetire;
-    if (!retireResult?.success) {
+    const result = await graphQLService.rawRequest(RETIRE_LABEL_MUTATION, { id: labelId });
+    if (!result.issueLabelRetire.success || !result.issueLabelRetire.issueLabel) {
         throw new Error(`Failed to retire label "${labelId}"`);
     }
-    outputSuccess(retireResult.issueLabel);
+    outputSuccess(result.issueLabelRetire.issueLabel);
 }
 async function handleRestoreLabel(labelId, _options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
-    const result = await graphQLService.rawRequest(RESTORE_LABEL_MUTATION, {
-        id: labelId,
-    });
-    const restoreResult = result.issueLabelRestore;
-    if (!restoreResult?.success) {
+    const result = await graphQLService.rawRequest(RESTORE_LABEL_MUTATION, { id: labelId });
+    if (!result.issueLabelRestore.success ||
+        !result.issueLabelRestore.issueLabel) {
         throw new Error(`Failed to restore label "${labelId}"`);
     }
-    outputSuccess(restoreResult.issueLabel);
+    outputSuccess(result.issueLabelRestore.issueLabel);
 }
 export function setupLabelsCommands(program) {
     const labels = program
@@ -79,7 +69,7 @@ export function setupLabelsCommands(program) {
         const rootOpts = getRootOpts(command);
         const teamFilter = options.team ? resolveTeam(options.team) : undefined;
         const nameFilter = options.name;
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const ttl = resolveCacheTTL({
             configTTL: loadConfig().cacheTTLSeconds,
             noCacheFlag: rootOpts.cache === false,

package/dist/commands/project-milestones.js

@@ -5,7 +5,7 @@ import { createLinearService, } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { isUuid } from "../utils/uuid.js";
-import { validateIsoDate } from "../utils/validators.js";
+import { parsePositiveInt, validateIsoDate } from "../utils/validators.js";
 async function resolveMilestoneId(milestoneNameOrId, graphQLService, linearService, projectNameOrId) {
     if (isUuid(milestoneNameOrId)) {
         return milestoneNameOrId;
@@ -17,22 +17,17 @@ async function resolveMilestoneId(milestoneNameOrId, graphQLService, linearServi
             name: milestoneNameOrId,
             projectId,
         });
-        const projectData = findRes.project;
-        const milestonesData = projectData?.projectMilestones;
-        nodes = milestonesData?.nodes || [];
+        nodes = findRes.project?.projectMilestones.nodes ?? [];
     }
     if (nodes.length === 0) {
-        const globalRes = await graphQLService.rawRequest(FIND_PROJECT_MILESTONE_BY_NAME_GLOBAL, {
-            name: milestoneNameOrId,
-        });
-        const globalMilestones = globalRes.projectMilestones;
-        nodes = globalMilestones?.nodes || [];
+        const globalRes = await graphQLService.rawRequest(FIND_PROJECT_MILESTONE_BY_NAME_GLOBAL, { name: milestoneNameOrId });
+        nodes = globalRes.projectMilestones.nodes;
     }
     if (nodes.length === 0) {
         throw notFoundError("Milestone", milestoneNameOrId);
     }
     if (nodes.length > 1) {
-        const matches = nodes.map((m) => `"${m.name}" in project "${m.project?.name}"`);
+        const matches = nodes.map((m) => `"${m.name}" in project "${m.project.name}"`);
         throw multipleMatchesError("milestone", milestoneNameOrId, matches, "specify --project or use the milestone ID");
     }
     return nodes[0].id;
@@ -44,11 +39,9 @@ async function handleListMilestones(options, command) {
     const projectId = await linearService.resolveProjectId(options.project);
     const result = await graphQLService.rawRequest(LIST_PROJECT_MILESTONES_QUERY, {
         projectId,
-        first: Number.parseInt(options.limit || "50", 10),
+        first: parsePositiveInt(options.limit || "50", "--limit"),
     });
-    const projectData = result.project;
-    const milestonesData = projectData?.projectMilestones;
-    const nodes = milestonesData?.nodes || [];
+    const nodes = result.project?.projectMilestones.nodes ?? [];
     outputSuccess({ data: nodes, meta: { count: nodes.length } });
 }
 async function handleReadMilestone(milestoneIdOrName, options, command) {
@@ -76,11 +69,11 @@ async function handleCreateMilestone(name, options, command) {
         description: options.description,
         targetDate: options.targetDate,
     });
-    const createData = result.projectMilestoneCreate;
-    if (!createData?.success) {
+    if (!result.projectMilestoneCreate.success ||
+        !result.projectMilestoneCreate.projectMilestone) {
         throw new Error("Failed to create project milestone");
     }
-    outputSuccess(createData.projectMilestone);
+    outputSuccess(result.projectMilestoneCreate.projectMilestone);
 }
 async function handleUpdateMilestone(milestoneIdOrName, options, command) {
     const rootOpts = getRootOpts(command);
@@ -102,11 +95,11 @@ async function handleUpdateMilestone(milestoneIdOrName, options, command) {
         updateVars.sortOrder = Number.parseFloat(options.sortOrder);
     }
     const result = await graphQLService.rawRequest(UPDATE_PROJECT_MILESTONE_MUTATION, updateVars);
-    const updateData = result.projectMilestoneUpdate;
-    if (!updateData?.success) {
+    if (!result.projectMilestoneUpdate.success ||
+        !result.projectMilestoneUpdate.projectMilestone) {
         throw new Error("Failed to update project milestone");
     }
-    outputSuccess(updateData.projectMilestone);
+    outputSuccess(result.projectMilestoneUpdate.projectMilestone);
 }
 export function setupProjectMilestonesCommands(program) {
     const projectMilestones = program