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

package/foundation/response/response-types.doc.test.mjs

@@ -0,0 +1,158 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file The response-types EnumDoc names every field of the responses below,
+ * nested entry fields included. Fields come from real responses where one is
+ * cheap to produce, else from the canonical typedef.
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {describe, it, expect} from 'vitest';
+import {doc} from './response-types.doc.mjs';
+import {runCli} from '../../test-utils/run-cli.mjs';
+
+/** @param {string} type */
+const describedAs = (type) => doc.members.find((m) => m.value === type)?.description ?? '';
+
+/** @param {string} text @param {string} field */
+const names = (text, field) => new RegExp(`(^|\\W)${field}(\\W|$)`).test(text);
+
+/**
+ * Keys of an object, plus the keys of each nested object or array entry, `depth`
+ * levels down.
+ * @param {unknown} value @param {number} depth @returns {Set<string>}
+ */
+function fieldsOf(value, depth = 2) {
+  const out = new Set();
+  const visit = (/** @type {unknown} */ v, /** @type {number} */ d) => {
+    if (Array.isArray(v)) return v.forEach((item) => visit(item, d));
+    if (!v || typeof v !== 'object' || d < 0) return;
+    for (const [key, child] of Object.entries(v)) {
+      out.add(key);
+      visit(child, d - 1);
+    }
+  };
+  visit(value, depth);
+  return out;
+}
+
+/** @param {string[]} args @param {string} [cwd] */
+async function data(args, cwd) {
+  const {status, stdout} = await runCli(['--json', ...args], cwd ? {cwd} : undefined);
+  expect(status, stdout).toBe(0);
+  return JSON.parse(stdout);
+}
+
+/** @param {string} type @param {Iterable<string>} fields */
+function expectNamed(type, fields) {
+  const text = describedAs(type);
+  const missing = [...fields].filter((f) => !names(text, f));
+  expect(missing, `${type} omits`).toEqual([]);
+}
+
+describe('response-types EnumDoc names every field', () => {
+  it('component.detail: the ownership fields and parentDoc', async () => {
+    const res = await data(['component', 'HStack']);
+    expect(res.type).toBe('component.detail');
+    const ownership = ['package', 'import', 'sourceAvailable', 'parentDoc'];
+    for (const f of ownership) expect(Object.keys(res.data)).toContain(f);
+    expectNamed('component.detail', ownership);
+    // The canonical response type declares parentDoc too.
+    const types = fs.readFileSync(
+      new URL('../../api/component/component.type.mjs', import.meta.url),
+      'utf8',
+    );
+    expect(types).toMatch(/@property \{string\} \[parentDoc\]/);
+  });
+
+  it('docs.index', async () => {
+    const res = await data(['docs', 'theme', '--index']);
+    expect(res.type).toBe('docs.index');
+    expectNamed('docs.index', fieldsOf(res.data));
+  });
+
+  it('search, across component, hook, template, and doc results', async () => {
+    const mixed = await data(['search', 'dashboard', '--limit', '50']);
+    const docsOnly = await data(['search', 'tokens', '--type', 'doc']);
+    expect(new Set(mixed.data.results.map((r) => r.domain))).toContain('template');
+    expectNamed('search', new Set([...fieldsOf(mixed.data), ...fieldsOf(docsOnly.data)]));
+  });
+
+  it('build.kit, including the hint a thin kit carries', async () => {
+    const res = await data(['build', 'zzqx-nothing-matches']);
+    expect(res.type).toBe('build.kit');
+    expect(res.data.hint).toBeDefined();
+    const fields = fieldsOf(res.data, 0);
+    for (const f of Object.keys(res.data.hint)) fields.add(f);
+    expectNamed('build.kit', fields);
+  });
+
+  it('theme.targets, including deprecatedFor', async () => {
+    const res = await data(['theme', 'targets']);
+    const fields = fieldsOf(res.data);
+    expect(fields).toContain('deprecatedFor');
+    expectNamed('theme.targets', fields);
+  });
+
+  it('gap-report.file, including each delivery', async () => {
+    const res = await data(['gap-report', 'Button', '--category', 'docs_gap', '--reason', 'probe']);
+    expect(res.type).toBe('gap-report.file');
+    expect(res.data.deliveries.length).toBeGreaterThan(0);
+    expectNamed('gap-report.file', fieldsOf(res.data));
+  });
+
+  it('theme.build, including notices', async () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-response-types-'));
+    fs.writeFileSync(path.join(cwd, 'package.json'), '{"name":"app","version":"1.0.0"}');
+    await data(['theme', 'template', 'starter.ts'], cwd);
+    const res = await data(['theme', 'build', 'starter.ts', '--out', 'starter.css'], cwd);
+    expect(res.type).toBe('theme.build');
+    expectNamed('theme.build', fieldsOf(res.data));
+  });
+
+  it('integration.pack-check (fields from api/integration/pack-check.type.mjs)', () => {
+    expectNamed('integration.pack-check', [
+      // PackCheckData
+      'name',
+      'version',
+      'packable',
+      'tarball',
+      'inventory',
+      'contributions',
+      'issues',
+      // PackCheckTarball
+      'filename',
+      'fileCount',
+      'size',
+      'unpackedSize',
+      // PackCheckInventory and PackCheckInventoryRoot
+      'manifest',
+      'roots',
+      'kind',
+      'path',
+      'expectedFiles',
+      'missingFiles',
+      'complete',
+      'packedFiles',
+      // contributions, each ContributionIdentities
+      'local',
+      'packed',
+      'themes',
+      'slug',
+      'exportName',
+      'components',
+      'templates',
+      'id',
+      'type',
+      'codemods',
+      'docs',
+      'agentDocsAppend',
+      // issues, each AstryxIntegrationIssue
+      'code',
+      'severity',
+      'message',
+    ]);
+  });
+});

