@enrichlayer/el-linear 1.10.0 → 1.15.0

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

@@ -1,5 +1,5 @@
 import { resolveUserDisplayName } from "../config/resolver.js";
-import { ARCHIVE_ISSUE_MUTATION, BATCH_RESOLVE_FOR_CREATE_QUERY, BATCH_RESOLVE_FOR_SEARCH_QUERY, BATCH_RESOLVE_FOR_UPDATE_QUERY, buildResolveLabelsByNameQuery, CREATE_ISSUE_MUTATION, DELETE_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 { ARCHIVE_ISSUE_MUTATION, BATCH_RESOLVE_FOR_CREATE_QUERY, BATCH_RESOLVE_FOR_SEARCH_QUERY, BATCH_RESOLVE_FOR_UPDATE_QUERY, buildResolveLabelsByNameQuery, CREATE_ISSUE_MUTATION, DELETE_ISSUE_MUTATION, FILTERED_SEARCH_ISSUES_QUERY, GET_ISSUE_BY_ID_QUERY, GET_ISSUE_BY_IDENTIFIER_QUERY, GET_ISSUE_START_CONTEXT_QUERY, GET_ISSUE_TEAM_QUERY, GET_ISSUES_QUERY, SEARCH_ISSUES_QUERY, TEAM_STARTED_STATUSES_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";
@@ -61,34 +61,81 @@ export class GraphQLIssuesService {
         }
         return this.transformIssueData(issueData);
     }
+    async startIssue(issueId) {
+        const resolvedIssueId = await this.linearService.resolveIssueId(issueId);
+        const context = await this.graphQLService.rawRequest(GET_ISSUE_START_CONTEXT_QUERY, { id: resolvedIssueId });
+        const issue = context.issue;
+        if (!issue) {
+            throw notFoundError("Issue", issueId);
+        }
+        const previousState = issue.state
+            ? {
+                id: issue.state.id,
+                name: issue.state.name,
+                type: issue.state.type,
+            }
+            : undefined;
+        if (previousState &&
+            ["started", "completed", "canceled"].includes(previousState.type)) {
+            return {
+                issue: await this.getIssueById(resolvedIssueId),
+                previousState,
+                started: false,
+            };
+        }
+        if (!issue.team?.id) {
+            throw new Error(`Issue ${issue.identifier} has no team; cannot start it.`);
+        }
+        const statuses = await this.graphQLService.rawRequest(TEAM_STARTED_STATUSES_QUERY, { teamId: issue.team.id });
+        const startedStatus = statuses.team?.states.nodes
+            .slice()
+            .sort((a, b) => a.position - b.position)[0];
+        if (!startedStatus) {
+            throw new Error(`Team ${issue.team.key} has no workflow status of type "started".`);
+        }
+        const updated = await this.updateIssue({ id: resolvedIssueId, statusId: startedStatus.id }, "adding");
+        return {
+            issue: updated,
+            previousState,
+            started: true,
+            targetState: { id: startedStatus.id, name: startedStatus.name },
+        };
+    }
     async updateIssue(args, labelMode = "overwriting") {
-        const { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult } = await this.resolveUpdateContext(args);
+        // Normalize URL/slug-id --project inputs to UUIDs before the batch
+        // resolver runs; see comment on `withNormalizedProjectId`.
+        const normalizedArgs = await this.withNormalizedProjectId(args);
+        const { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult } = await this.resolveUpdateContext(normalizedArgs);
         let teamIdForLabels = issueTeamId;
-        if (!teamIdForLabels && args.labelIds && resolvedIssueId) {
+        if (!teamIdForLabels && normalizedArgs.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)
+        const finalLabelIds = await this.resolveLabelsWithMode(normalizedArgs.labelIds, resolveResult, labelMode, currentIssueLabels, teamIdForLabels, normalizedArgs.teamId);
+        const finalProjectId = normalizedArgs.projectId
+            ? this.resolveProjectId(normalizedArgs.projectId, resolveResult)
             : undefined;
-        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);
+        const { projectMilestoneNodes, issueProjectMilestoneNodes } = this.extractMilestoneNodes(normalizedArgs, resolveResult);
+        const finalMilestoneId = this.resolveMilestoneId(normalizedArgs.milestoneId, resolveResult, projectMilestoneNodes, issueProjectMilestoneNodes);
+        const finalCycleId = await this.resolveCycleIdForUpdate(normalizedArgs, resolveResult, resolvedIssueId);
+        const resolvedStatusId = await this.resolveStatusIdForUpdate(normalizedArgs, resolvedIssueId);
         // Resolve assignee in place — `buildUpdateInput` reads it
         // directly. Match the createIssue pattern.
-        let assigneeId = args.assigneeId;
+        let assigneeId = normalizedArgs.assigneeId;
         if (assigneeId && !isUuid(assigneeId)) {
             assigneeId = await this.linearService.resolveUserId(assigneeId);
         }
-        const updateInput = this.buildUpdateInput({ ...args, assigneeId }, {
+        let delegateId = normalizedArgs.delegateId;
+        if (delegateId && !isUuid(delegateId)) {
+            delegateId = await this.linearService.resolveUserId(delegateId);
+        }
+        const updateInput = this.buildUpdateInput({ ...normalizedArgs, assigneeId, delegateId }, {
             statusId: resolvedStatusId,
             projectId: finalProjectId,
             labelIds: finalLabelIds,
             milestoneId: finalMilestoneId,
             cycleId: finalCycleId,
         });
-        return this.executeUpdateMutation(resolvedIssueId, args.id, updateInput);
+        return this.executeUpdateMutation(resolvedIssueId, normalizedArgs.id, updateInput);
     }
     async archiveIssue(issueId) {
         const resolvedIssueId = await this.linearService.resolveIssueId(issueId);
@@ -154,7 +201,12 @@ export class GraphQLIssuesService {
         return this.transformIssueData(issueUpdate.issue);
     }
     async createIssue(args) {
-        const resolveVariables = this.buildCreateResolveVariables(args);
+        // Pre-resolve URL/slug-id forms of --project to a UUID so the batch
+        // resolver below (which uses a `name eqIgnoreCase` filter) can skip
+        // the project lookup entirely. Plain name inputs flow through unchanged
+        // and get resolved by the batch query in a single round-trip.
+        const normalizedArgs = await this.withNormalizedProjectId(args);
+        const resolveVariables = this.buildCreateResolveVariables(normalizedArgs);
         let resolveResult = {};
         if (Object.keys(resolveVariables).length > 0) {
             const { __labelNames, ...queryVars } = resolveVariables;
@@ -165,23 +217,56 @@ export class GraphQLIssuesService {
                     batchPromise,
                     this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables),
                 ]);
-                resolveResult = { ...batch, labels: labels.labels };
+                resolveResult = {
+                    ...this.foldCreateBatchResult(batch),
+                    labels: labels.labels,
+                };
             }
             else {
-                resolveResult = await batchPromise;
+                resolveResult = this.foldCreateBatchResult(await batchPromise);
             }
         }
-        const resolved = await this.resolveCreateFields(args, resolveResult);
+        const resolved = await this.resolveCreateFields(normalizedArgs, resolveResult);
         // Mutate-the-input feels gross but matches the existing pattern
         // — `resolved` doesn't carry assigneeId, so the buildCreateInput
         // step reads `args.assigneeId` directly. Resolve in place.
-        let assigneeId = args.assigneeId;
+        let assigneeId = normalizedArgs.assigneeId;
         if (assigneeId && !isUuid(assigneeId)) {
             assigneeId = await this.linearService.resolveUserId(assigneeId);
         }
-        const createInput = this.buildCreateInput({ ...args, assigneeId }, resolved);
+        let delegateId = normalizedArgs.delegateId;
+        if (delegateId && !isUuid(delegateId)) {
+            delegateId = await this.linearService.resolveUserId(delegateId);
+        }
+        const createInput = this.buildCreateInput({ ...normalizedArgs, assigneeId, delegateId }, resolved);
         return this.executeCreateMutation(createInput);
     }
+    /**
+     * Folds the `@include`-gated `projectsByName` / `projectsById` aliases
+     * from a create batch response into the single `projects` field the
+     * field-resolution helpers expect. At most one project alias is ever
+     * present, since a `--project` input is either a name or a UUID.
+     */
+    foldCreateBatchResult(batch) {
+        return {
+            teams: batch.teams,
+            projects: batch.projectsByName ?? batch.projectsById,
+            milestones: batch.milestones,
+            parentIssues: batch.parentIssues,
+        };
+    }
+    /**
+     * Folds the `@include`-gated `projectsByName` / `projectsById` aliases
+     * from an update batch response into the single `projects` field the
+     * field-resolution helpers expect. See `foldCreateBatchResult`.
+     */
+    foldUpdateBatchResult(batch) {
+        return {
+            projects: batch.projectsByName ?? batch.projectsById,
+            milestones: batch.milestones,
+            issues: batch.issues,
+        };
+    }
     async resolveCreateFields(args, resolveResult) {
         let teamId = args.teamId
             ? await this.resolveTeamId(args.teamId, resolveResult)
@@ -239,14 +324,23 @@ export class GraphQLIssuesService {
         if (args.teamId && !isUuid(args.teamId)) {
             Object.assign(resolveVariables, this.buildResolveVariablesForTeam(args.teamId));
         }
-        if (args.projectId && !isUuid(args.projectId)) {
-            resolveVariables.projectName = args.projectId;
+        // Only the `id` arm carries a name/UUID for resolution; `none` and
+        // `undefined` skip the resolve.
+        const projectIdArg = args.project?.kind === "id" ? args.project.id : undefined;
+        if (projectIdArg && !isUuid(projectIdArg)) {
+            resolveVariables.projectName = projectIdArg;
+            resolveVariables.hasProjectName = true;
         }
         if (args.assigneeId &&
             !isUuid(args.assigneeId) &&
             args.assigneeId.includes("@")) {
             resolveVariables.assigneeEmail = args.assigneeId;
         }
+        if (args.delegateId &&
+            !isUuid(args.delegateId) &&
+            args.delegateId.includes("@")) {
+            resolveVariables.delegateEmail = args.delegateId;
+        }
         let resolveResult = {};
         if (Object.keys(resolveVariables).length > 0) {
             resolveResult =
@@ -255,10 +349,24 @@ export class GraphQLIssuesService {
         const finalTeamId = args.teamId
             ? await this.resolveTeamId(args.teamId, resolveResult)
             : undefined;
-        const finalProjectId = args.projectId
-            ? this.resolveProjectId(args.projectId, resolveResult)
+        const finalProjectId = projectIdArg
+            ? this.resolveProjectId(projectIdArg, resolveResult)
             : undefined;
         const finalAssigneeId = this.resolveAssigneeId(args.assigneeId, resolveResult);
+        const finalDelegateId = await this.resolveDelegateId(args.delegateId, resolveResult);
+        // Map the public discriminant back to the internal filter shape:
+        // `{ kind: "id", id }` → `{ kind: "id", id: <resolvedUuid> }`
+        // `{ kind: "none" }`  → pass through
+        // undefined            → undefined (filter off)
+        // Reused by both the full-text and structured search paths so
+        // `--no-project` (`{ kind: "none" }`) participates in both — pre-fix,
+        // the full-text branch silently dropped `noProject` because only
+        // the resolved `projectId` was forwarded.
+        const projectFilter = args.project?.kind === "id" && finalProjectId
+            ? { kind: "id", id: finalProjectId }
+            : args.project?.kind === "none"
+                ? { kind: "none" }
+                : undefined;
         const limit = args.limit ?? 10;
         if (args.query) {
             const searchResult = await this.graphQLService.rawRequest(SEARCH_ISSUES_QUERY, {
@@ -273,7 +381,8 @@ export class GraphQLIssuesService {
             return this.applySearchFilters(results, {
                 teamId: finalTeamId,
                 assigneeId: finalAssigneeId,
-                projectId: finalProjectId,
+                delegateId: finalDelegateId,
+                project: projectFilter,
                 status: args.status,
                 labelNames: args.labelNames,
                 priority: args.priority,
@@ -282,8 +391,8 @@ export class GraphQLIssuesService {
         const filter = this.buildSearchFilter({
             teamId: finalTeamId,
             assigneeId: finalAssigneeId,
-            projectId: finalProjectId,
-            noProject: args.noProject,
+            delegateId: finalDelegateId,
+            project: projectFilter,
             status: args.status,
             labelNames: args.labelNames,
             priority: args.priority,
@@ -316,6 +425,18 @@ export class GraphQLIssuesService {
     }
     resolveProjectId(projectId, resolveResult) {
         if (isUuid(projectId)) {
+            // The create/update batch queries fetch a `projectsById` block for a
+            // UUID `--project` (folded into `resolveResult.projects`). An empty
+            // `nodes` array means the block ran but matched nothing — i.e. the
+            // UUID doesn't exist. Fail clearly here instead of passing a dead
+            // UUID to the mutation, which would surface a vague server error.
+            // When no block was fetched (`projects` undefined — e.g. the search
+            // path has no `projectsById` arm) there's nothing to validate, so
+            // the UUID passes through unchanged.
+            const fetched = resolveResult.projects?.nodes;
+            if (fetched && fetched.length === 0) {
+                throw notFoundError("Project", projectId);
+            }
             return projectId;
         }
         const projectNodes = resolveResult.projects?.nodes;
@@ -542,6 +663,9 @@ export class GraphQLIssuesService {
         if (args.assigneeId) {
             input.assigneeId = args.assigneeId;
         }
+        if (args.delegateId) {
+            input.delegateId = args.delegateId;
+        }
         if (args.priority !== undefined) {
             input.priority = args.priority;
         }
@@ -597,6 +721,9 @@ export class GraphQLIssuesService {
         if (args.assigneeId !== undefined) {
             input.assigneeId = args.assigneeId;
         }
+        if (args.delegateId !== undefined) {
+            input.delegateId = args.delegateId;
+        }
         if (resolved.projectId !== undefined) {
             input.projectId = resolved.projectId;
         }
@@ -635,8 +762,22 @@ export class GraphQLIssuesService {
         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.delegateId) {
+            filtered = filtered.filter((issue) => issue.delegate?.id === filters.delegateId);
+        }
+        if (filters.project) {
+            switch (filters.project.kind) {
+                case "id": {
+                    const id = filters.project.id;
+                    filtered = filtered.filter((issue) => issue.project?.id === id);
+                    break;
+                }
+                case "none":
+                    filtered = filtered.filter((issue) => !issue.project);
+                    break;
+                default:
+                    return filters.project;
+            }
         }
         if (filters.status && filters.status.length > 0) {
             filtered = filtered.filter((issue) => filters.status.includes(issue.state?.name ?? ""));
@@ -661,11 +802,20 @@ export class GraphQLIssuesService {
         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.delegateId) {
+            filter.delegate = { id: { eq: filters.delegateId } };
+        }
+        if (filters.project) {
+            switch (filters.project.kind) {
+                case "id":
+                    filter.project = { id: { eq: filters.project.id } };
+                    break;
+                case "none":
+                    filter.project = { null: true };
+                    break;
+                default:
+                    return filters.project;
+            }
         }
         if (filters.status && filters.status.length > 0) {
             filter.state = { name: { in: filters.status } };
@@ -699,6 +849,19 @@ export class GraphQLIssuesService {
         }
         return userNodes[0].id;
     }
+    async resolveDelegateId(delegateId, resolveResult) {
+        if (!delegateId || isUuid(delegateId)) {
+            return delegateId;
+        }
+        if (!delegateId.includes("@")) {
+            return this.linearService.resolveUserId(delegateId);
+        }
+        const userNodes = resolveResult.delegates?.nodes;
+        if (!userNodes?.length) {
+            throw notFoundError("Delegate", delegateId);
+        }
+        return userNodes[0].id;
+    }
     async resolveUpdateContext(args) {
         let resolvedIssueId = args.id;
         let issueTeamId;
@@ -715,11 +878,23 @@ export class GraphQLIssuesService {
                 resolveVariables.__labelNames = nonUuidLabels;
             }
         }
-        if (args.projectId && !isUuid(args.projectId)) {
-            resolveVariables.projectName = args.projectId;
+        if (args.projectId) {
+            // A UUID resolves by `id` so the project's milestones are still
+            // fetched for `--project-milestone` name resolution; a name
+            // resolves by `name`. The `has*` flags gate the `@include`d
+            // blocks so an unset input never triggers a null no-op filter.
+            if (isUuid(args.projectId)) {
+                resolveVariables.projectId = args.projectId;
+                resolveVariables.hasProjectId = true;
+            }
+            else {
+                resolveVariables.projectName = args.projectId;
+                resolveVariables.hasProjectName = true;
+            }
         }
         if (args.milestoneId && !isUuid(args.milestoneId)) {
             resolveVariables.milestoneName = args.milestoneId;
+            resolveVariables.hasMilestoneName = true;
         }
         const { __labelNames, ...updateQueryVars } = resolveVariables;
         const batchPromise = this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_UPDATE_QUERY, updateQueryVars);
@@ -730,10 +905,13 @@ export class GraphQLIssuesService {
                 batchPromise,
                 this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables),
             ]);
-            resolveResult = { ...batch, labels: labels.labels };
+            resolveResult = {
+                ...this.foldUpdateBatchResult(batch),
+                labels: labels.labels,
+            };
         }
         else {
-            resolveResult = await batchPromise;
+            resolveResult = this.foldUpdateBatchResult(await batchPromise);
         }
         if (!isUuid(args.id)) {
             const resolvedIssueNodes = resolveResult.issues?.nodes ?? [];
@@ -769,16 +947,44 @@ export class GraphQLIssuesService {
         }
         return this.linearService.resolveStatusId(args.statusId, teamId);
     }
+    /**
+     * Pre-resolve URL/slug-id project inputs to UUIDs before the batch
+     * resolver runs. Plain names and UUIDs pass through unchanged; only
+     * URL/slug-id forms incur a separate slug→UUID round-trip (the batch
+     * query's `name eqIgnoreCase` filter can't match a URL string).
+     */
+    async withNormalizedProjectId(args) {
+        if (!args.projectId) {
+            return args;
+        }
+        const normalized = await this.linearService.normalizeProjectInput(args.projectId);
+        if (normalized === args.projectId) {
+            return args;
+        }
+        return { ...args, projectId: normalized };
+    }
     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.projectId) {
+            // A UUID is resolved by `id` so the project's team associations
+            // are still fetched for team-project validation; a name is
+            // resolved by `name`. The `has*` flags gate the `@include`d
+            // blocks so an unset input never triggers a null no-op filter.
+            if (isUuid(args.projectId)) {
+                resolveVariables.projectId = args.projectId;
+                resolveVariables.hasProjectId = true;
+            }
+            else {
+                resolveVariables.projectName = args.projectId;
+                resolveVariables.hasProjectName = true;
+            }
         }
         if (args.milestoneId && !isUuid(args.milestoneId)) {
             resolveVariables.milestoneName = args.milestoneId;
+            resolveVariables.hasMilestoneName = true;
         }
         if (args.labelIds && args.labelIds.length > 0) {
             const nonUuidLabels = args.labelIds.filter((id) => !isUuid(id));
@@ -852,6 +1058,13 @@ export class GraphQLIssuesService {
                     url: issue.assignee.url ?? undefined,
                 }
                 : undefined,
+            delegate: issue.delegate
+                ? {
+                    id: issue.delegate.id,
+                    name: resolveUserDisplayName(issue.delegate.id, issue.delegate.name),
+                    url: issue.delegate.url ?? undefined,
+                }
+                : undefined,
             team: issue.team
                 ? {
                     id: issue.team.id,

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

@@ -1,20 +1,18 @@
+import type { LinearCredential } from "../auth/linear-credential.js";
 import type { GraphQLResponseData, GraphQLVariables } from "../types/linear.js";
 import type { AuthOptions } from "./auth.js";
 /**
- * Constructor arg shapes for `GraphQLService`. Three variants:
- *   - `string` → personal API token (legacy; sent without `Bearer` prefix).
- *   - `{apiKey: string}` → personal API token (explicit).
- *   - `{oauthToken: string}` → OAuth access token (sent as
- *     `Authorization: Bearer <token>` via the SDK's accessToken option).
+ * Constructor arg for `GraphQLService`. Re-exported alias of the shared
+ * `LinearCredential` union (`{ apiKey } | { oauthToken }`). Kept as a
+ * named local export so call sites that already import
+ * `GraphQLServiceAuth` keep compiling — the alias collapses through to
+ * the shared shape.
  *
- * The string variant exists because hundreds of call sites and tests pass
- * a plain string. We continue to support it indefinitely.
+ * The bare-string legacy arm was dropped in DEV-4068 T7. Tests now
+ * construct with `{ apiKey: "test-token" }` (mechanical rewrite, no
+ * semantic change — same `Authorization: <token>` header is emitted).
  */
-export type GraphQLServiceAuth = string | {
-    apiKey: string;
-} | {
-    oauthToken: string;
-};
+export type GraphQLServiceAuth = LinearCredential;
 export declare class GraphQLService {
     private readonly graphQLClient;
     constructor(auth: GraphQLServiceAuth);

package/dist/utils/graphql-service.js

@@ -2,9 +2,6 @@ import { LinearClient } from "@linear/sdk";
 import { getActiveAuth } from "../auth/token-resolver.js";
 function buildLinearClient(auth) {
     const baseHeaders = { "public-file-urls-expire-in": "3600" };
-    if (typeof auth === "string") {
-        return new LinearClient({ apiKey: auth, headers: baseHeaders });
-    }
     if ("oauthToken" in auth) {
         // Linear's SDK natively supports OAuth via the `accessToken` option,
         // which causes the underlying graphql-request client to send

package/dist/utils/issue-reference-extractor.d.ts

@@ -5,6 +5,13 @@ export interface IssueReference {
     reverse: boolean;
     type: IssueRelationType;
 }
+/**
+ * Specificity ranking — used when the same identifier appears more than once
+ * in the text with different qualifiers. The strongest non-default inference
+ * wins. Exported because `auto-link-references` does the same merge over its
+ * own description+comments fan-in (DEV-4070 deduplication).
+ */
+export declare function specificity(ref: IssueReference): number;
 /**
  * Extract issue identifiers from text along with the inferred relation type.
  *

package/dist/utils/issue-reference-extractor.js

@@ -45,10 +45,12 @@ function inferRelation(textBefore) {
     return { type: "related", reverse: false };
 }
 /**
- * Specificity ranking — used when the same identifier appears more than once in the text
- * with different qualifiers. The strongest non-default inference wins.
+ * Specificity ranking — used when the same identifier appears more than once
+ * in the text with different qualifiers. The strongest non-default inference
+ * wins. Exported because `auto-link-references` does the same merge over its
+ * own description+comments fan-in (DEV-4070 deduplication).
  */
-function specificity(ref) {
+export function specificity(ref) {
     if (ref.type === "duplicate") {
         return 3;
     }

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

@@ -0,0 +1,28 @@
+/**
+ * Service-trio bootstrap helper.
+ *
+ * The 3-line incantation
+ *
+ * ```ts
+ * const graphQLService = await createGraphQLService(rootOpts);
+ * const linearService = await createLinearService(rootOpts);
+ * const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+ * ```
+ *
+ * repeats verbatim across ~13 issue/batch command handlers. This helper
+ * collapses it to a single line; callers destructure only what they use.
+ *
+ * Sites that need just `graphQLService` + `linearService` (no `issuesService`)
+ * can keep their direct calls — there's no benefit to routing through a
+ * helper that constructs an unused third service.
+ */
+import type { AuthOptions } from "./auth.js";
+import { GraphQLIssuesService } from "./graphql-issues-service.js";
+import { type GraphQLService } from "./graphql-service.js";
+import { type LinearService } from "./linear-service.js";
+export interface IssuesServiceTrio {
+    graphQLService: GraphQLService;
+    linearService: LinearService;
+    issuesService: GraphQLIssuesService;
+}
+export declare function createIssuesService(options: AuthOptions): Promise<IssuesServiceTrio>;

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

@@ -0,0 +1,27 @@
+/**
+ * Service-trio bootstrap helper.
+ *
+ * The 3-line incantation
+ *
+ * ```ts
+ * const graphQLService = await createGraphQLService(rootOpts);
+ * const linearService = await createLinearService(rootOpts);
+ * const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+ * ```
+ *
+ * repeats verbatim across ~13 issue/batch command handlers. This helper
+ * collapses it to a single line; callers destructure only what they use.
+ *
+ * Sites that need just `graphQLService` + `linearService` (no `issuesService`)
+ * can keep their direct calls — there's no benefit to routing through a
+ * helper that constructs an unused third service.
+ */
+import { GraphQLIssuesService } from "./graphql-issues-service.js";
+import { createGraphQLService, } from "./graphql-service.js";
+import { createLinearService } from "./linear-service.js";
+export async function createIssuesService(options) {
+    const graphQLService = await createGraphQLService(options);
+    const linearService = await createLinearService(options);
+    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    return { graphQLService, linearService, issuesService };
+}

package/dist/utils/linear-service.d.ts

@@ -1,20 +1,13 @@
+import type { LinearCredential } from "../auth/linear-credential.js";
 import type { LinearComment, LinearCycleDetail, LinearCycleSummary, LinearLabel, LinearProject, LinearTeam, LinearUser } from "../types/linear.js";
 import type { AuthOptions } from "./auth.js";
 /**
- * Constructor arg shapes for `LinearService`. Three variants:
- *   - `string` → personal API token (legacy; sent without `Bearer` prefix).
- *   - `{apiKey: string}` → personal API token (explicit).
- *   - `{oauthToken: string}` → OAuth access token (sent as
- *     `Authorization: Bearer <token>` via the SDK's accessToken option).
- *
- * The string variant exists because hundreds of call sites and tests pass
- * a plain string. We continue to support it indefinitely.
+ * Constructor arg for `LinearService`. Re-exported alias of the shared
+ * `LinearCredential` union (`{ apiKey } | { oauthToken }`). See
+ * `src/auth/linear-credential.ts` for the contract. The bare-string
+ * legacy arm was dropped in DEV-4068 T7.
  */
-export type LinearServiceAuth = string | {
-    apiKey: string;
-} | {
-    oauthToken: string;
-};
+export type LinearServiceAuth = LinearCredential;
 export declare class LinearService {
     private readonly client;
     constructor(auth: LinearServiceAuth);
@@ -26,6 +19,8 @@ export declare class LinearService {
         nameFilter?: string;
         states?: string[];
         excludeStates?: string[];
+        /** Resolved team UUID — applied as a server-side filter before pagination. */
+        teamId?: string;
     }): Promise<LinearProject[]>;
     resolveTeamId(teamKeyOrNameOrId: string): Promise<string>;
     resolveStatusId(statusName: string, teamId?: string): Promise<string>;
@@ -40,6 +35,18 @@ export declare class LinearService {
     getCycles(teamFilter?: string, activeOnly?: boolean, limit?: number): Promise<LinearCycleSummary[]>;
     getCycleById(cycleId: string, issuesLimit?: number): Promise<LinearCycleDetail>;
     resolveCycleId(cycleNameOrId: string, teamFilter?: string): Promise<string>;
-    resolveProjectId(projectNameOrId: string): Promise<string>;
+    resolveProjectId(projectInput: string): Promise<string>;
+    /**
+     * Normalize a user-supplied project input to a UUID when the input is
+     * a URL or slug-id form. Pass-through for UUIDs and plain names — the
+     * latter stays a name so downstream batch-resolve queries can fold the
+     * lookup into their single round-trip.
+     *
+     * Used by callers that route project resolution through a separate
+     * batch-resolve step (e.g. `GraphqlIssuesService.createIssue`) — they
+     * can pre-normalize URL/slug inputs to UUIDs so the batch query's
+     * `name eqIgnoreCase` filter doesn't have to learn the URL/slug shape.
+     */
+    normalizeProjectInput(projectInput: string): Promise<string>;
 }
 export declare function createLinearService(options: AuthOptions): Promise<LinearService>;