@jackwener/opencli 1.6.2 → 1.6.3

package/src/registry-api.ts

@@ -1,14 +0,0 @@
-/**
- * Public API for opencli plugins.
- *
- * TS plugins should import from '@jackwener/opencli/registry' which resolves to
- * this file. It re-exports ONLY the core registration API — no serialization,
- * no transitive side-effects — to avoid circular dependency deadlocks when
- * plugins are dynamically imported during discoverPlugins().
- */
-
-export { cli, Strategy, getRegistry, fullName, registerCommand } from './registry.js';
-export type { CliCommand, Arg, CliOptions } from './registry.js';
-export type { IPage } from './types.js';
-export { onStartup, onBeforeExecute, onAfterExecute } from './hooks.js';
-export type { HookFn, HookContext, HookName } from './hooks.js';

package/src/registry.test.ts

@@ -1,133 +0,0 @@
-/**
- * Tests for registry.ts: Strategy enum, cli() registration, helpers.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { cli, getRegistry, fullName, strategyLabel, registerCommand, Strategy, type CliCommand } from './registry.js';
-
-describe('cli() registration', () => {
-  it('registers a command and returns it', () => {
-    const cmd = cli({
-      site: 'test-registry',
-      name: 'hello',
-      description: 'A test command',
-      strategy: Strategy.PUBLIC,
-      browser: false,
-    });
-
-    expect(cmd.site).toBe('test-registry');
-    expect(cmd.name).toBe('hello');
-    expect(cmd.strategy).toBe(Strategy.PUBLIC);
-    expect(cmd.browser).toBe(false);
-    expect(cmd.args).toEqual([]);
-  });
-
-  it('puts registered command in the registry', () => {
-    cli({
-      site: 'test-registry',
-      name: 'registered',
-      description: 'test',
-    });
-
-    const registry = getRegistry();
-    expect(registry.has('test-registry/registered')).toBe(true);
-  });
-
-  it('defaults strategy to COOKIE when browser is true', () => {
-    const cmd = cli({
-      site: 'test-registry',
-      name: 'default-strategy',
-    });
-
-    expect(cmd.strategy).toBe(Strategy.COOKIE);
-    expect(cmd.browser).toBe(true);
-  });
-
-  it('defaults strategy to PUBLIC when browser is false', () => {
-    const cmd = cli({
-      site: 'test-registry',
-      name: 'no-browser',
-      browser: false,
-    });
-
-    expect(cmd.strategy).toBe(Strategy.PUBLIC);
-  });
-
-  it('overwrites existing command on re-registration', () => {
-    cli({ site: 'test-registry', name: 'overwrite', description: 'v1' });
-    cli({ site: 'test-registry', name: 'overwrite', description: 'v2' });
-
-    const reg = getRegistry();
-    expect(reg.get('test-registry/overwrite')?.description).toBe('v2');
-  });
-
-  it('registers aliases as alternate registry keys for the same command', () => {
-    const cmd = cli({
-      site: 'test-registry',
-      name: 'canonical',
-      description: 'test aliases',
-      aliases: ['compat', 'legacy-name'],
-    });
-
-    const registry = getRegistry();
-    expect(cmd.aliases).toEqual(['compat', 'legacy-name']);
-    expect(registry.get('test-registry/canonical')).toBe(cmd);
-    expect(registry.get('test-registry/compat')).toBe(cmd);
-    expect(registry.get('test-registry/legacy-name')).toBe(cmd);
-  });
-
-  it('preserves defaultFormat on the registered command', () => {
-    const cmd = cli({
-      site: 'test-registry',
-      name: 'plain-default',
-      description: 'prefers plain output',
-      defaultFormat: 'plain',
-    });
-
-    expect(cmd.defaultFormat).toBe('plain');
-    expect(getRegistry().get('test-registry/plain-default')?.defaultFormat).toBe('plain');
-  });
-});
-
-describe('fullName', () => {
-  it('returns site/name', () => {
-    const cmd: CliCommand = {
-      site: 'bilibili', name: 'hot', description: '', args: [],
-    };
-    expect(fullName(cmd)).toBe('bilibili/hot');
-  });
-});
-
-describe('strategyLabel', () => {
-  it('returns strategy string', () => {
-    const cmd: CliCommand = {
-      site: 'test', name: 'test', description: '', args: [],
-      strategy: Strategy.INTERCEPT,
-    };
-    expect(strategyLabel(cmd)).toBe('intercept');
-  });
-
-  it('returns public when no strategy set', () => {
-    const cmd: CliCommand = {
-      site: 'test', name: 'test', description: '', args: [],
-    };
-    expect(strategyLabel(cmd)).toBe('public');
-  });
-});
-
-describe('registerCommand', () => {
-  it('registers a pre-built command', () => {
-    const cmd: CliCommand = {
-      site: 'test-registry',
-      name: 'direct-reg',
-      description: 'directly registered',
-      args: [],
-      strategy: Strategy.HEADER,
-      browser: true,
-    };
-    registerCommand(cmd);
-
-    const reg = getRegistry();
-    expect(reg.get('test-registry/direct-reg')?.strategy).toBe(Strategy.HEADER);
-  });
-});

package/src/registry.ts

@@ -1,160 +0,0 @@
-/**
- * Core registry: Strategy enum, Arg/CliCommand interfaces, cli() registration.
- */
-
-import type { IPage } from './types.js';
-
-export enum Strategy {
-  PUBLIC = 'public',
-  COOKIE = 'cookie',
-  HEADER = 'header',
-  INTERCEPT = 'intercept',
-  UI = 'ui',
-}
-
-export interface Arg {
-  name: string;
-  type?: string;
-  default?: unknown;
-  required?: boolean;
-  valueRequired?: boolean;
-  positional?: boolean;
-  help?: string;
-  choices?: string[];
-}
-
-export interface RequiredEnv {
-  name: string;
-  help?: string;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- kwargs from CLI parsing are inherently untyped
-export type CommandArgs = Record<string, any>;
-
-export interface CliCommand {
-  site: string;
-  name: string;
-  aliases?: string[];
-  description: string;
-  domain?: string;
-  strategy?: Strategy;
-  browser?: boolean;
-  args: Arg[];
-  columns?: string[];
-  func?: (page: IPage, kwargs: CommandArgs, debug?: boolean) => Promise<unknown>;
-  pipeline?: Record<string, unknown>[];
-  timeoutSeconds?: number;
-  /** Origin of this command: 'yaml', 'ts', or plugin name. */
-  source?: string;
-  footerExtra?: (kwargs: CommandArgs) => string | undefined;
-  requiredEnv?: RequiredEnv[];
-  validateArgs?: (kwargs: CommandArgs) => void;
-  /** Deprecation note shown in help / execution warnings. */
-  deprecated?: boolean | string;
-  /** Preferred replacement command, if any. */
-  replacedBy?: string;
-  /**
-   * Control pre-navigation for cookie/header context before command execution.
-   *
-   * Browser adapters using COOKIE/HEADER strategy need the page to be on the
-   * target domain so that `fetch(url, { credentials: 'include' })` carries cookies.
-   *
-   * - `undefined` / `true`: navigate to `https://${domain}` (default)
-   * - `false`: skip — adapter handles its own navigation (e.g. boss common.ts)
-   * - `string`: navigate to this specific URL instead of the domain root
-   */
-  navigateBefore?: boolean | string;
-  /** Override the default CLI output format when the user does not pass -f/--format. */
-  defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
-}
-
-/** Internal extension for lazy-loaded TS modules (not exposed in public API) */
-export interface InternalCliCommand extends CliCommand {
-  _lazy?: boolean;
-  _modulePath?: string;
-}
-export interface CliOptions extends Partial<Omit<CliCommand, 'args' | 'description'>> {
-  site: string;
-  name: string;
-  description?: string;
-  args?: Arg[];
-}
-
-// Use globalThis to ensure a single shared registry across all module instances.
-// This is critical for TS plugins loaded via npm link / peerDependency — without
-// this, the plugin's import creates a separate module instance with its own Map.
-declare global { var __opencli_registry__: Map<string, CliCommand> | undefined; }
-const _registry: Map<string, CliCommand> =
-  globalThis.__opencli_registry__ ??= new Map<string, CliCommand>();
-
-export function cli(opts: CliOptions): CliCommand {
-  const strategy = opts.strategy ?? (opts.browser === false ? Strategy.PUBLIC : Strategy.COOKIE);
-  const browser = opts.browser ?? (strategy !== Strategy.PUBLIC);
-  const aliases = normalizeAliases(opts.aliases, opts.name);
-  const cmd: CliCommand = {
-    site: opts.site,
-    name: opts.name,
-    aliases,
-    description: opts.description ?? '',
-    domain: opts.domain,
-    strategy,
-    browser,
-    args: opts.args ?? [],
-    columns: opts.columns,
-    func: opts.func,
-    pipeline: opts.pipeline,
-    timeoutSeconds: opts.timeoutSeconds,
-    footerExtra: opts.footerExtra,
-    requiredEnv: opts.requiredEnv,
-    deprecated: opts.deprecated,
-    replacedBy: opts.replacedBy,
-    navigateBefore: opts.navigateBefore,
-    defaultFormat: opts.defaultFormat,
-  };
-
-  registerCommand(cmd);
-  return cmd;
-}
-
-export function getRegistry(): Map<string, CliCommand> {
-  return _registry;
-}
-
-export function fullName(cmd: CliCommand): string {
-  return `${cmd.site}/${cmd.name}`;
-}
-
-export function strategyLabel(cmd: CliCommand): string {
-  return cmd.strategy ?? Strategy.PUBLIC;
-}
-
-export function registerCommand(cmd: CliCommand): void {
-  const canonicalKey = fullName(cmd);
-  const existing = _registry.get(canonicalKey);
-  if (existing) {
-    for (const [key, value] of _registry.entries()) {
-      if (value === existing && key !== canonicalKey) _registry.delete(key);
-    }
-  }
-
-  const aliases = normalizeAliases(cmd.aliases, cmd.name);
-  cmd.aliases = aliases.length > 0 ? aliases : undefined;
-  _registry.set(canonicalKey, cmd);
-  for (const alias of aliases) {
-    _registry.set(`${cmd.site}/${alias}`, cmd);
-  }
-}
-
-function normalizeAliases(aliases: string[] | undefined, commandName: string): string[] {
-  if (!Array.isArray(aliases) || aliases.length === 0) return [];
-
-  const seen = new Set<string>();
-  const normalized: string[] = [];
-  for (const alias of aliases) {
-    const value = typeof alias === 'string' ? alias.trim() : '';
-    if (!value || value === commandName || seen.has(value)) continue;
-    seen.add(value);
-    normalized.push(value);
-  }
-  return normalized;
-}

package/src/runtime-detect.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { detectRuntime, getRuntimeVersion, getRuntimeLabel } from './runtime-detect.js';
-
-describe('runtime-detect', () => {
-  it('detectRuntime returns a valid runtime string', () => {
-    const rt = detectRuntime();
-    expect(['bun', 'node']).toContain(rt);
-  });
-
-  it('getRuntimeVersion returns a non-empty version string', () => {
-    const ver = getRuntimeVersion();
-    expect(typeof ver).toBe('string');
-    expect(ver.length).toBeGreaterThan(0);
-  });
-
-  it('getRuntimeLabel returns "<runtime> <version>" format', () => {
-    const label = getRuntimeLabel();
-    expect(label).toMatch(/^(bun|node) .+$/);
-  });
-
-  it('detects the current environment correctly', () => {
-    const isBun = typeof (globalThis as any).Bun !== 'undefined';
-    const rt = detectRuntime();
-    if (isBun) {
-      expect(rt).toBe('bun');
-    } else {
-      expect(rt).toBe('node');
-    }
-  });
-});

package/src/runtime-detect.ts

@@ -1,36 +0,0 @@
-/**
- * Runtime detection — identify whether opencli is running under Node.js or Bun.
- *
- * Bun injects `globalThis.Bun` at startup, making detection trivial.
- * This module centralises the check so other code can adapt behaviour
- * (e.g. logging, diagnostics) without littering runtime sniffing everywhere.
- */
-
-export type Runtime = 'bun' | 'node';
-
-/**
- * Detect the current JavaScript runtime.
- */
-export function detectRuntime(): Runtime {
-  // Bun always exposes globalThis.Bun (including Bun.version)
-  if (typeof (globalThis as any).Bun !== 'undefined') return 'bun';
-  return 'node';
-}
-
-/**
- * Return a human-readable version string for the current runtime.
- * Examples: "v22.13.0" (Node), "1.1.42" (Bun)
- */
-export function getRuntimeVersion(): string {
-  if (detectRuntime() === 'bun') {
-    return (globalThis as any).Bun.version as string;
-  }
-  return process.version; // e.g. "v22.13.0"
-}
-
-/**
- * Return a combined label like "node v22.13.0" or "bun 1.1.42".
- */
-export function getRuntimeLabel(): string {
-  return `${detectRuntime()} ${getRuntimeVersion()}`;
-}

package/src/runtime.ts

@@ -1,86 +0,0 @@
-import { BrowserBridge, CDPBridge } from './browser/index.js';
-import type { IPage } from './types.js';
-import { TimeoutError } from './errors.js';
-import { isElectronApp } from './electron-apps.js';
-
-/**
- * Returns the appropriate browser factory based on site type.
- * Uses CDPBridge for registered Electron apps, otherwise BrowserBridge.
- */
-export function getBrowserFactory(site?: string): new () => IBrowserFactory {
-  if (site && isElectronApp(site)) return CDPBridge;
-  return BrowserBridge;
-}
-
-function parseEnvTimeout(envVar: string, fallback: number): number {
-  const raw = process.env[envVar];
-  if (raw === undefined) return fallback;
-  const parsed = parseInt(raw, 10);
-  if (Number.isNaN(parsed) || parsed <= 0) {
-    console.error(`[runtime] Invalid ${envVar}="${raw}", using default ${fallback}s`);
-    return fallback;
-  }
-  return parsed;
-}
-
-export const DEFAULT_BROWSER_CONNECT_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_CONNECT_TIMEOUT', 30);
-export const DEFAULT_BROWSER_COMMAND_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_COMMAND_TIMEOUT', 60);
-export const DEFAULT_BROWSER_EXPLORE_TIMEOUT = parseEnvTimeout('OPENCLI_BROWSER_EXPLORE_TIMEOUT', 120);
-
-/**
- * Timeout with seconds unit. Used for high-level command timeouts.
- */
-export async function runWithTimeout<T>(
-  promise: Promise<T>,
-  opts: { timeout: number; label?: string; hint?: string },
-): Promise<T> {
-  const label = opts.label ?? 'Operation';
-  return withTimeoutMs(promise, opts.timeout * 1000,
-    () => new TimeoutError(label, opts.timeout, opts.hint));
-}
-
-/**
- * Timeout with milliseconds unit. Used for low-level internal timeouts.
- * Accepts a factory function to create the rejection error, keeping this
- * utility decoupled from specific error types.
- */
-export function withTimeoutMs<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-  makeError: string | (() => Error) = 'Operation timed out',
-): Promise<T> {
-  const reject_ = typeof makeError === 'string'
-    ? () => new Error(makeError)
-    : makeError;
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => reject(reject_()), timeoutMs);
-    promise.then(
-      (value) => { clearTimeout(timer); resolve(value); },
-      (error) => { clearTimeout(timer); reject(error); },
-    );
-  });
-}
-
-/** Interface for browser factory (BrowserBridge or test mocks) */
-export interface IBrowserFactory {
-  connect(opts?: { timeout?: number; workspace?: string; cdpEndpoint?: string }): Promise<IPage>;
-  close(): Promise<void>;
-}
-
-export async function browserSession<T>(
-  BrowserFactory: new () => IBrowserFactory,
-  fn: (page: IPage) => Promise<T>,
-  opts: { workspace?: string; cdpEndpoint?: string } = {},
-): Promise<T> {
-  const browser = new BrowserFactory();
-  try {
-    const page = await browser.connect({
-      timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT,
-      workspace: opts.workspace,
-      cdpEndpoint: opts.cdpEndpoint,
-    });
-    return await fn(page);
-  } finally {
-    await browser.close().catch(() => {});
-  }
-}

