@enrichlayer/el-linear 1.7.0 → 1.10.0

package/dist/commands/projects.js

@@ -1,114 +1,161 @@
 import { loadConfig } from "../config/config.js";
 import { resolveTeam } from "../config/resolver.js";
-import { CREATE_PROJECT_MUTATION, GET_PROJECT_QUERY, GET_PROJECT_TEAM_ISSUES_QUERY, PROJECT_BY_ID_QUERY, SEARCH_PROJECTS_BY_NAME_QUERY, UPDATE_PROJECT_MUTATION, } from "../queries/projects.js";
+import { ARCHIVE_PROJECT_MUTATION, CREATE_PROJECT_MUTATION, DELETE_PROJECT_MUTATION, GET_PROJECT_QUERY, GET_PROJECT_TEAM_ISSUES_QUERY, PROJECT_BY_ID_QUERY, SEARCH_PROJECTS_BY_NAME_QUERY, UPDATE_PROJECT_MUTATION, } from "../queries/projects.js";
 import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { renderCsv, renderFixedWidthTable, renderMarkdownTable, } from "../utils/table-formatter.js";
 import { isUuid } from "../utils/uuid.js";
-import { splitList } from "../utils/validators.js";
-function formatProjectsOutput(projects, format, fieldNames) {
-    const fields = fieldNames ?? [
-        "name",
-        "state",
-        "progress",
-        "teams",
-        "lead",
-        "targetDate",
-    ];
-    const rows = projects.map((p) => {
-        const row = {};
-        for (const f of fields) {
-            switch (f) {
-                case "name":
-                    row[f] = p.name;
-                    break;
-                case "state":
-                    row[f] = p.state ?? "";
-                    break;
-                case "progress":
-                    row[f] =
-                        p.progress !== undefined ? `${Math.round(p.progress * 100)}%` : "";
-                    break;
-                case "teams":
-                    row[f] = p.teams?.map((t) => t.key).join(", ") ?? "";
-                    break;
-                case "lead":
-                    row[f] = p.lead?.name ?? "";
-                    break;
-                case "targetDate":
-                    row[f] = p.targetDate ?? "";
-                    break;
-                case "id":
-                    row[f] = p.id;
-                    break;
-                default:
-                    row[f] = String(p[f] ?? "");
-            }
+import { parsePositiveInt, splitList } from "../utils/validators.js";
+const VALID_PROJECT_STATES = new Set([
+    "backlog",
+    "planned",
+    "started",
+    "paused",
+    "completed",
+    "canceled",
+]);
+function parseStateList(value, flagName) {
+    const states = splitList(value).map((s) => s.toLowerCase());
+    for (const s of states) {
+        if (!VALID_PROJECT_STATES.has(s)) {
+            throw new Error(`Invalid state "${s}" for ${flagName}. Valid: ${[...VALID_PROJECT_STATES].join(", ")}.`);
         }
-        return row;
-    });
+    }
+    return states;
+}
+export function resolveProjectStateFilter(options) {
+    const flags = [options.state, options.excludeState, options.active].filter(Boolean).length;
+    if (flags > 1) {
+        throw new Error("--state, --exclude-state, and --active are mutually exclusive.");
+    }
+    if (options.active) {
+        return { excludeStates: ["completed", "canceled"] };
+    }
+    if (options.state) {
+        return { states: parseStateList(options.state, "--state") };
+    }
+    if (options.excludeState) {
+        return {
+            excludeStates: parseStateList(options.excludeState, "--exclude-state"),
+        };
+    }
+    return {};
+}
+// ── Project column definitions ────────────────────────────────
+//
+// Pre-fix this file inlined an 80-line `formatProjectsOutput`
+// function that hand-rolled column width math, table padding, CSV
+// quoting, and markdown pipe syntax — all duplicating
+// `utils/table-formatter.ts`. Now we declare `ColumnDef<LinearProject>`
+// arrays and let the shared renderers do the work. ALL-938 cleanup.
+const PROJECT_COLUMNS = {
+    name: { key: "name", header: "Name", width: 32, extract: (p) => p.name },
+    state: {
+        key: "state",
+        header: "State",
+        width: 10,
+        extract: (p) => p.state ?? "",
+    },
+    progress: {
+        key: "progress",
+        header: "Progress",
+        width: 10,
+        extract: (p) => p.progress !== undefined ? `${Math.round(p.progress * 100)}%` : "",
+    },
+    teams: {
+        key: "teams",
+        header: "Teams",
+        width: 18,
+        extract: (p) => p.teams?.map((t) => t.key).join(", ") ?? "",
+    },
+    lead: {
+        key: "lead",
+        header: "Lead",
+        width: 18,
+        extract: (p) => p.lead?.name ?? "",
+    },
+    targetDate: {
+        key: "targetDate",
+        header: "Target",
+        width: 12,
+        extract: (p) => p.targetDate ?? "",
+    },
+    id: { key: "id", header: "ID", width: 38, extract: (p) => p.id },
+};
+const PROJECT_MD_COLUMNS = {
+    name: { header: "Name", extract: (p) => p.name },
+    state: { header: "State", extract: (p) => p.state ?? "" },
+    progress: {
+        header: "Progress",
+        extract: (p) => p.progress !== undefined ? `${Math.round(p.progress * 100)}%` : "",
+    },
+    teams: {
+        header: "Teams",
+        extract: (p) => p.teams?.map((t) => t.key).join(", ") ?? "",
+    },
+    lead: { header: "Lead", extract: (p) => p.lead?.name ?? "" },
+    targetDate: { header: "Target", extract: (p) => p.targetDate ?? "" },
+    id: { header: "ID", extract: (p) => p.id },
+};
+const DEFAULT_PROJECT_COLUMNS = [
+    "name",
+    "state",
+    "progress",
+    "teams",
+    "lead",
+    "targetDate",
+];
+function formatProjectsOutput(projects, format, fieldNames) {
+    const keys = fieldNames ?? DEFAULT_PROJECT_COLUMNS;
     if (format === "csv") {
-        logger.info(fields.join(","));
-        for (const row of rows) {
-            logger.info(fields.map((f) => `"${(row[f] ?? "").replace(/"/g, '""')}"`).join(","));
-        }
+        const columns = keys
+            .map((k) => PROJECT_COLUMNS[k])
+            .filter((c) => c !== undefined);
+        logger.info(renderCsv(projects, columns));
         return;
     }
-    // table and md formats
-    const widths = fields.map((f) => Math.max(f.length, ...rows.map((r) => (r[f] ?? "").length)));
-    const separator = format === "md"
-        ? `| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`
-        : widths.map((w) => "-".repeat(w + 2)).join("+");
-    const header = format === "md"
-        ? `| ${fields.map((f, i) => f.padEnd(widths[i])).join(" | ")} |`
-        : fields.map((f, i) => ` ${f.padEnd(widths[i])} `).join("|");
-    logger.info(header);
-    logger.info(separator);
-    for (const row of rows) {
-        const line = format === "md"
-            ? `| ${fields.map((f, i) => (row[f] ?? "").padEnd(widths[i])).join(" | ")} |`
-            : fields
-                .map((f, i) => ` ${(row[f] ?? "").padEnd(widths[i])} `)
-                .join("|");
-        logger.info(line);
+    if (format === "md") {
+        const columns = keys
+            .map((k) => PROJECT_MD_COLUMNS[k])
+            .filter((c) => c !== undefined);
+        logger.info(renderMarkdownTable(projects, columns));
+        return;
     }
+    // Default: fixed-width text table.
+    const columns = keys
+        .map((k) => PROJECT_COLUMNS[k])
+        .filter((c) => c !== undefined);
+    logger.info(renderFixedWidthTable(projects, columns));
 }
 async function resolveProjectWithTeams(graphQLService, projectNameOrId) {
     if (isUuid(projectNameOrId)) {
-        const result = await graphQLService.rawRequest(PROJECT_BY_ID_QUERY, {
-            id: projectNameOrId,
-        });
-        const project = result.project;
-        if (!project) {
+        const result = await graphQLService.rawRequest(PROJECT_BY_ID_QUERY, { id: projectNameOrId });
+        if (!result.project) {
             throw new Error(`Project "${projectNameOrId}" not found`);
         }
-        const teams = project.teams;
         return {
-            projectId: project.id,
-            projectName: project.name,
-            currentTeams: (teams?.nodes || []).map((t) => ({
+            projectId: result.project.id,
+            projectName: result.project.name,
+            currentTeams: result.project.teams.nodes.map((t) => ({
                 id: t.id,
                 key: t.key,
                 name: t.name,
             })),
         };
     }
-    const result = await graphQLService.rawRequest(GET_PROJECT_QUERY, {
-        name: projectNameOrId,
-    });
-    const projectNodes = result.projects?.nodes;
-    if (!projectNodes?.length) {
+    const result = await graphQLService.rawRequest(GET_PROJECT_QUERY, { name: projectNameOrId });
+    const project = result.projects.nodes[0];
+    if (!project) {
         throw new Error(`Project "${projectNameOrId}" not found`);
     }
-    const project = projectNodes[0];
-    const teams = project.teams;
     return {
         projectId: project.id,
         projectName: project.name,
-        currentTeams: (teams?.nodes || []).map((t) => ({
+        currentTeams: project.teams.nodes.map((t) => ({
             id: t.id,
             key: t.key,
             name: t.name,
@@ -116,12 +163,14 @@ async function resolveProjectWithTeams(graphQLService, projectNameOrId) {
     };
 }
 function formatTeamsOutput(projectUpdate) {
+    if (!projectUpdate.project) {
+        throw new Error("Failed to update project");
+    }
     const updatedProject = projectUpdate.project;
-    const updatedTeams = updatedProject.teams;
     return {
         id: updatedProject.id,
         name: updatedProject.name,
-        teams: (updatedTeams.nodes || []).map((t) => ({
+        teams: updatedProject.teams.nodes.map((t) => ({
             id: t.id,
             key: t.key,
             name: t.name,
@@ -200,9 +249,7 @@ async function handleRemoveTeam(projectNameOrId, teamInput, options, command) {
             projectId,
             teamId: finalTeamId,
         });
-        const project = issueCheck.project;
-        const issues = project.issues;
-        const issueNodes = issues.nodes || [];
+        const issueNodes = issueCheck.project?.issues.nodes ?? [];
         if (issueNodes.length > 0) {
             const examples = issueNodes
                 .slice(0, 5)
@@ -230,14 +277,10 @@ async function handleCreateProject(name, options, command) {
     const graphQLService = await createGraphQLService(rootOpts);
     // Step 1: Check for duplicate projects (case-insensitive)
     const searchResult = await graphQLService.rawRequest(SEARCH_PROJECTS_BY_NAME_QUERY, { name });
-    const existing = (searchResult.projects
-        ?.nodes ?? []).filter((p) => p.name.toLowerCase() === name.toLowerCase());
+    const existing = searchResult.projects.nodes.filter((p) => p.name.toLowerCase() === name.toLowerCase());
     if (existing.length > 0 && !options.force) {
         const match = existing[0];
-        const teams = (match.teams?.nodes ??
-            [])
-            .map((t) => t.key)
-            .join(", ");
+        const teams = match.teams.nodes.map((t) => t.key).join(", ");
         throw new Error(`Project "${match.name}" already exists (state: ${match.state}, teams: ${teams}). ` +
             `Use --force to create anyway, or use the existing project.`);
     }
@@ -255,11 +298,11 @@ async function handleCreateProject(name, options, command) {
         ...(teamIds.length > 0 ? { teamIds } : {}),
     };
     const createResult = await graphQLService.rawRequest(CREATE_PROJECT_MUTATION, { input });
-    const created = createResult.projectCreate;
-    if (!created?.success) {
+    if (!createResult.projectCreate.success ||
+        !createResult.projectCreate.project) {
         throw new Error("Failed to create project");
     }
-    const project = created.project;
+    const project = createResult.projectCreate.project;
     // Step 4: Set content if provided (separate mutation — Linear API quirk)
     if (options.content) {
         await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
@@ -267,10 +310,7 @@ async function handleCreateProject(name, options, command) {
             input: { content: options.content },
         });
     }
-    const teamList = (project.teams?.nodes ??
-        [])
-        .map((t) => t.key)
-        .join(", ");
+    const teamList = project.teams.nodes.map((t) => t.key).join(", ");
     outputSuccess({
         id: project.id,
         name: project.name,
@@ -285,6 +325,42 @@ async function handleCreateProject(name, options, command) {
             : {}),
     });
 }
+async function handleArchiveProject(projectNameOrId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(projectNameOrId);
+    const result = await graphQLService.rawRequest(ARCHIVE_PROJECT_MUTATION, { id: projectId });
+    const payload = result.projectArchive;
+    if (!payload.success) {
+        throw new Error(`Failed to archive project "${projectNameOrId}"`);
+    }
+    outputSuccess({
+        success: true,
+        archived: true,
+        id: projectId,
+        entity: payload.entity ?? undefined,
+        lastSyncId: payload.lastSyncId,
+    });
+}
+async function handleDeleteProject(projectNameOrId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(projectNameOrId);
+    const result = await graphQLService.rawRequest(DELETE_PROJECT_MUTATION, { id: projectId });
+    const payload = result.projectDelete;
+    if (!payload.success) {
+        throw new Error(`Failed to delete project "${projectNameOrId}"`);
+    }
+    outputSuccess({
+        success: true,
+        deleted: true,
+        id: projectId,
+        entity: payload.entity ?? undefined,
+        lastSyncId: payload.lastSyncId,
+    });
+}
 export function setupProjectsCommands(program) {
     const projects = program
         .command("projects")
@@ -299,22 +375,46 @@ export function setupProjectsCommands(program) {
         .option("--content <markdown>", "full markdown body (shown in project panel)")
         .option("--force", "create even if a project with the same name exists")
         .action(handleAsyncCommand(handleCreateProject));
+    projects
+        .command("archive <project>")
+        .description("Archive a project (resolves names)")
+        .action(handleAsyncCommand(handleArchiveProject));
+    projects
+        .command("delete <project>")
+        .description("Delete (trash) a project (resolves names)")
+        .action(handleAsyncCommand(handleDeleteProject));
     projects
         .command("list")
         .description("List projects")
         .option("-l, --limit <number>", "limit results", "100")
-        .option("--format <format>", "output format (json, table, md, csv)", "json")
+        .option("--format <format>", "output format (json, summary, table, md, csv)", "json")
         .option("--fields <fields>", "columns for table/csv (comma-separated: name,state,progress,teams,lead,targetDate)")
+        .option("--name <substring>", "filter by case-insensitive substring on project name")
+        .option("--state <names>", "include only projects in these states (comma-separated: backlog, planned, started, paused, completed, canceled)")
+        .option("--exclude-state <names>", "exclude projects in these states (comma-separated). Mutually exclusive with --state.")
+        .option("--active", "shorthand for --exclude-state completed,canceled (mutually exclusive with --state / --exclude-state)")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
+        const nameFilter = options.name;
+        const stateFilter = resolveProjectStateFilter(options);
         const ttl = resolveCacheTTL({
             configTTL: loadConfig().cacheTTLSeconds,
             noCacheFlag: rootOpts.cache === false,
         });
-        const result = await cached(`projects-list-limit:${limit}`, ttl, async () => {
+        // Cache key includes filter inputs so different filter combinations
+        // don't collide.
+        const cacheKey = `projects-list-limit:${limit}` +
+            `-name:${nameFilter ?? "_all"}` +
+            `-states:${stateFilter.states?.join(",") ?? "_any"}` +
+            `-excl:${stateFilter.excludeStates?.join(",") ?? "_none"}`;
+        const result = await cached(cacheKey, ttl, async () => {
             const service = await createLinearService(rootOpts);
-            return service.getProjects(limit);
+            return service.getProjects(limit, {
+                nameFilter,
+                states: stateFilter.states,
+                excludeStates: stateFilter.excludeStates,
+            });
         });
         const format = options.format;
         if (format === "table" ||

package/dist/commands/read-shortcut.d.ts

@@ -4,3 +4,9 @@ import type { Command } from "commander";
  * issue identifiers so `el-linear ADM-652` works without the `issues read` prefix.
  */
 export declare function setupReadShortcut(program: Command): void;
+/**
+ * Shared `issues read` body — exported so the top-level shortcut and
+ * `issues read` (in `commands/issues.ts`) both call one implementation
+ * instead of carrying byte-equivalent duplicates. ALL-938 cleanup.
+ */
+export declare function readIssues(issueIds: string[], _options: Record<string, unknown>, command: Command): Promise<void>;

package/dist/commands/read-shortcut.js

@@ -49,7 +49,12 @@ export function setupReadShortcut(program) {
         return originalParse(argv, parseOptions);
     };
 }
-async function readIssues(issueIds, _options, command) {
+/**
+ * Shared `issues read` body — exported so the top-level shortcut and
+ * `issues read` (in `commands/issues.ts`) both call one implementation
+ * instead of carrying byte-equivalent duplicates. ALL-938 cleanup.
+ */
+export async function readIssues(issueIds, _options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     const linearService = await createLinearService(rootOpts);

package/dist/commands/refs.js

@@ -3,6 +3,7 @@ import { createGraphQLService } from "../utils/graphql-service.js";
 import { extractIssueReferences } from "../utils/issue-reference-extractor.js";
 import { wrapIssueReferencesAsLinks, } from "../utils/issue-reference-wrapper.js";
 import { createLinearService } from "../utils/linear-service.js";
+import { logger } from "../utils/logger.js";
 import { handleAsyncCommand } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { validateReferences } from "../utils/validate-references.js";
@@ -67,13 +68,20 @@ async function handleWrap(options, command) {
             return new Set(map.keys());
         },
         async resolveUrlKey() {
+            // When --workspace-url-key or EL_LINEAR_WORKSPACE_URL_KEY supplies
+            // the key, the live lookup never fires — skip the GraphQL service
+            // instantiation entirely so `refs wrap --no-validate` works offline.
+            const override = options.workspaceUrlKey;
+            if (override || process.env.EL_LINEAR_WORKSPACE_URL_KEY) {
+                return getWorkspaceUrlKey(undefined, { override });
+            }
             const graphQLService = await createGraphQLService(rootOpts);
             return getWorkspaceUrlKey(graphQLService);
         },
     };
     if (!validate) {
         // stderr advisory only — keeps stdout a clean text stream for piping.
-        process.stderr.write("el-linear refs wrap: --no-validate set; emitting links for every regex match without checking the workspace.\n");
+        logger.error("el-linear refs wrap: --no-validate set; emitting links for every regex match without checking the workspace.");
     }
     const wrapped = await wrapRefsCore({ text, target, validate }, deps);
     process.stdout.write(wrapped);
@@ -92,5 +100,6 @@ export function setupRefsCommands(program) {
         .option("--file <path>", "read input from a file instead of stdin")
         .option("--target <target>", "output format: markdown (default) or slack", "markdown")
         .option("--no-validate", "skip workspace validation; wrap every regex match. Faster, but may produce broken links for IDs that don't exist.")
+        .option("--workspace-url-key <key>", "workspace URL key (the segment after linear.app/). Overrides config + env var. With --no-validate, makes the command fully offline.")
         .action(handleAsyncCommand(handleWrap));
 }

package/dist/commands/releases.js

@@ -2,18 +2,24 @@ import { CREATE_RELEASE_MUTATION, GET_RELEASE_BY_ID_QUERY, GET_RELEASE_PIPELINES
 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 transformRelease(release) {
+    // Lifecycle timestamps + dates only exist on the list/detail node shapes,
+    // not on the create-mutation shape; read defensively rather than splitting
+    // the function in two.
+    const r = release;
+    const documents = release.documents?.nodes;
     return {
         id: release.id,
         name: release.name,
-        description: release.description || undefined,
-        version: release.version || undefined,
-        url: release.url || undefined,
-        startDate: release.startDate || undefined,
-        targetDate: release.targetDate || undefined,
-        startedAt: release.startedAt || undefined,
-        completedAt: release.completedAt || undefined,
-        canceledAt: release.canceledAt || undefined,
+        description: release.description ?? undefined,
+        version: release.version ?? undefined,
+        url: release.url ?? undefined,
+        startDate: r.startDate ?? undefined,
+        targetDate: r.targetDate ?? undefined,
+        startedAt: r.startedAt ?? undefined,
+        completedAt: r.completedAt ?? undefined,
+        canceledAt: r.canceledAt ?? undefined,
         stage: release.stage
             ? {
                 id: release.stage.id,
@@ -27,7 +33,7 @@ function transformRelease(release) {
                 name: release.pipeline.name,
             }
             : undefined,
-        documents: release.documents?.nodes?.map((d) => ({
+        documents: documents?.map((d) => ({
             id: d.id,
             title: d.title,
             slugId: d.slugId,
@@ -40,14 +46,11 @@ async function handleCreateRelease(name, options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     const pipelines = await graphQLService.rawRequest(GET_RELEASE_PIPELINES_QUERY, { first: 50 });
-    const pipelineNodes = pipelines.releasePipelines
-        ?.nodes;
-    const pipeline = pipelineNodes?.find((p) => p.id === options.pipeline ||
+    const pipelineNodes = pipelines.releasePipelines.nodes;
+    const pipeline = pipelineNodes.find((p) => p.id === options.pipeline ||
         p.name.toLowerCase() === options.pipeline.toLowerCase());
     if (!pipeline) {
-        const available = (pipelineNodes ?? [])
-            .map((p) => p.name)
-            .join(", ");
+        const available = pipelineNodes.map((p) => p.name).join(", ");
         throw new Error(`Pipeline "${options.pipeline}" not found. Available: ${available || "none"}`);
     }
     const input = { name, pipelineId: pipeline.id };
@@ -58,21 +61,17 @@ async function handleCreateRelease(name, options, command) {
         input.version = options.version;
     }
     if (options.stage) {
-        const stageNodes = pipeline.stages?.nodes;
-        const stage = stageNodes?.find((s) => s.id === options.stage ||
+        const stage = pipeline.stages.nodes.find((s) => s.id === options.stage ||
             s.name.toLowerCase() === options.stage.toLowerCase());
         if (stage) {
             input.stageId = stage.id;
         }
     }
-    const result = await graphQLService.rawRequest(CREATE_RELEASE_MUTATION, {
-        input,
-    });
-    const releaseCreate = result.releaseCreate;
-    if (!releaseCreate?.success) {
+    const result = await graphQLService.rawRequest(CREATE_RELEASE_MUTATION, { input });
+    if (!result.releaseCreate.success || !result.releaseCreate.release) {
         throw new Error(`Failed to create release "${name}"`);
     }
-    outputSuccess(transformRelease(releaseCreate.release));
+    outputSuccess(transformRelease(result.releaseCreate.release));
 }
 export function setupReleasesCommands(program) {
     const releases = program
@@ -92,11 +91,10 @@ export function setupReleasesCommands(program) {
             filter.pipeline = { name: { eqIgnoreCase: options.pipeline } };
         }
         const result = await graphQLService.rawRequest(GET_RELEASES_QUERY, {
-            first: Number.parseInt(options.limit, 10),
+            first: parsePositiveInt(options.limit, "--limit"),
             filter: Object.keys(filter).length > 0 ? filter : undefined,
         });
-        const data = (result.releases
-            ?.nodes ?? []).map(transformRelease);
+        const data = result.releases.nodes.map(transformRelease);
         outputSuccess({ data, meta: { count: data.length } });
     }));
     releases
@@ -126,12 +124,10 @@ export function setupReleasesCommands(program) {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest(GET_RELEASE_PIPELINES_QUERY, { first: 50 });
-        const data = (result.releasePipelines
-            ?.nodes ?? []).map((p) => ({
+        const data = result.releasePipelines.nodes.map((p) => ({
             id: p.id,
             name: p.name,
-            stages: (p.stages
-                ?.nodes ?? []).map((s) => ({
+            stages: p.stages.nodes.map((s) => ({
                 id: s.id,
                 name: s.name,
                 type: s.type,