@enrichlayer/el-linear 1.2.0

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

@@ -0,0 +1,925 @@
+import { resolveUserDisplayName } from "../config/resolver.js";
+import { BATCH_RESOLVE_FOR_CREATE_QUERY, BATCH_RESOLVE_FOR_SEARCH_QUERY, BATCH_RESOLVE_FOR_UPDATE_QUERY, buildResolveLabelsByNameQuery, CREATE_ISSUE_MUTATION, FILTERED_SEARCH_ISSUES_QUERY, GET_ISSUE_BY_ID_QUERY, GET_ISSUE_BY_IDENTIFIER_QUERY, GET_ISSUE_TEAM_QUERY, GET_ISSUES_QUERY, SEARCH_ISSUES_QUERY, UPDATE_ISSUE_MUTATION, } from "../queries/issues.js";
+import { CREATE_LABEL_MUTATION } from "../queries/labels.js";
+import { toISOStringOrNow } from "./date-format.js";
+import { extractEmbeds } from "./embed-parser.js";
+import { notFoundError } from "./error-messages.js";
+import { parseIssueIdentifier, tryParseIssueIdentifier, } from "./identifier-parser.js";
+import { isUuid } from "./uuid.js";
+const TEAM_KEY_REGEX = /^[A-Z0-9]+$/i;
+function extractSummaryText(summary) {
+    if (summary.generationStatus !== "completed" || !summary.content) {
+        return undefined;
+    }
+    const parts = [];
+    const walk = (node) => {
+        if (node.text) {
+            parts.push(node.text);
+        }
+        if (Array.isArray(node.content)) {
+            for (const child of node.content) {
+                walk(child);
+            }
+        }
+    };
+    walk(summary.content);
+    return parts.length > 0 ? parts.join("") : undefined;
+}
+export class GraphQLIssuesService {
+    graphQLService;
+    linearService;
+    constructor(graphQLService, linearService) {
+        this.graphQLService = graphQLService;
+        this.linearService = linearService;
+    }
+    async getIssues(limit = 25) {
+        const result = await this.graphQLService.rawRequest(GET_ISSUES_QUERY, {
+            first: limit,
+            orderBy: "updatedAt",
+        });
+        const issues = result.issues;
+        if (!issues?.nodes) {
+            return [];
+        }
+        return issues.nodes.map((issue) => this.transformIssueData(issue));
+    }
+    async getIssueById(issueId) {
+        let issueData;
+        if (isUuid(issueId)) {
+            const result = await this.graphQLService.rawRequest(GET_ISSUE_BY_ID_QUERY, { id: issueId });
+            if (!result.issue) {
+                throw notFoundError("Issue", issueId);
+            }
+            issueData = result.issue;
+        }
+        else {
+            const { teamKey, issueNumber } = parseIssueIdentifier(issueId);
+            const result = await this.graphQLService.rawRequest(GET_ISSUE_BY_IDENTIFIER_QUERY, {
+                teamKey,
+                number: issueNumber,
+            });
+            const issues = result.issues;
+            const nodes = issues?.nodes;
+            if (!nodes?.length) {
+                throw notFoundError("Issue", issueId);
+            }
+            issueData = nodes[0];
+        }
+        return this.transformIssueData(issueData);
+    }
+    async updateIssue(args, labelMode = "overwriting") {
+        const { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult } = await this.resolveUpdateContext(args);
+        let teamIdForLabels = issueTeamId;
+        if (!teamIdForLabels && args.labelIds && resolvedIssueId) {
+            teamIdForLabels = await this.fetchIssueTeamId(resolvedIssueId);
+        }
+        const finalLabelIds = await this.resolveLabelsWithMode(args.labelIds, resolveResult, labelMode, currentIssueLabels, teamIdForLabels, args.teamId);
+        const finalProjectId = args.projectId
+            ? this.resolveProjectId(args.projectId, resolveResult)
+            : args.projectId;
+        const { projectMilestoneNodes, issueProjectMilestoneNodes } = this.extractMilestoneNodes(args, resolveResult);
+        const finalMilestoneId = this.resolveMilestoneId(args.milestoneId, resolveResult, projectMilestoneNodes, issueProjectMilestoneNodes);
+        const finalCycleId = await this.resolveCycleIdForUpdate(args, resolveResult, resolvedIssueId);
+        const resolvedStatusId = await this.resolveStatusIdForUpdate(args, resolvedIssueId);
+        if (args.assigneeId && !isUuid(args.assigneeId)) {
+            args.assigneeId = await this.linearService.resolveUserId(args.assigneeId);
+        }
+        const updateInput = this.buildUpdateInput(args, {
+            statusId: resolvedStatusId,
+            projectId: finalProjectId,
+            labelIds: finalLabelIds,
+            milestoneId: finalMilestoneId,
+            cycleId: finalCycleId,
+        });
+        return this.executeUpdateMutation(resolvedIssueId, args.id, updateInput);
+    }
+    extractMilestoneNodes(args, resolveResult) {
+        const projectNodes = resolveResult.projects?.nodes;
+        const projectMilestoneNodes = args.projectId
+            ? projectNodes?.[0]?.projectMilestones?.nodes
+            : undefined;
+        const issueNodes = resolveResult.issues
+            ?.nodes;
+        const issueProjectMilestoneNodes = issueNodes?.[0]?.project
+            ?.projectMilestones?.nodes;
+        return { projectMilestoneNodes, issueProjectMilestoneNodes };
+    }
+    async executeUpdateMutation(resolvedIssueId, originalId, updateInput) {
+        let updateResult;
+        try {
+            updateResult = await this.graphQLService.rawRequest(UPDATE_ISSUE_MUTATION, {
+                id: resolvedIssueId,
+                input: updateInput,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            if (msg.includes("Discrepancy between issue team")) {
+                const hint = updateInput.projectId
+                    ? `The project may not be associated with this issue's team. Fix with: el-linear projects add-team "<project>" <team>`
+                    : "The issue's team doesn't match the assigned project, cycle, or status.";
+                throw new Error(`Failed to update issue ${originalId}: ${hint}`);
+            }
+            throw new Error(`Failed to update issue ${originalId}: ${msg}`);
+        }
+        const issueUpdate = updateResult.issueUpdate;
+        if (!issueUpdate.success) {
+            throw new Error(`Failed to update issue ${originalId}`);
+        }
+        if (!issueUpdate.issue) {
+            throw new Error("Failed to retrieve updated issue");
+        }
+        return this.transformIssueData(issueUpdate.issue);
+    }
+    async createIssue(args) {
+        const resolveVariables = this.buildCreateResolveVariables(args);
+        let resolveResult = {};
+        if (Object.keys(resolveVariables).length > 0) {
+            const { __labelNames, ...queryVars } = resolveVariables;
+            const requests = [
+                this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_CREATE_QUERY, queryVars),
+            ];
+            if (__labelNames) {
+                const labelQuery = buildResolveLabelsByNameQuery(__labelNames);
+                requests.push(this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables));
+            }
+            const results = await Promise.all(requests);
+            resolveResult = results[0];
+            if (results[1]) {
+                resolveResult.labels = results[1].labels;
+            }
+        }
+        const resolved = await this.resolveCreateFields(args, resolveResult);
+        if (args.assigneeId && !isUuid(args.assigneeId)) {
+            args.assigneeId = await this.linearService.resolveUserId(args.assigneeId);
+        }
+        const createInput = this.buildCreateInput(args, resolved);
+        return this.executeCreateMutation(createInput);
+    }
+    async resolveCreateFields(args, resolveResult) {
+        let teamId = args.teamId
+            ? await this.resolveTeamId(args.teamId, resolveResult)
+            : args.teamId;
+        const projectId = args.projectId
+            ? this.resolveProjectId(args.projectId, resolveResult)
+            : args.projectId;
+        // Validate team-project compatibility and auto-correct when possible
+        if (projectId && teamId) {
+            teamId = this.validateProjectTeam(teamId, args.projectId, resolveResult);
+        }
+        const labelIds = await this.resolveLabels(args.labelIds, resolveResult, teamId, args.teamInput);
+        const parentId = this.resolveParentId(args.parentId, resolveResult);
+        const milestoneId = this.resolveMilestoneIdForCreate(args.milestoneId, resolveResult, projectId);
+        let cycleId = args.cycleId;
+        if (args.cycleId &&
+            typeof args.cycleId === "string" &&
+            !isUuid(args.cycleId)) {
+            cycleId = await this.linearService.resolveCycleId(args.cycleId, teamId);
+        }
+        let statusId = args.statusId;
+        if (args.statusId && !isUuid(args.statusId)) {
+            statusId = await this.linearService.resolveStatusId(args.statusId, teamId);
+        }
+        return {
+            teamId,
+            projectId,
+            statusId,
+            labelIds,
+            parentId,
+            milestoneId,
+            cycleId,
+        };
+    }
+    async executeCreateMutation(createInput) {
+        let createResult;
+        try {
+            createResult = await this.graphQLService.rawRequest(CREATE_ISSUE_MUTATION, {
+                input: createInput,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to create issue: ${msg}`);
+        }
+        const issueCreate = createResult.issueCreate;
+        if (!issueCreate.success) {
+            throw new Error("Failed to create issue: the API reported failure.");
+        }
+        if (!issueCreate.issue) {
+            throw new Error("Failed to retrieve created issue");
+        }
+        return this.transformIssueData(issueCreate.issue);
+    }
+    async searchIssues(args) {
+        const resolveVariables = {};
+        if (args.teamId && !isUuid(args.teamId)) {
+            Object.assign(resolveVariables, this.buildResolveVariablesForTeam(args.teamId));
+        }
+        if (args.projectId && !isUuid(args.projectId)) {
+            resolveVariables.projectName = args.projectId;
+        }
+        if (args.assigneeId &&
+            !isUuid(args.assigneeId) &&
+            args.assigneeId.includes("@")) {
+            resolveVariables.assigneeEmail = args.assigneeId;
+        }
+        let resolveResult = {};
+        if (Object.keys(resolveVariables).length > 0) {
+            resolveResult = await this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_SEARCH_QUERY, resolveVariables);
+        }
+        const finalTeamId = args.teamId
+            ? await this.resolveTeamId(args.teamId, resolveResult)
+            : args.teamId;
+        const finalProjectId = args.projectId
+            ? this.resolveProjectId(args.projectId, resolveResult)
+            : args.projectId;
+        const finalAssigneeId = this.resolveAssigneeId(args.assigneeId, resolveResult);
+        if (args.query) {
+            const searchResult = await this.graphQLService.rawRequest(SEARCH_ISSUES_QUERY, {
+                term: args.query,
+                first: args.limit || 10,
+            });
+            const searchIssues = searchResult.searchIssues;
+            if (!searchIssues?.nodes) {
+                return [];
+            }
+            const results = searchIssues.nodes.map((issue) => this.transformIssueData(issue));
+            return this.applySearchFilters(results, {
+                teamId: finalTeamId,
+                assigneeId: finalAssigneeId,
+                projectId: finalProjectId,
+                status: args.status,
+                labelNames: args.labelNames,
+                priority: args.priority,
+            });
+        }
+        const filter = this.buildSearchFilter({
+            teamId: finalTeamId,
+            assigneeId: finalAssigneeId,
+            projectId: finalProjectId,
+            noProject: args.noProject,
+            status: args.status,
+            labelNames: args.labelNames,
+            priority: args.priority,
+        });
+        const searchResult = await this.graphQLService.rawRequest(FILTERED_SEARCH_ISSUES_QUERY, {
+            first: args.limit || 10,
+            filter: Object.keys(filter).length > 0 ? filter : undefined,
+            orderBy: args.orderBy || "updatedAt",
+        });
+        const filteredIssues = searchResult.issues;
+        if (!filteredIssues?.nodes) {
+            return [];
+        }
+        return filteredIssues.nodes.map((issue) => this.transformIssueData(issue));
+    }
+    // --- Private helper methods for field resolution ---
+    async resolveTeamId(teamId, resolveResult) {
+        if (isUuid(teamId)) {
+            return teamId;
+        }
+        const teams = resolveResult.teams;
+        const teamNodes = teams?.nodes;
+        const resolvedTeam = teamNodes?.[0];
+        if (resolvedTeam &&
+            (resolvedTeam.key.toUpperCase() === teamId.toUpperCase() ||
+                resolvedTeam.name.toLowerCase() === teamId.toLowerCase())) {
+            return resolvedTeam.id;
+        }
+        // Exact GraphQL match failed — fall back to prefix matching via LinearService
+        return this.linearService.resolveTeamId(teamId);
+    }
+    resolveProjectId(projectId, resolveResult) {
+        if (isUuid(projectId)) {
+            return projectId;
+        }
+        const projects = resolveResult.projects;
+        const projectNodes = projects?.nodes;
+        if (!projectNodes?.length) {
+            throw notFoundError("Project", projectId);
+        }
+        return projectNodes[0].id;
+    }
+    /**
+     * Check that the resolved team is associated with the project.
+     * If not, auto-switch when the project belongs to exactly one team.
+     */
+    validateProjectTeam(teamId, projectInput, resolveResult) {
+        const projects = resolveResult.projects;
+        const projectNode = projects?.nodes?.[0];
+        if (!projectNode) {
+            return teamId;
+        }
+        const teamsConn = projectNode.teams;
+        const teamNodes = teamsConn?.nodes;
+        if (!teamNodes?.length) {
+            return teamId;
+        }
+        const isAssociated = teamNodes.some((t) => t.id === teamId);
+        if (isAssociated) {
+            return teamId;
+        }
+        const projectName = projectNode.name || projectInput;
+        const teamKeys = teamNodes.map((t) => t.key);
+        if (teamNodes.length === 1) {
+            const correctTeamId = teamNodes[0].id;
+            const correctKey = teamKeys[0];
+            process.stderr.write(`Auto-switched team to ${correctKey} (the only team associated with project "${projectName}").\n`);
+            return correctTeamId;
+        }
+        throw new Error(`Project "${projectName}" is not associated with the specified team.\n` +
+            `Associated teams: ${teamKeys.join(", ")}\n` +
+            `Hint: Use --team ${teamKeys[0]} or run \`el-linear projects add-team "${projectName}" TEAM\` to add your team.`);
+    }
+    async resolveLabels(labelIds, resolveResult, teamId, teamInput) {
+        return this.resolveLabelsWithMode(labelIds, resolveResult, "overwriting", [], teamId, teamInput);
+    }
+    async resolveLabelsWithMode(labelIds, resolveResult, labelMode, currentIssueLabels, teamId, teamInput) {
+        if (!(labelIds && Array.isArray(labelIds))) {
+            return labelIds;
+        }
+        const resolvedLabels = [];
+        const labels = resolveResult.labels;
+        const labelNodes = labels?.nodes;
+        for (const labelIdOrName of labelIds) {
+            if (isUuid(labelIdOrName)) {
+                resolvedLabels.push(labelIdOrName);
+            }
+            else {
+                const lowerName = labelIdOrName.toLowerCase();
+                const candidates = labelNodes?.filter((l) => l.name.toLowerCase() === lowerName);
+                let label;
+                if (candidates && candidates.length > 1 && teamId) {
+                    label = candidates.find((l) => {
+                        const team = l.team;
+                        return team?.id === teamId;
+                    });
+                }
+                if (!label) {
+                    label = candidates?.[0];
+                }
+                if (!label) {
+                    // Auto-create the missing label on the team
+                    const created = await this.autoCreateLabel(labelIdOrName, teamId);
+                    if (created) {
+                        resolvedLabels.push(created);
+                        continue;
+                    }
+                    const teamKey = this.resolveTeamKeyFromResult(resolveResult, teamId, teamInput);
+                    const hint = teamKey
+                        ? `— check available labels with: el-linear labels list --team ${teamKey}`
+                        : undefined;
+                    throw notFoundError("Label", labelIdOrName, undefined, hint);
+                }
+                if (label.isGroup) {
+                    const teamKey = this.resolveTeamKeyFromResult(resolveResult, teamId, teamInput);
+                    const hint = teamKey
+                        ? ` Run: el-linear labels list --team ${teamKey}`
+                        : "";
+                    throw new Error(`Label "${labelIdOrName}" is a group label. Use a specific child label instead.${hint}`);
+                }
+                resolvedLabels.push(label.id);
+            }
+        }
+        if (labelMode === "adding") {
+            return [...new Set([...currentIssueLabels, ...resolvedLabels])];
+        }
+        return resolvedLabels;
+    }
+    /** Auto-create a missing label on the team. Returns the new label ID or null on failure. */
+    async autoCreateLabel(name, teamId) {
+        try {
+            const input = { name };
+            if (teamId) {
+                input.teamId = teamId;
+            }
+            const result = await this.graphQLService.rawRequest(CREATE_LABEL_MUTATION, { input });
+            const created = result.issueLabelCreate;
+            if (created?.success && created.issueLabel) {
+                const labelData = created.issueLabel;
+                const teamInfo = labelData.team;
+                const teamKey = teamInfo?.key ?? "";
+                process.stderr.write(`Auto-created label "${name}" on team ${teamKey}\n`);
+                return labelData.id;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveTeamKeyFromResult(resolveResult, teamId, teamInput) {
+        // Collect team nodes from both the top-level teams query and the project's teams.
+        // When the team was pre-resolved to a UUID by config, the top-level teams query
+        // runs with null filters and may return an unrelated team. The project's teams
+        // always include the correct team when a project is specified.
+        const allTeamNodes = this.collectTeamNodes(resolveResult);
+        if (teamId) {
+            const match = allTeamNodes.find((t) => t.id === teamId);
+            if (match) {
+                return match.key;
+            }
+        }
+        // If the team was pre-resolved to UUID by config and not found in the result,
+        // use the original input (e.g., "DEV") as the hint.
+        if (teamInput && !isUuid(teamInput)) {
+            return teamInput.toUpperCase();
+        }
+        // Only fall back to first team if there's exactly one (unambiguous).
+        // With multiple teams, returning an arbitrary one produces misleading error hints.
+        const topLevelNodes = resolveResult.teams?.nodes;
+        return topLevelNodes?.length === 1
+            ? topLevelNodes[0].key
+            : undefined;
+    }
+    collectTeamNodes(resolveResult) {
+        const nodes = [];
+        const seen = new Set();
+        const topTeams = resolveResult.teams;
+        const topNodes = topTeams?.nodes;
+        if (topNodes) {
+            for (const t of topNodes) {
+                const id = t.id;
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    nodes.push(t);
+                }
+            }
+        }
+        // Also check project teams (which are always fetched when --project is used)
+        const projects = resolveResult.projects;
+        const projectNode = projects?.nodes?.[0];
+        if (projectNode) {
+            const projectTeams = projectNode.teams;
+            const projectTeamNodes = projectTeams?.nodes;
+            if (projectTeamNodes) {
+                for (const t of projectTeamNodes) {
+                    const id = t.id;
+                    if (!seen.has(id)) {
+                        seen.add(id);
+                        nodes.push(t);
+                    }
+                }
+            }
+        }
+        return nodes;
+    }
+    resolveMilestoneId(milestoneId, resolveResult, projectMilestoneNodes, issueProjectMilestoneNodes) {
+        if (!milestoneId || isUuid(milestoneId)) {
+            return milestoneId;
+        }
+        let resolved = milestoneId;
+        if (projectMilestoneNodes) {
+            const projectMilestone = projectMilestoneNodes.find((m) => m.name === milestoneId);
+            if (projectMilestone) {
+                resolved = projectMilestone.id;
+            }
+        }
+        if (!isUuid(resolved) && issueProjectMilestoneNodes) {
+            const issueMilestone = issueProjectMilestoneNodes.find((m) => m.name === milestoneId);
+            if (issueMilestone) {
+                resolved = issueMilestone.id;
+            }
+        }
+        const milestones = resolveResult.milestones;
+        const milestoneNodes = milestones?.nodes;
+        if (!isUuid(resolved) && milestoneNodes?.length) {
+            resolved = milestoneNodes[0].id;
+        }
+        if (!isUuid(resolved)) {
+            throw notFoundError("Milestone", milestoneId);
+        }
+        return resolved;
+    }
+    resolveMilestoneIdForCreate(milestoneId, resolveResult, finalProjectId) {
+        if (!milestoneId || isUuid(milestoneId)) {
+            return milestoneId;
+        }
+        let resolved;
+        const createProjects = resolveResult.projects;
+        const createProjectNodes = createProjects?.nodes;
+        const createProjectMilestones = createProjectNodes?.[0]
+            ?.projectMilestones;
+        const createProjectMilestoneNodes = createProjectMilestones?.nodes;
+        if (createProjectMilestoneNodes) {
+            const projectMilestone = createProjectMilestoneNodes.find((m) => m.name === milestoneId);
+            if (projectMilestone) {
+                resolved = projectMilestone.id;
+            }
+        }
+        const createMilestones = resolveResult.milestones;
+        const createMilestoneNodes = createMilestones?.nodes;
+        if (!resolved && createMilestoneNodes?.length) {
+            resolved = createMilestoneNodes[0].id;
+        }
+        if (!resolved) {
+            if (finalProjectId) {
+                throw notFoundError("Milestone", milestoneId, "in project");
+            }
+            throw notFoundError("Milestone", milestoneId, undefined, "Consider specifying --project.");
+        }
+        return resolved;
+    }
+    async fetchIssueTeamId(issueId) {
+        const result = await this.graphQLService.rawRequest(GET_ISSUE_TEAM_QUERY, {
+            issueId,
+        });
+        const fetchedIssue = result.issue;
+        const fetchedTeam = fetchedIssue?.team;
+        return fetchedTeam?.id;
+    }
+    buildCreateInput(args, resolved) {
+        const input = { title: args.title };
+        if (resolved.teamId) {
+            input.teamId = resolved.teamId;
+        }
+        if (args.description) {
+            input.description = args.description;
+        }
+        if (args.assigneeId) {
+            input.assigneeId = args.assigneeId;
+        }
+        if (args.priority !== undefined) {
+            input.priority = args.priority;
+        }
+        if (resolved.projectId) {
+            input.projectId = resolved.projectId;
+        }
+        if (resolved.statusId) {
+            input.stateId = resolved.statusId;
+        }
+        if (resolved.labelIds &&
+            Array.isArray(resolved.labelIds) &&
+            resolved.labelIds.length > 0) {
+            input.labelIds = resolved.labelIds;
+        }
+        if (args.estimate !== undefined) {
+            input.estimate = args.estimate;
+        }
+        if (resolved.parentId) {
+            input.parentId = resolved.parentId;
+        }
+        if (resolved.milestoneId) {
+            input.projectMilestoneId = resolved.milestoneId;
+        }
+        if (resolved.cycleId) {
+            input.cycleId = resolved.cycleId;
+        }
+        if (args.subscriberIds &&
+            Array.isArray(args.subscriberIds) &&
+            args.subscriberIds.length > 0) {
+            input.subscriberIds = args.subscriberIds;
+        }
+        if (args.dueDate !== undefined) {
+            input.dueDate = args.dueDate;
+        }
+        return input;
+    }
+    buildUpdateInput(args, resolved) {
+        const input = {};
+        if (args.title !== undefined) {
+            input.title = args.title;
+        }
+        if (args.description !== undefined) {
+            input.description = args.description;
+        }
+        if (resolved.statusId !== undefined) {
+            input.stateId = resolved.statusId;
+        }
+        if (args.priority !== undefined) {
+            input.priority = args.priority;
+        }
+        if (args.assigneeId !== undefined) {
+            input.assigneeId = args.assigneeId;
+        }
+        if (resolved.projectId !== undefined) {
+            input.projectId = resolved.projectId;
+        }
+        if (resolved.cycleId !== undefined) {
+            input.cycleId = resolved.cycleId;
+        }
+        if (args.estimate !== undefined) {
+            input.estimate = args.estimate;
+        }
+        if (args.parentId !== undefined) {
+            input.parentId = args.parentId;
+        }
+        if (resolved.milestoneId !== undefined) {
+            input.projectMilestoneId = resolved.milestoneId;
+        }
+        if (resolved.labelIds !== undefined) {
+            input.labelIds = resolved.labelIds;
+        }
+        if (args.dueDate !== undefined) {
+            input.dueDate = args.dueDate;
+        }
+        return input;
+    }
+    buildResolveVariablesForTeam(teamId) {
+        const isTeamKey = teamId.length <= 5 && TEAM_KEY_REGEX.test(teamId);
+        if (isTeamKey) {
+            return { teamKey: teamId, teamName: null };
+        }
+        return { teamKey: null, teamName: teamId };
+    }
+    applySearchFilters(results, filters) {
+        let filtered = results;
+        if (filters.teamId) {
+            filtered = filtered.filter((issue) => issue.team?.id === filters.teamId);
+        }
+        if (filters.assigneeId) {
+            filtered = filtered.filter((issue) => issue.assignee?.id === filters.assigneeId);
+        }
+        if (filters.projectId) {
+            filtered = filtered.filter((issue) => issue.project?.id === filters.projectId);
+        }
+        if (filters.status && filters.status.length > 0) {
+            filtered = filtered.filter((issue) => filters.status.includes(issue.state?.name ?? ""));
+        }
+        if (filters.labelNames && filters.labelNames.length > 0) {
+            const lowerNames = filters.labelNames.map((n) => n.toLowerCase());
+            filtered = filtered.filter((issue) => {
+                const issueLabels = issue.labels.map((l) => l.name.toLowerCase());
+                return lowerNames.every((name) => issueLabels.includes(name));
+            });
+        }
+        if (filters.priority && filters.priority.length > 0) {
+            filtered = filtered.filter((issue) => filters.priority.includes(issue.priority));
+        }
+        return filtered;
+    }
+    buildSearchFilter(filters) {
+        const filter = {};
+        if (filters.teamId) {
+            filter.team = { id: { eq: filters.teamId } };
+        }
+        if (filters.assigneeId) {
+            filter.assignee = { id: { eq: filters.assigneeId } };
+        }
+        if (filters.noProject) {
+            filter.project = { null: true };
+        }
+        else if (filters.projectId) {
+            filter.project = { id: { eq: filters.projectId } };
+        }
+        if (filters.status && filters.status.length > 0) {
+            filter.state = { name: { in: filters.status } };
+        }
+        if (filters.labelNames && filters.labelNames.length > 0) {
+            if (filters.labelNames.length === 1) {
+                filter.labels = {
+                    some: { name: { eqIgnoreCase: filters.labelNames[0] } },
+                };
+            }
+            else {
+                filter.labels = {
+                    and: filters.labelNames.map((name) => ({
+                        some: { name: { eqIgnoreCase: name } },
+                    })),
+                };
+            }
+        }
+        if (filters.priority && filters.priority.length > 0) {
+            filter.priority = { in: filters.priority };
+        }
+        return filter;
+    }
+    resolveAssigneeId(assigneeId, resolveResult) {
+        if (!assigneeId || isUuid(assigneeId) || !assigneeId.includes("@")) {
+            return assigneeId;
+        }
+        const users = resolveResult.users;
+        const userNodes = users?.nodes;
+        if (!userNodes?.length) {
+            throw notFoundError("User", assigneeId);
+        }
+        return userNodes[0].id;
+    }
+    async resolveUpdateContext(args) {
+        let resolvedIssueId = args.id;
+        let issueTeamId;
+        let currentIssueLabels = [];
+        const resolveVariables = {};
+        if (!isUuid(args.id)) {
+            const { teamKey, issueNumber } = parseIssueIdentifier(args.id);
+            resolveVariables.teamKey = teamKey;
+            resolveVariables.issueNumber = issueNumber;
+        }
+        if (args.labelIds && Array.isArray(args.labelIds)) {
+            const nonUuidLabels = args.labelIds.filter((id) => !isUuid(id));
+            if (nonUuidLabels.length > 0) {
+                resolveVariables.__labelNames = nonUuidLabels;
+            }
+        }
+        if (args.projectId && !isUuid(args.projectId)) {
+            resolveVariables.projectName = args.projectId;
+        }
+        if (args.milestoneId &&
+            typeof args.milestoneId === "string" &&
+            !isUuid(args.milestoneId)) {
+            resolveVariables.milestoneName = args.milestoneId;
+        }
+        const { __labelNames, ...updateQueryVars } = resolveVariables;
+        const requests = [
+            this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_UPDATE_QUERY, updateQueryVars),
+        ];
+        if (__labelNames) {
+            const labelQuery = buildResolveLabelsByNameQuery(__labelNames);
+            requests.push(this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables));
+        }
+        const results = await Promise.all(requests);
+        const resolveResult = results[0];
+        if (results[1]) {
+            resolveResult.labels = results[1].labels;
+        }
+        if (!isUuid(args.id)) {
+            const resolvedIssues = resolveResult.issues;
+            const resolvedIssueNodes = resolvedIssues.nodes;
+            if (!resolvedIssueNodes.length) {
+                throw notFoundError("Issue", args.id);
+            }
+            resolvedIssueId = resolvedIssueNodes[0].id;
+            const team = resolvedIssueNodes[0].team;
+            issueTeamId = team?.id;
+            const issueLabels = resolvedIssueNodes[0].labels;
+            currentIssueLabels = issueLabels.nodes.map((l) => l.id);
+        }
+        return { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult };
+    }
+    async resolveCycleIdForUpdate(args, resolveResult, resolvedIssueId) {
+        if (args.cycleId === undefined || args.cycleId === null) {
+            return args.cycleId;
+        }
+        if (typeof args.cycleId !== "string" || isUuid(args.cycleId)) {
+            return args.cycleId;
+        }
+        let teamIdForCycle = resolveResult.issues?.nodes?.[0]?.team?.id;
+        if (!teamIdForCycle && resolvedIssueId && isUuid(resolvedIssueId)) {
+            teamIdForCycle = await this.fetchIssueTeamId(resolvedIssueId);
+        }
+        return this.linearService.resolveCycleId(args.cycleId, teamIdForCycle);
+    }
+    async resolveStatusIdForUpdate(args, resolvedIssueId) {
+        if (!args.statusId || isUuid(args.statusId)) {
+            return args.statusId;
+        }
+        let teamId;
+        if (resolvedIssueId && isUuid(resolvedIssueId)) {
+            teamId = await this.fetchIssueTeamId(resolvedIssueId);
+        }
+        return this.linearService.resolveStatusId(args.statusId, teamId);
+    }
+    buildCreateResolveVariables(args) {
+        const resolveVariables = {};
+        if (args.teamId && !isUuid(args.teamId)) {
+            Object.assign(resolveVariables, this.buildResolveVariablesForTeam(args.teamId));
+        }
+        if (args.projectId && !isUuid(args.projectId)) {
+            resolveVariables.projectName = args.projectId;
+        }
+        if (args.milestoneId && !isUuid(args.milestoneId)) {
+            resolveVariables.milestoneName = args.milestoneId;
+        }
+        if (args.labelIds && Array.isArray(args.labelIds)) {
+            const nonUuidLabels = args.labelIds.filter((id) => !isUuid(id));
+            if (nonUuidLabels.length > 0) {
+                resolveVariables.__labelNames = nonUuidLabels;
+            }
+        }
+        if (args.parentId && !isUuid(args.parentId)) {
+            const parentParsed = tryParseIssueIdentifier(args.parentId);
+            if (parentParsed) {
+                resolveVariables.parentTeamKey = parentParsed.teamKey;
+                resolveVariables.parentIssueNumber = parentParsed.issueNumber;
+            }
+        }
+        return resolveVariables;
+    }
+    resolveParentId(parentId, resolveResult) {
+        if (!parentId || isUuid(parentId)) {
+            return parentId;
+        }
+        const parentIssues = resolveResult.parentIssues;
+        const parentNodes = parentIssues?.nodes;
+        if (!parentNodes?.length) {
+            throw notFoundError("Parent issue", parentId);
+        }
+        return parentNodes[0].id;
+    }
+    transformIssueData(issue) {
+        const labels = issue.labels;
+        return {
+            ...this.transformIssueCoreFields(issue),
+            ...this.transformIssueRelations(issue),
+            summary: issue.summary
+                ? extractSummaryText(issue.summary)
+                : undefined,
+            priority: issue.priority,
+            estimate: issue.estimate || undefined,
+            dueDate: issue.dueDate || undefined,
+            labels: labels.nodes.map((label) => ({
+                id: label.id,
+                name: label.name,
+            })),
+            ...this.transformIssueHierarchy(issue),
+            comments: this.transformIssueComments(issue),
+            createdAt: toISOStringOrNow(issue.createdAt),
+            updatedAt: toISOStringOrNow(issue.updatedAt),
+        };
+    }
+    transformIssueCoreFields(issue) {
+        return {
+            id: issue.id,
+            identifier: issue.identifier,
+            url: issue.url,
+            title: issue.title,
+            description: issue.description || undefined,
+            branchName: issue.branchName || undefined,
+            embeds: issue.description
+                ? extractEmbeds(issue.description)
+                : undefined,
+        };
+    }
+    transformIssueRelations(issue) {
+        const state = issue.state;
+        const assignee = issue.assignee;
+        const team = issue.team;
+        const project = issue.project;
+        const cycle = issue.cycle;
+        const milestone = issue.projectMilestone;
+        return {
+            state: state
+                ? { id: state.id, name: state.name }
+                : undefined,
+            assignee: assignee
+                ? {
+                    id: assignee.id,
+                    name: resolveUserDisplayName(assignee.id, assignee.name),
+                    url: assignee.url || undefined,
+                }
+                : undefined,
+            team: team
+                ? {
+                    id: team.id,
+                    key: team.key,
+                    name: team.name,
+                }
+                : undefined,
+            project: project
+                ? { id: project.id, name: project.name }
+                : undefined,
+            cycle: cycle
+                ? {
+                    id: cycle.id,
+                    name: cycle.name,
+                    number: cycle.number,
+                }
+                : undefined,
+            projectMilestone: milestone
+                ? {
+                    id: milestone.id,
+                    name: milestone.name,
+                    targetDate: milestone.targetDate || undefined,
+                }
+                : undefined,
+        };
+    }
+    transformIssueHierarchy(issue) {
+        const parent = issue.parent;
+        const children = issue.children;
+        return {
+            parentIssue: parent
+                ? {
+                    id: parent.id,
+                    identifier: parent.identifier,
+                    title: parent.title,
+                }
+                : undefined,
+            subIssues: children?.nodes?.map((child) => ({
+                id: child.id,
+                identifier: child.identifier,
+                title: child.title,
+            })) || undefined,
+        };
+    }
+    transformIssueComments(issue) {
+        const comments = issue.comments;
+        return (comments?.nodes?.map((comment) => {
+            const commentUser = comment.user;
+            return {
+                id: comment.id,
+                body: comment.body,
+                embeds: extractEmbeds(comment.body),
+                user: commentUser
+                    ? {
+                        id: commentUser.id,
+                        name: resolveUserDisplayName(commentUser.id, commentUser.name),
+                        url: commentUser.url || undefined,
+                    }
+                    : undefined,
+                createdAt: toISOStringOrNow(comment.createdAt),
+                updatedAt: toISOStringOrNow(comment.updatedAt),
+            };
+        }) || []);
+    }
+}