package/src/scripts/framework.ts

@@ -1,20 +0,0 @@
-/**
- * Injected script for detecting frontend frameworks (Vue, React, Next, Nuxt, etc.)
- */
-export function detectFramework() {
-  const r: Record<string, boolean> = {};
-  try {
-    const app = document.querySelector('#app') as any;
-    r.vue3 = !!(app && app.__vue_app__);
-    r.vue2 = !!(app && app.__vue__);
-    r.react = !!(window as any).__REACT_DEVTOOLS_GLOBAL_HOOK__ || !!document.querySelector('[data-reactroot]');
-    r.nextjs = !!(window as any).__NEXT_DATA__;
-    r.nuxt = !!(window as any).__NUXT__;
-    if (r.vue3 && app.__vue_app__) {
-      const gp = app.__vue_app__.config?.globalProperties;
-      r.pinia = !!(gp && gp.$pinia);
-      r.vuex = !!(gp && gp.$store);
-    }
-  } catch {}
-  return r;
-}

package/src/scripts/interact.ts

@@ -1,22 +0,0 @@
-/**
- * Injected script for interactive fuzzing (clicking elements to trigger lazy loading)
- */
-export async function interactFuzz() {
-  const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
-  const clickables = Array.from(document.querySelectorAll(
-    'button, [role="button"], [role="tab"], .tab, .btn, a[href="javascript:void(0)"], a[href="#"]'
-  )).slice(0, 15); // limit to a small number to avoid endless loops
-
-  let clicked = 0;
-  for (const el of clickables) {
-    try {
-      const rect = el.getBoundingClientRect();
-      if (rect.width > 0 && rect.height > 0) {
-        el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
-        clicked++;
-        await sleep(300); // give it time to trigger network
-      }
-    } catch {}
-  }
-  return clicked;
-}

