@enrichlayer/el-linear 1.7.0 → 1.9.0

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/templates.d.ts

@@ -1,2 +1,5 @@
 export declare const TEMPLATES_LIST_QUERY = "\n  query {\n    templates {\n      id\n      name\n      type\n      description\n      templateData\n      createdAt\n      updatedAt\n      team { id key name }\n      creator { id name }\n    }\n  }\n";
 export declare const TEMPLATE_BY_ID_QUERY = "\n  query ($id: String!) {\n    template(id: $id) {\n      id\n      name\n      type\n      description\n      templateData\n      createdAt\n      updatedAt\n      team { id key name }\n      creator { id name }\n    }\n  }\n";
+export declare const TEMPLATE_CREATE_MUTATION = "\n  mutation ($input: TemplateCreateInput!) {\n    templateCreate(input: $input) {\n      success\n      lastSyncId\n      template {\n        id\n        name\n        type\n        description\n        templateData\n        team { id key name }\n        createdAt\n        updatedAt\n      }\n    }\n  }\n";
+export declare const TEMPLATE_UPDATE_MUTATION = "\n  mutation ($id: String!, $input: TemplateUpdateInput!) {\n    templateUpdate(id: $id, input: $input) {\n      success\n      lastSyncId\n      template {\n        id\n        name\n        type\n        description\n        templateData\n        team { id key name }\n        updatedAt\n      }\n    }\n  }\n";
+export declare const TEMPLATE_DELETE_MUTATION = "\n  mutation ($id: String!) {\n    templateDelete(id: $id) {\n      success\n      lastSyncId\n    }\n  }\n";

package/dist/queries/templates.js

@@ -28,3 +28,46 @@ export const TEMPLATE_BY_ID_QUERY = `
     }
   }
 `;
+export const TEMPLATE_CREATE_MUTATION = `
+  mutation ($input: TemplateCreateInput!) {
+    templateCreate(input: $input) {
+      success
+      lastSyncId
+      template {
+        id
+        name
+        type
+        description
+        templateData
+        team { id key name }
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`;
+export const TEMPLATE_UPDATE_MUTATION = `
+  mutation ($id: String!, $input: TemplateUpdateInput!) {
+    templateUpdate(id: $id, input: $input) {
+      success
+      lastSyncId
+      template {
+        id
+        name
+        type
+        description
+        templateData
+        team { id key name }
+        updatedAt
+      }
+    }
+  }
+`;
+export const TEMPLATE_DELETE_MUTATION = `
+  mutation ($id: String!) {
+    templateDelete(id: $id) {
+      success
+      lastSyncId
+    }
+  }
+`;

