@enrichlayer/el-linear 1.9.0 → 1.10.0

package/dist/commands/projects.js

@@ -1,6 +1,6 @@
 import { loadConfig } from "../config/config.js";
 import { resolveTeam } from "../config/resolver.js";
-import { CREATE_PROJECT_MUTATION, GET_PROJECT_QUERY, GET_PROJECT_TEAM_ISSUES_QUERY, PROJECT_BY_ID_QUERY, SEARCH_PROJECTS_BY_NAME_QUERY, UPDATE_PROJECT_MUTATION, } from "../queries/projects.js";
+import { ARCHIVE_PROJECT_MUTATION, CREATE_PROJECT_MUTATION, DELETE_PROJECT_MUTATION, GET_PROJECT_QUERY, GET_PROJECT_TEAM_ISSUES_QUERY, PROJECT_BY_ID_QUERY, SEARCH_PROJECTS_BY_NAME_QUERY, UPDATE_PROJECT_MUTATION, } from "../queries/projects.js";
 import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
@@ -9,7 +9,7 @@ import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { renderCsv, renderFixedWidthTable, renderMarkdownTable, } from "../utils/table-formatter.js";
 import { isUuid } from "../utils/uuid.js";
-import { splitList } from "../utils/validators.js";
+import { parsePositiveInt, splitList } from "../utils/validators.js";
 const VALID_PROJECT_STATES = new Set([
     "backlog",
     "planned",
@@ -133,37 +133,29 @@ function formatProjectsOutput(projects, format, fieldNames) {
 }
 async function resolveProjectWithTeams(graphQLService, projectNameOrId) {
     if (isUuid(projectNameOrId)) {
-        const result = await graphQLService.rawRequest(PROJECT_BY_ID_QUERY, {
-            id: projectNameOrId,
-        });
-        const project = result.project;
-        if (!project) {
+        const result = await graphQLService.rawRequest(PROJECT_BY_ID_QUERY, { id: projectNameOrId });
+        if (!result.project) {
             throw new Error(`Project "${projectNameOrId}" not found`);
         }
-        const teams = project.teams;
         return {
-            projectId: project.id,
-            projectName: project.name,
-            currentTeams: (teams?.nodes || []).map((t) => ({
+            projectId: result.project.id,
+            projectName: result.project.name,
+            currentTeams: result.project.teams.nodes.map((t) => ({
                 id: t.id,
                 key: t.key,
                 name: t.name,
             })),
         };
     }
-    const result = await graphQLService.rawRequest(GET_PROJECT_QUERY, {
-        name: projectNameOrId,
-    });
-    const projectNodes = result.projects?.nodes;
-    if (!projectNodes?.length) {
+    const result = await graphQLService.rawRequest(GET_PROJECT_QUERY, { name: projectNameOrId });
+    const project = result.projects.nodes[0];
+    if (!project) {
         throw new Error(`Project "${projectNameOrId}" not found`);
     }
-    const project = projectNodes[0];
-    const teams = project.teams;
     return {
         projectId: project.id,
         projectName: project.name,
-        currentTeams: (teams?.nodes || []).map((t) => ({
+        currentTeams: project.teams.nodes.map((t) => ({
             id: t.id,
             key: t.key,
             name: t.name,
@@ -171,12 +163,14 @@ async function resolveProjectWithTeams(graphQLService, projectNameOrId) {
     };
 }
 function formatTeamsOutput(projectUpdate) {
+    if (!projectUpdate.project) {
+        throw new Error("Failed to update project");
+    }
     const updatedProject = projectUpdate.project;
-    const updatedTeams = updatedProject.teams;
     return {
         id: updatedProject.id,
         name: updatedProject.name,
-        teams: (updatedTeams.nodes || []).map((t) => ({
+        teams: updatedProject.teams.nodes.map((t) => ({
             id: t.id,
             key: t.key,
             name: t.name,
@@ -255,9 +249,7 @@ async function handleRemoveTeam(projectNameOrId, teamInput, options, command) {
             projectId,
             teamId: finalTeamId,
         });
-        const project = issueCheck.project;
-        const issues = project.issues;
-        const issueNodes = issues.nodes || [];
+        const issueNodes = issueCheck.project?.issues.nodes ?? [];
         if (issueNodes.length > 0) {
             const examples = issueNodes
                 .slice(0, 5)
@@ -285,14 +277,10 @@ async function handleCreateProject(name, options, command) {
     const graphQLService = await createGraphQLService(rootOpts);
     // Step 1: Check for duplicate projects (case-insensitive)
     const searchResult = await graphQLService.rawRequest(SEARCH_PROJECTS_BY_NAME_QUERY, { name });
-    const existing = (searchResult.projects
-        ?.nodes ?? []).filter((p) => p.name.toLowerCase() === name.toLowerCase());
+    const existing = searchResult.projects.nodes.filter((p) => p.name.toLowerCase() === name.toLowerCase());
     if (existing.length > 0 && !options.force) {
         const match = existing[0];
-        const teams = (match.teams?.nodes ??
-            [])
-            .map((t) => t.key)
-            .join(", ");
+        const teams = match.teams.nodes.map((t) => t.key).join(", ");
         throw new Error(`Project "${match.name}" already exists (state: ${match.state}, teams: ${teams}). ` +
             `Use --force to create anyway, or use the existing project.`);
     }
@@ -310,11 +298,11 @@ async function handleCreateProject(name, options, command) {
         ...(teamIds.length > 0 ? { teamIds } : {}),
     };
     const createResult = await graphQLService.rawRequest(CREATE_PROJECT_MUTATION, { input });
-    const created = createResult.projectCreate;
-    if (!created?.success) {
+    if (!createResult.projectCreate.success ||
+        !createResult.projectCreate.project) {
         throw new Error("Failed to create project");
     }
-    const project = created.project;
+    const project = createResult.projectCreate.project;
     // Step 4: Set content if provided (separate mutation — Linear API quirk)
     if (options.content) {
         await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
@@ -322,10 +310,7 @@ async function handleCreateProject(name, options, command) {
             input: { content: options.content },
         });
     }
-    const teamList = (project.teams?.nodes ??
-        [])
-        .map((t) => t.key)
-        .join(", ");
+    const teamList = project.teams.nodes.map((t) => t.key).join(", ");
     outputSuccess({
         id: project.id,
         name: project.name,
@@ -340,6 +325,42 @@ async function handleCreateProject(name, options, command) {
             : {}),
     });
 }
+async function handleArchiveProject(projectNameOrId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(projectNameOrId);
+    const result = await graphQLService.rawRequest(ARCHIVE_PROJECT_MUTATION, { id: projectId });
+    const payload = result.projectArchive;
+    if (!payload.success) {
+        throw new Error(`Failed to archive project "${projectNameOrId}"`);
+    }
+    outputSuccess({
+        success: true,
+        archived: true,
+        id: projectId,
+        entity: payload.entity ?? undefined,
+        lastSyncId: payload.lastSyncId,
+    });
+}
+async function handleDeleteProject(projectNameOrId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(projectNameOrId);
+    const result = await graphQLService.rawRequest(DELETE_PROJECT_MUTATION, { id: projectId });
+    const payload = result.projectDelete;
+    if (!payload.success) {
+        throw new Error(`Failed to delete project "${projectNameOrId}"`);
+    }
+    outputSuccess({
+        success: true,
+        deleted: true,
+        id: projectId,
+        entity: payload.entity ?? undefined,
+        lastSyncId: payload.lastSyncId,
+    });
+}
 export function setupProjectsCommands(program) {
     const projects = program
         .command("projects")
@@ -354,6 +375,14 @@ export function setupProjectsCommands(program) {
         .option("--content <markdown>", "full markdown body (shown in project panel)")
         .option("--force", "create even if a project with the same name exists")
         .action(handleAsyncCommand(handleCreateProject));
+    projects
+        .command("archive <project>")
+        .description("Archive a project (resolves names)")
+        .action(handleAsyncCommand(handleArchiveProject));
+    projects
+        .command("delete <project>")
+        .description("Delete (trash) a project (resolves names)")
+        .action(handleAsyncCommand(handleDeleteProject));
     projects
         .command("list")
         .description("List projects")
@@ -366,7 +395,7 @@ export function setupProjectsCommands(program) {
         .option("--active", "shorthand for --exclude-state completed,canceled (mutually exclusive with --state / --exclude-state)")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const nameFilter = options.name;
         const stateFilter = resolveProjectStateFilter(options);
         const ttl = resolveCacheTTL({

package/dist/commands/refs.js

@@ -68,6 +68,13 @@ async function handleWrap(options, command) {
             return new Set(map.keys());
         },
         async resolveUrlKey() {
+            // When --workspace-url-key or EL_LINEAR_WORKSPACE_URL_KEY supplies
+            // the key, the live lookup never fires — skip the GraphQL service
+            // instantiation entirely so `refs wrap --no-validate` works offline.
+            const override = options.workspaceUrlKey;
+            if (override || process.env.EL_LINEAR_WORKSPACE_URL_KEY) {
+                return getWorkspaceUrlKey(undefined, { override });
+            }
             const graphQLService = await createGraphQLService(rootOpts);
             return getWorkspaceUrlKey(graphQLService);
         },
@@ -93,5 +100,6 @@ export function setupRefsCommands(program) {
         .option("--file <path>", "read input from a file instead of stdin")
         .option("--target <target>", "output format: markdown (default) or slack", "markdown")
         .option("--no-validate", "skip workspace validation; wrap every regex match. Faster, but may produce broken links for IDs that don't exist.")
+        .option("--workspace-url-key <key>", "workspace URL key (the segment after linear.app/). Overrides config + env var. With --no-validate, makes the command fully offline.")
         .action(handleAsyncCommand(handleWrap));
 }

package/dist/commands/releases.js

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

package/dist/commands/search.js

@@ -3,6 +3,7 @@ import { SEMANTIC_SEARCH_QUERY } from "../queries/search.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 const TEMPLATES_QUERY = `
   query {
     templates {
@@ -24,59 +25,50 @@ const VALID_TYPES = new Set([
 ]);
 const WHITESPACE_RE = /\s+/;
 function transformSearchResult(r) {
-    const rType = r.type;
-    switch (rType) {
+    switch (r.type) {
         case "issue": {
             const issue = r.issue;
-            const state = issue?.state;
-            const team = issue?.team;
-            const assignee = issue?.assignee;
-            const project = issue?.project;
             return {
                 type: "issue",
                 identifier: issue?.identifier,
                 title: issue?.title,
-                state: state?.name,
-                team: team?.key,
-                assignee: assignee
-                    ? resolveUserDisplayName(assignee.id, assignee.name)
+                state: issue?.state?.name,
+                team: issue?.team?.key,
+                assignee: issue?.assignee
+                    ? resolveUserDisplayName(issue.assignee.id, issue.assignee.name)
                     : undefined,
-                priority: issue?.priority,
-                project: project?.name,
+                priority: issue?.priority ?? undefined,
+                project: issue?.project?.name,
                 id: issue?.id,
             };
         }
         case "project": {
-            const project = r.project;
             return {
                 type: "project",
-                name: project?.name,
-                state: project?.state,
-                id: project?.id,
+                name: r.project?.name,
+                state: r.project?.state,
+                id: r.project?.id,
             };
         }
         case "initiative": {
-            const initiative = r.initiative;
             return {
                 type: "initiative",
-                name: initiative?.name,
-                status: initiative?.status,
-                id: initiative?.id,
+                name: r.initiative?.name,
+                status: r.initiative?.status ?? undefined,
+                id: r.initiative?.id,
             };
         }
         case "document": {
-            const doc = r.document;
-            const docProject = doc?.project;
             return {
                 type: "document",
-                title: doc?.title,
-                project: docProject?.name,
-                slugId: doc?.slugId,
-                id: doc?.id,
+                title: r.document?.title,
+                project: r.document?.project?.name,
+                slugId: r.document?.slugId ?? undefined,
+                id: r.document?.id,
             };
         }
         default:
-            return { type: rType, id: null };
+            return { type: r.type, id: null };
     }
 }
 function matchesQuery(name, query) {
@@ -122,8 +114,7 @@ function buildSemanticQuery(graphQLService, query, limit, teamOption) {
     });
 }
 function extractSemanticResults(semanticResult, requestedTypes, onlyTemplates) {
-    const semanticSearch = semanticResult.semanticSearch;
-    let results = semanticSearch?.results ?? [];
+    let results = semanticResult.semanticSearch?.results ?? [];
     if (requestedTypes && !onlyTemplates) {
         const semanticTypes = requestedTypes.filter((t) => t !== "template");
         results = results.filter((r) => semanticTypes.includes(r.type));
@@ -140,7 +131,7 @@ export function setupSearchCommands(program) {
         .action(handleAsyncCommand(async (query, options, command) => {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const requestedTypes = options.type
             ? options.type.split(",").map((t) => t.trim().toLowerCase())
             : null;

package/dist/commands/teams.js

@@ -3,6 +3,7 @@ import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 export function setupTeamsCommands(program) {
     const teams = program
         .command("teams")
@@ -15,7 +16,7 @@ export function setupTeamsCommands(program) {
         .option("-l, --limit <number>", "limit results", "100")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const ttl = resolveCacheTTL({
             configTTL: loadConfig().cacheTTLSeconds,
             // commander's `--no-cache` produces `cache: false` on the root opts.

package/dist/commands/templates.js

@@ -48,14 +48,11 @@ export function setupTemplatesCommands(program) {
         .action(handleAsyncCommand(async (templateId, _options, command) => {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
-        const result = await graphQLService.rawRequest(TEMPLATE_BY_ID_QUERY, {
-            id: templateId,
-        });
-        const template = result.template;
-        if (!template) {
+        const result = await graphQLService.rawRequest(TEMPLATE_BY_ID_QUERY, { id: templateId });
+        if (!result.template) {
             throw new Error(`Template "${templateId}" not found`);
         }
-        outputSuccess(template);
+        outputSuccess(result.template);
     }));
     templates
         .command("create")
@@ -87,11 +84,10 @@ export function setupTemplatesCommands(program) {
         if (options.color)
             input.color = options.color;
         const result = await graphQLService.rawRequest(TEMPLATE_CREATE_MUTATION, { input });
-        const payload = result.templateCreate;
-        if (!payload?.success) {
+        if (!result.templateCreate.success || !result.templateCreate.template) {
             throw new Error("templateCreate returned success=false");
         }
-        outputSuccess(payload.template);
+        outputSuccess(result.templateCreate.template);
     }));
     templates
         .command("update <templateId>")
@@ -126,11 +122,11 @@ export function setupTemplatesCommands(program) {
             throw new Error("templates update: at least one of --name, --description, --data, --data-file, --icon, --color, --team-id is required");
         }
         const result = await graphQLService.rawRequest(TEMPLATE_UPDATE_MUTATION, { id: templateId, input });
-        const payload = result.templateUpdate;
-        if (!payload?.success) {
+        if (!result.templateUpdate.success ||
+            !result.templateUpdate.template) {
             throw new Error("templateUpdate returned success=false");
         }
-        outputSuccess(payload.template);
+        outputSuccess(result.templateUpdate.template);
     }));
     templates
         .command("delete <templateId>")
@@ -139,8 +135,7 @@ export function setupTemplatesCommands(program) {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest(TEMPLATE_DELETE_MUTATION, { id: templateId });
-        const payload = result.templateDelete;
-        if (!payload?.success) {
+        if (!result.templateDelete.success) {
             throw new Error("templateDelete returned success=false");
         }
         outputSuccess({ id: templateId, deleted: true });

package/dist/commands/users.js

@@ -1,6 +1,7 @@
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 export function setupUsersCommands(program) {
     const users = program.command("users").description("User operations");
     users.action(() => users.help());
@@ -13,7 +14,7 @@ export function setupUsersCommands(program) {
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
         const service = await createLinearService(rootOpts);
-        const result = await service.getUsers(options.active, Number.parseInt(options.limit, 10), options.name);
+        const result = await service.getUsers(options.active, parsePositiveInt(options.limit, "--limit"), options.name);
         outputSuccess({ data: result, meta: { count: result.length } });
     }));
 }

package/dist/config/resolver.js

@@ -93,11 +93,10 @@ export async function resolveAssignee(input, rootOpts) {
     if (input.toLowerCase() === "me") {
         const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest("{ viewer { id } }");
-        const viewer = result.viewer;
-        if (!viewer?.id) {
+        if (!result.viewer?.id) {
             throw new Error('Could not resolve "me" — viewer query returned no user. Check your API token.');
         }
-        return viewer.id;
+        return result.viewer.id;
     }
     return resolveMember(input);
 }

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

@@ -0,0 +1,30 @@
+/**
+ * Typed response shapes for the queries in `./attachments.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ */
+/** Mirrors `ATTACHMENT_FRAGMENT` from `src/queries/attachments.ts`. */
+export interface AttachmentNode {
+    id: string;
+    title: string | null;
+    url: string;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface CreateAttachmentResponse {
+    attachmentCreate: {
+        success: boolean;
+        attachment: AttachmentNode | null;
+    };
+}
+export interface DeleteAttachmentResponse {
+    attachmentDelete: {
+        success: boolean;
+    };
+}
+export interface ListAttachmentsResponse {
+    issue: {
+        attachments: {
+            nodes: AttachmentNode[];
+        };
+    } | null;
+}

package/dist/queries/attachments-types.js

@@ -0,0 +1,5 @@
+/**
+ * Typed response shapes for the queries in `./attachments.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ */
+export {};

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

@@ -0,0 +1,49 @@
+/**
+ * Typed response shapes for the queries in `./comments.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ */
+export interface CommentUserRef {
+    id: string;
+    name: string;
+    displayName: string | null;
+    url: string | null;
+}
+/**
+ * Mirrors the comment selection set used by `LIST_COMMENTS_QUERY`,
+ * `CREATE_COMMENT_MUTATION`, and (with `issue` overlay)
+ * `UPDATE_COMMENT_MUTATION`.
+ */
+export interface CommentNode {
+    id: string;
+    body: string;
+    createdAt: string;
+    updatedAt: string;
+    user: CommentUserRef;
+}
+export interface UpdatedCommentNode extends CommentNode {
+    issue: {
+        id: string;
+        identifier: string;
+    } | null;
+}
+export interface ListCommentsResponse {
+    issue: {
+        id: string;
+        identifier: string;
+        comments: {
+            nodes: CommentNode[];
+        };
+    } | null;
+}
+export interface CreateCommentResponse {
+    commentCreate: {
+        success: boolean;
+        comment: CommentNode | null;
+    };
+}
+export interface UpdateCommentResponse {
+    commentUpdate: {
+        success: boolean;
+        comment: UpdatedCommentNode | null;
+    };
+}

package/dist/queries/comments-types.js

@@ -0,0 +1,5 @@
+/**
+ * Typed response shapes for the queries in `./comments.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ */
+export {};