package/src/scripts/store.ts

@@ -1,40 +0,0 @@
-/**
- * Injected script for discovering Pinia or Vuex stores and their actions/state representations
- */
-export function discoverStores() {
-  const stores: Array<{ type: string; id: string; actions: string[]; stateKeys: string[] }> = [];
-  try {
-    const app = document.querySelector('#app') as any;
-    if (!app?.__vue_app__) return stores;
-    const gp = app.__vue_app__.config?.globalProperties;
-
-    // Pinia stores
-    const pinia = gp?.$pinia;
-    if (pinia?._s) {
-      pinia._s.forEach((store: any, id: string) => {
-        const actions: string[] = [];
-        const stateKeys: string[] = [];
-        for (const k in store) {
-          try {
-            if (k.startsWith('$') || k.startsWith('_')) continue;
-            if (typeof store[k] === 'function') actions.push(k);
-            else stateKeys.push(k);
-          } catch {}
-        }
-        stores.push({ type: 'pinia', id, actions: actions.slice(0, 20), stateKeys: stateKeys.slice(0, 15) });
-      });
-    }
-
-    // Vuex store modules
-    const vuex = gp?.$store;
-    if (vuex?._modules?.root?._children) {
-      const children = vuex._modules.root._children;
-      for (const [modName, mod] of Object.entries<any>(children)) {
-        const actions = Object.keys(mod._rawModule?.actions ?? {}).slice(0, 20);
-        const stateKeys = Object.keys(mod.state ?? {}).slice(0, 15);
-        stores.push({ type: 'vuex', id: modName, actions, stateKeys });
-      }
-    }
-  } catch {}
-  return stores;
-}

