@enrichlayer/el-linear 1.2.0

package/dist/commands/labels.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupLabelsCommands(program: Command): void;

package/dist/commands/labels.js

@@ -0,0 +1,100 @@
+import { resolveTeam } from "../config/resolver.js";
+import { CREATE_LABEL_MUTATION, FIND_PARENT_LABEL_QUERY, RESTORE_LABEL_MUTATION, RETIRE_LABEL_MUTATION, } from "../queries/labels.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { validateHexColor } from "../utils/validators.js";
+async function handleCreateLabel(name, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const teamId = resolveTeam(options.team);
+    const graphQLService = createGraphQLService(rootOpts);
+    const input = { name, teamId };
+    if (options.color) {
+        input.color = validateHexColor(options.color);
+    }
+    if (options.description) {
+        input.description = options.description;
+    }
+    if (options.parent) {
+        const parentResult = await graphQLService.rawRequest(FIND_PARENT_LABEL_QUERY, {
+            name: options.parent,
+            teamId,
+        });
+        const issueLabels = parentResult.issueLabels;
+        const nodes = issueLabels?.nodes;
+        const parentLabel = nodes?.[0];
+        if (parentLabel) {
+            input.parentId = parentLabel.id;
+        }
+    }
+    const result = await graphQLService.rawRequest(CREATE_LABEL_MUTATION, {
+        input,
+    });
+    const createResult = result.issueLabelCreate;
+    if (!createResult?.success) {
+        throw new Error(`Failed to create label "${name}"`);
+    }
+    outputSuccess(createResult.issueLabel);
+}
+async function handleRetireLabel(labelId, _options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const result = await graphQLService.rawRequest(RETIRE_LABEL_MUTATION, {
+        id: labelId,
+    });
+    const retireResult = result.issueLabelRetire;
+    if (!retireResult?.success) {
+        throw new Error(`Failed to retire label "${labelId}"`);
+    }
+    outputSuccess(retireResult.issueLabel);
+}
+async function handleRestoreLabel(labelId, _options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const result = await graphQLService.rawRequest(RESTORE_LABEL_MUTATION, {
+        id: labelId,
+    });
+    const restoreResult = result.issueLabelRestore;
+    if (!restoreResult?.success) {
+        throw new Error(`Failed to restore label "${labelId}"`);
+    }
+    outputSuccess(restoreResult.issueLabel);
+}
+export function setupLabelsCommands(program) {
+    const labels = program
+        .command("labels")
+        .alias("label")
+        .description("Label operations");
+    labels.action(() => labels.help());
+    labels
+        .command("list")
+        .description("List all available labels")
+        .option("--team <team>", "filter by team key, name, or ID")
+        .option("-l, --limit <number>", "limit results", "100")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const teamFilter = options.team ? resolveTeam(options.team) : undefined;
+        const service = createLinearService(rootOpts);
+        const result = await service.getLabels(teamFilter, Number.parseInt(options.limit, 10));
+        outputSuccess({
+            data: result.labels,
+            meta: { count: result.labels.length },
+        });
+    }));
+    labels
+        .command("create <name>")
+        .description("Create a new label on a team")
+        .requiredOption("--team <team>", "team key, name, or ID")
+        .option("--color <color>", "label color (hex, e.g. #e06666)")
+        .option("--description <desc>", "label description")
+        .option("--parent <parent>", "parent label group name or ID")
+        .action(handleAsyncCommand(handleCreateLabel));
+    labels
+        .command("retire <labelId>")
+        .description("Retire a label (soft-delete — can be restored later)")
+        .action(handleAsyncCommand(handleRetireLabel));
+    labels
+        .command("restore <labelId>")
+        .description("Restore a previously retired label")
+        .action(handleAsyncCommand(handleRestoreLabel));
+}

package/dist/commands/project-milestones.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupProjectMilestonesCommands(program: Command): void;

package/dist/commands/project-milestones.js

