@enrichlayer/el-linear 1.9.0 → 1.15.0

package/dist/queries/search-types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Typed response shapes for `SEMANTIC_SEARCH_QUERY` and the inline
+ * templates listing in `commands/search.ts`. See `./issues-types.ts`
+ * for the rationale (ALL-937).
+ */
+import type { LinearPriority } from "../types/linear.js";
+interface SearchIssueRef {
+    id: string;
+    identifier: string;
+    title: string;
+    priority: LinearPriority | null;
+    state: {
+        id: string;
+        name: string;
+    } | null;
+    team: {
+        id: string;
+        key: string;
+        name: string;
+    } | null;
+    assignee: {
+        id: string;
+        name: string;
+        url: string | null;
+    } | null;
+    project: {
+        id: string;
+        name: string;
+    } | null;
+}
+interface SearchProjectRef {
+    id: string;
+    name: string;
+    state: string;
+}
+interface SearchInitiativeRef {
+    id: string;
+    name: string;
+    status: string | null;
+}
+interface SearchDocumentRef {
+    id: string;
+    title: string;
+    slugId: string | null;
+    project: {
+        id: string;
+        name: string;
+    } | null;
+}
+/**
+ * A single semanticSearch result. Discriminated union on `type` — given
+ * a row, only the field named by `type` is meaningful (the other three
+ * are absent / null on the wire). Consumers `switch (r.type)` and access
+ * the corresponding payload directly; the compiler statically rejects
+ * cross-arm access like `r.project` in a `case "issue"` branch.
+ *
+ * The payload itself is `| null` because Linear can return null when
+ * the underlying entity was deleted between indexing and query time —
+ * that's an orthogonal concern from the discriminant.
+ *
+ * The four `type` literals match Linear's `semanticSearch.results.type`
+ * enum verbatim — keep in lock-step with the GraphQL schema's enum.
+ */
+export type SemanticSearchResult = {
+    type: "issue";
+    issue: SearchIssueRef | null;
+} | {
+    type: "project";
+    project: SearchProjectRef | null;
+} | {
+    type: "initiative";
+    initiative: SearchInitiativeRef | null;
+} | {
+    type: "document";
+    document: SearchDocumentRef | null;
+};
+export interface SemanticSearchResponse {
+    semanticSearch: {
+        results: SemanticSearchResult[];
+    } | null;
+}
+/**
+ * Mirrors the inline `TEMPLATES_QUERY` in `commands/search.ts` —
+ * a smaller selection set than the full templates query, dropping
+ * fields the search command doesn't display.
+ */
+export interface SearchTemplateNode {
+    id: string;
+    name: string;
+    type: string;
+    description: string | null;
+    team: {
+        key: string;
+    } | null;
+    creator: {
+        name: string;
+    } | null;
+}
+export interface SearchTemplatesResponse {
+    templates: SearchTemplateNode[];
+}
+export {};

package/dist/queries/search-types.js

@@ -0,0 +1,6 @@
+/**
+ * Typed response shapes for `SEMANTIC_SEARCH_QUERY` and the inline
+ * templates listing in `commands/search.ts`. See `./issues-types.ts`
+ * for the rationale (ALL-937).
+ */
+export {};

