@astryxdesign/cli 0.6.3-canary.ea2f048 → 0.6.3-canary.ee13359

package/clients/cli/commands/build.playbook.test.mjs

@@ -0,0 +1,75 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file The no-query `build` playbook is data. `--json` carries every step,
+ * rule and command; the text output is rendered from those values and shows
+ * nothing the envelope lacks.
+ */
+
+import {describe, it, expect} from 'vitest';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+import {program} from '../index.mjs';
+
+// Run against the monorepo root so @astryxdesign/core is discoverable.
+const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../..');
+const SLOW = 30_000;
+
+/** @param {string} s */
+const ascii = s => s.replace(/[\u2014\u2013]/g, '-');
+
+describe('build playbook: text is a projection of the JSON', () => {
+  it('prints exactly the commands, steps and rules the envelope carries', async () => {
+    const json = await runCli(['build', '--json'], REPO);
+    expect(json.status).toBe(0);
+    const {type, data} = JSON.parse(json.stdout);
+    expect(type).toBe('build.help');
+    expect(data.steps.length).toBeGreaterThan(0);
+    expect(data.rules.length).toBeGreaterThan(0);
+
+    const human = await runCli(['build'], REPO);
+    expect(human.status).toBe(0);
+    const out = human.stdout;
+
+    expect(out).toContain(ascii(data.title));
+    for (const step of data.steps) {
+      expect(out).toContain(ascii(step.title));
+      if (step.returns) expect(out).toContain(ascii(step.returns));
+    }
+    for (const rule of data.rules) expect(out).toContain(ascii(rule));
+
+    /** @type {Array<{command: string, purpose?: string}>} */
+    const commands = [
+      ...data.steps.flatMap((/** @type {any} */ s) => s.commands),
+      ...data.related,
+    ];
+    // Each command is one record whose field names are the JSON keys:
+    // `command:` (run with the caller's invocation), then `purpose:`.
+    const printed = out
+      .split('\n')
+      .filter(line => line.startsWith('command: '))
+      .map(line => line.slice('command: '.length).trim());
+    expect(printed).toHaveLength(commands.length);
+    commands.forEach(({command, purpose}, i) => {
+      expect(printed[i].endsWith(` ${command}`)).toBe(true);
+      if (purpose) expect(out).toContain(`purpose: ${ascii(purpose)}`);
+    });
+    // No column the handler drew itself.
+    expect(out).not.toMatch(/ {2,}# /);
+  }, SLOW);
+
+  it('names only commands this CLI registers', async () => {
+    const {stdout} = await runCli(['build', '--json'], REPO);
+    const {data} = JSON.parse(stdout);
+    const registered = new Set(program.commands.map(c => c.name()));
+    const commands = [
+      ...data.steps.flatMap((/** @type {any} */ s) => s.commands),
+      ...data.related,
+    ];
+    expect(commands.length).toBeGreaterThan(0);
+    for (const {command} of commands) {
+      expect(registered.has(command.split(' ')[0])).toBe(true);
+    }
+  }, SLOW);
+});

package/clients/cli/commands/build.text-fields.test.mjs

@@ -0,0 +1,40 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file `build "<idea>"` text output names only fields the `build.kit`
+ * envelope carries — on the kit itself or on its entries.
+ */
+
+import {describe, it, expect} from 'vitest';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+
+// Run against the monorepo root so @astryxdesign/core is discoverable.
+const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../..');
+const SLOW = 60_000;
+
+describe('build kit text fields mirror the JSON keys', () => {
+  it('prints no field the envelope lacks', async () => {
+    const json = await runCli(['build', 'analytics dashboard', '--json', '--verbose'], REPO);
+    expect(json.status).toBe(0);
+    const {data} = JSON.parse(json.stdout);
+    const keys = new Set([
+      ...Object.keys(data),
+      ...[...data.pages, ...data.blocks, ...data.domain].flatMap(e => Object.keys(e)),
+    ]);
+
+    const human = await runCli(['build', 'analytics dashboard', '--verbose'], REPO);
+    expect(human.status).toBe(0);
+    const fields = [
+      ...new Set(
+        human.stdout
+          .split('\n')
+          .map(line => /^([A-Za-z]+):\s/.exec(line)?.[1])
+          .filter(Boolean),
+      ),
+    ];
+    expect(fields).toContain('frame');
+    for (const field of fields) expect(keys).toContain(field);
+  }, SLOW);
+});

package/clients/cli/commands/component/index.mjs

@@ -26,7 +26,6 @@ import {defineCommand} from '../../lib/define-command.mjs';
 import {resultSet} from '../../../../foundation/debug/index.mjs';
 import {ERROR_CODES} from '../../../../foundation/response/error-codes.mjs';
 import {component as componentApi} from '../../../../api/component/component.mjs';
-import {findRelatedBlocks} from '../../../../api/template/template.mjs';
 import {Project} from '../../../../foundation/config/project.mjs';
 import {warnOnIntegrationIssues} from '../../../../foundation/integrations/integration-warnings.mjs';
 import {doc as componentCommand} from '../component.doc.mjs';
@@ -112,7 +111,7 @@ export function registerComponent(program) {
       // doctor integration validate. Best-effort; suppressed in --json mode.
       try {
         const project = await Project.load(process.cwd());
-        await warnOnIntegrationIssues(project.loadedIntegrations, {json});
+        await warnOnIntegrationIssues(project, {json});
       } catch {
         // Never let the nudge break the command.
       }
@@ -235,18 +234,14 @@ export function registerComponent(program) {
         case 'component.detail': {
           const resolvedName = (name || '').replace(/^XDS/, '');
           const importHint = result.data.import;
+          if (result.data.parentDoc) emit(record(result.data, {fields: ['parentDoc']}));
           const doc =
             detail === 'brief'
               ? code(formatBrief(result.data, resolvedName, importHint, {themeData}))
               : detail === 'compact'
                 ? code(formatCompact(result.data, resolvedName, importHint))
                 : code(formatFull(result.data, {themeData, importHint}));
-          const related = await findRelatedBlocks(resolvedName);
-          emit(
-            doc,
-            related.length > 0 && section('Related block templates'),
-            related.length > 0 && records(related, {fields: ['dirName', 'description']}),
-          );
+          emit(doc);
           break;
         }
 

package/clients/cli/commands/component-ownership.test.mjs

@@ -71,7 +71,7 @@ function createFixture({
   );
   fs.writeFileSync(
     path.join(compDir, 'MetaAppShell.doc.mjs'),
-    `export const docs = {\n  name: 'MetaAppShell',\n  usage: { description: 'Meta-flavored app shell.' },\n  props: [{ name: 'title', type: 'string', description: 'Header title' }],\n};\n`,
+    `export default {\n  type: 'component',\n  name: 'MetaAppShell',\n  usage: { description: 'Meta-flavored app shell.' },\n  props: [{ name: 'title', type: 'string', description: 'Header title' }],\n};\n`,
   );
   if (withSource) {
     fs.writeFileSync(
@@ -82,7 +82,7 @@ function createFixture({
   if (extraComponent) {
     fs.writeFileSync(
       path.join(compDir, `${extraComponent}.doc.mjs`),
-      `export const docs = {\n  name: '${extraComponent}',\n  usage: { description: '${extraComponent} from meta.' },\n};\n`,
+      `export default {\n  type: 'component',\n  name: '${extraComponent}',\n  usage: { description: '${extraComponent} from meta.' },\n  props: [],\n};\n`,
     );
     fs.writeFileSync(
       path.join(compDir, `${extraComponent}.tsx`),
@@ -100,7 +100,7 @@ function createFixture({
       : '';
     fs.writeFileSync(
       path.join(entryDir, `${entryPoint.component}.doc.mjs`),
-      `export const docs = {\n  name: '${entryPoint.component}',${ownSpecifier}\n  usage: { description: '${entryPoint.component} from an entry point.' },\n};\n`,
+      `export default {\n  type: 'component',\n  name: '${entryPoint.component}',${ownSpecifier}\n  usage: { description: '${entryPoint.component} from an entry point.' },\n  props: [],\n};\n`,
     );
   }
 

package/clients/cli/commands/component-package.test.mjs

@@ -5,6 +5,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import {component} from '../../../api/component/component.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
 
 // These tests create a minimal monorepo fixture with:
 // - packages/core (symlinked to real @astryxdesign/core for loadDocs compatibility)
@@ -120,4 +121,49 @@ describe('component() with --package option', () => {
     expect(result.data.source).toContain('ProfileCardShowcase');
     expect(result.data.aspectRatio).toBeCloseTo(16 / 9);
   });
+
+  // A legacy package ships docs only: --source and --blocks answer the same
+  // way scoped as unscoped, never falling back to the plain doc.
+  it('--package + --source reports the missing source, like the unscoped lookup', async () => {
+    await expect(
+      component('ProfileCard', {cwd: tmpDir, source: true}),
+    ).rejects.toMatchObject({code: 'ERR_NO_SOURCE'});
+    await expect(
+      component('ProfileCard', {cwd: tmpDir, package: '@test/ext', source: true}),
+    ).rejects.toMatchObject({code: 'ERR_NO_SOURCE'});
+  });
+
+  it('--package + --blocks returns the blocks, like the unscoped lookup', async () => {
+    const unscoped = await component('ProfileCard', {cwd: tmpDir, blocks: true});
+    const scoped = await component('ProfileCard', {cwd: tmpDir, package: '@test/ext', blocks: true});
+    expect(scoped.type).toBe('component.detail.blocks');
+    expect(scoped.data).toEqual(unscoped.data);
+  });
+
+  // `cwd` is an explicit API input: --blocks must discover from it, as
+  // --showcase does, not from the process working directory.
+  it('--blocks discovers blocks from options.cwd, like --showcase', async () => {
+    const showcase = await component('ProfileCard', {cwd: tmpDir, showcase: true});
+    expect(showcase.data.source).toContain('ProfileCardShowcase');
+
+    const blocks = await component('ProfileCard', {cwd: tmpDir, blocks: true});
+    expect(blocks.type).toBe('component.detail.blocks');
+    expect(blocks.data.showcase?.name).toBe('ProfileCardShowcase');
+  });
+
+  // List and detail report one import for a legacy package component; the
+  // text list projects the JSON value instead of deriving a Core path.
+  it('the names list gives a legacy package component the import its detail reports', async () => {
+    const detail = await component('ProfileCard', {cwd: tmpDir});
+    const list = await component(undefined, {cwd: tmpDir, list: true});
+    const entry = Object.values(list.data.components)
+      .flat()
+      .find(e => e.name === 'ProfileCard' && e.package === '@test/ext');
+    expect(entry?.import).toBe(detail.data.import);
+
+    const text = await runCli(['component', '--list'], tmpDir);
+    expect(text.code).toBe(0);
+    expect(text.stdout).toContain(`name:   ProfileCard\nimport: ${detail.data.import}  [@test/ext]`);
+    expect(text.stdout).not.toMatch(/^import: +@astryxdesign\/core\S* +\[@test\/ext\]$/m);
+  });
 });

package/clients/cli/commands/component-resolution.test.mjs

@@ -3,6 +3,7 @@
 import {describe, it, expect} from 'vitest';
 import {component} from '../../../api/component/component.mjs';
 import {findShowcase, findRelatedBlocks} from '../../../api/template/template.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
 
 const CWD = {cwd: '.'};
 
@@ -74,6 +75,26 @@ describe('component() sub-component scoping', () => {
     const result = await component('SideNav', CWD);
     expect(result.data.name).toBe('SideNav');
   });
+
+  // `parentDoc` is part of the component.detail schema: the text view
+  // projects it under the same key.
+  it('component("HStack") names its parent doc in JSON and text', async () => {
+    const result = await component('HStack', CWD);
+    expect(result.data.parentDoc).toBe('Stack');
+
+    const text = await runCli(['component', 'HStack'], process.cwd());
+    expect(text.code).toBe(0);
+    expect(text.stdout).toMatch(/^parentDoc: +Stack$/m);
+  });
+
+  it('component("Stack") carries no parentDoc in JSON or text', async () => {
+    const result = await component('Stack', CWD);
+    expect(result.data).not.toHaveProperty('parentDoc');
+
+    const text = await runCli(['component', 'Stack'], process.cwd());
+    expect(text.code).toBe(0);
+    expect(text.stdout).not.toMatch(/^parentDoc:/m);
+  });
 }, SCAN_TIMEOUT);
 
 // ─── Bug: findShowcase priority ─────────────────────────────────

package/clients/cli/commands/component.doc.mjs

@@ -13,7 +13,7 @@ export const doc = {
   type: 'command',
   name: 'component',
   displayName: 'astryx component',
-  namespace: 'cli',
+  namespace: 'cli/commands',
   summary: 'List components or print component docs',
   description:
     'Resolves a component by name across core and integration packages and prints ' +

package/clients/cli/commands/component.test.mjs

@@ -13,6 +13,9 @@ import {
   levenshteinDistance,
   findClosestComponents,
 } from './component/index.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+
+const REPO_ROOT = path.resolve(import.meta.dirname, '../../../../..');
 
 let tmpDir;
 
@@ -591,3 +594,19 @@ describe('searchComponents', () => {
     expect(results.length).toBe(0);
   });
 });
+
+describe('component <Name> text output', () => {
+  // The text is a projection of the JSON envelope: it may show less, never
+  // data the envelope does not carry.
+  it('shows no related-block records that the JSON lacks', async () => {
+    const json = await runCli(['--json', 'component', 'Button'], REPO_ROOT);
+    expect(json.code).toBe(0);
+    expect(JSON.stringify(JSON.parse(json.stdout).data)).not.toContain('dirName');
+
+    const text = await runCli(['component', 'Button'], REPO_ROOT);
+    expect(text.code).toBe(0);
+    expect(text.stdout).toContain('# Button');
+    expect(text.stdout).not.toMatch(/^dirName:/m);
+    expect(text.stdout).not.toContain('Related block templates');
+  }, 30_000);
+});

package/clients/cli/commands/detail-levels.test.mjs

@@ -52,7 +52,7 @@ describe('--detail level ordering: component --list', () => {
 
   it('brief is names-only (no targets, import hints, or prose descriptions)', () => {
     expect(brief).not.toMatch(/Targets:/);
-    expect(brief).not.toMatch(/\u2190 from/);
+    expect(brief).not.toMatch(/<- from/);
     // Names only — should contain XDS component names but no " — " desc separator.
     expect(brief).toMatch(/Button/);
     expect(brief).not.toMatch(/ \u2014 /);
@@ -66,7 +66,7 @@ describe('--detail level ordering: component --list', () => {
 
   it('full has dense per-entry docs (props, targets, and import hints)', () => {
     expect(full).toMatch(/Targets:/);
-    expect(full).toMatch(/\u2190 from/);
+    expect(full).toMatch(/<- from/);
     // Prop name lists appear in the dense brief-all rendering.
     expect(full).toMatch(/children/);
   });

package/clients/cli/commands/discover.broken-integration.test.mjs

@@ -69,11 +69,12 @@ describe('astryx discover with a manifest that fails to load', () => {
 
     expect(status).toBe(0);
     expect(stderr).toContain(
-      'Warning: @test/broken has 1 integration issue(s). ' +
-        'Run: astryx doctor integration validate @test/broken',
+      'Warning: @test/broken has 1 integration issue(s). Run: astryx doctor',
     );
     expect(stdout).not.toContain('No integrations configured.');
-    expect(stdout).toContain('No external components found in configured integrations.');
+    expect(stdout).toContain(
+      'No external components found in configured integrations.',
+    );
   });
 
   it('reports meta.configured=true in --json, with the nudge suppressed', async () => {
@@ -87,6 +88,53 @@ describe('astryx discover with a manifest that fails to load', () => {
   });
 });
 
+describe('astryx discover with a configured package that is not installed', () => {
+  beforeEach(() => {
+    const healthy = path.join(project, 'node_modules', '@test', 'healthy');
+    fs.mkdirSync(path.join(healthy, 'components'), {recursive: true});
+    fs.writeFileSync(
+      path.join(healthy, 'package.json'),
+      JSON.stringify({name: '@test/healthy', version: '2.0.0'}),
+    );
+    fs.writeFileSync(
+      path.join(healthy, 'astryx.integration.mjs'),
+      `export default {components: './components'};\n`,
+    );
+    fs.writeFileSync(
+      path.join(healthy, 'components', 'Widget.doc.mjs'),
+      `export const docs = {name: 'Widget', usage: {description: 'A widget.'}, props: []};\n`,
+    );
+    fs.writeFileSync(
+      path.join(healthy, 'components', 'Widget.tsx'),
+      `export function Widget() { return null; }\n`,
+    );
+    fs.writeFileSync(
+      path.join(project, 'astryx.config.mjs'),
+      `export default {integrations: ['@test/missing', '@test/healthy']};\n`,
+    );
+  });
+
+  it('still lists the healthy package and exits 0', async () => {
+    const {status, stdout} = await runCli(['discover', '--json'], {
+      cwd: project,
+    });
+
+    expect(status).toBe(0);
+    expect(JSON.parse(stdout).data).toEqual([
+      expect.objectContaining({name: '@test/healthy', components: ['Widget']}),
+    ]);
+  });
+
+  it('names the missing package in the stderr nudge', async () => {
+    const {status, stderr} = await runCli(['discover'], {cwd: project});
+
+    expect(status).toBe(0);
+    expect(stderr).toContain(
+      'Warning: @test/missing has 1 integration issue(s). Run: astryx doctor\n',
+    );
+  });
+});
+
 describe('astryx search with a manifest that fails to load', () => {
   // search needs a resolvable @astryxdesign/core; without one it errors out
   // before it can list anything, which is not the case under test.
@@ -101,8 +149,7 @@ describe('astryx search with a manifest that fails to load', () => {
 
     expect(status).toBe(0);
     expect(stderr).toContain(
-      'Warning: @test/broken has 1 integration issue(s). ' +
-        'Run: astryx doctor integration validate @test/broken',
+      'Warning: @test/broken has 1 integration issue(s). Run: astryx doctor',
     );
 
     const asJson = await runCli(['search', 'button', '--json'], {cwd: project});

package/clients/cli/commands/discover.components-flag.test.mjs

@@ -0,0 +1,97 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file `astryx discover --components` does what its doc says.
+ *
+ * The flag only lifts the package list's component summary (the first 10
+ * names plus "+N more") so every component prints. It changes nothing in
+ * `--json`, whose entries always carry the full array.
+ */
+
+import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+import {doc} from './discover.doc.mjs';
+import {doc as discoverFn} from '../../../api/discover/discover.doc.mjs';
+
+const NAMES = Array.from({length: 12}, (_, i) => `Part${String(i).padStart(2, '0')}`);
+
+let tmpDir;
+let project;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-discover-components-'));
+  project = path.join(tmpDir, 'project');
+  const pkgDir = path.join(project, 'node_modules', '@test', 'kit');
+  fs.mkdirSync(path.join(pkgDir, 'components'), {recursive: true});
+  fs.writeFileSync(
+    path.join(project, 'package.json'),
+    JSON.stringify({name: 'proj', version: '1.0.0'}),
+  );
+  fs.writeFileSync(
+    path.join(project, 'astryx.config.mjs'),
+    `export default {integrations: ['@test/kit']};\n`,
+  );
+  fs.writeFileSync(
+    path.join(pkgDir, 'package.json'),
+    JSON.stringify({name: '@test/kit', version: '1.0.0'}),
+  );
+  fs.writeFileSync(
+    path.join(pkgDir, 'astryx.integration.mjs'),
+    `export default {components: './components'};\n`,
+  );
+  for (const name of NAMES) {
+    fs.writeFileSync(
+      path.join(pkgDir, 'components', `${name}.doc.mjs`),
+      `export const docs = {name: '${name}', usage: {description: 'A part.'}};\n`,
+    );
+    fs.writeFileSync(
+      path.join(pkgDir, 'components', `${name}.tsx`),
+      `export function ${name}() { return null; }\n`,
+    );
+  }
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+/** @param {string} stdout */
+function componentsLine(stdout) {
+  return stdout.split('\n').find(line => line.startsWith('components:'));
+}
+
+describe('astryx discover --components', () => {
+  it('lists every component where the default list shows the first 10', async () => {
+    const summary = await runCli(['discover'], {cwd: project});
+    const full = await runCli(['discover', '--components'], {cwd: project});
+
+    expect(componentsLine(summary.stdout)).toMatch(
+      new RegExp(`${NAMES[9]}, \\+2 more$`),
+    );
+    expect(componentsLine(full.stdout)).toMatch(new RegExp(`${NAMES.join(', ')}$`));
+  });
+
+  it('leaves the --json response unchanged', async () => {
+    const plain = await runCli(['discover', '--json'], {cwd: project});
+    const flagged = await runCli(['discover', '--components', '--json'], {
+      cwd: project,
+    });
+
+    expect(JSON.parse(flagged.stdout)).toEqual(JSON.parse(plain.stdout));
+  });
+
+  it('is documented as that behavior, with an example', () => {
+    const option = doc.options?.find(o => o.flag === '--components');
+    const param = discoverFn.params?.find(p => p.name === 'options.components');
+
+    for (const description of [option?.description, param?.description]) {
+      expect(description).toMatch(/every component/i);
+      expect(description).toMatch(/first 10/);
+      expect(description).not.toMatch(/components only/i);
+    }
+    expect(doc.examples?.some(e => /\s--components\b/.test(e.cli))).toBe(true);
+  });
+});

package/clients/cli/commands/discover.doc.mjs

@@ -13,7 +13,7 @@ export const doc = {
   type: 'command',
   name: 'discover',
   displayName: 'astryx discover',
-  namespace: 'cli',
+  namespace: 'cli/commands',
   summary: 'Discover external packages and components',
   description:
     'Explores components contributed by configured external packages and integrations. ' +
@@ -25,18 +25,20 @@ export const doc = {
     {
       flag: '--components',
       param: 'options.components',
-      description: 'List components only',
+      description:
+        'In the package list, print every component of each package instead of the first 10 and a "+N more" count. No effect on --json output or on a package, component, or search query.',
     },
   ],
   examples: [
     {label: 'List packages', cli: 'astryx discover --json'},
+    {label: 'List every component of each package', cli: 'astryx discover --components'},
     {label: 'Browse a package', cli: 'astryx discover @acme/ui'},
   ],
   exitCodes: [
     {code: 0, when: 'success'},
     {
       code: 1,
-      when: 'unknown package or component, a malformed doc, or an empty free-text query',
+      when: 'unknown package or component, a malformed doc, or a blank query when packages are discovered',
     },
   ],
   related: ['component', 'search', 'template'],

package/clients/cli/commands/discover.mjs

@@ -83,7 +83,7 @@ export function registerDiscover(program) {
       // doctor integration validate. Best-effort; suppressed in --json mode.
       try {
         const project = await Project.load(process.cwd());
-        await warnOnIntegrationIssues(project.loadedIntegrations, {json});
+        await warnOnIntegrationIssues(project, {json});
       } catch {
         // Never let the nudge break the command.
       }
@@ -122,11 +122,11 @@ export function registerDiscover(program) {
             break;
           }
 
-          // One record per package — fields mirror the JSON entry. The default
+          // One record per package, every field of the JSON entry. The default
           // view summarizes each package's components (first N + "+N more");
           // --components lists them all (record comma-joins the full array).
           /** @type {import('../formatters/index.mjs').RecordOptions} */
-          const listOpts = {fields: ['displayName', 'name', 'description', 'components']};
+          const listOpts = {};
           if (!options.components) {
             listOpts.format = {
               components: (/** @type {string[]} */ comps) => {
@@ -155,7 +155,7 @@ export function registerDiscover(program) {
         case 'discover.detail': {
           const d = result.data;
           emit(
-            record(d, {fields: ['displayName', 'name', 'description', 'components']}),
+            record(d),
             text(`Usage: ${run} discover ${d.name}/<ComponentName>`),
           );
           break;