@enrichlayer/el-linear 1.7.0 → 1.10.0

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

@@ -1,4 +1,5 @@
-import { TEMPLATE_BY_ID_QUERY, TEMPLATES_LIST_QUERY, } from "../queries/templates.js";
+import { readFileSync } from "node:fs";
+import { TEMPLATE_BY_ID_QUERY, TEMPLATE_CREATE_MUTATION, TEMPLATE_DELETE_MUTATION, TEMPLATE_UPDATE_MUTATION, TEMPLATES_LIST_QUERY, } from "../queries/templates.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
@@ -47,13 +48,133 @@ 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")
+        .description("Create a new issue / document / project template")
+        .requiredOption("--type <type>", "template kind (issue, document, project, recurringIssue)")
+        .requiredOption("--name <name>", "template display name")
+        .requiredOption("--team-id <id>", "team id (UUID) the template belongs to. See `el-linear teams list`")
+        .option("--description <text>", "description shown in the template picker")
+        .option("--data <json>", "templateData as a JSON string (typically { title, description, labelIds, priority })")
+        .option("--data-file <path>", "templateData read from a JSON file (relative path). Mutually exclusive with --data")
+        .option("--allow-absolute", "allow --data-file to read absolute or `..`-traversing paths (file contents are sent to Linear's API)")
+        .option("--icon <name>", "Lucide icon name shown in the picker")
+        .option("--color <hex>", "color (hex) for the template badge")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = getRootOpts(command);
+        const graphQLService = await createGraphQLService(rootOpts);
+        const templateData = parseTemplateData(options);
+        const input = {
+            type: options.type,
+            name: options.name,
+            teamId: options.teamId,
+        };
+        if (options.description)
+            input.description = options.description;
+        if (templateData !== undefined)
+            input.templateData = templateData;
+        if (options.icon)
+            input.icon = options.icon;
+        if (options.color)
+            input.color = options.color;
+        const result = await graphQLService.rawRequest(TEMPLATE_CREATE_MUTATION, { input });
+        if (!result.templateCreate.success || !result.templateCreate.template) {
+            throw new Error("templateCreate returned success=false");
+        }
+        outputSuccess(result.templateCreate.template);
+    }));
+    templates
+        .command("update <templateId>")
+        .description("Update a template's name, description, templateData, icon, or color")
+        .option("--name <name>", "new display name")
+        .option("--description <text>", "new description")
+        .option("--data <json>", "new templateData as a JSON string")
+        .option("--data-file <path>", "new templateData read from a JSON file (relative path)")
+        .option("--allow-absolute", "allow --data-file to read absolute or `..`-traversing paths")
+        .option("--icon <name>", "Lucide icon name")
+        .option("--color <hex>", "color (hex)")
+        .option("--team-id <id>", "move the template to a different team")
+        .action(handleAsyncCommand(async (templateId, options, command) => {
+        const rootOpts = getRootOpts(command);
+        const graphQLService = await createGraphQLService(rootOpts);
+        const input = {};
+        if (options.name)
+            input.name = options.name;
+        if (options.description !== undefined) {
+            input.description = options.description;
+        }
+        const templateData = parseTemplateData(options);
+        if (templateData !== undefined)
+            input.templateData = templateData;
+        if (options.icon)
+            input.icon = options.icon;
+        if (options.color)
+            input.color = options.color;
+        if (options.teamId)
+            input.teamId = options.teamId;
+        if (Object.keys(input).length === 0) {
+            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 });
+        if (!result.templateUpdate.success ||
+            !result.templateUpdate.template) {
+            throw new Error("templateUpdate returned success=false");
+        }
+        outputSuccess(result.templateUpdate.template);
+    }));
+    templates
+        .command("delete <templateId>")
+        .description("Delete a template (cannot be undone)")
+        .action(handleAsyncCommand(async (templateId, _options, command) => {
+        const rootOpts = getRootOpts(command);
+        const graphQLService = await createGraphQLService(rootOpts);
+        const result = await graphQLService.rawRequest(TEMPLATE_DELETE_MUTATION, { id: templateId });
+        if (!result.templateDelete.success) {
+            throw new Error("templateDelete returned success=false");
+        }
+        outputSuccess({ id: templateId, deleted: true });
     }));
 }