package/dist/queries/templates-types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Typed response shapes for the queries in `./templates.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ *
+ * Note: `templates` is unusual — it returns the array directly rather
+ * than wrapped in `{ nodes: ... }`. The response type below mirrors
+ * what the API actually returns, not the connection convention.
+ */
+interface TemplateTeamRef {
+    id: string;
+    key: string;
+    name: string;
+}
+interface TemplateCreatorRef {
+    id: string;
+    name: string;
+}
+/**
+ * Mirrors the template selection set used by `TEMPLATES_LIST_QUERY` /
+ * `TEMPLATE_BY_ID_QUERY` / `TEMPLATE_CREATE_MUTATION` /
+ * `TEMPLATE_UPDATE_MUTATION`. (Some of those omit `creator` and
+ * `createdAt`; we model the union — consumers only read what their
+ * query selected.)
+ */
+export interface TemplateNode {
+    id: string;
+    name: string;
+    type: string;
+    description: string | null;
+    templateData: unknown;
+    createdAt: string;
+    updatedAt: string;
+    team: TemplateTeamRef | null;
+    creator: TemplateCreatorRef | null;
+}
+export interface TemplatesListResponse {
+    templates: TemplateNode[];
+}
+export interface GetTemplateResponse {
+    template: TemplateNode | null;
+}
+export interface CreateTemplateResponse {
+    templateCreate: {
+        success: boolean;
+        lastSyncId?: number;
+        template: TemplateNode | null;
+    };
+}
+export interface UpdateTemplateResponse {
+    templateUpdate: {
+        success: boolean;
+        lastSyncId?: number;
+        template: TemplateNode | null;
+    };
+}
+export interface DeleteTemplateResponse {
+    templateDelete: {
+        success: boolean;
+        lastSyncId?: number;
+    };
+}
+export {};

package/dist/queries/templates-types.js

@@ -0,0 +1,9 @@
+/**
+ * Typed response shapes for the queries in `./templates.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ *
+ * Note: `templates` is unusual — it returns the array directly rather
+ * than wrapped in `{ nodes: ... }`. The response type below mirrors
+ * what the API actually returns, not the connection convention.
+ */
+export {};

package/dist/types/linear.d.ts

@@ -3,6 +3,17 @@
  * These represent the public API surface — GraphQL responses are
  * transformed into these shapes at the service boundary.
  */