package/foundation/response/response.doc.mjs

@@ -12,7 +12,7 @@ export const doc = {
   type: 'schema',
   name: 'output',
   displayName: 'Output Envelope',
-  namespace: 'cli',
+  namespace: 'cli/api',
   description:
     'The single JSON envelope every command emits under --json. Success is ' +
     '{ apiVersion, type, data, meta? }; failure is { apiVersion, error, code, ' +

package/foundation/text/string-utils.mjs

@@ -56,7 +56,7 @@ export function findClosestComponents(name, components, maxDistance = 3) {
  * @returns {Promise<{name: string, score: number, reason: string}[]>}
  */
 export async function searchComponents(needle, coreDir, components) {
-  const {pathToFileURL} = await import('node:url');
+  const {readDocView} = await import('../doc-compiler/read.mjs');
   const fs = await import('node:fs');
   const path = await import('node:path');
 
@@ -100,8 +100,10 @@ export async function searchComponents(needle, coreDir, components) {
     // Levenshtein on name
     const dist = levenshteinDistance(term, compLower);
     if (dist === 1) addMatch(comp, 80, 'similar name (distance ' + dist + ')');
-    else if (dist === 2) addMatch(comp, 40, 'similar name (distance ' + dist + ')');
-    else if (dist === 3) addMatch(comp, 20, 'similar name (distance ' + dist + ')');
+    else if (dist === 2)
+      addMatch(comp, 40, 'similar name (distance ' + dist + ')');
+    else if (dist === 3)
+      addMatch(comp, 20, 'similar name (distance ' + dist + ')');
   }
 
   // --- Pass 2: Keyword + description matching (async, reads doc files) ---
@@ -124,15 +126,22 @@ export async function searchComponents(needle, coreDir, components) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const nested = path.join(srcDir, entry.name, comp, comp + '.doc.mjs');
-        if (fs.existsSync(nested)) { docPath = nested; break; }
+        if (fs.existsSync(nested)) {
+          docPath = nested;
+          break;
+        }
       }
     }
 
     if (!docPath) continue;
 
     try {
-      const mod = await import(pathToFileURL(docPath).href);
-      const docs = mod.docs;
+      // Only the legacy `docs` export has ever been indexed here.
+      const docs = await readDocView(docPath, {
+        root: 'components',
+        loader: 'native',
+        exports: ['docs'],
+      });
       if (!docs) continue;
 
       // Keyword matching
@@ -157,8 +166,10 @@ export async function searchComponents(needle, coreDir, components) {
           }
 
           const dist = levenshteinDistance(term, kwLower);
-          if (dist === 1) addMatch(comp, 70, 'keyword "' + kw + '" (distance ' + dist + ')');
-          else if (dist === 2) addMatch(comp, 30, 'keyword "' + kw + '" (distance ' + dist + ')');
+          if (dist === 1)
+            addMatch(comp, 70, 'keyword "' + kw + '" (distance ' + dist + ')');
+          else if (dist === 2)
+            addMatch(comp, 30, 'keyword "' + kw + '" (distance ' + dist + ')');
         }
       }
 
@@ -191,8 +202,9 @@ export async function searchComponents(needle, coreDir, components) {
     }
   }
 
