@enrichlayer/el-linear 1.6.0 → 1.9.0

package/dist/commands/profile/migrate-legacy.js

@@ -38,7 +38,8 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { confirm, input, password } from "@inquirer/prompts";
-import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, PROFILES_DIR, profilePaths, TOKEN_PATH, } from "../../config/paths.js";
+import { atomicWrite } from "../../auth/oauth-fs.js";
+import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, isSafeProfileName as isSafeName, PROFILES_DIR, profilePaths, TOKEN_PATH, } from "../../config/paths.js";
 import { sanitizeForLog, validateToken } from "../init/token.js";
 const DEFAULT_PROMPTS = { input, password, confirm };
 /** Register `el-linear profile migrate-legacy` under the parent `profile` command. */
@@ -165,10 +166,7 @@ async function resolveAndValidateToken(options, prompts, validate) {
 async function copyConfigIntoProfile(destConfigPath, options, prompts) {
     const sourceContent = await fsp.readFile(CONFIG_PATH, "utf8");
     if (!(await pathExists(destConfigPath))) {
-        await fsp.writeFile(destConfigPath, sourceContent, {
-            mode: 0o644,
-            encoding: "utf8",
-        });
+        await atomicWrite(destConfigPath, sourceContent, 0o644);
         return;
     }
     const destContent = await fsp.readFile(destConfigPath, "utf8");
@@ -192,21 +190,15 @@ async function copyConfigIntoProfile(destConfigPath, options, prompts) {
             throw new Error("Aborted by user.");
         }
     }
-    await fsp.writeFile(destConfigPath, sourceContent, {
-        mode: 0o644,
-        encoding: "utf8",
-    });
+    await atomicWrite(destConfigPath, sourceContent, 0o644);
 }
 async function writeProfileToken(destTokenPath, token, options, prompts) {
     const newline = `${token}\n`;
     if (!(await pathExists(destTokenPath))) {
-        await fsp.writeFile(destTokenPath, newline, {
-            mode: 0o600,
-            encoding: "utf8",
-        });
-        // fs.writeFile mode is only honored on file creation; chmod defensively
-        // in case a parent process pre-created the file with permissive perms.
-        await fsp.chmod(destTokenPath, 0o600);
+        // atomicWrite creates the tmp file with the requested mode and
+        // renames into place, so there is no window where the token is
+        // readable at a looser mode than 0o600.
+        await atomicWrite(destTokenPath, newline, 0o600);
         return;
     }
     const existing = (await fsp.readFile(destTokenPath, "utf8")).trim();
@@ -230,11 +222,7 @@ async function writeProfileToken(destTokenPath, token, options, prompts) {
             throw new Error("Aborted by user.");
         }
     }
-    await fsp.writeFile(destTokenPath, newline, {
-        mode: 0o600,
-        encoding: "utf8",
-    });
-    await fsp.chmod(destTokenPath, 0o600);
+    await atomicWrite(destTokenPath, newline, 0o600);
 }
 async function ensureActiveProfile(name) {
     await fsp.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
@@ -244,10 +232,7 @@ async function ensureActiveProfile(name) {
     }
     if (current === name)
         return;
-    await fsp.writeFile(ACTIVE_PROFILE_FILE, `${name}\n`, {
-        mode: 0o644,
-        encoding: "utf8",
-    });
+    await atomicWrite(ACTIVE_PROFILE_FILE, `${name}\n`, 0o644);
 }
 async function pathExists(p) {
     try {
@@ -258,14 +243,6 @@ async function pathExists(p) {
         return false;
     }
 }
-/**
- * Profile names land in filesystem paths and the active-profile marker.
- * Same conservative charset as `profile add` to avoid `..` traversal,
- * shell metacharacters, and Unicode lookalikes.
- */
-function isSafeName(name) {
-    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name);
-}
 // Re-export internals so the integration test (and follow-up commands)
 // can compose them without re-implementing the idempotency rules.
 export { CONFIG_PATH, PROFILES_DIR, TOKEN_PATH };

package/dist/commands/profile.js

@@ -23,7 +23,7 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { confirm } from "@inquirer/prompts";
-import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, PROFILES_DIR, profilePaths, resolveActiveProfile, setActiveProfileForSession, TOKEN_PATH, } from "../config/paths.js";
+import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, isSafeProfileName as isSafeName, PROFILES_DIR, profilePaths, resolveActiveProfile, setActiveProfileForSession, TOKEN_PATH, } from "../config/paths.js";
 import { outputSuccess, outputWarning } from "../utils/output.js";
 import { runFullWizard } from "./init/index.js";
 import { registerMigrateLegacy } from "./profile/migrate-legacy.js";