package/src/serialization.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { CliCommand } from './registry.js';
-import { Strategy } from './registry.js';
-import { formatRegistryHelpText, serializeCommand } from './serialization.js';
-
-describe('formatRegistryHelpText', () => {
-  it('summarizes long choices lists so help text stays readable', () => {
-    const cmd: CliCommand = {
-      site: 'demo',
-      name: 'dynamic',
-      description: 'Demo command',
-      strategy: Strategy.PUBLIC,
-      browser: false,
-      args: [
-        {
-          name: 'field',
-          help: 'Field to use',
-          choices: ['all-fields', 'topic', 'title', 'author', 'publication-titles', 'year-published', 'doi'],
-        },
-      ],
-      columns: ['field'],
-    };
-
-    expect(formatRegistryHelpText(cmd)).toContain('--field: all-fields, topic, title, author, ... (+3 more)');
-  });
-
-  it('includes aliases in structured serialization and help text', () => {
-    const cmd: CliCommand = {
-      site: 'demo',
-      name: 'get',
-      aliases: ['metadata'],
-      description: 'Demo command',
-      strategy: Strategy.COOKIE,
-      browser: true,
-      args: [],
-    };
-
-    expect(serializeCommand(cmd)).toMatchObject({
-      command: 'demo/get',
-      aliases: ['metadata'],
-    });
-    expect(formatRegistryHelpText(cmd)).toContain('Aliases: metadata');
-  });
-});