+/**
+ * Linear priority levels — `0` = no priority, `1` = urgent, `2` = high,
+ * `3` = medium (alias: normal), `4` = low. Sourced from Linear's
+ * `Issue.priority` enum; the GraphQL API returns a number in this range.
+ * Use this instead of `number` at every API boundary so an out-of-range
+ * value (`9`) fails to compile.
+ *
+ * The runtime parser is `validatePriority` in `src/utils/validators.ts`
+ * — it narrows arbitrary `string` input to this union.
+ */
+export type LinearPriority = 0 | 1 | 2 | 3 | 4;
 interface TeamRef {
     id: string;
     key: string;
@@ -87,6 +98,7 @@ export interface LinearIssue {
     comments?: LinearComment[];
     createdAt: string;
     cycle?: CycleRef;
+    delegate?: UserRef;
     description?: string;
     dueDate?: string;
     embeds?: import("../utils/embed-parser.js").Embed[];
@@ -95,7 +107,7 @@ export interface LinearIssue {
     identifier: string;
     labels: LabelRef[];
     parentIssue?: IssueRef;
-    priority: number;
+    priority: LinearPriority;
     project?: ProjectRef;
     projectMilestone?: MilestoneRef;
     state?: StateRef;
@@ -208,8 +220,14 @@ type GraphQLPrimitive = string | number | boolean | null | undefined;
 type GraphQLValue = GraphQLPrimitive | GraphQLResponseData | GraphQLResponseData[];
 /**
  * Recursive index type for raw GraphQL responses.
- * All nested property access requires narrowing via `as GraphQLResponseData`
- * or `as string` etc. — this prevents `any` from leaking into the type system.
+ *
+ * **Prefer per-query response types** (see `src/queries/*-types.ts`)
+ * over `GraphQLResponseData` for any new consumer. ALL-937 swept the
+ * old service/command consumers; this type is kept as the fallback
+ * for the few generic transports (e.g. `graphql-service.rawRequest`'s
+ * default generic). Don't reach for `as GraphQLResponseData` to skip
+ * a typed shape — the per-query types catch query/consumer drift at
+ * compile time. This type cannot.
  */
 export interface GraphQLResponseData {
     [key: string]: GraphQLValue;

package/dist/utils/auto-link-references.d.ts

@@ -1,20 +1,20 @@
 import type { GraphQLService } from "./graphql-service.js";
 import { type IssueRelationType } from "./issue-reference-extractor.js";
 import type { LinearService } from "./linear-service.js";
-export interface AutoLinkLinked {
+interface AutoLinkLinked {
     identifier: string;
     /** True when source/target were swapped on the create (e.g. "blocked by X" → X→source) */
     reverse: boolean;
     title: string;
     type: IssueRelationType;
 }
-export interface AutoLinkSkipped {
+interface AutoLinkSkipped {
     existingType: string;
     identifier: string;
     /** Type that would have been created had the reference been new */
     inferredType: IssueRelationType;
 }
-export interface AutoLinkFailed {
+interface AutoLinkFailed {
     identifier: string;
     reason: string;
 }

package/dist/utils/auto-link-references.js

@@ -1,14 +1,5 @@
 import { GET_ISSUE_RELATIONS_QUERY, ISSUE_RELATION_CREATE_MUTATION, } from "../queries/issues.js";
-import { extractIssueReferences, } from "./issue-reference-extractor.js";
-function specificity(ref) {
-    if (ref.type === "duplicate") {
-        return 3;
-    }
-    if (ref.type === "blocks") {
-        return 2;
-    }
-    return 1;
-}
+import { extractIssueReferences, specificity, } from "./issue-reference-extractor.js";
 /**
  * Merge candidates from multiple sources (description, comments) into one list,
  * keeping the strongest (most-specific) inference per identifier. The first source
@@ -26,37 +17,44 @@ function mergeCandidates(...sources) {
     }
     return [...byId.values()];
 }
-function mergeRelationNodes(nodes, peerKey, normalizeType, out) {
-    for (const rel of nodes ?? []) {
-        const peer = rel[peerKey];
+function mergeOutgoingRelations(nodes, out) {
+    for (const rel of nodes) {
+        const peer = rel.relatedIssue;
         if (!peer) {
             continue;
         }
-        const id = peer.identifier;
-        const uuid = peer.id;
-        const type = normalizeType(rel.type);
-        if (id && !out.byIdentifier.has(id)) {
-            out.byIdentifier.set(id, type);
+        if (!out.byIdentifier.has(peer.identifier)) {
+            out.byIdentifier.set(peer.identifier, rel.type);
         }
-        if (uuid && !out.byUuid.has(uuid)) {
-            out.byUuid.set(uuid, type);
+        if (!out.byUuid.has(peer.id)) {
+            out.byUuid.set(peer.id, rel.type);
+        }
+    }
+}
+function mergeIncomingRelations(nodes, out) {
+    for (const rel of nodes) {
+        const peer = rel.issue;
+        if (!peer) {
+            continue;
+        }
+        // Normalize incoming "blocks" → "blockedBy" so the reported type reads naturally
+        const type = rel.type === "blocks" ? "blockedBy" : rel.type;
+        if (!out.byIdentifier.has(peer.identifier)) {
+            out.byIdentifier.set(peer.identifier, type);
+        }
+        if (!out.byUuid.has(peer.id)) {
+            out.byUuid.set(peer.id, type);
         }
     }
 }
 async function fetchExistingRelations(issueId, graphQLService) {
-    const result = await graphQLService.rawRequest(GET_ISSUE_RELATIONS_QUERY, {
-        id: issueId,
-    });
-    const issue = result.issue;
+    const result = await graphQLService.rawRequest(GET_ISSUE_RELATIONS_QUERY, { id: issueId });
     const out = { byIdentifier: new Map(), byUuid: new Map() };
-    if (!issue) {
+    if (!result.issue) {
         return out;
     }
-    const outgoing = issue.relations;
-    mergeRelationNodes(outgoing?.nodes, "relatedIssue", (raw) => raw, out);
-    const incoming = issue.inverseRelations;
-    // Normalize incoming "blocks" → "blockedBy" so the reported type reads naturally
-    mergeRelationNodes(incoming?.nodes, "issue", (raw) => (raw === "blocks" ? "blockedBy" : raw), out);
+    mergeOutgoingRelations(result.issue.relations.nodes, out);
+    mergeIncomingRelations(result.issue.inverseRelations.nodes, out);
     return out;
 }
 function describeError(err) {
@@ -70,11 +68,9 @@ async function createTypedRelation(ref, sourceId, resolvedId, graphQLService) {
             type: ref.type,
         },
     });
-    const create = result.issueRelationCreate;
-    const issueRelation = create?.issueRelation;
+    const issueRelation = result.issueRelationCreate.issueRelation;
     // The peer (the issue NOT identified by `sourceId`) is whichever side wasn't the source
-    const peerKey = ref.reverse ? "issue" : "relatedIssue";
-    const peer = issueRelation?.[peerKey];
+    const peer = ref.reverse ? issueRelation?.issue : issueRelation?.relatedIssue;
     return {
         identifier: peer?.identifier ?? ref.identifier,
         title: peer?.title ?? "",

package/dist/utils/extract-field.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Extract a named section from a Linear issue's markdown description.
+ *
+ * Linear issue bodies follow a small set of repeated structures —
+ * "Why we need this", "Done when", "Scope", "Out of scope", etc. —
+ * usually as `##` or `###` headers, sometimes as bold pseudo-headers
+ * (`**Done when**`). Agents end up repeatedly piping
+ * `el-linear issues read X | python -c '...desc.find("Done when")...'`
+ * to pull one section out. This helper centralizes that.
+ *
+ * Matching is case-insensitive on the header text. The first matching
+ * header wins. Content is everything between that header and the next
+ * header line (any `#{1,6}` or bold pseudo-header at line start) or EOF,
+ * trimmed of surrounding whitespace.
+ *
+ * Returns `null` when the field isn't found, so callers can distinguish
+ * "missing" from "empty body".
+ */
+export declare function extractField(body: string, fieldName: string): string | null;

package/dist/utils/extract-field.js

@@ -0,0 +1,99 @@
+/**
+ * Extract a named section from a Linear issue's markdown description.
+ *
+ * Linear issue bodies follow a small set of repeated structures —
+ * "Why we need this", "Done when", "Scope", "Out of scope", etc. —
+ * usually as `##` or `###` headers, sometimes as bold pseudo-headers
+ * (`**Done when**`). Agents end up repeatedly piping
+ * `el-linear issues read X | python -c '...desc.find("Done when")...'`
+ * to pull one section out. This helper centralizes that.
+ *
+ * Matching is case-insensitive on the header text. The first matching
+ * header wins. Content is everything between that header and the next
+ * header line (any `#{1,6}` or bold pseudo-header at line start) or EOF,
+ * trimmed of surrounding whitespace.
+ *
+ * Returns `null` when the field isn't found, so callers can distinguish
+ * "missing" from "empty body".
+ */
+// Header forms accepted:
+//   `# ... `, `## ...`, `### ...`, ... up to `######`
+//   `**Done when**`, `**Done when:**` (bold pseudo-headers)
+// Trailing colons after the header text are stripped.
+const ATX_HEADER_RE = /^(?:#{1,6})\s+([^\n]+?)(?::\s*)?\s*$/;
+const BOLD_PSEUDO_HEADER_RE = /^\*\*([^*\n]+?)(?::\s*)?\*\*\s*$/;
+// Fenced code block delimiters per CommonMark: at least three backticks or
+// tildes at the start of a line, with up to 3 leading SPACES of indent (4+
+// is an indented code block, which is a different construct; tabs are not
+// permitted as fence indent per the CommonMark spec). We toggle an inFence
+// flag while scanning so section headers inside code samples don't
+// terminate the real section.
+const FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+function normalize(s) {
+    return s.toLowerCase().trim().replace(/\s+/g, " ");
+}
+// Bold pseudo-header heuristic: any `**...**` line could be a header, but
+// inline emphasis paragraphs (e.g. a single bolded sentence in prose) are
+// false positives. Require either a trailing colon OR ≤6 words so that
+// "**Done when:**" and "**Why we need this**" qualify but "**Note that all
+// downstream consumers ...**" does not.
+function isLikelyBoldHeader(text, hadTrailingColon) {
+    if (hadTrailingColon)
+        return true;
+    const wordCount = text.trim().split(/\s+/).filter(Boolean).length;
+    return wordCount > 0 && wordCount <= 6;
+}
+function matchHeader(line) {
+    const atx = line.match(ATX_HEADER_RE);
+    if (atx)
+        return { text: atx[1] };
+    const bold = line.match(BOLD_PSEUDO_HEADER_RE);
+    if (bold) {
+        const text = bold[1];
+        // match[1] excludes the bold delimiters; the regex consumed a trailing
+        // colon if present, so detect by re-checking the raw line.
+        const hadColon = /:\*\*\s*$/.test(line);
+        if (!isLikelyBoldHeader(text, hadColon))
+            return null;
+        return { text };
+    }
+    return null;
+}
+export function extractField(body, fieldName) {
+    if (!body)
+        return null;
+    const target = normalize(fieldName);
+    const lines = body.split("\n");
+    let inFence = false;
+    let startIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (FENCE_RE.test(lines[i])) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const match = matchHeader(lines[i]);
+        if (!match)
+            continue;
+        if (normalize(match.text) === target) {
+            startIdx = i + 1;
+            break;
+        }
+    }
+    if (startIdx === -1)
+        return null;
+    const out = [];
+    let sectionInFence = false;
+    for (let i = startIdx; i < lines.length; i++) {
+        if (FENCE_RE.test(lines[i])) {
+            sectionInFence = !sectionInFence;
+            out.push(lines[i]);
+            continue;
+        }
+        if (!sectionInFence && matchHeader(lines[i]) !== null)
+            break;
+        out.push(lines[i]);
+    }
+    return out.join("\n").trim();
+}

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

@@ -1,19 +1,12 @@
+import type { LinearCredential } from "../auth/linear-credential.js";
 import type { FileDownloadResult, FileUploadResult } from "../types/linear.js";
 /**
- * Constructor arg shapes for `FileService`:
- *   - `string` → personal API token (legacy; sent as `Authorization: <token>`).
- *   - `{apiKey: string}` → personal API token (explicit).
- *   - `{oauthToken: string}` → OAuth access token (sent as
- *     `Authorization: Bearer <token>`).
- *
- * The string variant exists because dozens of tests construct `FileService`
- * with a plain string. We continue to support it indefinitely.
+ * Constructor arg for `FileService`. 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 FileServiceAuth = string | {
-    apiKey: string;
-} | {
-    oauthToken: string;
-};
+export type FileServiceAuth = LinearCredential;
 export declare class FileService {
     private readonly authHeader;
     constructor(auth: FileServiceAuth);

package/dist/utils/file-service.js

@@ -38,8 +38,6 @@ function getMimeType(filePath) {
     return MIME_TYPES[ext] || "application/octet-stream";
 }
 function buildAuthHeader(auth) {
-    if (typeof auth === "string")
-        return auth;
     if ("oauthToken" in auth)
         return `Bearer ${auth.oauthToken}`;
     return auth.apiKey;

package/dist/utils/formatters/summary.js

@@ -591,7 +591,12 @@ function formatGenericInline(v) {
     if (o)
         return s(o.name ?? o.displayName ?? o.identifier ?? o.id ?? "{…}");
     if (typeof v === "string" && v.length > 80) {
-        return `${v.slice(0, 80)}…`;
+        // Route through sanitizeForTerminal (via `s()`) before slicing so that
+        // long strings from the generic-fallback path can't smuggle ANSI
+        // escapes (cursor moves, clear-screen, OSC 8 hyperlinks) into the
+        // user's terminal. Every other branch in this function already goes
+        // through `s()`; this one previously didn't.
+        return `${s(v).slice(0, 80)}…`;
     }
     return s(v);
 }

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

@@ -4,9 +4,9 @@ function transformAttachment(att) {
     return {
         id: att.id,
         url: att.url,
-        title: att.title || undefined,
-        createdAt: att.createdAt || undefined,
-        updatedAt: att.updatedAt || undefined,
+        title: att.title ?? undefined,
+        createdAt: att.createdAt ?? undefined,
+        updatedAt: att.updatedAt ?? undefined,
     };
 }
 class GraphQLAttachmentsService {
@@ -17,15 +17,14 @@ class GraphQLAttachmentsService {
     async createAttachment(input) {
         const result = await this.graphqlService.rawRequest(CREATE_ATTACHMENT_MUTATION, { input });
         const attachmentCreate = result.attachmentCreate;
-        if (!attachmentCreate.success) {
+        if (!attachmentCreate.success || !attachmentCreate.attachment) {
             throw new Error(`Failed to create attachment on issue ${input.issueId} for URL "${input.url}"`);
         }
         return transformAttachment(attachmentCreate.attachment);
     }
     async deleteAttachment(id) {
         const result = await this.graphqlService.rawRequest(DELETE_ATTACHMENT_MUTATION, { id });
-        const attachmentDelete = result.attachmentDelete;
-        if (!attachmentDelete.success) {
+        if (!result.attachmentDelete.success) {
             throw new Error(`Failed to delete attachment: ${id}`);
         }
         return true;
@@ -35,9 +34,7 @@ class GraphQLAttachmentsService {
         if (!result.issue) {
             throw new Error(`Issue not found: ${issueId}`);
         }
-        const issue = result.issue;
-        const attachments = issue.attachments;
-        return attachments.nodes.map(transformAttachment);
+        return result.issue.attachments.nodes.map(transformAttachment);
     }
 }
 export async function createGraphQLAttachmentsService(options) {

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

@@ -1,32 +1,29 @@
 import { CREATE_DOCUMENT_MUTATION, DELETE_DOCUMENT_MUTATION, GET_DOCUMENT_QUERY, LIST_DOCUMENTS_QUERY, UPDATE_DOCUMENT_MUTATION, } from "../queries/documents.js";
 import { createGraphQLService, } from "./graphql-service.js";
 function transformDocument(doc) {
-    const creator = doc.creator;
-    const project = doc.project;
-    const issue = doc.issue;
     return {
         id: doc.id,
         title: doc.title,
-        content: doc.content || undefined,
-        color: doc.color || undefined,
-        icon: doc.icon || undefined,
-        slugId: doc.slugId || undefined,
-        url: doc.url || undefined,
-        creator: creator
-            ? { id: creator.id, name: creator.name }
+        content: doc.content ?? undefined,
+        color: doc.color ?? undefined,
+        icon: doc.icon ?? undefined,
+        slugId: doc.slugId ?? undefined,
+        url: doc.url ?? undefined,
+        creator: doc.creator
+            ? { id: doc.creator.id, name: doc.creator.name }
             : undefined,
-        project: project
-            ? { id: project.id, name: project.name }
+        project: doc.project
+            ? { id: doc.project.id, name: doc.project.name }
             : undefined,
-        issue: issue
+        issue: doc.issue
             ? {
-                id: issue.id,
-                identifier: issue.identifier,
-                title: issue.title,
+                id: doc.issue.id,
+                identifier: doc.issue.identifier,
+                title: doc.issue.title,
             }
             : undefined,
-        createdAt: doc.createdAt || undefined,
-        updatedAt: doc.updatedAt || undefined,
+        createdAt: doc.createdAt ?? undefined,
+        updatedAt: doc.updatedAt ?? undefined,
     };
 }
 class GraphQLDocumentsService {
@@ -37,7 +34,7 @@ class GraphQLDocumentsService {
     async createDocument(input) {
         const result = await this.graphqlService.rawRequest(CREATE_DOCUMENT_MUTATION, { input });
         const createData = result.documentCreate;
-        if (!createData.success) {
+        if (!createData.success || !createData.document) {
             throw new Error(`Failed to create document "${input.title}"${input.projectId ? ` in project ${input.projectId}` : ""}${input.teamId ? ` for team ${input.teamId}` : ""}`);
         }
         return transformDocument(createData.document);
@@ -45,15 +42,13 @@ class GraphQLDocumentsService {
     async updateDocument(id, input) {
         const result = await this.graphqlService.rawRequest(UPDATE_DOCUMENT_MUTATION, { id, input });
         const updateData = result.documentUpdate;
-        if (!updateData.success) {
+        if (!updateData.success || !updateData.document) {
             throw new Error(`Failed to update document: ${id}`);
         }
         return transformDocument(updateData.document);
     }
     async getDocument(id) {
-        const result = await this.graphqlService.rawRequest(GET_DOCUMENT_QUERY, {
-            id,
-        });
+        const result = await this.graphqlService.rawRequest(GET_DOCUMENT_QUERY, { id });
         if (!result.document) {
             throw new Error(`Document not found: ${id}`);
         }
@@ -71,8 +66,7 @@ class GraphQLDocumentsService {
     }
     async deleteDocument(id) {
         const result = await this.graphqlService.rawRequest(DELETE_DOCUMENT_MUTATION, { id });
-        const deleteData = result.documentDelete;
-        if (!deleteData.success) {
+        if (!result.documentDelete.success) {
             throw new Error(`Failed to delete document: ${id}`);
         }
         return true;