@@ -180,12 +180,3 @@ async function pathExists(p) {
         return false;
     }
 }
-/**
- * Profile names land in filesystem paths AND get written to a
- * single-line marker. Restrict to a conservative charset so we can't
- * accidentally pick up `..` traversal, command-line metacharacters, or
- * Unicode lookalikes that would confuse `profile use`.
- */
-function isSafeName(name) {
-    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name);
-}

package/dist/commands/projects.d.ts

@@ -1,2 +1,6 @@
-import type { Command } from "commander";
+import type { Command, OptionValues } from "commander";
+export declare function resolveProjectStateFilter(options: OptionValues): {
+    states?: string[];
+    excludeStates?: string[];
+};
 export declare function setupProjectsCommands(program: Command): void;

package/dist/commands/projects.js

@@ -1,78 +1,135 @@
+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 { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
 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";
-function formatProjectsOutput(projects, format, fieldNames) {
-    const fields = fieldNames ?? [
-        "name",
-        "state",
-        "progress",
-        "teams",
-        "lead",
-        "targetDate",
-    ];
-    const rows = projects.map((p) => {
-        const row = {};
-        for (const f of fields) {
-            switch (f) {
-                case "name":
-                    row[f] = p.name;
-                    break;
-                case "state":
-                    row[f] = p.state ?? "";
-                    break;
-                case "progress":
-                    row[f] =
-                        p.progress !== undefined ? `${Math.round(p.progress * 100)}%` : "";
-                    break;
-                case "teams":
-                    row[f] = p.teams?.map((t) => t.key).join(", ") ?? "";
-                    break;
-                case "lead":
-                    row[f] = p.lead?.name ?? "";
-                    break;
-                case "targetDate":
-                    row[f] = p.targetDate ?? "";
-                    break;
-                case "id":
-                    row[f] = p.id;
-                    break;
-                default:
-                    row[f] = String(p[f] ?? "");
-            }
+const VALID_PROJECT_STATES = new Set([
+    "backlog",
+    "planned",
+    "started",
+    "paused",
+    "completed",
+    "canceled",
+]);
+function parseStateList(value, flagName) {
+    const states = splitList(value).map((s) => s.toLowerCase());
+    for (const s of states) {
+        if (!VALID_PROJECT_STATES.has(s)) {
+            throw new Error(`Invalid state "${s}" for ${flagName}. Valid: ${[...VALID_PROJECT_STATES].join(", ")}.`);
         }
-        return row;
-    });
+    }
+    return states;
+}
+export function resolveProjectStateFilter(options) {
+    const flags = [options.state, options.excludeState, options.active].filter(Boolean).length;
+    if (flags > 1) {
+        throw new Error("--state, --exclude-state, and --active are mutually exclusive.");
+    }
+    if (options.active) {
+        return { excludeStates: ["completed", "canceled"] };
+    }
+    if (options.state) {
+        return { states: parseStateList(options.state, "--state") };
+    }
+    if (options.excludeState) {
+        return {
+            excludeStates: parseStateList(options.excludeState, "--exclude-state"),
+        };
+    }
+    return {};
+}
+// ── Project column definitions ────────────────────────────────
+//
+// Pre-fix this file inlined an 80-line `formatProjectsOutput`
+// function that hand-rolled column width math, table padding, CSV
+// quoting, and markdown pipe syntax — all duplicating
+// `utils/table-formatter.ts`. Now we declare `ColumnDef<LinearProject>`
+// arrays and let the shared renderers do the work. ALL-938 cleanup.
+const PROJECT_COLUMNS = {
+    name: { key: "name", header: "Name", width: 32, extract: (p) => p.name },
+    state: {
+        key: "state",
+        header: "State",
+        width: 10,
+        extract: (p) => p.state ?? "",
+    },
+    progress: {
+        key: "progress",
+        header: "Progress",
+        width: 10,
+        extract: (p) => p.progress !== undefined ? `${Math.round(p.progress * 100)}%` : "",
+    },
+    teams: {
+        key: "teams",
+        header: "Teams",
+        width: 18,
+        extract: (p) => p.teams?.map((t) => t.key).join(", ") ?? "",
+    },
+    lead: {
+        key: "lead",
+        header: "Lead",
+        width: 18,
+        extract: (p) => p.lead?.name ?? "",
+    },
+    targetDate: {
+        key: "targetDate",
+        header: "Target",
+        width: 12,
+        extract: (p) => p.targetDate ?? "",
+    },
+    id: { key: "id", header: "ID", width: 38, extract: (p) => p.id },
+};
+const PROJECT_MD_COLUMNS = {
+    name: { header: "Name", extract: (p) => p.name },
+    state: { header: "State", extract: (p) => p.state ?? "" },
+    progress: {
+        header: "Progress",
+        extract: (p) => p.progress !== undefined ? `${Math.round(p.progress * 100)}%` : "",
+    },
+    teams: {
+        header: "Teams",
+        extract: (p) => p.teams?.map((t) => t.key).join(", ") ?? "",
+    },
+    lead: { header: "Lead", extract: (p) => p.lead?.name ?? "" },
+    targetDate: { header: "Target", extract: (p) => p.targetDate ?? "" },
+    id: { header: "ID", extract: (p) => p.id },
+};
+const DEFAULT_PROJECT_COLUMNS = [
+    "name",
+    "state",
+    "progress",
+    "teams",
+    "lead",
+    "targetDate",
+];
+function formatProjectsOutput(projects, format, fieldNames) {
+    const keys = fieldNames ?? DEFAULT_PROJECT_COLUMNS;
     if (format === "csv") {
-        logger.info(fields.join(","));
-        for (const row of rows) {
-            logger.info(fields.map((f) => `"${(row[f] ?? "").replace(/"/g, '""')}"`).join(","));
-        }
+        const columns = keys
+            .map((k) => PROJECT_COLUMNS[k])
+            .filter((c) => c !== undefined);
+        logger.info(renderCsv(projects, columns));
         return;
     }
-    // table and md formats
-    const widths = fields.map((f) => Math.max(f.length, ...rows.map((r) => (r[f] ?? "").length)));
-    const separator = format === "md"
-        ? `| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`
-        : widths.map((w) => "-".repeat(w + 2)).join("+");
-    const header = format === "md"
-        ? `| ${fields.map((f, i) => f.padEnd(widths[i])).join(" | ")} |`
-        : fields.map((f, i) => ` ${f.padEnd(widths[i])} `).join("|");
-    logger.info(header);
-    logger.info(separator);
-    for (const row of rows) {
-        const line = format === "md"
-            ? `| ${fields.map((f, i) => (row[f] ?? "").padEnd(widths[i])).join(" | ")} |`
-            : fields
-                .map((f, i) => ` ${(row[f] ?? "").padEnd(widths[i])} `)
-                .join("|");
-        logger.info(line);
+    if (format === "md") {
+        const columns = keys
+            .map((k) => PROJECT_MD_COLUMNS[k])
+            .filter((c) => c !== undefined);
+        logger.info(renderMarkdownTable(projects, columns));
+        return;
     }
+    // Default: fixed-width text table.
+    const columns = keys
+        .map((k) => PROJECT_COLUMNS[k])
+        .filter((c) => c !== undefined);
+    logger.info(renderFixedWidthTable(projects, columns));
 }
 async function resolveProjectWithTeams(graphQLService, projectNameOrId) {
     if (isUuid(projectNameOrId)) {
@@ -301,12 +358,35 @@ export function setupProjectsCommands(program) {
         .command("list")
         .description("List projects")
         .option("-l, --limit <number>", "limit results", "100")
-        .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: name,state,progress,teams,lead,targetDate)")
+        .option("--name <substring>", "filter by case-insensitive substring on project name")
+        .option("--state <names>", "include only projects in these states (comma-separated: backlog, planned, started, paused, completed, canceled)")
+        .option("--exclude-state <names>", "exclude projects in these states (comma-separated). Mutually exclusive with --state.")
+        .option("--active", "shorthand for --exclude-state completed,canceled (mutually exclusive with --state / --exclude-state)")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
-        const service = await createLinearService(rootOpts);
-        const result = await service.getProjects(Number.parseInt(options.limit, 10));
+        const limit = Number.parseInt(options.limit, 10);
+        const nameFilter = options.name;
+        const stateFilter = resolveProjectStateFilter(options);
+        const ttl = resolveCacheTTL({
+            configTTL: loadConfig().cacheTTLSeconds,
+            noCacheFlag: rootOpts.cache === false,
+        });
+        // Cache key includes filter inputs so different filter combinations
+        // don't collide.
+        const cacheKey = `projects-list-limit:${limit}` +
+            `-name:${nameFilter ?? "_all"}` +
+            `-states:${stateFilter.states?.join(",") ?? "_any"}` +
+            `-excl:${stateFilter.excludeStates?.join(",") ?? "_none"}`;
+        const result = await cached(cacheKey, ttl, async () => {
+            const service = await createLinearService(rootOpts);
+            return service.getProjects(limit, {
+                nameFilter,
+                states: stateFilter.states,
+                excludeStates: stateFilter.excludeStates,
+            });
+        });
         const format = options.format;
         if (format === "table" ||
             format === "md" ||

package/dist/commands/read-shortcut.d.ts

@@ -4,3 +4,9 @@ import type { Command } from "commander";
  * issue identifiers so `el-linear ADM-652` works without the `issues read` prefix.
  */
 export declare function setupReadShortcut(program: Command): void;
+/**
+ * Shared `issues read` body — exported so the top-level shortcut and
+ * `issues read` (in `commands/issues.ts`) both call one implementation
+ * instead of carrying byte-equivalent duplicates. ALL-938 cleanup.
+ */
+export declare function readIssues(issueIds: string[], _options: Record<string, unknown>, command: Command): Promise<void>;

package/dist/commands/read-shortcut.js

@@ -49,7 +49,12 @@ export function setupReadShortcut(program) {
         return originalParse(argv, parseOptions);
     };
 }
-async function readIssues(issueIds, _options, command) {
+/**
+ * Shared `issues read` body — exported so the top-level shortcut and
+ * `issues read` (in `commands/issues.ts`) both call one implementation
+ * instead of carrying byte-equivalent duplicates. ALL-938 cleanup.
+ */
+export async function readIssues(issueIds, _options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     const linearService = await createLinearService(rootOpts);

package/dist/commands/refs.js

@@ -3,6 +3,7 @@ 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 } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { validateReferences } from "../utils/validate-references.js";
@@ -73,7 +74,7 @@ async function handleWrap(options, command) {
     };
     if (!validate) {
         // stderr advisory only — keeps stdout a clean text stream for piping.
-        process.stderr.write("el-linear refs wrap: --no-validate set; emitting links for every regex match without checking the workspace.\n");
+        logger.error("el-linear refs wrap: --no-validate set; emitting links for every regex match without checking the workspace.");
     }
     const wrapped = await wrapRefsCore({ text, target, validate }, deps);
     process.stdout.write(wrapped);

package/dist/commands/teams.js

@@ -1,3 +1,5 @@
+import { loadConfig } from "../config/config.js";
+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";
@@ -13,8 +15,16 @@ export function setupTeamsCommands(program) {
         .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.getTeams(Number.parseInt(options.limit, 10));
+        const limit = Number.parseInt(options.limit, 10);
+        const ttl = resolveCacheTTL({
+            configTTL: loadConfig().cacheTTLSeconds,
+            // commander's `--no-cache` produces `cache: false` on the root opts.
+            noCacheFlag: rootOpts.cache === false,
+        });
+        const result = await cached(`teams-list-limit:${limit}`, ttl, async () => {
+            const service = await createLinearService(rootOpts);
+            return service.getTeams(limit);
+        });
         outputSuccess({ data: result, meta: { count: result.length } });
     }));
 }

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";
@@ -56,4 +57,129 @@ export function setupTemplatesCommands(program) {
         }
         outputSuccess(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 });
+        const payload = result.templateCreate;
+        if (!payload?.success) {
+            throw new Error("templateCreate returned success=false");
+        }
+        outputSuccess(payload.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 });
+        const payload = result.templateUpdate;
+        if (!payload?.success) {
+            throw new Error("templateUpdate returned success=false");
+        }
+        outputSuccess(payload.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 });
+        const payload = result.templateDelete;
+        if (!payload?.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

@@ -8,11 +8,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, Number.parseInt(options.limit, 10), options.name);
         outputSuccess({ data: result, meta: { count: result.length } });
     }));
 }

package/dist/config/config.d.ts

@@ -57,6 +57,25 @@ export interface ElLinearConfig {
      *   }
      */
     descriptionTemplates?: Record<string, string>;
+    /**
+     * Default assignee identifier (alias / display name / email / UUID — same
+     * shapes resolveAssignee accepts) for `issues create`. Applied when
+     * `--assignee` is not passed. Pass `--no-assignee` to override at one site.
+     */
+    defaultAssignee?: string;
+    /**
+     * Default priority for `issues create` / `issues update`. Accepts the same
+     * keywords as the --priority flag: `none|urgent|high|medium|normal|low`
+     * or `0`–`4`. Applied when `--priority` is not passed.
+     */
+    defaultPriority?: string;
+    /**
+     * TTL (seconds) for the on-disk cache used by `teams list`, `labels list`,
+     * and `projects list`. Defaults to 3600 (1 hour) when omitted. A value of
+     * `0` disables the cache entirely. Override per-invocation with
+     * `--no-cache`.
+     */
+    cacheTTLSeconds?: number;
 }
 /** Test seam — resets the cache between test cases. */
 export declare function _resetConfigCacheForTests(): void;