@enrichlayer/el-linear 1.6.0 → 1.9.0

package/dist/commands/issues/description.js

@@ -0,0 +1,187 @@
+/**
+ * Description-handling helpers for issues create/update and the
+ * `issues link-references --rewrite-description` flow.
+ *
+ * Three concerns live here:
+ *
+ *  1. Resolving the description value from `--description`,
+ *     `--description-file`, or `--template`.
+ *  2. The shared wrap-and-resolve pipeline (`wrapAndResolveRefs`)
+ *     used by the create/update path and the rewrite-description
+ *     path. Both wrap valid identifiers as markdown links and
+ *     return the resolved id→uuid map for downstream auto-link.
+ *  3. The post-create/update `maybeAutoLink` hook that creates
+ *     sidebar relations for refs in the description.
+ *
+ * Extracted from `commands/issues.ts` (ALL-938) so that file can
+ * focus on commander wiring + handlers.
+ */
+import fs from "node:fs";
+import { loadConfig } from "../../config/config.js";
+import { UPDATE_ISSUE_MUTATION } from "../../queries/issues.js";
+import { autoLinkReferences, } from "../../utils/auto-link-references.js";
+import { extractIssueReferences } from "../../utils/issue-reference-extractor.js";
+import { wrapIssueReferencesAsLinks } from "../../utils/issue-reference-wrapper.js";
+import { validateReferences } from "../../utils/validate-references.js";
+import { getWorkspaceUrlKey } from "../../utils/workspace-url.js";
+/**
+ * Read description from a file path or stdin ("-").
+ * Avoids shell escaping issues when descriptions contain special characters.
+ */
+export function readDescriptionFile(filePath) {
+    if (filePath === "-") {
+        return fs.readFileSync(0, "utf8").trim();
+    }
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Description file not found: ${filePath}`);
+    }
+    return fs.readFileSync(filePath, "utf8").trim();
+}
+/**
+ * Resolve the description from --description, --description-file, or
+ * --template (looked up in `config.descriptionTemplates`).
+ *
+ * Precedence: --description-file > --description > --template
+ *
+ * Passing --template alongside --description / --description-file is
+ * a usage error — the explicit body and a template both producing
+ * content would silently drop one. We throw so the user picks one.
+ */
+export function resolveDescription(options) {
+    const hasInline = typeof options.description === "string" && options.description.length > 0;
+    const hasFile = Boolean(options.descriptionFile);
+    const hasTemplate = typeof options.template === "string" && options.template;
+    if (hasTemplate && (hasInline || hasFile)) {
+        throw new Error("--template is mutually exclusive with --description / --description-file. " +
+            "Pick one.");
+    }
+    if (hasFile) {
+        return readDescriptionFile(options.descriptionFile);
+    }
+    if (hasInline) {
+        return options.description;
+    }
+    if (hasTemplate) {
+        const templates = loadConfig().descriptionTemplates ?? {};
+        const body = templates[options.template];
+        if (!body) {
+            const available = Object.keys(templates).sort();
+            const hint = available.length
+                ? `Available templates: ${available.join(", ")}`
+                : "No templates configured. Add one under `descriptionTemplates` in your config.";
+            throw new Error(`Template "${options.template}" not found. ${hint}`);
+        }
+        return body;
+    }
+    return undefined;
+}
+/**
+ * Shared core for the wrap-and-resolve pipeline used by both the
+ * create/update path (`prepareAutoLinkedDescription`) and the
+ * `link-references --rewrite-description` path
+ * (`prepareDescriptionRewrite`).
+ *
+ * Returns:
+ *   - `wrapped: undefined` when the original description had no
+ *     resolvable refs to wrap (no-op for the caller),
+ *   - `wrapped: <string>` when at least one ref was wrapped,
+ *   - `preResolved` — the validated id→uuid map, passed downstream
+ *     to `autoLinkReferences` to skip a second resolve roundtrip.
+ */
+async function wrapAndResolveRefs(description, selfIdentifier, linearService, graphQLService) {
+    const refs = extractIssueReferences(description, selfIdentifier);
+    if (refs.length === 0) {
+        return { wrapped: undefined, preResolved: new Map() };
+    }
+    const preResolved = await validateReferences(refs.map((r) => r.identifier), linearService);
+    if (preResolved.size === 0) {
+        return { wrapped: undefined, preResolved };
+    }
+    const validIds = new Set(preResolved.keys());
+    const urlKey = await getWorkspaceUrlKey(graphQLService);
+    const rewritten = wrapIssueReferencesAsLinks(description, validIds, urlKey);
+    return {
+        wrapped: rewritten === description ? undefined : rewritten,
+        preResolved,
+    };
+}
+/**
+ * Pre-process a description before sending to Linear:
+ *  1. Extract all issue references.
+ *  2. Validate them (drop ones that don't resolve in the workspace —
+ *     handles "ISO-1424"-style false positives).
+ *  3. Wrap valid identifiers as markdown links — skipping any
+ *     already inside a link, code block, or backtick span.
+ *
+ * No-ops (returns the original description with an empty map) when:
+ *  - description is empty/undefined
+ *  - the user passed `--no-auto-link`
+ */
+export async function prepareAutoLinkedDescription(description, options, selfIdentifier, linearService, graphQLService) {
+    if (!description || options.autoLink === false) {
+        return { description, preResolved: new Map(), rewritten: false };
+    }
+    const { wrapped, preResolved } = await wrapAndResolveRefs(description, selfIdentifier, linearService, graphQLService);
+    return {
+        description: wrapped ?? description,
+        preResolved,
+        rewritten: wrapped !== undefined,
+    };
+}
+/**
+ * Prepare a description rewrite for `link-references --rewrite-description`.
+ * Same wrap-and-resolve core; different return shape so the caller can
+ * skip the rewrite mutation when nothing would change.
+ */
+export async function prepareDescriptionRewrite(description, selfIdentifier, linearService, graphQLService) {
+    if (!description) {
+        return { preResolved: undefined, wrapped: undefined };
+    }
+    const { wrapped, preResolved } = await wrapAndResolveRefs(description, selfIdentifier, linearService, graphQLService);
+    return {
+        // `link-references --rewrite-description` historically used
+        // `preResolved: undefined` to mean "no refs at all"; preserve
+        // that signal so the existing call site keeps the same shape.
+        preResolved: preResolved.size === 0 ? undefined : preResolved,
+        wrapped,
+    };
+}
+export async function pushDescriptionUpdate(issueUuid, description, graphQLService) {
+    const updateResult = await graphQLService.rawRequest(UPDATE_ISSUE_MUTATION, {
+        id: issueUuid,
+        input: { description },
+    });
+    const mutation = updateResult.issueUpdate;
+    if (!mutation?.success) {
+        throw new Error("Failed to rewrite description");
+    }
+}
+/**
+ * Run auto-linking for issue references found in a description, unless
+ * the user opted out with `--no-auto-link` or no description was
+ * provided. Returns undefined when nothing was linked / skipped /
+ * failed (so callers can omit the field from JSON output).
+ */
+export async function maybeAutoLink(input) {
+    const { issueId, identifier, description, options, graphQLService, linearService, preResolved, } = input;
+    if (options.autoLink === false) {
+        return;
+    }
+    if (!description) {
+        return;
+    }
+    const result = await autoLinkReferences({
+        issueId,
+        identifier,
+        description,
+        graphQLService,
+        linearService,
+        preResolved,
+    });
+    if (result.linked.length === 0 &&
+        result.skipped.length === 0 &&
+        result.failed.length === 0) {
+        return;
+    }
+    return result;
+}

package/dist/commands/issues.js

@@ -1,29 +1,26 @@
 import { execFileSync } from "node:child_process";
-import fs from "node:fs";
 import { loadConfig } from "../config/config.js";
 import { enforceValidation, validateIssueCreation, } from "../config/issue-validation.js";
 import { resolveAssignee, resolveLabels, resolveMember, resolveTeam, } from "../config/resolver.js";
 import { resolveDefaultStatus } from "../config/status-defaults.js";
 import { enforceTerms } from "../config/term-enforcer.js";
 import { LIST_COMMENTS_QUERY } from "../queries/comments.js";
-import { GET_ISSUE_RELATIONS_QUERY, GET_ISSUE_STATE_HISTORY_QUERY, ISSUE_RELATION_CREATE_MUTATION, SCAN_ISSUES_QUERY, UPDATE_ISSUE_MUTATION, } from "../queries/issues.js";
+import { GET_ISSUE_RELATIONS_QUERY, GET_ISSUE_STATE_HISTORY_QUERY, ISSUE_RELATION_CREATE_MUTATION, SCAN_ISSUES_QUERY, } from "../queries/issues.js";
 import { autoLinkReferences, } from "../utils/auto-link-references.js";
-import { downloadLinearUploads } from "../utils/download-uploads.js";
 import { createFileService } from "../utils/file-service.js";
 import { applyFooter } from "../utils/footer.js";
 import { createGraphQLAttachmentsService } from "../utils/graphql-attachments-service.js";
-import { GraphQLIssuesService } from "../utils/graphql-issues-service.js";
+import { GraphQLIssuesService, } from "../utils/graphql-issues-service.js";
 import { createGraphQLService, } from "../utils/graphql-service.js";
-import { extractIssueReferences } from "../utils/issue-reference-extractor.js";
-import { wrapIssueReferencesAsLinks } from "../utils/issue-reference-wrapper.js";
 import { createLinearService, } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { formatCsv, formatMarkdown, formatTable, } from "../utils/table-formatter.js";
-import { validateReferences } from "../utils/validate-references.js";
 import { parsePriorityFilter, splitList, validatePriority, } from "../utils/validators.js";
-import { getWorkspaceUrlKey } from "../utils/workspace-url.js";
+import { gitCheckoutBranch, toBranchName } from "./issues/branch.js";
+import { maybeAutoLink, prepareAutoLinkedDescription, prepareDescriptionRewrite, pushDescriptionUpdate, readDescriptionFile, resolveDescription, } from "./issues/description.js";
+import { readIssues } from "./read-shortcut.js";
 const IMAGE_EXTENSIONS = new Set([
     ".png",
     ".jpg",
@@ -33,90 +30,7 @@ const IMAGE_EXTENSIONS = new Set([
     ".svg",
     ".ico",
 ]);
-const LINEAR_BRANCH_REGEX = /^([a-zA-Z]+)-(\d+)-(.+)$/;
 const COMMIT_HASH_PREFIX_REGEX = /^[a-f0-9]+ /;
-/**
- * Transform Linear's branchName (e.g. "dev-3549-slug") into our convention:
- * "feature/DEV-3549-slug" — uppercase team key with a configurable prefix.
- */
-function toBranchName(linearBranchName, prefix = "feature/") {
-    // Linear branch names look like "dev-123-some-slug"
-    // We need to uppercase the team key: "DEV-123-some-slug"
-    const match = linearBranchName.match(LINEAR_BRANCH_REGEX);
-    if (!match) {
-        return `${prefix}${linearBranchName}`;
-    }
-    const [, teamKey, number, slug] = match;
-    return `${prefix}${teamKey.toUpperCase()}-${number}-${slug}`;
-}
-/**
- * Check out a new git branch. Warns and skips if not in a git repo.
- * Throws if the branch already exists.
- */
-function gitCheckoutBranch(branchName) {
-    try {
-        execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
-            stdio: "pipe",
-        });
-    }
-    catch {
-        outputWarning("Not inside a git repository — skipping branch checkout.");
-        return;
-    }
-    execFileSync("git", ["checkout", "-b", branchName], { stdio: "pipe" });
-}
-/**
- * Read description from a file path or stdin ("-").
- * Avoids shell escaping issues when descriptions contain special characters.
- */
-function readDescriptionFile(filePath) {
-    if (filePath === "-") {
-        return fs.readFileSync(0, "utf8").trim();
-    }
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`Description file not found: ${filePath}`);
-    }
-    return fs.readFileSync(filePath, "utf8").trim();
-}
-/**
- * Resolve the description from --description, --description-file, or
- * --template (looked up in `config.descriptionTemplates`).
- *
- * Precedence:
- *   --description-file > --description > --template
- *
- * Passing --template alongside --description or --description-file is a
- * usage error — the explicit body and a template both producing content
- * would be silently dropping one. We throw so the user picks one.
- */
-function resolveDescription(options) {
-    const hasInline = typeof options.description === "string" && options.description.length > 0;
-    const hasFile = Boolean(options.descriptionFile);
-    const hasTemplate = typeof options.template === "string" && options.template;
-    if (hasTemplate && (hasInline || hasFile)) {
-        throw new Error("--template is mutually exclusive with --description / --description-file. " +
-            "Pick one.");
-    }
-    if (hasFile) {
-        return readDescriptionFile(options.descriptionFile);
-    }
-    if (hasInline) {
-        return options.description;
-    }
-    if (hasTemplate) {
-        const templates = loadConfig().descriptionTemplates ?? {};
-        const body = templates[options.template];
-        if (!body) {
-            const available = Object.keys(templates).sort();
-            const hint = available.length
-                ? `Available templates: ${available.join(", ")}`
-                : "No templates configured. Add one under `descriptionTemplates` in your config.";
-            throw new Error(`Template "${options.template}" not found. ${hint}`);
-        }
-        return body;
-    }
-    return undefined;
-}
 function isImageFile(filename) {
     const ext = filename.lastIndexOf(".");
     return ext !== -1 && IMAGE_EXTENSIONS.has(filename.slice(ext).toLowerCase());
@@ -168,67 +82,6 @@ async function createRelations(sourceId, options, graphQLService, linearService)
     }
     return relations;
 }
-/**
- * Pre-process a description before sending to Linear:
- * 1. Extract all issue references from the description.
- * 2. Validate them (drop those that don't resolve in this workspace — handles "ISO-1424"-style false positives).
- * 3. Wrap valid identifiers as markdown links — skipping any already inside a link, code block, or backtick span.
- *
- * Returns the rewritten description plus the validated map for downstream auto-linking.
- *
- * No-ops (returns the original description with an empty map) when:
- * - description is empty/undefined
- * - the user passed `--no-auto-link`
- */
-async function prepareAutoLinkedDescription(description, options, selfIdentifier, linearService, graphQLService) {
-    if (!description || options.autoLink === false) {
-        return { description, preResolved: new Map(), rewritten: false };
-    }
-    const refs = extractIssueReferences(description, selfIdentifier);
-    if (refs.length === 0) {
-        return { description, preResolved: new Map(), rewritten: false };
-    }
-    const preResolved = await validateReferences(refs.map((r) => r.identifier), linearService);
-    if (preResolved.size === 0) {
-        return { description, preResolved, rewritten: false };
-    }
-    const validIds = new Set(preResolved.keys());
-    const urlKey = await getWorkspaceUrlKey(graphQLService);
-    const wrapped = wrapIssueReferencesAsLinks(description, validIds, urlKey);
-    return {
-        description: wrapped,
-        preResolved,
-        rewritten: wrapped !== description,
-    };
-}
-/**
- * Run auto-linking for issue references found in a description, unless the user opted out
- * with --no-auto-link or no description was provided. Returns undefined when nothing was linked
- * and nothing was skipped/failed (so callers can omit the field from JSON output).
- */
-async function maybeAutoLink(input) {
-    const { issueId, identifier, description, options, graphQLService, linearService, preResolved, } = input;
-    if (options.autoLink === false) {
-        return;
-    }
-    if (!description) {
-        return;
-    }
-    const result = await autoLinkReferences({
-        issueId,
-        identifier,
-        description,
-        graphQLService,
-        linearService,
-        preResolved,
-    });
-    if (result.linked.length === 0 &&
-        result.skipped.length === 0 &&
-        result.failed.length === 0) {
-        return;
-    }
-    return result;
-}
 function validateUpdateOptions(options) {
     if (options.parentTicket && options.clearParentTicket) {
         throw new Error("Cannot use --parent-ticket and --clear-parent-ticket together");
@@ -263,12 +116,20 @@ function buildUpdateArgs(issueId, options, assigneeId) {
     else if (options.labels) {
         labelIds = splitList(options.labels);
     }
+    // On update, fall back to config.defaultPriority only when --priority
+    // wasn't passed. This keeps every update setting a priority for users who
+    // want a workspace-wide baseline (e.g. all unassigned triage tickets bump
+    // to "medium"). To leave priority untouched, omit defaultPriority from
+    // config — the field is opt-in.
+    const priorityInput = typeof options.priority === "string"
+        ? options.priority
+        : loadConfig().defaultPriority;
     return {
         id: issueId,
         title: options.title,
         description: options.description,
         statusId: options.status,
-        priority: options.priority ? validatePriority(options.priority) : undefined,
+        priority: priorityInput ? validatePriority(priorityInput) : undefined,
         assigneeId,
         projectId: options.project,
         labelIds,
@@ -392,17 +253,38 @@ async function handleSearchIssues(query, options, command) {
 async function resolveCreateInputs(title, options, rootOpts) {
     const config = loadConfig();
     enforceTerms([title, options.description], { strict: options.strict });
+    // Effective assignee: explicit --assignee wins; --no-assignee (commander
+    // parses as `assignee === false`) skips both flag and config; otherwise
+    // fall back to config.defaultAssignee. Computed BEFORE validation so the
+    // "assignee required" rule sees the resolved value, not undefined.
+    const noAssignee = options.assignee === false;
+    const explicitAssignee = typeof options.assignee === "string" ? options.assignee : undefined;
+    const effectiveAssignee = noAssignee
+        ? undefined
+        : (explicitAssignee ?? config.defaultAssignee);
+    // Effective priority: explicit --priority wins; otherwise fall back to
+    // config.defaultPriority. Both go through validatePriority so a bad config
+    // value fails fast with a useful error.
+    const effectivePriorityInput = typeof options.priority === "string"
+        ? options.priority
+        : config.defaultPriority;
     // --- Validation (labels, description, assignee, project, title) ---
     // Controlled by config.validation.enabled (default: true).
-    // Bypassed by --skip-validation flag.
-    if (!options.skipValidation) {
+    // Bypassed by --skip-validation flag, OR by --from-template which
+    // defers field provision to Linear's server-side template
+    // instantiation. With --from-template + no overrides, the
+    // resulting issue inherits title/description/labels/etc. from the
+    // template — running the local validator against undefined fields
+    // would produce a false-negative "Missing --labels" error.
+    const hasFromTemplate = typeof options.fromTemplate === "string" && options.fromTemplate;
+    if (!options.skipValidation && !hasFromTemplate) {
         const rawLabels = options.labels ? splitList(options.labels) : null;
         const description = resolveDescription(options);
         const validationResult = validateIssueCreation({
             labels: rawLabels,
             description: description || undefined,
             title,
-            assignee: options.assignee,
+            assignee: effectiveAssignee,
             project: options.project,
         });
         // Apply normalized labels back so resolution uses the canonical names
@@ -411,13 +293,13 @@ async function resolveCreateInputs(title, options, rootOpts) {
         }
         enforceValidation(validationResult);
     }
-    if (!options.priority) {
-        outputWarning("Creating issue without --priority. Consider specifying it for better triage.", "missing_fields");
+    if (!effectivePriorityInput) {
+        outputWarning("Creating issue without --priority. Consider specifying it for better triage.");
     }
     const teamInput = options.team || config.defaultTeam;
     const teamId = resolveTeam(teamInput);
-    const assigneeId = options.assignee
-        ? await resolveAssignee(options.assignee, rootOpts)
+    const assigneeId = effectiveAssignee
+        ? await resolveAssignee(effectiveAssignee, rootOpts)
         : undefined;
     let labelIds = [];
     if (options.labels) {
@@ -438,7 +320,18 @@ async function resolveCreateInputs(title, options, rootOpts) {
     if (options.subscriber) {
         subscriberIds = splitList(options.subscriber).map((s) => resolveMember(s));
     }
-    return { teamInput, teamId, assigneeId, labelIds, status, subscriberIds };
+    const priority = effectivePriorityInput
+        ? validatePriority(effectivePriorityInput)
+        : undefined;
+    return {
+        teamInput,
+        teamId,
+        assigneeId,
+        labelIds,
+        status,
+        subscriberIds,
+        priority,
+    };
 }
 async function uploadAttachmentsIfNeeded(options, rootOpts) {
     if (!options.attachment) {
@@ -472,7 +365,7 @@ function buildDescriptionWithAttachments(baseDescription, uploadResults) {
 }
 async function handleCreateIssue(title, options, command) {
     const rootOpts = getRootOpts(command);
-    const { teamInput, teamId, assigneeId, labelIds, status, subscriberIds } = await resolveCreateInputs(title, options, rootOpts);
+    const { teamInput, teamId, assigneeId, labelIds, status, subscriberIds, priority, } = await resolveCreateInputs(title ?? "", options, rootOpts);
     const uploadResults = await uploadAttachmentsIfNeeded(options, rootOpts);
     const descriptionWithAttachments = buildDescriptionWithAttachments(resolveDescription(options) || "", uploadResults);
     // Append messageFooter (config or --footer flag) so auto-link picks up any
@@ -492,12 +385,14 @@ async function handleCreateIssue(title, options, command) {
     // because the issue doesn't exist yet — pass undefined.
     const prepared = await prepareAutoLinkedDescription(description || undefined, options, undefined, linearService, graphQLService);
     const result = await issuesService.createIssue({
-        title,
+        // title is omitted when --from-template is set without an override,
+        // so Linear copies the template's title server-side.
+        ...(title ? { title } : {}),
         teamId,
         teamInput,
         description: prepared.description,
         assigneeId,
-        priority: options.priority ? validatePriority(options.priority) : undefined,
+        priority,
         projectId: options.project,
         statusId: status,
         labelIds: labelIds.length > 0 ? labelIds : undefined,
@@ -506,6 +401,12 @@ async function handleCreateIssue(title, options, command) {
         cycleId: options.cycle,
         subscriberIds,
         dueDate: options.dueDate,
+        // Linear server-side template instantiation. When set,
+        // Linear copies the template's title/description/labels/priority
+        // onto the new issue; any explicit field above wins by override.
+        ...(typeof options.fromTemplate === "string" && options.fromTemplate
+            ? { templateId: options.fromTemplate }
+            : {}),
     });
     const relations = await createRelations(result.id, options, graphQLService, linearService);
     // Pass the ORIGINAL description (pre-wrap) so the extractor's prose-keyword inference
@@ -710,40 +611,6 @@ async function linkReferencesForIssue(args) {
         preResolved: args.preResolved,
     });
 }
-/**
- * Prepare a description rewrite: validate refs, wrap valid IDs as markdown links,
- * and return the rewritten text (or undefined if nothing would change).
- */
-async function prepareDescriptionRewrite(description, selfIdentifier, linearService, graphQLService) {
-    if (!description) {
-        return { preResolved: undefined, wrapped: undefined };
-    }
-    const refs = extractIssueReferences(description, selfIdentifier);
-    if (refs.length === 0) {
-        return { preResolved: undefined, wrapped: undefined };
-    }
-    const preResolved = await validateReferences(refs.map((r) => r.identifier), linearService);
-    if (preResolved.size === 0) {
-        return { preResolved, wrapped: undefined };
-    }
-    const validIds = new Set(preResolved.keys());
-    const urlKey = await getWorkspaceUrlKey(graphQLService);
-    const wrapped = wrapIssueReferencesAsLinks(description, validIds, urlKey);
-    return {
-        preResolved,
-        wrapped: wrapped === description ? undefined : wrapped,
-    };
-}
-async function pushDescriptionUpdate(issueUuid, description, graphQLService) {
-    const updateResult = await graphQLService.rawRequest(UPDATE_ISSUE_MUTATION, {
-        id: issueUuid,
-        input: { description },
-    });
-    const mutation = updateResult.issueUpdate;
-    if (!mutation?.success) {
-        throw new Error("Failed to rewrite description");
-    }
-}
 async function handleLinkReferencesSingle(issueId, options, graphQLService, linearService) {
     const resolvedId = await linearService.resolveIssueId(issueId);
     // GET_ISSUE_RELATIONS_QUERY also returns description, so this single call gives us everything
@@ -869,25 +736,6 @@ async function handleLinkReferencesIssue(issueIdOrTeamFlag, options, command) {
     }
     return handleLinkReferencesSingle(issueIdOrTeamFlag, options, graphQLService, linearService);
 }
-async function handleReadIssue(issueIds, _options, command) {
-    const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
-    const fileService = await createFileService(rootOpts);
-    if (issueIds.length === 1) {
-        const issue = await issuesService.getIssueById(issueIds[0]);
-        const resolved = await downloadLinearUploads(issue, fileService);
-        outputSuccess(resolved);
-    }
-    else {
-        const results = await Promise.all(issueIds.map(async (id) => {
-            const issue = await issuesService.getIssueById(id);
-            return downloadLinearUploads(issue, fileService);
-        }));
-        outputSuccess(results);
-    }
-}
 async function handleUpdateIssue(issueId, options, command) {
     // Normalize aliases
     if (options.state && !options.status) {
@@ -1048,7 +896,7 @@ export function setupIssuesCommands(program) {
         .option("--status <status>", "filter by status (comma-separated, e.g. Todo,Backlog)")
         .option("--priority <priority>", "filter by priority (comma-separated: urgent,high,medium,low,none or 0-4)")
         .option("--sort <field>", "sort results (priority, status, created, updated)")
-        .option("--format <format>", "output format (json, table, md, csv)", "json")
+        .option("--format <format>", "output format (json, summary, table, md, csv)", "json")
         .option("--fields <fields>", "columns for table/csv (comma-separated: identifier,title,status,priority,assignee,project,team,labels,updated)")
         .action(handleAsyncCommand(handleListIssues));
     issues
@@ -1063,7 +911,7 @@ export function setupIssuesCommands(program) {
         .option("--label <labels>", "alias for --labels")
         .option("--priority <priority>", "filter by priority (comma-separated: urgent,high,medium,low,none or 0-4)")
         .option("--sort <field>", "sort results (priority, status, created, updated)")
-        .option("--format <format>", "output format (json, table, md, csv)", "json")
+        .option("--format <format>", "output format (json, summary, table, md, csv)", "json")
         .option("--fields <fields>", "columns for table/csv output")
         .option("-l, --limit <number>", "limit results", "10")
         .action(handleAsyncCommand(handleSearchIssues));
@@ -1074,7 +922,9 @@ export function setupIssuesCommands(program) {
         .option("-d, --description <desc>", "issue description")
         .option("--description-file <path>", "read description from file (use - for stdin)")
         .option("--template <name>", "use a named description template from config.descriptionTemplates")
+        .option("--from-template <id>", "instantiate the issue from a Linear server-side template (UUID from `el-linear templates list`). Sets templateId on the underlying issueCreate mutation; Linear copies the template's title, description, labels, priority, etc. as the new issue's defaults. Override any field with the matching --title / --description / --labels flag.")
         .option("-a, --assignee <assignee>", "assign to user (name, alias, or UUID)")
+        .option("--no-assignee", "create unassigned even when config.defaultAssignee is set")
         .option("-p, --priority <priority>", "priority: name (none/urgent/high/medium/normal/low) or number (0-4)")
         .option("--project <project>", "add to project (name or ID)")
         .option("--team <team>", "team key or name (default: from config)")
@@ -1103,8 +953,12 @@ export function setupIssuesCommands(program) {
             options.labels = options.label;
         }
         const title = options.title || titleArg;
-        if (!title) {
-            throw new Error("Title is required. Provide it as a positional argument or with --title.");
+        // --from-template lets Linear copy the template's title, so a
+        // local title is optional in that path. Without --from-template,
+        // the create mutation requires a title up front.
+        const fromTemplate = typeof options.fromTemplate === "string" && options.fromTemplate;
+        if (!title && !fromTemplate) {
+            throw new Error("Title is required. Provide it as a positional argument, with --title, or use --from-template to copy the template's title.");
         }
         return handleCreateIssue(title, options, command);
     }));
@@ -1115,7 +969,7 @@ export function setupIssuesCommands(program) {
         .alias("show")
         .description("Get issue details. Accepts multiple IDs for batch retrieval.")
         .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.\nMultiple IDs: el-linear issue get DEV-123 DEV-456 DEV-789")
-        .action(handleAsyncCommand(handleReadIssue));
+        .action(handleAsyncCommand(readIssues));
     issues
         .command("update <issueId>")
         .alias("edit")

package/dist/commands/labels.js

@@ -1,5 +1,7 @@
+import { loadConfig } from "../config/config.js";
 import { resolveTeam } from "../config/resolver.js";
 import { CREATE_LABEL_MUTATION, FIND_PARENT_LABEL_QUERY, RESTORE_LABEL_MUTATION, RETIRE_LABEL_MUTATION, } from "../queries/labels.js";
+import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
@@ -71,12 +73,25 @@ export function setupLabelsCommands(program) {
         .command("list")
         .description("List all available labels")
         .option("--team <team>", "filter by team key, name, or ID")
+        .option("--name <substring>", "filter by case-insensitive substring on label name")
         .option("-l, --limit <number>", "limit results", "100")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
         const teamFilter = options.team ? resolveTeam(options.team) : undefined;
-        const service = await createLinearService(rootOpts);
-        const result = await service.getLabels(teamFilter, Number.parseInt(options.limit, 10));
+        const nameFilter = options.name;
+        const limit = Number.parseInt(options.limit, 10);
+        const ttl = resolveCacheTTL({
+            configTTL: loadConfig().cacheTTLSeconds,
+            noCacheFlag: rootOpts.cache === false,
+        });
+        // Cache key includes the team filter and name filter so different
+        // filter combinations don't collide. Same `limit` participates
+        // because a smaller list isn't a valid cached answer for a larger ask.
+        const cacheKey = `labels-list-team:${teamFilter ?? "_all"}-name:${nameFilter ?? "_all"}-limit:${limit}`;
+        const result = await cached(cacheKey, ttl, async () => {
+            const service = await createLinearService(rootOpts);
+            return service.getLabels(teamFilter, limit, nameFilter);
+        });
         outputSuccess({
             data: result.labels,
             meta: { count: result.labels.length },