@astryxdesign/cli 0.1.1 → 0.1.2-canary.043f3fd

package/src/commands/component-ownership.test.mjs

@@ -0,0 +1,227 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect, beforeEach, afterEach, vi} from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  discoverIntegrationComponents,
+  discoverOwnedComponents,
+  findIntegrationComponentDoc,
+  findIntegrationComponentSource,
+  CORE_PACKAGE,
+} from '../lib/component-discovery.mjs';
+
+// The api `component()` reads integrations via Project.load(). In the vitest
+// environment, Vite's `server.fs.allow` only permits loading modules from
+// under `node_modules`, so a real astryx.config.mjs at a tmp root cannot be
+// imported. We therefore mock Project.load to return a project whose
+// `loadedIntegrations` are resolved (exactly the shape lib/integrations.mjs
+// produces) while keeping the integration's `components` dir on disk under
+// node_modules so its `.doc.mjs` files load normally.
+const projectLoadMock = vi.fn();
+vi.mock('../lib/project.mjs', () => ({
+  Project: {load: (...args) => projectLoadMock(...args)},
+}));
+
+// Import the api AFTER the mock is registered.
+const {component} = await import('../api/component.mjs');
+
+let tmpDir;
+
+const INTEGRATION_NAME = '@test/meta';
+const INTEGRATION_ISSUES = 'https://example.com/meta/issues';
+
+/**
+ * Build a consumer fixture:
+ * - packages/core symlinked to the real @astryxdesign/core (loadDocs source)
+ * - node_modules/@test/meta with a `components` dir using the same-stem
+ *   source/doc convention (MetaAppShell.tsx + MetaAppShell.doc.mjs)
+ * Returns the absolute `components` dir so the Project.load mock can hand back a
+ * resolved integration entry.
+ */
+function createFixture({withSource = true, extraComponent = null} = {}) {
+  const realCoreDir = path.resolve(import.meta.dirname, '..', '..', '..', 'core');
+  const coreDir = path.join(tmpDir, 'packages', 'core');
+  fs.mkdirSync(path.dirname(coreDir), {recursive: true});
+  fs.symlinkSync(realCoreDir, coreDir);
+
+  const intDir = path.join(tmpDir, 'node_modules', '@test', 'meta');
+  const compDir = path.join(intDir, 'components');
+  fs.mkdirSync(compDir, {recursive: true});
+  fs.writeFileSync(
+    path.join(intDir, 'package.json'),
+    JSON.stringify({name: INTEGRATION_NAME, version: '1.2.3'}),
+  );
+  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`,
+  );
+  if (withSource) {
+    fs.writeFileSync(
+      path.join(compDir, 'MetaAppShell.tsx'),
+      "'use client';\nexport function MetaAppShell() { return null; }\n",
+    );
+  }
+  if (extraComponent) {
+    fs.writeFileSync(
+      path.join(compDir, `${extraComponent}.doc.mjs`),
+      `export const docs = {\n  name: '${extraComponent}',\n  usage: { description: '${extraComponent} from meta.' },\n};\n`,
+    );
+    fs.writeFileSync(
+      path.join(compDir, `${extraComponent}.tsx`),
+      `export function ${extraComponent}() { return null; }\n`,
+    );
+  }
+
+  const integration = {
+    name: INTEGRATION_NAME,
+    version: '1.2.3',
+    components: compDir,
+    templates: undefined,
+    codemods: undefined,
+    issuesUrl: INTEGRATION_ISSUES,
+  };
+  projectLoadMock.mockResolvedValue({
+    integrations: [INTEGRATION_NAME],
+    loadedIntegrations: [integration],
+  });
+  return {coreDir, intDir, compDir, integration};
+}
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-ownership-'));
+  projectLoadMock.mockReset();
+  // Default: no integrations (core only).
+  projectLoadMock.mockResolvedValue({integrations: [], loadedIntegrations: []});
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+describe('discoverIntegrationComponents (ownership records)', () => {
+  it('records name, package, sourcePath, and issuesUrl for same-stem components', () => {
+    const {integration, compDir} = createFixture();
+    const records = discoverIntegrationComponents(integration);
+    expect(records).toHaveLength(1);
+    const rec = records[0];
+    expect(rec.name).toBe('MetaAppShell');
+    expect(rec.package).toBe(INTEGRATION_NAME);
+    expect(rec.issuesUrl).toBe(INTEGRATION_ISSUES);
+    expect(rec.sourcePath).toBe(path.join(compDir, 'MetaAppShell.tsx'));
+    expect(fs.existsSync(rec.sourcePath)).toBe(true);
+  });
+
+  it('records sourcePath: null when the integration ships docs without source', () => {
+    const {integration} = createFixture({withSource: false});
+    const [rec] = discoverIntegrationComponents(integration);
+    expect(rec.sourcePath).toBeNull();
+  });
+});
+
+describe('discoverOwnedComponents (core + integrations)', () => {
+  it('marks core components with the core package and integration components with their owner', () => {
+    const {coreDir, integration} = createFixture();
+    const records = discoverOwnedComponents(coreDir, [integration]);
+    const core = records.find(r => r.package === CORE_PACKAGE);
+    expect(core).toBeTruthy();
+    expect(core.issuesUrl).toBeUndefined();
+    const meta = records.find(r => r.name === 'MetaAppShell');
+    expect(meta.package).toBe(INTEGRATION_NAME);
+    expect(meta.issuesUrl).toBe(INTEGRATION_ISSUES);
+    expect(meta.sourcePath).toContain('MetaAppShell.tsx');
+  });
+});
+
+describe('findIntegrationComponentDoc / Source', () => {
+  it('finds doc + source by name', () => {
+    const {integration} = createFixture();
+    expect(findIntegrationComponentDoc(integration, 'MetaAppShell')).toContain('MetaAppShell.doc.mjs');
+    expect(findIntegrationComponentSource(integration, 'MetaAppShell')).toContain('MetaAppShell.tsx');
+  });
+
+  it('returns null source when none present', () => {
+    const {integration} = createFixture({withSource: false});
+    expect(findIntegrationComponentSource(integration, 'MetaAppShell')).toBeNull();
+  });
+});
+
+describe('component() — integration ownership via config', () => {
+  it('discovers a config integration component by package ownership (detail)', async () => {
+    createFixture();
+    const result = await component('MetaAppShell', {cwd: tmpDir});
+    expect(result.type).toBe('component.detail');
+    expect(result.data.name).toBe('MetaAppShell');
+    expect(result.data.package).toBe(INTEGRATION_NAME);
+    expect(result.data.sourceAvailable).toBe(true);
+    expect(result.data.import).toBe(`${INTEGRATION_NAME}/MetaAppShell`);
+  });
+
+  it('--package resolves the integration component', async () => {
+    createFixture();
+    const result = await component('MetaAppShell', {cwd: tmpDir, package: INTEGRATION_NAME});
+    expect(result.type).toBe('component.detail');
+    expect(result.data.package).toBe(INTEGRATION_NAME);
+  });
+
+  it('--source returns the integration source when available', async () => {
+    createFixture();
+    const result = await component('MetaAppShell', {cwd: tmpDir, source: true});
+    expect(result.type).toBe('component.detail.source');
+    expect(result.data.component).toBe('MetaAppShell');
+    expect(result.data.source).toContain('MetaAppShell');
+  });
+
+  it('--source throws ERR_NO_SOURCE when the integration ships no source', async () => {
+    createFixture({withSource: false});
+    await expect(
+      component('MetaAppShell', {cwd: tmpDir, source: true}),
+    ).rejects.toMatchObject({code: 'ERR_NO_SOURCE'});
+  });
+
+  it('errors with candidate packages when a name is ambiguous (core + integration)', async () => {
+    // 'AppShell' exists in core; add a same-named integration component.
+    createFixture({extraComponent: 'AppShell'});
+    let caught;
+    try {
+      await component('AppShell', {cwd: tmpDir});
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).toBeTruthy();
+    expect(caught.code).toBe('ERR_UNKNOWN_COMPONENT');
+    const pkgs = (caught.suggestions ?? []).map(s => s.name);
+    expect(pkgs).toContain(CORE_PACKAGE);
+    expect(pkgs).toContain(INTEGRATION_NAME);
+  });
+
+  it('--package disambiguates an ambiguous name to core', async () => {
+    createFixture({extraComponent: 'AppShell'});
+    const result = await component('AppShell', {cwd: tmpDir, package: CORE_PACKAGE});
+    expect(result.type).toBe('component.detail');
+    expect(result.data.package).toBe(CORE_PACKAGE);
+  });
+
+  it('--package disambiguates an ambiguous name to the integration', async () => {
+    createFixture({extraComponent: 'AppShell'});
+    const result = await component('AppShell', {cwd: tmpDir, package: INTEGRATION_NAME});
+    expect(result.type).toBe('component.detail');
+    expect(result.data.package).toBe(INTEGRATION_NAME);
+  });
+
+  it('JSON list includes integration components as {name, package} objects', async () => {
+    createFixture();
+    const result = await component(undefined, {cwd: tmpDir, list: true});
+    expect(result.type).toBe('component.list');
+    const allEntries = Object.values(result.data).flat();
+    for (const entry of allEntries) {
+      expect(typeof entry.name).toBe('string');
+      expect(typeof entry.package).toBe('string');
+    }
+    const meta = allEntries.find(e => e.name === 'MetaAppShell');
+    expect(meta).toBeTruthy();
+    expect(meta.package).toBe(INTEGRATION_NAME);
+    expect(allEntries.some(e => e.package === CORE_PACKAGE)).toBe(true);
+  });
+});

package/src/commands/discover.mjs

@@ -10,7 +10,6 @@
  *   astryx discover searchterm                Search across all packages
  */
 
-import {loadConfig} from '../lib/config.mjs';
 import {formatFull, formatBrief, formatCompact} from '../lib/component-format.mjs';
 import {jsonOut, humanLog} from '../lib/json.mjs';
 import {cliError} from '../lib/cli-error.mjs';
@@ -45,27 +44,17 @@ export function registerDiscover(program) {
       switch (result.type) {
         case 'discover.list': {
           if (result.data.length === 0) {
-            const config = await loadConfig();
             humanLog('');
-            if (config.packages.length === 0) {
-              humanLog('No package directories configured.');
+            if (result.meta && result.meta.configured === false) {
+              humanLog('No integrations configured.');
               humanLog('');
-              humanLog('Add a packages field to astryx.config.mjs:');
+              humanLog('Add integration package names to astryx.config.mjs:');
               humanLog('');
               humanLog('  export default {');
-              humanLog("    packages: ['/path/to/your/libs'],");
+              humanLog("    integrations: ['@scope/your-integration'],");
               humanLog('  };');
             } else {
-              humanLog('No external packages found.');
-              humanLog('');
-              humanLog('Packages opt in by adding an "astryx" field to package.json:');
-              humanLog('');
-              humanLog('  {');
-              humanLog('    "astryx": {');
-              humanLog('      "docs": "./src",');
-              humanLog('      "category": "Common"');
-              humanLog('    }');
-              humanLog('  }');
+              humanLog('No external components found in configured integrations.');
             }
             humanLog('');
           } else {

package/src/commands/doctor.test.mjs

@@ -132,7 +132,7 @@ describe('doctor — individual checks', () => {
     );
     const configPath = path.join(fixtureDir, 'astryx.config.mjs');
     try {
-      fs.writeFileSync(configPath, 'export default { theme: "default" };');
+      fs.writeFileSync(configPath, 'export default { integrations: [] };');
       const res = await checkConfig({cwd: fixtureDir, configPath});
       if (res.status !== 'pass') {
         throw new Error(`expected pass, got ${res.status}: ${res.message}`);
@@ -158,13 +158,13 @@ describe('doctor — individual checks', () => {
     }
   });
 
-  it('config: FAIL when packages is the wrong shape', async () => {
+  it('config: FAIL when default export is not an object', async () => {
     const fixtureDir = fs.mkdtempSync(
       path.join(path.dirname(new URL(import.meta.url).pathname), '__doctor_cfg_'),
     );
     const configPath = path.join(fixtureDir, 'astryx.config.mjs');
     try {
-      fs.writeFileSync(configPath, 'export default { packages: [123] };');
+      fs.writeFileSync(configPath, 'export default 123;');
       const res = await checkConfig({cwd: fixtureDir, configPath});
       expect(res.status).toBe('fail');
     } finally {

package/src/commands/init.mjs

@@ -29,6 +29,37 @@ import {requireInteractive} from '../utils/interactive.mjs';
 const VALID_FEATURES = ['agents', 'theme', 'template'];
 const run = getRunPrefix();
 
+/**
+ * Build the "Next steps" lines printed at the end of `astryx init`.
+ *
+ * Theme guidance must match the runtime recommendation emitted by core's
+ * <Theme> component (packages/core/src/theme/Theme.tsx): the pre-built theme
+ * path (`/built` import + `theme.css`) plus the base CSS import, so users
+ * don't end up with an unstyled app or the slower runtime style-injection
+ * path. See https://github.com/facebook/astryx/issues/3080.
+ *
+ * Exported for testing.
+ *
+ * @param {string} runPrefix package-manager run prefix (e.g. `npx`)
+ * @returns {string[]} ordered list of human-facing lines
+ */
+export function getNextSteps(runPrefix) {
+  return [
+    '',
+    '  Next steps:',
+    "    1. Import base styles: import '@astryxdesign/core/reset.css'",
+    "       and import '@astryxdesign/core/astryx.css'",
+    "    2. Import components: import { Button } from '@astryxdesign/core'",
+    '    3. Optionally add a theme (use the pre-built path for performance):',
+    "       import { neutralTheme } from '@astryxdesign/theme-neutral/built'",
+    "       import '@astryxdesign/theme-neutral/theme.css'",
+    '       <Theme theme={neutralTheme}>...</Theme>',
+    `       For custom themes, run \`${runPrefix} astryx theme build <file>\` to generate the built artifacts.`,
+    `    4. ${runPrefix} astryx --help for all commands`,
+    '',
+  ];
+}
+
 function isCancel(value) {
   if (p.isCancel(value)) {
     p.cancel('Setup cancelled.');
@@ -250,13 +281,8 @@ export function registerInit(program) {
       // Outro
       p.outro('Design system initialized!');
 
-      humanLog('');
-      humanLog('  Next steps:');
-      humanLog("    1. Import components: import { Button } from '@astryxdesign/core'");
-      humanLog('    2. Optionally add a theme:');
-      humanLog("       import { neutralTheme } from '@astryxdesign/theme-neutral'");
-      humanLog('       <Theme theme={neutralTheme}>...</Theme>');
-      humanLog(`    3. ${run} astryx --help for all commands`);
-      humanLog('');
+      for (const line of getNextSteps(run)) {
+        humanLog(line);
+      }
     });
 }