package/src/serialization.ts

@@ -1,92 +0,0 @@
-/**
- * Serialization and formatting helpers for CLI commands and args.
- *
- * Used by the `list` command, Commander --help, and build-manifest.
- * Separated from registry.ts to keep the registry focused on types + registration.
- */
-
-import type { Arg, CliCommand } from './registry.js';
-import { fullName, strategyLabel } from './registry.js';
-
-// ── Serialization ───────────────────────────────────────────────────────────
-
-export type SerializedArg = {
-  name: string;
-  type: string;
-  required: boolean;
-  valueRequired: boolean;
-  positional: boolean;
-  choices: string[];
-  default: unknown;
-  help: string;
-};
-
-/** Stable arg schema — every field is always present (no sparse objects). */
-export function serializeArg(a: Arg): SerializedArg {
-  return {
-    name: a.name,
-    type: a.type ?? 'string',
-    required: !!a.required,
-    valueRequired: !!a.valueRequired,
-    positional: !!a.positional,
-    choices: a.choices ?? [],
-    default: a.default ?? null,
-    help: a.help ?? '',
-  };
-}
-
-/** Full command metadata for structured output (json/yaml). */
-export function serializeCommand(cmd: CliCommand) {
-  return {
-    command: fullName(cmd),
-    site: cmd.site,
-    name: cmd.name,
-    aliases: cmd.aliases ?? [],
-    description: cmd.description,
-    strategy: strategyLabel(cmd),
-    browser: !!cmd.browser,
-    args: cmd.args.map(serializeArg),
-    columns: cmd.columns ?? [],
-    domain: cmd.domain ?? null,
-    deprecated: cmd.deprecated ?? null,
-    replacedBy: cmd.replacedBy ?? null,
-  };
-}
-
-// ── Formatting ──────────────────────────────────────────────────────────────
-
-/** Human-readable arg summary: `<required> [optional]` style. */
-export function formatArgSummary(args: Arg[]): string {
-  return args
-    .map(a => {
-      if (a.positional) return a.required ? `<${a.name}>` : `[${a.name}]`;
-      return a.required ? `--${a.name}` : `[--${a.name}]`;
-    })
-    .join(' ');
-}
-
-function summarizeChoices(choices: string[]): string {
-  if (choices.length <= 4) return choices.join(', ');
-  return `${choices.slice(0, 4).join(', ')}, ... (+${choices.length - 4} more)`;
-}
-
-/** Generate the --help appendix showing registry metadata not exposed by Commander. */
-export function formatRegistryHelpText(cmd: CliCommand): string {
-  const lines: string[] = [];
-  const choicesArgs = cmd.args.filter(a => a.choices?.length);
-  for (const a of choicesArgs) {
-    const prefix = a.positional ? `<${a.name}>` : `--${a.name}`;
-    const def = a.default != null ? `  (default: ${a.default})` : '';
-    lines.push(`  ${prefix}: ${summarizeChoices(a.choices!)}${def}`);
-  }
-  const meta: string[] = [];
-  meta.push(`Strategy: ${strategyLabel(cmd)}`);
-  meta.push(`Browser: ${cmd.browser ? 'yes' : 'no'}`);
-  if (cmd.domain) meta.push(`Domain: ${cmd.domain}`);
-  if (cmd.deprecated) meta.push(`Deprecated: ${typeof cmd.deprecated === 'string' ? cmd.deprecated : 'yes'}`);
-  if (cmd.replacedBy) meta.push(`Use instead: ${cmd.replacedBy}`);
-  if (cmd.aliases?.length) meta.push(`Aliases: ${cmd.aliases.join(', ')}`);
-  lines.push(meta.join(' | '));
-  if (cmd.columns?.length) lines.push(`Output columns: ${cmd.columns.join(', ')}`);
-  return '\n' + lines.join('\n') + '\n';
-}