linear-sdk-cli 0.1.0 → 0.1.2

package/src/lib/output-shapes.ts

@@ -130,10 +130,7 @@ export const UPDATE_ROW_SHAPE = shape<UpdateRow>({
   body: "string",
   health: "string|null",
 });
-const UPDATE_RECEIPT_SHAPE = shape<UpdateRow & { url: string }>({
-  ...UPDATE_ROW_SHAPE,
-  url: "string",
-});
+const UPDATE_RECEIPT_SHAPE = shape<UpdateRow & { url: string }>({ ...UPDATE_ROW_SHAPE, url: "string" });
 
 /** `whoami` / `auth whoami`. */
 const WHOAMI_SHAPE: ObjectFields = {
@@ -145,15 +142,12 @@ const WHOAMI_SHAPE: ObjectFields = {
   organization: { id: "string", name: "string", urlKey: "string" },
 };
 
-const SETTING_ORIGIN_SHAPE = shape<SettingOrigin>({
-  source: "string",
-  "path?": "string",
-  "key?": "string",
-});
+const SETTING_ORIGIN_SHAPE = shape<SettingOrigin>({ source: "string", "path?": "string" });
 const SETTING_ORIGINS_SHAPE = shape<SettingOrigins>({
   team: SETTING_ORIGIN_SHAPE,
   workspace: SETTING_ORIGIN_SHAPE,
   sort: SETTING_ORIGIN_SHAPE,
+  vcs: SETTING_ORIGIN_SHAPE,
 });
 
 /** `config show`: every resolved setting, redacted, with its provenance. */
@@ -164,6 +158,7 @@ const CONFIG_SHOW_SHAPE: ObjectFields = {
   team: "string|null",
   workspace: "string|null",
   sort: "string",
+  vcs: "string",
   origins: SETTING_ORIGINS_SHAPE,
   userConfigPath: "string",
   projectConfigPath: "string|null",
@@ -176,20 +171,7 @@ export const COMMAND_NODE_SHAPE = shape<CommandNode>({
   description: "string",
   aliases: ["string"],
   arguments: [{ name: "string", required: "boolean", variadic: "boolean" }],
-  options: [
-    {
-      flags: "string",
-      description: "string",
-      attribute: "string",
-      valueRequired: "boolean",
-      valueOptional: "boolean",
-      variadic: "boolean",
-      "choices?": ["string"],
-      "defaultValue?": "unknown",
-      global: "boolean",
-      applicable: "boolean",
-    },
-  ],
+  options: [{ flags: "string", description: "string" }],
   "output?": {
     kind: "string",
     "fields?": "object",
@@ -228,8 +210,8 @@ const RELATION_ROW: ObjectFields = { type: "string", issue: "string", title: "st
 
 const ISSUE_VIEW = object(ISSUE_DETAIL_SHAPE, {
   variants: {
+    "--comments": object({ ...ISSUE_DETAIL_SHAPE, comments: [COMMENT_ROW_SHAPE] }),
     "--web": receipt({ ...ISSUE_URL_RECEIPT, opened: "boolean" }),
-    "--app": receipt({ ...ISSUE_URL_RECEIPT, opened: "boolean" }),
   },
 });
 const ISSUE_LIST = list(ISSUE_ROW_SHAPE);
@@ -254,13 +236,6 @@ export const OUTPUT_SHAPES: Record<string, OutputShape | null> = {
   "attachment list": list(ATTACHMENT_ROW_SHAPE),
 
   auth: null,
-  "auth adopt": receipt({
-    success: "boolean",
-    workspace: "string",
-    user: { id: "string", name: "string", email: "string" },
-    storage: "string",
-    path: "string",
-  }),
   "auth default": receipt({ success: "boolean", default_workspace: "string", path: "string" }),
   "auth list": list({ slug: "string", isDefault: "boolean", storage: "string" }),
   "auth login": receipt({
@@ -341,28 +316,7 @@ export const OUTPUT_SHAPES: Record<string, OutputShape | null> = {
   "issue agent-session": null,
   "issue agent-session list": list(AGENT_SESSION_ROW_SHAPE),
   "issue agent-session view": object(AGENT_SESSION_DETAIL_SHAPE),
-  "issue archive": receipt(
-    { ...ISSUE_REF, archived: "boolean" },
-    {
-      variants: {
-        "--bulk": receipt({
-          action: "string",
-          results: [
-            {
-              input: "string",
-              "id?": "string",
-              "identifier?": "string",
-              "archived?": "boolean",
-              "deleted?": "boolean",
-              "error?": { message: "string", code: "string" },
-            },
-          ],
-          succeeded: "number",
-          failed: "number",
-        }),
-      },
-    },
-  ),
+  "issue archive": receipt({ ...ISSUE_REF, archived: "boolean" }),
   "issue assign": receipt(ISSUE_REF),
   "issue attach": list(
     {
@@ -396,33 +350,10 @@ export const OUTPUT_SHAPES: Record<string, OutputShape | null> = {
       }),
     },
   }),
-  "issue delete": receipt(
-    { ...ISSUE_REF, deleted: "boolean" },
-    {
-      variants: {
-        "--bulk": receipt({
-          action: "string",
-          results: [
-            {
-              input: "string",
-              "id?": "string",
-              "identifier?": "string",
-              "archived?": "boolean",
-              "deleted?": "boolean",
-              "error?": { message: "string", code: "string" },
-            },
-          ],
-          succeeded: "number",
-          failed: "number",
-        }),
-      },
-    },
-  ),
+  "issue delete": receipt({ ...ISSUE_REF, deleted: "boolean" }),
   "issue describe": receipt(
     { identifier: "string", title: "string", url: "string", trailer: "string", message: "string" },
-    {
-      note: "`trailer` is the magic-word phrase (Fixes TES-1); `message` the full commit text as printed",
-    },
+    { note: "`trailer` is the magic-word phrase (Fixes TES-1); `message` the full commit text as printed" },
   ),
   "issue id": receipt({ id: "string" }, { note: "`id` is the identifier (TES-123), not the UUID" }),
   "issue label": receipt(ISSUE_REF),
@@ -485,8 +416,6 @@ export const OUTPUT_SHAPES: Record<string, OutputShape | null> = {
   "notification snooze": receipt({ id: "string", snoozedUntilAt: "string" }),
   "notification unread": receipt({ id: "string", read: "boolean" }),
 
-  open: receipt({ target: "string", url: "string", label: "string", opened: "boolean" }),
-
   organization: runs("organization view", object(ORGANIZATION_DETAIL_SHAPE)),
   "organization invites": list(INVITE_ROW_SHAPE),
   "organization members": list(ORGANIZATION_MEMBER_ROW_SHAPE),
@@ -530,7 +459,6 @@ export const OUTPUT_SHAPES: Record<string, OutputShape | null> = {
     movedIssues: "number",
     movedTo: { nullable: TEAM_ROW_SHAPE },
   }),
-  "team id": receipt(TEAM_ROW_SHAPE),
   "team labels": list(TEAM_LABEL_ROW_SHAPE),
   "team list": list(TEAM_ROW_SHAPE),
   "team members": list(TEAM_MEMBER_ROW_SHAPE),

package/src/lib/pagination.ts

@@ -5,10 +5,7 @@
  * and `.fetchNext()` mutates the connection to append the next page's nodes.
  */
 
-import { fetchNextWithRetry, withRetry } from "../client.js";
-
-/** Linear accepts at most 250 nodes per connection page. */
-export const MAX_PAGE_SIZE = 250;
+import { withRetry } from "../client.js";
 
 export interface Connection<T> {
   nodes: T[];
@@ -16,49 +13,22 @@ export interface Connection<T> {
   fetchNext: () => Promise<Connection<T>>;
 }
 
-/** Non-enumerable metadata carried by list arrays without changing their JSON contract. */
-const HAS_MORE = Symbol.for("linear-sdk-cli.pagination.has-more");
-
-type PagedArray<T> = T[] & { [HAS_MORE]?: boolean };
-
-function withMoreMetadata<T>(items: T[], hasMore: boolean): T[] {
-  Object.defineProperty(items, HAS_MORE, { value: hasMore, enumerable: false });
-  return items;
-}
-
-/** Attach an explicit pagination result to an array without changing its JSON value. */
-export function setPaginationMetadata<T>(items: T[], hasMore: boolean): T[] {
-  return withMoreMetadata(items, hasMore);
-}
-
-/** Whether a service list stopped at its caller-supplied limit. */
-export function hasMoreResults(items: readonly unknown[]): boolean {
-  return (items as PagedArray<unknown>)[HAS_MORE] === true;
-}
-
-/** Carry pagination metadata through a service's map/filter/sort result. */
-export function inheritPaginationMetadata<T>(items: T[], source: readonly unknown[]): T[] {
-  return withMoreMetadata(items, hasMoreResults(source));
-}
-
-export async function collect<T>(first: Connection<T>, limit: number): Promise<T[]> {
+export async function collect<T>(
+  first: Connection<T>,
+  limit: number,
+): Promise<T[]> {
   let conn = first;
   // Each fetchNext() appends to conn.nodes in place.
   while (conn.nodes.length < limit && conn.pageInfo.hasNextPage) {
-    // Page two and later are independent requests and can be rate-limited just
-    // like page one. Keep them behind the same bounded retry policy.
-    conn = await fetchNextWithRetry(conn);
+    conn = await conn.fetchNext();
   }
-  if (limit === Infinity) return withMoreMetadata(conn.nodes, false);
-  const hasMore =
-    conn.nodes.length > limit || (conn.nodes.length >= limit && conn.pageInfo.hasNextPage);
-  return withMoreMetadata(conn.nodes.slice(0, limit), hasMore);
+  return limit === Infinity ? conn.nodes : conn.nodes.slice(0, limit);
 }
 
 /** How many to request per page given a desired total limit. */
 export function pageSize(limit: number): number {
-  if (limit === Infinity) return MAX_PAGE_SIZE;
-  return Math.min(Math.max(limit, 1), MAX_PAGE_SIZE);
+  if (limit === Infinity) return 100;
+  return Math.min(Math.max(limit, 1), 100);
 }
 
 /**
@@ -106,7 +76,7 @@ interface RawClient {
  * `withRetry`; pagination stops at `limit` or when `hasNextPage` is false.
  *
  * Mirrors the hand-rolled loops in the list services exactly: page size is
- * `limit === Infinity ? 250 : Math.min(limit, 250)`, and rows are capped at
+ * `limit === Infinity ? 100 : Math.min(limit, 100)`, and rows are capped at
  * `limit` mid-page.
  */
 export async function collectRawQuery<T>(
@@ -117,29 +87,26 @@ export async function collectRawQuery<T>(
   limit: number,
   transform: (node: any) => T,
 ): Promise<T[]> {
-  const pageLimit = pageSize(limit);
+  const pageLimit = limit === Infinity ? 100 : Math.min(limit, 100);
   const rows: T[] = [];
   let after: string | undefined;
-  let hasMore = false;
 
   for (;;) {
     const data: any = await withRetry(() =>
       client.client.rawRequest(query, { ...variables, first: pageLimit, after }),
     );
-    const conn = connectionPath.split(".").reduce((acc: any, key) => acc?.[key], data.data) as
-      RawConnection | null | undefined;
+    const conn = connectionPath
+      .split(".")
+      .reduce((acc: any, key) => acc?.[key], data.data) as RawConnection | null | undefined;
     // A nested path (`issue.comments`) can land on null when the parent entity
     // is gone; that is an empty list, not a crash.
     if (!conn) break;
-    for (const [index, n] of conn.nodes.entries()) {
+    for (const n of conn.nodes) {
       rows.push(transform(n));
-      if (rows.length >= limit) {
-        hasMore = index < conn.nodes.length - 1 || conn.pageInfo.hasNextPage;
-        break;
-      }
+      if (rows.length >= limit) break;
     }
     if (rows.length >= limit || !conn.pageInfo.hasNextPage) break;
     after = conn.pageInfo.endCursor;
   }
-  return withMoreMetadata(rows, hasMore);
+  return rows;
 }

package/src/lib/resolve.ts

@@ -15,27 +15,6 @@ const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 export const isUuid = (v: string): boolean => UUID_RE.test(v);
 
 const IDENTIFIER_RE = /^([a-zA-Z][a-zA-Z0-9]*)-(\d+)$/;
-const ISSUE_NUMBER_RE = /^\d+$/;
-
-/**
- * Expand a bare issue number with the configured team (`42` + `TES` →
- * `TES-42`). This is deliberately pure: commands can normalize every place an
- * issue reference appears before handing it to the existing resolvers.
- */
-export function normalizeIssueReference(input: string, defaultTeamKey?: string): string {
-  if (!ISSUE_NUMBER_RE.test(input)) return input;
-  if (!defaultTeamKey) {
-    throw usageError(
-      `Bare issue number '${input}' needs a default team. Pass --team <KEY> or set one in config.`,
-    );
-  }
-  if (!/^[a-zA-Z][a-zA-Z0-9]*$/.test(defaultTeamKey)) {
-    throw usageError(
-      `Cannot expand issue number '${input}' with default team '${defaultTeamKey}'; configure a team key such as TES.`,
-    );
-  }
-  return `${defaultTeamKey.toUpperCase()}-${Number.parseInt(input, 10)}`;
-}
 
 /** Known workflow-state types, used to decide name-vs-type filtering. */
 export const STATE_TYPES = ["triage", "backlog", "unstarted", "started", "completed", "canceled"];
@@ -122,15 +101,13 @@ export async function resolveTeam(
         "linear team list",
       )}`,
     );
-  if (matches.length > 1)
-    throw ambiguous(`Multiple teams match '${value}': ${matches.map((t) => t.key).join(", ")}`);
+  if (matches.length > 1) throw ambiguous(`Multiple teams match '${value}': ${matches.map((t) => t.key).join(", ")}`);
   const team = matches[0]!;
   return { id: team.id, key: team.key, name: team.name };
 }
 
 /** The spellings that mean "the authenticated user": ours (`me`, `@me`) and the reference CLI's (`self`). */
-export const isSelf = (input: string): boolean =>
-  input === "me" || input === "@me" || input === "self";
+export const isSelf = (input: string): boolean => input === "me" || input === "@me" || input === "self";
 
 /**
  * Resolve an assignee reference (`me`, email, name, or id) to a user id.
@@ -161,9 +138,7 @@ export async function resolveUserId(client: LinearClient, input: string): Promis
   if (nodes.length === 0)
     throw notFound(`No user matching '${input}'. Run 'linear user list' to see workspace members.`);
   if (nodes.length > 1)
-    throw ambiguous(
-      `Multiple users match '${input}': ${nodes.map((u: any) => u.email).join(", ")}`,
-    );
+    throw ambiguous(`Multiple users match '${input}': ${nodes.map((u: any) => u.email).join(", ")}`);
   return nodes[0]!.id;
 }
 
@@ -228,8 +203,7 @@ export async function resolveLabelIds(
     // Narrow to this team's labels + workspace-level labels when a team is known.
     // If a team is known and nothing is in scope, that's not-found (do NOT fall
     // back to an out-of-scope label from another team).
-    // Label groups are containers, not labels that can be applied to an issue.
-    let candidates: any[] = nodes.filter((label: any) => !label.isGroup);
+    let candidates: any[] = nodes;
     if (teamId) {
       const scoped = await Promise.all(
         nodes.map(async (l: any) => ({ label: l, team: await l.team })),
@@ -360,9 +334,7 @@ export async function resolveProjectId(client: LinearClient, input: string): Pro
   if (nodes.length === 0)
     throw notFound(`No project matching '${input}'. Run 'linear project list' to see the options.`);
   if (nodes.length > 1)
-    throw ambiguous(
-      `Multiple projects match '${input}': ${nodes.map((p: any) => p.name).join(", ")}`,
-    );
+    throw ambiguous(`Multiple projects match '${input}': ${nodes.map((p: any) => p.name).join(", ")}`);
   return nodes[0]!.id;
 }
 
@@ -513,11 +485,7 @@ export async function resolveReleaseId(client: LinearClient, input: string): Pro
       first: RESOLVE_PAGE,
     }),
   );
-  const nodes = await scanAll<any>(
-    conn as any,
-    "releases",
-    "linear api '{ releases { nodes { id name version } } }'",
-  );
+  const nodes = await scanAll<any>(conn as any, "releases", "linear api '{ releases { nodes { id name version } } }'");
   if (nodes.length === 0) throw notFound(`No release named or versioned '${input}'.`);
   if (nodes.length > 1)
     throw ambiguous(
@@ -579,8 +547,7 @@ export async function resolveTemplateId(
 export async function resolveIssue(client: LinearClient, input: string): Promise<Issue> {
   if (isUuid(input)) return withRetry(() => client.issue(input));
   const match = input.match(IDENTIFIER_RE);
-  if (!match)
-    throw usageError(`'${input}' is not a valid issue id (expected e.g. TES-123 or a UUID).`);
+  if (!match) throw usageError(`'${input}' is not a valid issue id (expected e.g. TES-123 or a UUID).`);
   const key = match[1]!.toUpperCase();
   const number = Number.parseInt(match[2]!, 10);
   // includeArchived so archive/unarchive/delete can operate on archived issues.

package/src/lib/shape.ts

@@ -66,13 +66,11 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
 type ObjectShapeOf<T> = string extends keyof T
   ? "object"
   : {
-      [
-        K in keyof T as IsAny<T[K]> extends true
-          ? K & string
-          : undefined extends T[K]
-            ? `${K & string}?`
-            : K & string
-      ]-?: ShapeOf<Exclude<T[K], undefined>>;
+      [K in keyof T as IsAny<T[K]> extends true
+        ? K & string
+        : undefined extends T[K]
+          ? `${K & string}?`
+          : K & string]-?: ShapeOf<Exclude<T[K], undefined>>;
     };
 
 export type ShapeOf<T> =
@@ -121,7 +119,10 @@ export type ObjectFields = Record<string, FieldShape>;
 
 function isNullableWrapper(s: FieldShape): s is { readonly nullable: FieldShape } {
   return (
-    typeof s === "object" && !Array.isArray(s) && Object.keys(s).length === 1 && "nullable" in s
+    typeof s === "object" &&
+    !Array.isArray(s) &&
+    Object.keys(s).length === 1 &&
+    "nullable" in s
   );
 }
 
@@ -159,9 +160,7 @@ export function matchesShape(
   }
   if (Array.isArray(shape)) {
     if (!Array.isArray(value)) return [`${path}: expected an array, got ${describe(value)}`];
-    return value.flatMap((item, i) =>
-      matchesShape(item, shape[0], `${path}[${i}]`, strictNullable),
-    );
+    return value.flatMap((item, i) => matchesShape(item, shape[0], `${path}[${i}]`, strictNullable));
   }
   if (isNullableWrapper(shape)) {
     if (value === undefined) return [`${path}: expected an object or null, got undefined`];
@@ -185,8 +184,7 @@ export function matchesShape(
     problems.push(...matchesShape(record[key], sub, `${path}.${key}`, strictNullable));
   }
   for (const key of Object.keys(record)) {
-    if (!declared.has(key) && record[key] !== undefined)
-      problems.push(`${path}.${key}: not in the declared shape`);
+    if (!declared.has(key) && record[key] !== undefined) problems.push(`${path}.${key}: not in the declared shape`);
   }
   return problems;
 }
@@ -205,9 +203,7 @@ export function renderShape(shape: FieldShape): string {
   if (typeof shape === "string") return shape.replace("|null", " | null");
   if (Array.isArray(shape)) {
     const inner = renderShape(shape[0]);
-    return typeof shape[0] === "string" && !shape[0].includes("|")
-      ? `${inner}[]`
-      : `Array<${inner}>`;
+    return typeof shape[0] === "string" && !shape[0].includes("|") ? `${inner}[]` : `Array<${inner}>`;
   }
   if (isNullableWrapper(shape)) return `${renderShape(shape.nullable)} | null`;
   const parts = Object.entries(shape).map(([k, v]) => `${k}: ${renderShape(v)}`);

package/src/lib/upload.ts

@@ -294,9 +294,7 @@ function redact(text: string, uploadUrl: string): string {
 }
 
 /** Markdown for a comment body: images embed inline, anything else links. */
-export function formatEmbed(
-  r: Pick<UploadResult, "filename" | "assetUrl" | "contentType">,
-): string {
+export function formatEmbed(r: Pick<UploadResult, "filename" | "assetUrl" | "contentType">): string {
   return `${isImage(r.contentType) ? "!" : ""}[${r.filename}](${r.assetUrl})`;
 }
 

package/src/output/format.ts

@@ -6,7 +6,7 @@
  *   - lists → bare array, single resource → bare object, mutations → affected
  *     object (or {success,id} when there is no body)
  *   - status/progress/pagination notes → stderr
- *   - errors → {"error":{"message","code", …optional additive fields}} on stderr + non-zero exit
+ *   - errors → {"error":{"message","code"}} on stderr + non-zero exit
  */
 
 import pc from "picocolors";
@@ -20,9 +20,6 @@ import {
   type Column,
 } from "./table.js";
 import { sanitizeForTerminal } from "./sanitize.js";
-import { renderMarkdown } from "./markdown.js";
-import { pageOutput, shouldUsePager } from "./pager.js";
-import { hasMoreResults } from "../lib/pagination.js";
 
 export interface OutputOptions {
   json: boolean;
@@ -31,38 +28,10 @@ export interface OutputOptions {
   debug: boolean;
   /** `--fields`: table columns / detail lines (human), top-level keys (json). */
   fields?: string[];
-  /** Injectable terminal facts; default to stdout's live state. */
-  isTTY?: boolean;
-  terminalRows?: number;
-  terminalColumns?: number;
-  /** Used only to resolve PAGER when long-form output is eligible. */
-  env?: NodeJS.ProcessEnv;
-}
-
-export interface ListOutputOptions {
-  /** JSON rows may be richer/differently shaped than the human table rows. */
-  jsonRows?: unknown[];
-  /** Context shown instead of the default `(no results)` in human mode. */
-  empty?: string;
-}
-
-export interface MarkdownOutputOptions {
-  /** Leave Markdown syntax intact (terminal controls are still removed). */
-  raw?: boolean;
-  /** Commands with `--no-pager` pass false. Defaults to enabled. */
-  pager?: boolean;
 }
 
 export class Output {
-  private readonly opts: OutputOptions;
-  private readonly colors: ReturnType<typeof pc.createColors>;
-
-  constructor(opts: OutputOptions) {
-    this.opts = opts;
-    // Do not rely on picocolors' module-load-time environment detection:
-    // CLICOLOR_FORCE and per-stream TTY policy are resolved by Context.
-    this.colors = pc.createColors(opts.color);
-  }
+  constructor(private readonly opts: OutputOptions) {}
 
   get json(): boolean {
     return this.opts.json;
@@ -85,28 +54,13 @@ export class Output {
    * Emit a list as a table (human) or bare array (json). `--fields` narrows
    * both: the table's columns (or any row key), and the JSON objects' keys.
    */
-  list<T>(
-    rows: T[],
-    columns: Column<T>[],
-    jsonRowsOrOptions?: unknown[] | ListOutputOptions,
-    legacyOptions?: Pick<ListOutputOptions, "empty">,
-  ): void {
-    const options: ListOutputOptions = Array.isArray(jsonRowsOrOptions)
-      ? { jsonRows: jsonRowsOrOptions, ...legacyOptions }
-      : (jsonRowsOrOptions ?? {});
-    if (hasMoreResults(rows)) {
-      this.info(
-        `Showing ${rows.length} results; more exist. Use --all or increase --limit to see them.`,
-      );
-    }
+  list<T>(rows: T[], columns: Column<T>[], jsonRows?: unknown[]): void {
     if (this.opts.json) {
-      this.writeJson(projectFields(options.jsonRows ?? rows, this.opts.fields));
+      this.writeJson(projectFields(jsonRows ?? rows, this.opts.fields));
       return;
     }
     const cols = selectColumns(columns, this.opts.fields, rows[0]);
-    process.stdout.write(
-      renderTable(rows, cols, { color: this.opts.color, empty: options.empty }) + "\n",
-    );
+    process.stdout.write(renderTable(rows, cols, { color: this.opts.color }) + "\n");
   }
 
   /**
@@ -130,41 +84,6 @@ export class Output {
     if (!this.opts.json) process.stdout.write(sanitizeForTerminal(text) + "\n");
   }
 
-  /**
-   * Render a long Markdown body for a human, optionally through a pager.
-   *
-   * Non-TTY output keeps the original Markdown so pipes/files receive stable,
-   * reusable text. JSON mode writes nothing — callers normally put this inside
-   * `emit(value, () => output.markdown(...))`, but the guard prevents an
-   * accidental second stdout value. Both human paths remain terminal-sanitized.
-   */
-  markdown(text: string, options: MarkdownOutputOptions = {}): void {
-    if (this.opts.json) return;
-
-    const isTTY = this.opts.isTTY ?? process.stdout.isTTY === true;
-    const columns = this.opts.terminalColumns ?? process.stdout.columns ?? 80;
-    const rows = this.opts.terminalRows ?? process.stdout.rows;
-    const content =
-      isTTY && options.raw !== true
-        ? renderMarkdown(text, { color: this.opts.color, width: columns })
-        : sanitizeForTerminal(text);
-    const output = content.endsWith("\n") ? content : `${content}\n`;
-
-    if (
-      shouldUsePager(output, {
-        enabled: options.pager,
-        json: this.opts.json,
-        isTTY,
-        rows,
-        columns,
-      }) &&
-      pageOutput(output, { env: this.opts.env })
-    ) {
-      return;
-    }
-    process.stdout.write(output);
-  }
-
   /** Status/progress to stderr. Suppressed by --quiet. */
   info(text: string): void {
     if (!this.opts.quiet) process.stderr.write(sanitizeForTerminal(text) + "\n");
@@ -172,11 +91,13 @@ export class Output {
 
   success(text: string): void {
     if (!this.opts.quiet)
-      process.stderr.write(this.colors.green("✓ ") + sanitizeForTerminal(text) + "\n");
+      process.stderr.write(
+        (this.opts.color ? pc.green("✓ ") : "✓ ") + sanitizeForTerminal(text) + "\n",
+      );
   }
 
   warn(text: string): void {
-    process.stderr.write(this.colors.yellow("! ") + sanitizeForTerminal(text) + "\n");
+    process.stderr.write((this.opts.color ? pc.yellow("! ") : "! ") + sanitizeForTerminal(text) + "\n");
   }
 
   /**
@@ -196,7 +117,7 @@ export class Output {
     }
     if (!this.opts.quiet) {
       process.stderr.write(
-        this.colors.yellow("! ") + `Cancelled: ${sanitizeForTerminal(action)}\n`,
+        (this.opts.color ? pc.yellow("! ") : "! ") + `Cancelled: ${sanitizeForTerminal(action)}\n`,
       );
     }
   }
@@ -216,19 +137,20 @@ export class Output {
       // `message` and `code` keep their positions; `detail` is additive, and
       // absent entirely without --debug.
       const error: Record<string, unknown> = { message: err.message, code: err.code };
-      if (err.suggestion !== undefined) error.suggestion = err.suggestion;
       if (showDetail) error.detail = err.detail;
       process.stderr.write(JSON.stringify({ error }) + "\n");
       return;
     }
     // An error message can quote API data (a name that matched several, …).
-    process.stderr.write(this.colors.red("error: ") + sanitizeForTerminal(err.message) + "\n");
-    if (err.suggestion !== undefined) {
-      process.stderr.write(this.colors.dim("hint: ") + sanitizeForTerminal(err.suggestion) + "\n");
-    }
+    process.stderr.write(
+      (this.opts.color ? pc.red("error: ") : "error: ") + sanitizeForTerminal(err.message) + "\n",
+    );
     if (showDetail) {
-      const detail = JSON.stringify(err.detail, null, 2) ?? String(err.detail);
-      process.stderr.write(this.colors.dim("detail: ") + sanitizeForTerminal(detail) + "\n");
+      process.stderr.write(
+        (this.opts.color ? pc.dim("detail: ") : "detail: ") +
+          JSON.stringify(err.detail, null, 2) +
+          "\n",
+      );
     }
   }