package/src/commands/init.next-steps.test.mjs

@@ -0,0 +1,46 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Regression test for `astryx init` "Next steps" theme guidance.
+ *
+ * The init command previously steered users toward the slower runtime
+ * style-injection path:
+ *
+ *   import { neutralTheme } from '@astryxdesign/theme-neutral'
+ *   <Theme theme={neutralTheme}>...</Theme>
+ *
+ * ...which contradicted the runtime console warning emitted by core's
+ * <Theme> component (packages/core/src/theme/Theme.tsx) recommending the
+ * pre-built path, and left users with an unstyled app because the base CSS
+ * imports were never mentioned (facebook/astryx#3080).
+ *
+ * These assertions lock in the corrected guidance: base CSS imports, the
+ * pre-built (`/built` + `theme.css`) theme path, and the custom-theme build
+ * command.
+ */
+
+import {describe, it, expect} from 'vitest';
+import {getNextSteps} from './init.mjs';
+
+describe('init Next steps theme guidance', () => {
+  const text = getNextSteps('npx').join('\n');
+
+  it('mentions the base CSS imports so the app is not left unstyled', () => {
+    expect(text).toContain("'@astryxdesign/core/reset.css'");
+    expect(text).toContain("'@astryxdesign/core/astryx.css'");
+  });
+
+  it('uses the pre-built theme path matching the runtime recommendation', () => {
+    expect(text).toContain("'@astryxdesign/theme-neutral/built'");
+    expect(text).toContain("'@astryxdesign/theme-neutral/theme.css'");
+  });
+
+  it('mentions building custom themes via `astryx theme build`', () => {
+    expect(text).toContain('astryx theme build <file>');
+  });
+
+  it('does not steer users to the runtime style-injection import', () => {
+    // The bare source import (no `/built`) is the slow runtime-injection path.
+    expect(text).not.toContain("from '@astryxdesign/theme-neutral'");
+  });
+});

package/src/commands/json-contract.test.mjs

@@ -91,15 +91,6 @@ describe('--json contract: rejects before side effects', () => {
     expect(fs.readdirSync(tmpDir)).toEqual([]);
   });
 
-  it('astryx gap-report setup --json rejects before prompting', () => {
-    const {status, stdout} = runCli(['gap-report', 'setup', '--json'], {cwd: tmpDir});
-    expect(status).toBe(1);
-    const parsed = parseJson(stdout);
-    expect(parsed.error).toMatch(/gap-report setup/);
-    // No astryx.config.mjs written.
-    expect(fs.existsSync(path.join(tmpDir, 'astryx.config.mjs'))).toBe(false);
-  });
-
   it('astryx theme --json (parent, no subcommand) rejects without printing help', () => {
     const {status, stdout, stderr} = runCli(['theme', '--json'], {cwd: tmpDir});
     expect(status).toBe(1);
@@ -145,29 +136,6 @@ describe('--json contract: supported commands emit valid envelopes', () => {
     expect(Array.isArray(parsed.data.jsonSupported)).toBe(true);
   });
 
-  it('astryx gap-report --json --list-categories returns a typed envelope', () => {
-    const {status, stdout} = runCli(['gap-report', '--json', '--list-categories'], {cwd: tmpDir});
-    expect(status).toBe(0);
-    const parsed = parseJson(stdout);
-    expect(parsed.type).toBe('gap-report.categories');
-    expect(Array.isArray(parsed.data)).toBe(true);
-  });
-
-  it('astryx gap-report --json without required flags emits a structured error (no clack)', () => {
-    // Configure gap-report so it doesn't error on "disabled" — we want to
-    // hit the "interactive prompt would start" branch.
-    fs.writeFileSync(
-      path.join(tmpDir, 'astryx.config.mjs'),
-      'export default { gapReport: { command: "true" } };\n',
-    );
-    const {status, stdout} = runCli(['gap-report', '--json'], {cwd: tmpDir});
-    expect(status).toBe(1);
-    const parsed = parseJson(stdout);
-    expect(parsed.error).toMatch(/component/i);
-    // Must not contain clack-rendered prompt characters.
-    expect(stdout).not.toMatch(/Which component/);
-  });
-
   it('astryx upgrade --json --list returns the codemod list', () => {
     const {status, stdout} = runCli(['upgrade', '--json', '--list'], {cwd: tmpDir});
     expect(status).toBe(0);

package/src/commands/layout.mjs

@@ -0,0 +1,139 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file layout command — thin CLI wrapper around api/layout.mjs.
+ *
+ * Subcommands:
+ *   astryx layout expand "<expr>" [path]   compressed expression → validated TSX
+ *   astryx layout check "<expr>"           validate + echo both canonical surfaces
+ *   astryx layout grammar                  agent cheatsheet (alias table is branch-generated)
+ *
+ * The expression argument may also come from --file or stdin (`-`),
+ * which is how multi-line outline (XLO) input usually arrives.
+ */
+
+import * as fs from 'node:fs';
+import {jsonOut, humanLog} from '../lib/json.mjs';
+import {cliError} from '../lib/cli-error.mjs';
+import {layoutExpand, layoutCheck, layoutGrammar} from '../api/layout.mjs';
+
+/** Resolve the expression from arg, --file, or stdin ('-'). */
+async function readExpression(expr, options) {
+  if (options.file) return fs.readFileSync(options.file, 'utf-8');
+  if (expr === '-' || (!expr && !process.stdin.isTTY)) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString('utf-8');
+  }
+  return expr;
+}
+
+export function registerLayout(program) {
+  const layoutCmd = program
+    .command('layout')
+    .description('Generate XDS layouts from compressed expressions (XLE/XLO)');
+
+  layoutCmd
+    .command('expand [expression] [path]')
+    .description('Expand a layout expression into validated XDS TSX')
+    .option('--file <file>', 'Read the expression from a file')
+    .option('--form <form>', 'Input surface: compact, outline, or auto', 'auto')
+    .option('--name <name>', 'Generated component name (PascalCase)', 'GeneratedLayout')
+    .option('--loose', 'Downgrade unknown {block} hints to TODO placeholders')
+    .action(async (expression, targetPath, options) => {
+      const json = program.opts().json || false;
+      const source = await readExpression(expression, options);
+      if (!source || source.trim() === '') {
+        cliError('No layout expression given — pass it as an argument, via --file, or on stdin');
+        return;
+      }
+      let result;
+      try {
+        result = await layoutExpand(source, {
+          targetPath,
+          form: options.form,
+          loose: options.loose || false,
+          name: options.name,
+          cwd: process.cwd(),
+        });
+      } catch (e) {
+        cliError(e.message, {suggestions: e.suggestions || [], code: e.code});
+        return;
+      }
+      if (json) return jsonOut(result.type, result.data);
+
+      for (const warning of result.data.warnings) humanLog(`⚠ ${warning}`);
+      if (result.data.written) {
+        humanLog(`\n✓ Expanded to ${result.data.written}`);
+        humanLog(`  Components: ${result.data.componentsUsed.join(', ')}`);
+        if (result.data.todos.length > 0) {
+          humanLog(`  TODOs: ${result.data.todos.length} (search for "TODO(xle)")`);
+        }
+        humanLog('');
+      } else {
+        humanLog(result.data.code);
+      }
+    });
+
+  layoutCmd
+    .command('check [expression]')
+    .description('Validate a layout expression and echo canonical compact/outline forms')
+    .option('--file <file>', 'Read the expression from a file')
+    .option('--form <form>', 'Input surface: compact, outline, or auto', 'auto')
+    .option('--loose', 'Downgrade unknown {block} hints to TODO placeholders')
+    .action(async (expression, options) => {
+      const json = program.opts().json || false;
+      const source = await readExpression(expression, options);
+      if (!source || source.trim() === '') {
+        cliError('No layout expression given — pass it as an argument, via --file, or on stdin');
+        return;
+      }
+      let result;
+      try {
+        result = await layoutCheck(source, {
+          form: options.form,
+          loose: options.loose || false,
+          cwd: process.cwd(),
+        });
+      } catch (e) {
+        cliError(e.message, {suggestions: e.suggestions || [], code: e.code});
+        return;
+      }
+      if (json) return jsonOut(result.type, result.data);
+
+      const {valid, form, errors, warnings, compact, outline} = result.data;
+      if (!valid) {
+        humanLog(`\n✗ Invalid (${errors.length} error${errors.length === 1 ? '' : 's'}):`);
+        for (const e of errors) {
+          humanLog(`  - ${e.formatted}`);
+          if (e.suggestions?.length > 0) humanLog(`    did you mean: ${e.suggestions.join(', ')}?`);
+        }
+        humanLog('');
+        process.exitCode = 1;
+        return;
+      }
+      humanLog(`\n✓ Valid (parsed as ${form})`);
+      for (const warning of warnings) humanLog(`⚠ ${warning}`);
+      humanLog('\ncompact:');
+      humanLog(`  ${compact}`);
+      humanLog('\noutline:');
+      humanLog(outline.split('\n').map(l => `  ${l}`).join('\n'));
+      humanLog('');
+    });
+
+  layoutCmd
+    .command('grammar')
+    .description('Print the XLE/XLO cheatsheet (alias table generated from this branch)')
+    .action(async () => {
+      const json = program.opts().json || false;
+      let result;
+      try {
+        result = await layoutGrammar({cwd: process.cwd()});
+      } catch (e) {
+        cliError(e.message, {suggestions: e.suggestions || [], code: e.code});
+        return;
+      }
+      if (json) return jsonOut(result.type, result.data);
+      humanLog(result.data.text);
+    });
+}