+/**
+ * Resolve `--data <json>` or `--data-file <path>` into the parsed
+ * templateData object. Returns undefined when neither flag was set
+ * so the caller can omit the field from the input object.
+ */
+function parseTemplateData(options) {
+    if (options.data && options.dataFile) {
+        throw new Error("Pass either --data or --data-file, not both");
+    }
+    if (options.data) {
+        try {
+            return JSON.parse(options.data);
+        }
+        catch (err) {
+            throw new Error(`--data is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (options.dataFile) {
+        const dataFile = String(options.dataFile);
+        // Reject absolute paths and `..` traversal unless explicitly
+        // allowed. CI invocations or scripted callers can pass an
+        // attacker-controlled path otherwise (e.g. `~/.aws/credentials.json`,
+        // `/etc/passwd`) and have its contents flow into Linear's API
+        // via the `templateData` field.
+        if (!options.allowAbsolute && /^(\/|\.\.\/|\.\.\\)/.test(dataFile)) {
+            throw new Error(`--data-file ${dataFile} resolves outside the current directory. Pass --allow-absolute to opt in (sends file contents to Linear's API).`);
+        }
+        const raw = readFileSync(dataFile, "utf8");
+        try {
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`--data-file ${dataFile} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return undefined;
+}

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());
@@ -8,11 +9,12 @@ export function setupUsersCommands(program) {
         .command("list")
         .description("List all users")
         .option("--active", "Only show active users")
+        .option("--name <substring>", "filter by case-insensitive substring on user name")
         .option("-l, --limit <number>", "limit results", "100")
         .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));
+        const result = await service.getUsers(options.active, parsePositiveInt(options.limit, "--limit"), options.name);
         outputSuccess({ data: result, meta: { count: result.length } });
     }));
 }

package/dist/config/config.js

@@ -22,23 +22,38 @@ const DEFAULT_CONFIG = {
     },
     terms: [],
 };
-let cachedConfig;
+// Profile-keyed cache. Pre-fix this was a single `cachedConfig` —
+// switching the active profile mid-process and calling `loadConfig`
+// again would return the OLD profile's config until
+// `_resetConfigCacheForTests` ran. Today the CLI sets the profile
+// in `preAction` before any command body, so this is latent — but
+// keying by profile makes it future-proof and makes test isolation
+// less footgun-prone (profile A's setup pollutes profile B's read).
+// ALL-935 deferred fix.
+//
+// Key: `null` for the legacy single-file layout (no active profile),
+// otherwise the profile name. We never mix the two paths in the
+// cache — the marker name selects exactly one path.
+const cachedConfigByProfile = new Map();
 /** Test seam — resets the cache between test cases. */
 export function _resetConfigCacheForTests() {
-    cachedConfig = undefined;
+    cachedConfigByProfile.clear();
 }
 export function loadConfig() {
-    if (cachedConfig) {
-        return cachedConfig;
-    }
     // Profile-aware: read from <CONFIG_DIR>/profiles/<name>/config.json
     // when a profile is active, falling back to the legacy single-file
     // path so existing setups keep working without migration.
     const active = resolveActiveProfile();
+    const cacheKey = active.name;
+    const cached = cachedConfigByProfile.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
     const candidates = [active.configPath];
     if (active.configPath !== CONFIG_PATH)
         candidates.push(CONFIG_PATH);
     const sourcePath = candidates.find((p) => fs.existsSync(p));
+    let resolved;
     if (sourcePath) {
         try {
             const userConfig = JSON.parse(fs.readFileSync(sourcePath, "utf8"));
@@ -61,11 +76,11 @@ export function loadConfig() {
                 }
                 delete userConfig.brand;
             }
-            cachedConfig = deepMerge(DEFAULT_CONFIG, userConfig);
+            resolved = deepMerge(DEFAULT_CONFIG, userConfig);
         }
         catch {
             outputWarning(`Failed to parse ${sourcePath}, using empty defaults`);
-            cachedConfig = DEFAULT_CONFIG;
+            resolved = DEFAULT_CONFIG;
         }
     }
     else {
@@ -73,13 +88,20 @@ export function loadConfig() {
             ? ` (active profile: \`${active.name}\` — expected at ${active.configPath})`
             : "";
         outputWarning(`No config found at ${active.configPath}${profileNote}. Run \`el-linear init\` (or \`el-linear profile add ${active.name ?? "<name>"}\`) to create one.`);
-        cachedConfig = DEFAULT_CONFIG;
+        resolved = DEFAULT_CONFIG;
     }
-    return cachedConfig;
+    cachedConfigByProfile.set(cacheKey, resolved);
+    return resolved;
 }
 function deepMerge(target, source) {
     const result = { ...target };
     for (const key of Object.keys(source)) {
+        // Reject prototype-pollution keys regardless of value shape: a
+        // hand-edited config.json with `__proto__` would otherwise mutate
+        // Object.prototype for the whole process.
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            continue;
+        }
         if (source[key] &&
             typeof source[key] === "object" &&
             !Array.isArray(source[key]) &&

package/dist/config/issue-validation.js

@@ -252,7 +252,7 @@ function checkTitleVerbAlignment(title, typeLabel, result) {
  */
 export function enforceValidation(result) {
     for (const warning of result.warnings) {
-        outputWarning(warning, "validation");
+        outputWarning(warning);
     }
     if (result.errors.length > 0) {
         const errorMsg = "Issue creation blocked by validation:\n\n" +

package/dist/config/paths.d.ts

@@ -31,9 +31,20 @@ export interface ProfileFsOps {
     readFileSync: (p: string) => string;
     existsSync: (p: string) => boolean;
 }
+/**
+ * Conservative profile-name charset. Rejects path traversal (`..`, `/`),
+ * shell metacharacters, and Unicode lookalikes that would confuse `profile
+ * use` or let `--profile`/EL_LINEAR_PROFILE/active-profile escape out of
+ * <CONFIG_DIR>/profiles/.
+ */
+export declare function isSafeProfileName(name: string): boolean;
 /**
  * Set the active profile for the duration of this process. Pass `null`
  * to clear the override and fall back to env / on-disk markers.
+ *
+ * @throws when `name` is not a safe profile name. Validation lives here
+ * so every entry point (CLI flag, env var, marker file) goes through one
+ * gate — see `resolveActiveProfile`.
  */
 export declare function setActiveProfileForSession(name: string | null): void;
 /** Read-only accessor for the per-session override (test seam). */

package/dist/config/paths.js

@@ -44,6 +44,15 @@ const DEFAULT_FS_OPS = {
     readFileSync: (p) => fs.readFileSync(p, "utf8"),
     existsSync: (p) => fs.existsSync(p),
 };
+/**
+ * Conservative profile-name charset. Rejects path traversal (`..`, `/`),
+ * shell metacharacters, and Unicode lookalikes that would confuse `profile
+ * use` or let `--profile`/EL_LINEAR_PROFILE/active-profile escape out of
+ * <CONFIG_DIR>/profiles/.
+ */
+export function isSafeProfileName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name);
+}
 /**
  * Per-process override for the active profile name. Set by main.ts when
  * `--profile <name>` is passed (highest priority).
@@ -52,9 +61,25 @@ let sessionProfileOverride = null;
 /**
  * Set the active profile for the duration of this process. Pass `null`
  * to clear the override and fall back to env / on-disk markers.
+ *
+ * @throws when `name` is not a safe profile name. Validation lives here
+ * so every entry point (CLI flag, env var, marker file) goes through one
+ * gate — see `resolveActiveProfile`.
  */
 export function setActiveProfileForSession(name) {
-    sessionProfileOverride = name && name.trim().length > 0 ? name.trim() : null;
+    if (name === null) {
+        sessionProfileOverride = null;
+        return;
+    }
+    const trimmed = name.trim();
+    if (trimmed.length === 0) {
+        sessionProfileOverride = null;
+        return;
+    }
+    if (!isSafeProfileName(trimmed)) {
+        throw new Error(`Invalid profile name "${trimmed}". Allowed: [A-Za-z0-9][A-Za-z0-9_.-]{0,63}.`);
+    }
+    sessionProfileOverride = trimmed;
 }
 /** Read-only accessor for the per-session override (test seam). */
 export function getSessionProfileOverride() {
@@ -66,11 +91,24 @@ export function getSessionProfileOverride() {
  * keep working without migration.
  */
 export function resolveActiveProfile(env = process.env, fsImpl = DEFAULT_FS_OPS) {
-    const explicit = sessionProfileOverride ??
-        (env.EL_LINEAR_PROFILE?.trim() || null) ??
-        readActiveProfileMarker(fsImpl);
-    if (explicit) {
-        return profilePaths(explicit);
+    // session override is already validated at write time (see
+    // setActiveProfileForSession). Env var is explicit user input and
+    // must fail loudly. Marker file is our own on-disk state; treat
+    // invalid contents as "no marker" so a stale/corrupt file doesn't
+    // brick every command.
+    if (sessionProfileOverride) {
+        return profilePaths(sessionProfileOverride);
+    }
+    const envName = env.EL_LINEAR_PROFILE?.trim();
+    if (envName) {
+        if (!isSafeProfileName(envName)) {
+            throw new Error(`Invalid EL_LINEAR_PROFILE value "${envName}". Allowed: [A-Za-z0-9][A-Za-z0-9_.-]{0,63}.`);
+        }
+        return profilePaths(envName);
+    }
+    const marker = readActiveProfileMarker(fsImpl);
+    if (marker && isSafeProfileName(marker)) {
+        return profilePaths(marker);
     }
     return {
         name: null,

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/config/term-enforcer.js

@@ -62,7 +62,7 @@ export function enforceTerms(texts, options = {}) {
     if (options.strict) {
         throw new Error(`Term enforcement failed:\n${warnings.map((w) => `  - ${w}`).join("\n")}`);
     }
-    outputWarning(warnings, "term_enforcement");
+    outputWarning(warnings);
 }
 function escapeRegExp(string) {
     return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/main.js

@@ -24,16 +24,17 @@ import { setupTeamsCommands } from "./commands/teams.js";
 import { setupTemplatesCommands } from "./commands/templates.js";
 import { setupUsersCommands } from "./commands/users.js";
 import { setActiveProfileForSession } from "./config/paths.js";
-import { setFieldsFilter, setJqFilter, setRawMode } from "./utils/output.js";
+import { setFieldsFilter, setJqFilter, setOutputFormat, setRawMode, } from "./utils/output.js";
 import { outputUsageInfo } from "./utils/usage.js";
 import { splitList } from "./utils/validators.js";
 program
     .name("el-linear")
     .description("A pragmatic CLI for Linear.app — deterministic resolution, structured validation, GraphQL escape hatch.")
-    .version("1.7.0")
+    .version("1.8.1")
     .option("--api-token <token>", "Linear API token")
     .option("--profile <name>", "named profile (under ~/.config/el-linear/profiles/<name>/) for this invocation. Overrides EL_LINEAR_PROFILE env + the on-disk active-profile marker.")
     .option("--json", "output as JSON (default, accepted for compatibility)")
+    .option("--format <kind>", "output format: json (default, structured envelope) or summary (human-readable)", "json")
     .option("--raw", "strip { data, meta } wrapper from list output — emit the array directly")
     .option("--jq <filter>", "apply a jq filter to the JSON output")
     .option("--fields <fields>", "filter output to specific fields (comma-separated)")
@@ -49,6 +50,40 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
     if (rootOpts.fields) {
         setFieldsFilter(splitList(rootOpts.fields));
     }
+    // Subcommand --format wins over the global flag (commander resolves
+    // options closest to the action), so `optsWithGlobals` returns the
+    // subcommand value when one is set. We accept any of the per-command
+    // formats (table/md/csv) silently — those take a different code path
+    // inside the handler and never reach outputSuccess. The global
+    // behavior only triggers for `summary`.
+    const fmt = typeof rootOpts.format === "string"
+        ? rootOpts.format.toLowerCase()
+        : "json";
+    if (fmt === "summary") {
+        setOutputFormat("summary");
+    }
+    else if (fmt === "json") {
+        setOutputFormat("json");
+    }
+    else if (fmt === "table" ||
+        fmt === "md" ||
+        fmt === "markdown" ||
+        fmt === "csv") {
+        // Per-subcommand format: no global state change. The subcommand
+        // owns its own output path.
+        setOutputFormat("json");
+    }
+    else {
+        // Match outputSuccess's stable JSON-on-stdout shape so machine
+        // callers always get a parseable error envelope on stdout. We
+        // can't route through handleAsyncCommand here — preAction runs
+        // before the action handler.
+        const msg = `Unknown --format: "${rootOpts.format}". Use one of: json, summary` +
+            " (per-command formats table/md/csv are also accepted on issues" +
+            " list/search and projects list).";
+        process.stdout.write(`${JSON.stringify({ error: msg }, null, 2)}\n`);
+        process.exit(1);
+    }
     // `--profile <name>` is highest-priority. preAction runs BEFORE the
     // command body, which is BEFORE getApiToken / loadConfig fire — so
     // setting the override here means the rest of the run picks up the

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 {};