@@ -0,0 +1,143 @@
+import { CREATE_PROJECT_MILESTONE_MUTATION, FIND_PROJECT_MILESTONE_BY_NAME_GLOBAL, FIND_PROJECT_MILESTONE_BY_NAME_SCOPED, GET_PROJECT_MILESTONE_BY_ID_QUERY, LIST_PROJECT_MILESTONES_QUERY, UPDATE_PROJECT_MILESTONE_MUTATION, } from "../queries/project-milestones.js";
+import { multipleMatchesError, notFoundError, } from "../utils/error-messages.js";
+import { createGraphQLService, } from "../utils/graphql-service.js";
+import { createLinearService, } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { isUuid } from "../utils/uuid.js";
+import { validateIsoDate } from "../utils/validators.js";
+async function resolveMilestoneId(milestoneNameOrId, graphQLService, linearService, projectNameOrId) {
+    if (isUuid(milestoneNameOrId)) {
+        return milestoneNameOrId;
+    }
+    let nodes = [];
+    if (projectNameOrId) {
+        const projectId = await linearService.resolveProjectId(projectNameOrId);
+        const findRes = await graphQLService.rawRequest(FIND_PROJECT_MILESTONE_BY_NAME_SCOPED, {
+            name: milestoneNameOrId,
+            projectId,
+        });
+        const projectData = findRes.project;
+        const milestonesData = projectData?.projectMilestones;
+        nodes = milestonesData?.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 || [];
+    }
+    if (nodes.length === 0) {
+        throw notFoundError("Milestone", milestoneNameOrId);
+    }
+    if (nodes.length > 1) {
+        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;
+}
+async function handleListMilestones(options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const linearService = createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(options.project);
+    const result = await graphQLService.rawRequest(LIST_PROJECT_MILESTONES_QUERY, {
+        projectId,
+        first: Number.parseInt(options.limit || "50", 10),
+    });
+    const projectData = result.project;
+    const milestonesData = projectData?.projectMilestones;
+    const nodes = milestonesData?.nodes || [];
+    outputSuccess({ data: nodes, meta: { count: nodes.length } });
+}
+async function handleReadMilestone(milestoneIdOrName, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const linearService = createLinearService(rootOpts);
+    const milestoneId = await resolveMilestoneId(milestoneIdOrName, graphQLService, linearService, options.project);
+    const result = await graphQLService.rawRequest(GET_PROJECT_MILESTONE_BY_ID_QUERY, {
+        id: milestoneId,
+        issuesFirst: Number.parseInt(options.issuesFirst || "50", 10),
+    });
+    outputSuccess(result.projectMilestone);
+}
+async function handleCreateMilestone(name, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const linearService = createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(options.project);
+    if (options.targetDate) {
+        validateIsoDate(options.targetDate);
+    }
+    const result = await graphQLService.rawRequest(CREATE_PROJECT_MILESTONE_MUTATION, {
+        projectId,
+        name,
+        description: options.description,
+        targetDate: options.targetDate,
+    });
+    const createData = result.projectMilestoneCreate;
+    if (!createData?.success) {
+        throw new Error("Failed to create project milestone");
+    }
+    outputSuccess(createData.projectMilestone);
+}
+async function handleUpdateMilestone(milestoneIdOrName, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const linearService = createLinearService(rootOpts);
+    const milestoneId = await resolveMilestoneId(milestoneIdOrName, graphQLService, linearService, options.project);
+    const updateVars = { id: milestoneId };
+    if (options.name !== undefined) {
+        updateVars.name = options.name;
+    }
+    if (options.description !== undefined) {
+        updateVars.description = options.description;
+    }
+    if (options.targetDate !== undefined) {
+        validateIsoDate(options.targetDate);
+        updateVars.targetDate = options.targetDate;
+    }
+    if (options.sortOrder !== undefined) {
+        updateVars.sortOrder = Number.parseFloat(options.sortOrder);
+    }
+    const result = await graphQLService.rawRequest(UPDATE_PROJECT_MILESTONE_MUTATION, updateVars);
+    const updateData = result.projectMilestoneUpdate;
+    if (!updateData?.success) {
+        throw new Error("Failed to update project milestone");
+    }
+    outputSuccess(updateData.projectMilestone);
+}
+export function setupProjectMilestonesCommands(program) {
+    const projectMilestones = program
+        .command("project-milestones")
+        .description("Project milestone operations");
+    projectMilestones.action(() => projectMilestones.help());
+    projectMilestones
+        .command("list")
+        .description("List milestones in a project")
+        .requiredOption("--project <project>", "project name or ID")
+        .option("-l, --limit <number>", "limit results", "50")
+        .action(handleAsyncCommand(handleListMilestones));
+    projectMilestones
+        .command("read <milestoneIdOrName>")
+        .description("Get milestone details including issues.")
+        .option("--project <project>", "project name or ID to scope name lookup")
+        .option("--issues-first <n>", "how many issues to fetch (default 50)", "50")
+        .action(handleAsyncCommand(handleReadMilestone));
+    projectMilestones
+        .command("create <name>")
+        .description("Create a new project milestone")
+        .requiredOption("--project <project>", "project name or ID")
+        .option("-d, --description <description>", "milestone description")
+        .option("--target-date <date>", "target date in ISO format (YYYY-MM-DD)")
+        .action(handleAsyncCommand(handleCreateMilestone));
+    projectMilestones
+        .command("update <milestoneIdOrName>")
+        .description("Update an existing project milestone.")
+        .option("--project <project>", "project name or ID to scope name lookup")
+        .option("-n, --name <name>", "new milestone name")
+        .option("-d, --description <description>", "new milestone description")
+        .option("--target-date <date>", "new target date in ISO format (YYYY-MM-DD)")
+        .option("--sort-order <number>", "new sort order")
+        .action(handleAsyncCommand(handleUpdateMilestone));
+}

package/dist/commands/projects.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupProjectsCommands(program: Command): void;

package/dist/commands/projects.js

@@ -0,0 +1,336 @@
+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 { 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 { 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] ?? "");
+            }
+        }
+        return row;
+    });
+    if (format === "csv") {
+        logger.info(fields.join(","));
+        for (const row of rows) {
+            logger.info(fields.map((f) => `"${(row[f] ?? "").replace(/"/g, '""')}"`).join(","));
+        }
+        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);
+    }
+}
+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) {
+            throw new Error(`Project "${projectNameOrId}" not found`);
+        }
+        const teams = project.teams;
+        return {
+            projectId: project.id,
+            projectName: project.name,
+            currentTeams: (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) {
+        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) => ({
+            id: t.id,
+            key: t.key,
+            name: t.name,
+        })),
+    };
+}
+function formatTeamsOutput(projectUpdate) {
+    const updatedProject = projectUpdate.project;
+    const updatedTeams = updatedProject.teams;
+    return {
+        id: updatedProject.id,
+        name: updatedProject.name,
+        teams: (updatedTeams.nodes || []).map((t) => ({
+            id: t.id,
+            key: t.key,
+            name: t.name,
+        })),
+    };
+}
+async function handleAddTeam(projectNameOrId, teamInput, _options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const finalTeamId = await createLinearService(rootOpts).resolveTeamId(resolveTeam(teamInput));
+    const { projectId, currentTeams } = await resolveProjectWithTeams(graphQLService, projectNameOrId);
+    const currentTeamIds = currentTeams.map((t) => t.id);
+    if (currentTeamIds.includes(finalTeamId)) {
+        outputSuccess({
+            message: `Team "${teamInput}" is already associated with the project`,
+            projectId,
+        });
+        return;
+    }
+    const updateResult = await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
+        id: projectId,
+        input: { teamIds: [...currentTeamIds, finalTeamId] },
+    });
+    const projectUpdate = updateResult.projectUpdate;
+    if (!projectUpdate.success) {
+        throw new Error("Failed to update project");
+    }
+    outputSuccess(formatTeamsOutput(projectUpdate));
+}
+async function handleAddTeams(projectNameOrId, teamInputs, _options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const resolvedTeamIds = await Promise.all(teamInputs.map((t) => createLinearService(rootOpts).resolveTeamId(resolveTeam(t))));
+    const { projectId, currentTeams } = await resolveProjectWithTeams(graphQLService, projectNameOrId);
+    const currentTeamIds = currentTeams.map((t) => t.id);
+    const newTeamIds = resolvedTeamIds.filter((id) => !currentTeamIds.includes(id));
+    const skippedInputs = teamInputs.filter((_, i) => currentTeamIds.includes(resolvedTeamIds[i]));
+    if (newTeamIds.length === 0) {
+        outputSuccess({
+            message: "All teams are already associated with the project",
+            projectId,
+            skipped: skippedInputs,
+        });
+        return;
+    }
+    const mergedTeamIds = [...currentTeamIds, ...newTeamIds];
+    const updateResult = await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
+        id: projectId,
+        input: { teamIds: mergedTeamIds },
+    });
+    const projectUpdate = updateResult.projectUpdate;
+    if (!projectUpdate.success) {
+        throw new Error("Failed to update project");
+    }
+    const result = formatTeamsOutput(projectUpdate);
+    outputSuccess({
+        ...result,
+        added: newTeamIds.length,
+        skipped: skippedInputs.length > 0 ? skippedInputs : undefined,
+    });
+}
+async function handleRemoveTeam(projectNameOrId, teamInput, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const finalTeamId = await createLinearService(rootOpts).resolveTeamId(resolveTeam(teamInput));
+    const { projectId, projectName, currentTeams } = await resolveProjectWithTeams(graphQLService, projectNameOrId);
+    const currentTeamIds = currentTeams.map((t) => t.id);
+    if (!currentTeamIds.includes(finalTeamId)) {
+        throw new Error(`Team "${teamInput}" is not associated with project "${projectName}"`);
+    }
+    if (!options.force) {
+        const issueCheck = await graphQLService.rawRequest(GET_PROJECT_TEAM_ISSUES_QUERY, {
+            projectId,
+            teamId: finalTeamId,
+        });
+        const project = issueCheck.project;
+        const issues = project.issues;
+        const issueNodes = issues.nodes || [];
+        if (issueNodes.length > 0) {
+            const examples = issueNodes
+                .slice(0, 5)
+                .map((i) => `${i.identifier}: ${i.title}`)
+                .join("\n  ");
+            throw new Error(`Cannot remove team "${teamInput}" — it has ${issueNodes.length}${issueNodes.length >= 50 ? "+" : ""} issues in project "${projectName}". Reassign or remove those issues first.\n  ${examples}${issueNodes.length > 5 ? "\n  ..." : ""}\n\nUse --force to bypass this check.`);
+        }
+    }
+    const updatedTeamIds = currentTeamIds.filter((id) => id !== finalTeamId);
+    const updateResult = await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
+        id: projectId,
+        input: { teamIds: updatedTeamIds },
+    });
+    const projectUpdate = updateResult.projectUpdate;
+    if (!projectUpdate.success) {
+        throw new Error("Failed to update project");
+    }
+    outputSuccess({
+        ...formatTeamsOutput(projectUpdate),
+        removed: teamInput,
+    });
+}
+async function handleCreateProject(name, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = 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());
+    if (existing.length > 0 && !options.force) {
+        const match = existing[0];
+        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.`);
+    }
+    // Step 2: Resolve team IDs
+    const service = createLinearService(rootOpts);
+    const teamKeys = options.team ? splitList(options.team) : [];
+    const teamIds = [];
+    for (const key of teamKeys) {
+        teamIds.push(await service.resolveTeamId(resolveTeam(key)));
+    }
+    // Step 3: Create the project
+    const input = {
+        name,
+        ...(options.description ? { description: options.description } : {}),
+        ...(teamIds.length > 0 ? { teamIds } : {}),
+    };
+    const createResult = await graphQLService.rawRequest(CREATE_PROJECT_MUTATION, { input });
+    const created = createResult.projectCreate;
+    if (!created?.success) {
+        throw new Error("Failed to create project");
+    }
+    const project = created.project;
+    // Step 4: Set content if provided (separate mutation — Linear API quirk)
+    if (options.content) {
+        await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
+            id: project.id,
+            input: { content: options.content },
+        });
+    }
+    const teamList = (project.teams?.nodes ??
+        [])
+        .map((t) => t.key)
+        .join(", ");
+    outputSuccess({
+        id: project.id,
+        name: project.name,
+        state: project.state ?? "planned",
+        teams: teamList,
+        ...(existing.length > 0
+            ? {
+                _warnings: [
+                    `Created despite existing project "${existing[0].name}" (--force used)`,
+                ],
+            }
+            : {}),
+    });
+}
+export function setupProjectsCommands(program) {
+    const projects = program
+        .command("projects")
+        .alias("project")
+        .description("Project operations");
+    projects.action(() => projects.help());
+    projects
+        .command("create <name>")
+        .description("Create a project (checks for duplicates first)")
+        .option("--team <teams>", "comma-separated team keys (e.g., FE,DEV)")
+        .option("-d, --description <text>", "short summary (max 255 chars, shown in lists)")
+        .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("list")
+        .description("List projects")
+        .option("-l, --limit <number>", "limit results", "100")
+        .option("--format <format>", "output format (json, table, md, csv)", "json")
+        .option("--fields <fields>", "columns for table/csv (comma-separated: name,state,progress,teams,lead,targetDate)")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const service = createLinearService(rootOpts);
+        const result = await service.getProjects(Number.parseInt(options.limit, 10));
+        const format = options.format;
+        if (format === "table" ||
+            format === "md" ||
+            format === "markdown" ||
+            format === "csv") {
+            const fieldList = options.fields
+                ? splitList(options.fields)
+                : undefined;
+            formatProjectsOutput(result, format, fieldList);
+            if (format === "table") {
+                logger.info(`\n${result.length} projects`);
+            }
+        }
+        else {
+            outputSuccess({ data: result, meta: { count: result.length } });
+        }
+    }));
+    projects
+        .command("add-team <project> <team>")
+        .description("Associate a project with an additional team (resolves names)")
+        .action(handleAsyncCommand(handleAddTeam));
+    projects
+        .command("add-teams <project> <teams...>")
+        .description("Associate a project with multiple teams in one operation (resolves names)")
+        .action(handleAsyncCommand(handleAddTeams));
+    projects
+        .command("remove-team <project> <team>")
+        .description("Remove a team from a project (checks for issues first)")
+        .option("--force", "remove even if the team has issues in the project")
+        .action(handleAsyncCommand(handleRemoveTeam));
+}

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

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+/**
+ * Registers a top-level `read` command and a catch-all that auto-detects
+ * issue identifiers so `el-linear ADM-652` works without the `issues read` prefix.
+ */
+export declare function setupReadShortcut(program: Command): void;

package/dist/commands/read-shortcut.js

@@ -0,0 +1,69 @@
+import { getApiToken } from "../utils/auth.js";
+import { downloadLinearUploads } from "../utils/download-uploads.js";
+import { GraphQLIssuesService } from "../utils/graphql-issues-service.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+/**
+ * Issue ID pattern: 1-5 uppercase letters, dash, 1+ digits (e.g. ADM-652, DEV-12).
+ */
+const ISSUE_ID_PATTERN = /^[A-Z]{1,5}-\d+$/;
+/**
+ * Registers a top-level `read` command and a catch-all that auto-detects
+ * issue identifiers so `el-linear ADM-652` works without the `issues read` prefix.
+ */
+export function setupReadShortcut(program) {
+    // Top-level `read` / `get` / `view` / `show` command
+    program
+        .command("read <issueId...>")
+        .alias("get")
+        .alias("view")
+        .alias("show")
+        .description("Shortcut for `issues read`. Get issue details by identifier.")
+        .addHelpText("after", "\nExamples:\n  el-linear read ADM-652\n  el-linear get DEV-123 DEV-456\n  el-linear ADM-652          (auto-detected)")
+        .action(handleAsyncCommand(readIssues));
+    // Catch-all: if argv looks like `el-linear ADM-652 [DEV-123 ...]`, run read
+    const originalParse = program.parse.bind(program);
+    program.parse = (argv, parseOptions) => {
+        const args = argv ?? process.argv;
+        const userArgs = args.slice(2); // skip node + script
+        // Only intercept when every positional arg looks like an issue ID
+        // and there are no flags (to avoid hijacking other commands)
+        const positionals = userArgs.filter((a) => !a.startsWith("-"));
+        const flags = userArgs.filter((a) => a.startsWith("-"));
+        const onlyCompatFlags = flags.every((f) => f === "--json" || f.startsWith("--api-token"));
+        if (positionals.length > 0 &&
+            positionals.every((a) => ISSUE_ID_PATTERN.test(a)) &&
+            onlyCompatFlags) {
+            // Check the first positional isn't a known command
+            const knownCommands = new Set(program.commands
+                .map((c) => c.name())
+                .concat(program.commands.flatMap((c) => c.aliases())));
+            if (!knownCommands.has(positionals[0])) {
+                // Rewrite to `read <ids...>`
+                const rewritten = [...args.slice(0, 2), "read", ...userArgs];
+                return originalParse(rewritten, parseOptions);
+            }
+        }
+        return originalParse(argv, parseOptions);
+    };
+}
+async function readIssues(issueIds, _options, command) {
+    const rootOpts = command.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const linearService = createLinearService(rootOpts);
+    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const apiToken = getApiToken(rootOpts);
+    if (issueIds.length === 1) {
+        const issue = await issuesService.getIssueById(issueIds[0]);
+        const resolved = await downloadLinearUploads(issue, apiToken);
+        outputSuccess(resolved);
+    }
+    else {
+        const results = await Promise.all(issueIds.map(async (id) => {
+            const issue = await issuesService.getIssueById(id);
+            return downloadLinearUploads(issue, apiToken);
+        }));
+        outputSuccess(results);
+    }
+}

package/dist/commands/releases.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupReleasesCommands(program: Command): void;