package/dist/utils/auth.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { LEGACY_LINCTL_TOKEN_PATH, LEGACY_TOKEN_PATH, resolveActiveProfile, TOKEN_PATH, } from "../config/paths.js";
+import { LEGACY_LINCTL_TOKEN_PATH, LEGACY_TOKEN_PATH, resolveActiveProfile, } from "../config/paths.js";
 import { maybeEmitMigrationHint } from "./migration-hint.js";
 export function getApiToken(options) {
     if (options.apiToken) {
@@ -9,18 +9,16 @@ export function getApiToken(options) {
         return process.env.LINEAR_API_TOKEN;
     }
     // Profile-aware: read from <CONFIG_DIR>/profiles/<name>/token when a
-    // profile is active, falling back to the legacy single-file path
-    // (TOKEN_PATH) for the no-profile case.
+    // profile is active. When the user has explicitly selected a profile
+    // (--profile / EL_LINEAR_PROFILE / active-profile marker), do NOT
+    // fall back to the legacy single-file token — that path silently
+    // posts writes to the wrong workspace when a profile token is missing.
     const active = resolveActiveProfile();
     if (fs.existsSync(active.tokenPath)) {
         return fs.readFileSync(active.tokenPath, "utf8").trim();
     }
-    // Even when a profile is selected, fall through to the legacy token
-    // path so an operator who only has the single-file layout doesn't
-    // suddenly fail. The active-profile name is informational only when
-    // no profile-scoped token exists yet.
-    if (active.tokenPath !== TOKEN_PATH && fs.existsSync(TOKEN_PATH)) {
-        return fs.readFileSync(TOKEN_PATH, "utf8").trim();
+    if (active.name !== null) {
+        throw new Error(`No token for active profile \`${active.name}\` (expected at ${active.tokenPath}). Run \`el-linear init token --profile ${active.name}\` (or unset --profile / EL_LINEAR_PROFILE / \`el-linear profile use <name>\`) before retrying. Refusing to fall back to the legacy single-file token to avoid posting writes to the wrong workspace.`);
     }
     // Fallback to the linctl-era token (the CLI was briefly published as
     // `@enrichlayer/linctl` then reverted). Kept for one release.

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

@@ -155,7 +155,21 @@ export async function autoLinkReferences(input) {
     const failed = [];
     const descriptionRefs = extractIssueReferences(description ?? "", identifier);
     const commentRefs = (comments ?? []).flatMap((body) => extractIssueReferences(body, identifier));
-    const candidates = mergeCandidates(descriptionRefs, commentRefs);
+    const merged = mergeCandidates(descriptionRefs, commentRefs);
+    // Cap the number of candidates we'll resolve per call. A malicious
+    // (or merely careless) issue body containing hundreds of fake
+    // identifiers — `AAA-1, AAA-2, …, AAA-999` — would otherwise trigger
+    // 999 GraphQL roundtrips before deciding none resolve. Realistic
+    // human-authored bodies stay well under this cap.
+    const MAX_CANDIDATES_PER_CALL = 50;
+    const candidates = merged.slice(0, MAX_CANDIDATES_PER_CALL);
+    if (merged.length > MAX_CANDIDATES_PER_CALL) {
+        const overflow = merged.length - MAX_CANDIDATES_PER_CALL;
+        failed.push({
+            identifier: `+${overflow} more`,
+            reason: `Too many candidate references (${merged.length}); only the first ${MAX_CANDIDATES_PER_CALL} are processed.`,
+        });
+    }
     if (candidates.length === 0) {
         return { linked, skipped, failed };
     }

package/dist/utils/disk-cache.js

@@ -25,6 +25,7 @@ import { randomBytes } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveActiveProfile } from "../config/paths.js";
+import { logger } from "./logger.js";
 const CACHE_VERSION = 1;
 const CACHE_FILE_MODE = 0o644;
 const CACHE_DIR_MODE = 0o700;
@@ -138,7 +139,7 @@ export async function cached(key, ttlSeconds, fetcher, options) {
         // Cache writes are best-effort — log to stderr and return the data
         // anyway so a flaky disk doesn't break the user's command.
         const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[disk-cache] write failed for "${key}": ${msg}\n`);
+        logger.error(`[disk-cache] write failed for "${key}": ${msg}`);
     }
     return data;
 }

package/dist/utils/formatters/summary.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Human-readable summary formatters for the `--format summary` output mode.
+ *
+ * These are pure functions: each takes the same shape that the JSON output
+ * path receives (a single resource object or a `{ data, meta }` envelope)
+ * and returns a plain string suitable for terminal display.
+ *
+ * Why this exists: every consumer (humans and LLMs) was piping
+ * `el-linear ... | python -c 'json.load(...)'` or jq-based extraction to
+ * pull out title/state/assignee. This codifies that recurring shape as a
+ * first-class output mode, so callers don't reinvent it in shell.
+ *
+ * The summary format is intentionally stable — it's a contract, not a
+ * pretty-print. Field ordering and labels should not change across
+ * patch releases without a CHANGELOG entry.
+ */
+export declare function formatIssueSummary(issue: Record<string, unknown>): string;
+export declare function formatIssueList(issues: unknown[]): string;
+export declare function formatProjectSummary(project: Record<string, unknown>): string;
+export declare function formatProjectList(projects: unknown[]): string;
+export declare function formatCommentSummary(comment: Record<string, unknown>): string;
+export declare function formatCommentList(comments: unknown[]): string;
+export declare function formatCycleSummary(cycle: Record<string, unknown>): string;
+export declare function formatCycleList(cycles: unknown[]): string;
+export declare function formatMilestoneSummary(milestone: Record<string, unknown>): string;
+export declare function formatMilestoneList(milestones: unknown[]): string;
+export declare function formatTeamList(teams: unknown[]): string;
+export declare function formatLabelList(labels: unknown[]): string;
+export declare function formatUserSummary(user: Record<string, unknown>): string;
+export declare function formatUserList(users: unknown[]): string;
+export declare function formatDocumentSummary(doc: Record<string, unknown>): string;
+export declare function formatDocumentList(docs: unknown[]): string;
+export declare function formatTemplateSummary(tpl: Record<string, unknown>): string;
+export declare function formatTemplateList(tpls: unknown[]): string;
+export declare function formatAttachmentList(attachments: unknown[]): string;
+export declare function formatReleaseSummary(release: Record<string, unknown>): string;
+export declare function formatReleaseList(releases: unknown[]): string;
+export declare function formatSearchResultList(results: unknown[]): string;
+/**
+ * Generic fallback for resources we don't have a dedicated formatter for
+ * yet (e.g. profile/config/template/document). Renders any object as a
+ * label-padded key/value block, with a "..." footer hinting at JSON for
+ * the full payload. Lists fall back to a simple bulleted list.
+ */
+export declare function formatGenericSummary(value: unknown): string;
+export type ResourceKind = "issue" | "issue-list" | "project" | "project-list" | "comment" | "comment-list" | "cycle" | "cycle-list" | "milestone" | "milestone-list" | "team-list" | "label-list" | "user" | "user-list" | "document" | "document-list" | "template" | "template-list" | "attachment-list" | "release" | "release-list" | "search-result-list" | "empty-list" | "generic";
+/**
+ * Heuristic — used by the central `outputSuccess` path which doesn't know
+ * which command produced the payload. Looks at the shape of the data to
+ * pick a formatter.
+ *
+ * Single-resource detection: uses signature fields (e.g. `identifier` +
+ * `state` for issues, `name` + `progress` for projects). When a payload
+ * doesn't match any known shape we fall through to `formatGenericSummary`.
+ */
+export declare function inferKindFromPayload(value: unknown): ResourceKind;
+/**
+ * Central dispatch: given a resource kind and payload, return the
+ * formatted string. The payload for list kinds may be either the raw
+ * array or a `{ data: [...] }` envelope — both are handled.
+ */
+export declare function dispatch(kind: ResourceKind, payload: unknown): string;