-  const results = Array.from(scored.values())
-    .sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  const results = Array.from(scored.values()).sort(
+    (a, b) => b.score - a.score || a.name.localeCompare(b.name),
+  );
 
   return results;
 }

package/foundation/xle/expand.d.mts

@@ -21,3 +21,5 @@ export function expand(doc: {
     states: number;
     todos: string[];
 };
+/** The most copies one `*N` repeat expands to. */
+export const MAX_REPEAT: 10000;

package/foundation/xle/expand.mjs

@@ -20,7 +20,8 @@ import {PAYLOAD_PROPS} from './validate.mjs';
 import {mergeImports, renderImport, prepareSpliceModule} from './splice.mjs';
 
 const INDENT = '  ';
-const MAX_REPEAT = 10000;
+/** The most copies one `*N` repeat expands to. */
+export const MAX_REPEAT = 10000;
 
 /** @param {string | null | undefined} text */
 function slugify(text) {
@@ -544,7 +545,7 @@ class Emitter {
       const flags = hint.flags.length > 0 ? ` (+${hint.flags.join(' +')})` : '';
       const arg = hint.arg ? `:${hint.arg}` : '';
       return [
-        `${pad}{/* TODO(xle): content block '${hint.block.name}'${flags}${arg} — scaffold it with: astryx template ${hint.block.name} */}`,
+        `${pad}{/* TODO(xle): content block '${hint.block.name}'${flags}${arg} — scaffold it with: astryx template ${hint.block.name} --type block */}`,
       ];
     }
     this.todos.push(`unresolved hint {${hint.name}}`);
@@ -642,7 +643,7 @@ class Emitter {
     /** @type {import('./xle-ast').XLENode[]} */
     const out = [];
     for (const item of items) {
-      const count = item.repeat || 1;
+      const count = Math.min(item.repeat || 1, MAX_REPEAT);
       for (let i = 1; i <= count; i++) {
         const clone = count > 1 ? cloneItem(item) : item;
         if (count > 1) {

package/foundation/xle/expand.test.mjs

@@ -0,0 +1,54 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Expander tests for the repeat cap. Every path that expands a `*N`
+ * repeat — emitted children, table rows, the root count — honours MAX_REPEAT.
+ * Uses the real @astryxdesign/core registry.
+ */
+
+import {describe, it, expect, beforeAll} from 'vitest';
+import {parse} from './parse.mjs';
+import {validate} from './validate.mjs';
+import {buildRegistry} from './registry.mjs';
+import {expand, MAX_REPEAT} from './expand.mjs';
+
+/** @type {import('./xle-ast').Registry} */
+let registry;
+
+// The registry imports every component doc on first use; warm it once.
+beforeAll(async () => {
+  registry = /** @type {import('./xle-ast').Registry} */ (
+    /** @type {unknown} */ (await buildRegistry())
+  );
+}, 120_000);
+
+/**
+ * @param {string} expression
+ * @returns {string}
+ */
+function expandCode(expression) {
+  const doc = parse(expression);
+  const {errors} = validate(doc, registry, []);
+  expect(errors).toEqual([]);
+  return expand(doc, registry).code;
+}
+
+/**
+ * @param {string} code
+ * @param {string} component
+ */
+function countOpening(code, component) {
+  return (code.match(new RegExp(`<(?:XDS)?${component}\\b`, 'g')) || []).length;
+}
+
+describe('expand — repeat cap', () => {
+  it('caps a repeated child at MAX_REPEAT copies', () => {
+    expect(countOpening(expandCode(`V > B*${MAX_REPEAT + 5}`), 'Button')).toBe(MAX_REPEAT);
+  });
+
+  it('caps repeated table rows at MAX_REPEAT copies too', () => {
+    expect(countOpening(expandCode(`T > TR*${MAX_REPEAT + 5} > TC`), 'TableRow')).toBe(
+      MAX_REPEAT,
+    );
+  });
+});

package/foundation/xle/xle.test.mjs

@@ -10,6 +10,7 @@ import {describe, it, expect} from 'vitest';
 import {parse, parseCompact, parseOutline, detectForm, XLEParseError} from './parse.mjs';
 import {toCompact, toOutline} from './print.mjs';
 import {validate} from './validate.mjs';
+import {expand} from './expand.mjs';
 import {parseEnumValues, SPACING_STEPS} from './registry.mjs';
 
 // ─── parser: compact ───────────────────────────────────────────────────────
@@ -309,6 +310,18 @@ describe('validate', () => {
     expect(doc.roots[0].hint.block.name).toBe('CardCallout');
   });
 
+  it('includes --type block when a known block source is unavailable', () => {
+    const doc = parse('Bx{card-callout}');
+    expect(validate(doc, registry, BLOCKS).errors).toEqual([]);
+    const result = expand(doc, registry, {
+      componentName: 'Demo',
+      blockModules: new Map(),
+    });
+    expect(result.code).toContain(
+      'astryx template CardCallout --type block',
+    );
+  });
+
   it('enforces structural pairings', () => {
     const doc = parse('Bx > Sh');
     const {errors} = validate(doc, registry, BLOCKS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astryxdesign/cli",
-  "version": "0.6.3-canary.ea2f048",
+  "version": "0.6.3-canary.ee13359",
   "displayName": "CLI",
   "description": "Scaffold projects, browse templates, generate themes, and get agent-ready docs from the command line.",
   "author": "Meta Open Source",
@@ -91,6 +91,7 @@
     "@babel/types": "7.29.8",
     "ast-types": "0.16.3",
     "commander": "^12.1.0",
+    "ignore": "^7.0.5",
     "jiti": "^2.7.0",
     "jscodeshift": "^17.3.0",
     "node-diff3": "3.2.1",
@@ -100,11 +101,10 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@astryxdesign/charts": "0.6.3-canary.ea2f048",
-    "@astryxdesign/core": "0.6.3-canary.ea2f048",
-    "@astryxdesign/lab": "0.6.3-canary.ea2f048",
-    "@astryxdesign/theme-neutral": "0.6.3-canary.ea2f048",
-    "gpt-tokenizer": "^3.4.0"
+    "@astryxdesign/charts": "0.6.3-canary.ee13359",
+    "@astryxdesign/core": "0.6.3-canary.ee13359",
+    "@astryxdesign/lab": "0.6.3-canary.ee13359",
+    "@astryxdesign/theme-neutral": "0.6.3-canary.ee13359"
   },
   "peerDependenciesMeta": {
     "@astryxdesign/charts": {
@@ -121,14 +121,13 @@
     }
   },
   "devDependencies": {
-    "@astryxdesign/charts": "0.6.3-canary.ea2f048",
-    "@astryxdesign/core": "0.6.3-canary.ea2f048",
-    "@astryxdesign/lab": "0.6.3-canary.ea2f048",
-    "@astryxdesign/theme-neutral": "0.6.3-canary.ea2f048",
+    "@astryxdesign/charts": "0.6.3-canary.ee13359",
+    "@astryxdesign/core": "0.6.3-canary.ee13359",
+    "@astryxdesign/lab": "0.6.3-canary.ee13359",
+    "@astryxdesign/theme-neutral": "0.6.3-canary.ee13359",
     "@heroicons/react": "^2.2.0",
     "@stylexjs/stylex": "^0.19.0",
     "@types/babel__core": "^7.20.5",
-    "gpt-tokenizer": "^3.4.0",
     "lucide-react": "^1.18.0",
     "recharts": "^3.9.2"
   },

package/assets/templates/themes/manifest.json

@@ -1,95 +0,0 @@
-{
-  "version": 1,
-  "generatedBy": "scripts/generate-cli-themes.mjs",
-  "themes": [
-    {
-      "slug": "butter",
-      "displayName": "Butter",
-      "description": "Warm, creamy yellows with a friendly blue accent. Playful enough for consumer surfaces, soft enough to stay readable.",
-      "maintained": false,
-      "entry": "butterTheme.ts",
-      "exportName": "butterTheme",
-      "files": [
-        "butterTheme.ts",
-        "icons.tsx"
-      ]
-    },
-    {
-      "slug": "chocolate",
-      "displayName": "Chocolate",
-      "description": "Warm chocolate theme for Astryx — rich brown palette with Fraunces headings, Albert Sans body, and Lucide icons",
-      "maintained": false,
-      "entry": "chocolateTheme.ts",
-      "exportName": "chocolateTheme",
-      "files": [
-        "chocolateTheme.ts",
-        "icons.tsx"
-      ]
-    },
-    {
-      "slug": "gothic",
-      "displayName": "Gothic",
-      "description": "Deep blue-grays and a signature display serif. Dramatic and editorial, for surfaces that want to be remembered.",
-      "maintained": false,
-      "entry": "gothicTheme.ts",
-      "exportName": "gothicTheme",
-      "files": [
-        "gothicTheme.ts",
-        "icons.tsx"
-      ]
-    },
-    {
-      "slug": "matcha",
-      "displayName": "Matcha",
-      "description": "Earthy greens with a calm, organic feel. Naturalistic and grounded, great for wellness or content-first apps.",
-      "maintained": false,
-      "entry": "matchaTheme.ts",
-      "exportName": "matchaTheme",
-      "files": [
-        "matchaTheme.ts",
-        "icons.tsx"
-      ]
-    },
-    {
-      "slug": "neutral",
-      "displayName": "Neutral",
-      "description": "Restrained warm grays. Minimal and quiet, so the content stays the focus.",
-      "maintained": true,
-      "entry": "neutralTheme.ts",
-      "exportName": "neutralTheme",
-      "files": [
-        "neutralTheme.ts",
-        "icons.tsx",
-        "neutralPalettes.ts",
-        "neutralPalettes.generated.ts",
-        "neutralPaletteRefs.generated.ts",
-        "neutralPalettes.generated.receipt.json",
-        "palette.config.json"
-      ]
-    },
-    {
-      "slug": "stone",
-      "displayName": "Stone",
-      "description": "Warm stone and slate, earthy and understated, with just enough character to feel handcrafted.",
-      "maintained": false,
-      "entry": "stoneTheme.ts",
-      "exportName": "stoneTheme",
-      "files": [
-        "stoneTheme.ts",
-        "icons.tsx"
-      ]
-    },
-    {
-      "slug": "y2k",
-      "displayName": "Y2K",
-      "description": "Hot pinks, lime greens, and Poppins. Bubbly, playful, and unmistakably retro.",
-      "maintained": false,
-      "entry": "y2kTheme.ts",
-      "exportName": "y2kTheme",
-      "files": [
-        "y2kTheme.ts",
-        "icons.tsx"
-      ]
-    }
-  ]
-}

package/clients/cli/lib/update-check.mjs

@@ -1,83 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Check for newer @astryxdesign/core versions via local signals.
- *
- * Resolution order:
- * 1. $ASTRYX_LATEST_VERSION env var
- * 2. If unset: no hint (no network calls from this module)
- *
- * When a newer version is detected, returns a hint string for CLI output.
- * Also sets $ASTRYX_LATEST_VERSION for subsequent commands in the same shell.
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import {semverGt} from '../../../foundation/env/semver.mjs';
-import {getCliInvocation} from '../../../foundation/env/package-manager.mjs';
-
-/**
- * Read the latest available version from local signals.
- * No network calls — purely an env-var check ($ASTRYX_LATEST_VERSION),
- * so it takes no arguments.
- *
- * @returns {string|null} Latest version string, or null if unknown
- */
-export function getLatestVersion() {
-  // 1. Check env var (fastest — set by previous CLI run)
-  const envVersion = process.env.ASTRYX_LATEST_VERSION;
-  if (envVersion && /^\d+\.\d+\.\d+/.test(envVersion)) {
-    return envVersion;
-  }
-
-  return null;
-}
-
-/**
- * Get the currently installed @astryxdesign/core version from the consumer's package.json.
- *
- * @param {string} [cwd] - Project directory
- * @returns {string|null} Installed version, or null
- */
-export function getInstalledVersion(cwd = process.cwd()) {
-  try {
-    const pkgPath = path.resolve(cwd, 'package.json');
-    if (!fs.existsSync(pkgPath)) return null;
-
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-    const deps = {...pkg.dependencies, ...pkg.devDependencies};
-    const version = deps['@astryxdesign/core'];
-    if (!version) return null;
-
-    // Strip semver range prefix
-    return version.replace(/^[^\d]*/, '');
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check for available updates and return a hint string if one exists.
- * Also sets $ASTRYX_LATEST_VERSION env var for subsequent commands.
- *
- * @param {string} [cwd] - Project directory
- * @returns {string|null} FYI hint string, or null if up to date / unknown
- */
-export function checkForUpdate(cwd = process.cwd()) {
-  const latest = getLatestVersion();
-  if (!latest) return null;
-
-  // Persist for subsequent commands in this shell session
-  process.env.ASTRYX_LATEST_VERSION = latest;
-
-  const installed = getInstalledVersion(cwd);
-  if (!installed) return null;
-
-  // Use semver-aware comparison so '0.0.20' is correctly treated as greater
-  // than '0.0.5' (lexicographic compare gets that backwards).
-  if (semverGt(latest, installed)) {
-    return `FYI: A newer version of @astryxdesign/core (${latest}) is available. Install the new package version, then run: ${getCliInvocation()} upgrade --from <old-version> --apply`;
-  }
-
-  return null;
-}