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

package/foundation/discovery/docs-discovery.test.mjs

@@ -31,7 +31,9 @@ function topic(fields) {
     name: 'deploying',
     title: 'Deploying',
     description: 'How to ship it.',
-    sections: [{title: 'Overview', content: [{type: 'prose', text: 'Ship it.'}]}],
+    sections: [
+      {title: 'Overview', content: [{type: 'prose', text: 'Ship it.'}]},
+    ],
     ...fields,
   };
 }
@@ -97,7 +99,9 @@ describe('discoverIntegrationDocs', () => {
       }),
     );
     expect(errors).toEqual([]);
-    expect(records.map(r => [r.name, r.package, r.replaces, r.extendsTopic])).toEqual([
+    expect(
+      records.map(r => [r.name, r.package, r.replaces, r.extendsTopic]),
+    ).toEqual([
       ['deploying', '@acme/widgets', undefined, undefined],
       ['getting-started', '@acme/widgets', 'getting-started', undefined],
       ['theme-extra', '@acme/widgets', undefined, 'theme'],
@@ -126,7 +130,9 @@ describe('discoverIntegrationDocs', () => {
 
   it('reports a doc that exports nothing, rather than skipping it silently', async () => {
     const {records, errors} = await discoverIntegrationDocs(
-      integration('@acme/empty', {'deploying.doc.mjs': 'export const nope = 1;\n'}),
+      integration('@acme/empty', {
+        'deploying.doc.mjs': 'export const nope = 1;\n',
+      }),
     );
     expect(records).toEqual([]);
     expect(errors).toHaveLength(1);
@@ -153,6 +159,49 @@ describe('discoverIntegrationDocs', () => {
     expect(records).toEqual([]);
     expect(errors[0].message).toContain('declares both');
   });
+
+  it('rejects graph blocks at the legacy topic-reader boundary', async () => {
+    const {records, errors} = await discoverIntegrationDocs(
+      integration('@acme/graph-block', {
+        'deploying.doc.mjs': topic({
+          sections: [
+            {
+              id: 'steps',
+              title: 'Steps',
+              content: [
+                {
+                  type: 'workflow',
+                  steps: [{title: 'Install', description: 'Run install.'}],
+                },
+              ],
+            },
+          ],
+        }),
+      }),
+    );
+    expect(records).toEqual([]);
+    expect(errors[0].message).toContain('requires the compiled graph renderer');
+  });
+
+  it('names a namespace doc instead of listing topic fields it lacks', async () => {
+    const {records, errors} = await discoverIntegrationDocs(
+      integration('@acme/namespace', {
+        'guides.doc.mjs': {
+          type: 'namespace',
+          name: 'guides',
+          title: 'Guides',
+          summary: 'Every guide.',
+          slots: {guides: {title: 'Guides', accepts: {kinds: ['generic']}}},
+        },
+      }),
+    );
+    expect(records).toEqual([]);
+    expect(errors).toHaveLength(1);
+    expect(errors[0].message).toContain(
+      '"guides" is a namespace doc. Only the docs graph reads namespace docs',
+    );
+    expect(errors[0].message).not.toContain('sections:');
+  });
 });
 
 describe('problemsInTopic', () => {
@@ -170,7 +219,11 @@ describe('problemsInTopic', () => {
     // A misspelled required field: the block renders nothing at all.
     expect(
       problemsInTopic(
-        topic({sections: [{title: 'Overview', content: [{type: 'prose', txt: 'oops'}]}]}),
+        topic({
+          sections: [
+            {title: 'Overview', content: [{type: 'prose', txt: 'oops'}]},
+          ],
+        }),
       ),
     ).toEqual([
       'sections[0].content[0].text: required for a prose block',
@@ -180,7 +233,12 @@ describe('problemsInTopic', () => {
     expect(
       problemsInTopic(
         topic({
-          sections: [{title: 'Overview', content: [{type: 'heading', level: 2, text: 'x'}]}],
+          sections: [
+            {
+              title: 'Overview',
+              content: [{type: 'heading', level: 2, text: 'x'}],
+            },
+          ],
         }),
       ),
     ).toContain('sections[0].content[0].level: 2 is not one of 3, 4, 5, 6');
@@ -196,11 +254,27 @@ describe('problemsInTopic', () => {
           ],
         }),
       ),
-    ).toContain('sections[0].content[0].rows[0]: has 1 cells but the table has 2 headers');
+    ).toContain(
+      'sections[0].content[0].rows[0]: has 1 cells but the table has 2 headers',
+    );
+  });
+
+  it('rejects graph metadata at the legacy topic-reader boundary', () => {
+    for (const fields of [
+      {placement: {parent: 'namespace:cli'}},
+      {aliases: ['setup']},
+      {audience: 'internal'},
+    ]) {
+      expect(problemsInTopic(topic(fields)).join('\n')).toContain(
+        'requires the compiled graph reader',
+      );
+    }
   });
 
   it('rejects a name that is not URL-safe', () => {
-    expect(problemsInTopic(topic({name: 'not a topic'})).join('\n')).toContain('URL-safe');
+    expect(problemsInTopic(topic({name: 'not a topic'})).join('\n')).toContain(
+      'URL-safe',
+    );
   });
 });
 
@@ -228,11 +302,23 @@ describe('DocsCatalog', () => {
     expect(catalog.resolve('deploying').package).toBe('@acme/widgets');
   });
 
+  it('treats topic identities case-insensitively without losing display case', () => {
+    const catalog = DocsCatalog.fromBuiltins();
+    expect(catalog.add(record({name: 'Deploying'}))).toBeNull();
+    expect(catalog.resolve('deploying').name).toBe('Deploying');
+    expect(catalog.resolve('DEPLOYING').name).toBe('Deploying');
+
+    const issue = catalog.add(
+      record({name: 'deploying', package: '@acme/duplicate'}),
+    );
+    expect(issue).toMatchObject({code: 'invalid_doc', severity: 'error'});
+  });
+
   it('refuses to shadow an existing topic by name alone', () => {
     const catalog = DocsCatalog.fromBuiltins({tokens: '/cli/tokens.doc.mjs'});
     const issue = catalog.add(record({name: 'tokens'}));
     expect(issue).toMatchObject({code: 'invalid_doc', severity: 'error'});
-    expect(issue.message).toContain("already provided by @astryxdesign/cli");
+    expect(issue.message).toContain('already provided by @astryxdesign/cli');
     expect(issue.message).toContain("replaces: 'tokens'");
     // The built-in topic is untouched.
     expect(catalog.resolve('tokens').package).toBe(BUILTIN_DOCS_PACKAGE);
@@ -244,7 +330,9 @@ describe('DocsCatalog', () => {
       tokens: '/cli/tokens.doc.mjs',
     });
     expect(
-      catalog.add(record({name: 'getting-started', replaces: 'getting-started'})),
+      catalog.add(
+        record({name: 'getting-started', replaces: 'getting-started'}),
+      ),
     ).toBeNull();
     expect(catalog.names()).toEqual(['getting-started', 'tokens']);
     const entry = catalog.resolve('getting-started');
@@ -276,12 +364,16 @@ describe('DocsCatalog', () => {
 
   it('warns, and lets the later package win, when two replace one topic', () => {
     const catalog = DocsCatalog.fromBuiltins({tokens: '/cli/tokens.doc.mjs'});
-    expect(catalog.add(record({name: 'tokens', replaces: 'tokens'}))).toBeNull();
+    expect(
+      catalog.add(record({name: 'tokens', replaces: 'tokens'})),
+    ).toBeNull();
     const issue = catalog.add(
       record({name: 'tokens', package: '@acme/later', replaces: 'tokens'}),
     );
     expect(issue).toMatchObject({code: 'duplicate_doc', severity: 'warning'});
-    expect(issue.message).toContain('@acme/later is configured later, so it wins');
+    expect(issue.message).toContain(
+      '@acme/later is configured later, so it wins',
+    );
     expect(catalog.resolve('tokens').package).toBe('@acme/later');
   });
 
@@ -327,15 +419,189 @@ describe('mergeTopic', () => {
         {title: 'Internal', content: [{type: 'prose', text: 'the meta way'}]},
       ],
     });
-    expect(merged.sections.map(s => s.title)).toEqual(['Install', 'Tokens', 'Internal']);
+    expect(merged.sections.map(s => s.title)).toEqual([
+      'Install',
+      'Tokens',
+      'Internal',
+    ]);
     expect(merged.sections[0].content[0].text).toBe('yarn add');
     expect(merged.sections[1].content[0].text).toBe('use tokens');
     // The base is untouched.
     expect(base.sections[0].content[0].text).toBe('npm i');
   });
 
+  it('replaces a section by stable ID even when its title changes', () => {
+    const merged = mergeTopic(
+      {
+        ...base,
+        sections: [
+          {id: 'install', title: 'Install', content: []},
+          {id: 'tokens', title: 'Tokens', content: []},
+        ],
+      },
+      {
+        sections: [{id: 'install', title: 'Setup', content: []}],
+      },
+    );
+    expect(merged.sections.map(section => [section.id, section.title])).toEqual(
+      [
+        ['install', 'Setup'],
+        ['tokens', 'Tokens'],
+      ],
+    );
+  });
+
+  it('migrates a legacy section to a stable ID without duplicating it', () => {
+    const merged = mergeTopic(base, {
+      sections: [
+        {
+          id: 'install',
+          title: 'Install',
+          content: [{type: 'prose', text: 'yarn add'}],
+        },
+      ],
+    });
+    expect(
+      merged.sections.map(section => [section.id ?? null, section.title]),
+    ).toEqual([
+      ['install', 'Install'],
+      [null, 'Tokens'],
+    ]);
+    expect(merged.sections[0].content[0].text).toBe('yarn add');
+  });
+
+  it('lets a legacy extension replace a section that has since gained an ID', () => {
+    const merged = mergeTopic(
+      {
+        ...base,
+        sections: [
+          {id: 'setup-steps', title: 'Install', content: []},
+          {title: 'Tokens', content: []},
+        ],
+      },
+      {
+        sections: [
+          {title: 'Install', content: [{type: 'prose', text: 'yarn add'}]},
+        ],
+      },
+    );
+    expect(
+      merged.sections.map(section => [section.id ?? null, section.title]),
+    ).toEqual([
+      ['setup-steps', 'Install'],
+      [null, 'Tokens'],
+    ]);
+    expect(merged.sections[0].content[0].text).toBe('yarn add');
+  });
+
+  it('keeps two different authored IDs distinct under one title', () => {
+    const merged = mergeTopic(
+      {...base, sections: [{id: 'install', title: 'Install', content: []}]},
+      {sections: [{id: 'install-yarn', title: 'Install', content: []}]},
+    );
+    expect(merged.sections.map(section => section.id)).toEqual([
+      'install',
+      'install-yarn',
+    ]);
+  });
+
   it('takes the title and description only when the overlay states them', () => {
     expect(mergeTopic(base, {sections: []}).title).toBe('Theme');
-    expect(mergeTopic(base, {title: 'Theming', sections: []}).title).toBe('Theming');
+    expect(mergeTopic(base, {title: 'Theming', sections: []}).title).toBe(
+      'Theming',
+    );
+  });
+});
+
+describe('problemsInTopic section keys', () => {
+  /** @param {object[]} sections */
+  const doc = sections => ({
+    type: 'generic',
+    name: 'keys',
+    title: 'Keys',
+    description: 'Section keys.',
+    sections: sections.map(s => ({
+      content: [{type: 'prose', text: 'x'}],
+      ...s,
+    })),
+  });
+
+  it('rejects two sections that derive the same key', () => {
+    expect(
+      problemsInTopic(doc([{title: 'Quick Start'}, {title: 'Quick-start'}])),
+    ).toEqual([
+      expect.stringContaining('"quick-start" is already used by sections[0]'),
+    ]);
+  });
+
+  it('rejects an unsafe id', () => {
+    expect(
+      problemsInTopic(doc([{id: 'Quick Start', title: 'Quick Start'}])),
+    ).toEqual([expect.stringContaining('is not a stable key')]);
+  });
+
+  it('rejects a title no key derives from, unless it has an id', () => {
+    expect(problemsInTopic(doc([{title: '亮/暗模式'}]))).toEqual([
+      expect.stringContaining('Give the section an id'),
+    ]);
+    expect(
+      problemsInTopic(doc([{id: 'light-dark', title: '亮/暗模式'}])),
+    ).toEqual([]);
+  });
+});
+
+describe('mergeTopic by section key', () => {
+  const base = {
+    title: 'Theme',
+    sections: [
+      {title: 'Quick Start', content: [{type: 'prose', text: 'base'}]},
+      {title: 'Light/Dark Mode', content: [{type: 'prose', text: 'base'}]},
+    ],
+  };
+  const titles = doc =>
+    doc.sections.map(s => [s.id ?? null, s.title, s.content[0].text]);
+
+  it('replaces the section whose derived key an extension id names', () => {
+    const merged = mergeTopic(base, {
+      sections: [
+        {
+          id: 'quick-start',
+          title: 'Quick Start with Acme',
+          content: [{type: 'prose', text: 'acme'}],
+        },
+      ],
+    });
+    expect(titles(merged)).toEqual([
+      ['quick-start', 'Quick Start with Acme', 'acme'],
+      [null, 'Light/Dark Mode', 'base'],
+    ]);
+  });
+
+  it('replaces the section a title variant derives the same key as', () => {
+    const merged = mergeTopic(base, {
+      sections: [
+        {title: 'Light-Dark Mode', content: [{type: 'prose', text: 'acme'}]},
+      ],
+    });
+    expect(titles(merged)).toEqual([
+      [null, 'Quick Start', 'base'],
+      [null, 'Light-Dark Mode', 'acme'],
+    ]);
+  });
+
+  it('prefers the key over a legacy title for an extension with an id', () => {
+    const merged = mergeTopic(base, {
+      sections: [
+        {
+          id: 'light-dark-mode',
+          title: 'Quick Start',
+          content: [{type: 'prose', text: 'acme'}],
+        },
+      ],
+    });
+    expect(titles(merged)).toEqual([
+      [null, 'Quick Start', 'base'],
+      ['light-dark-mode', 'Quick Start', 'acme'],
+    ]);
   });
 });

package/foundation/discovery/docs-output-budget.d.mts

@@ -0,0 +1,28 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in foundation/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * A payload's size as `--json` prints it: the envelope data, two-space
+ * indented, in UTF-8 bytes.
+ * @param {unknown} payload
+ * @returns {number}
+ */
+export function docPayloadBytes(payload: unknown): number;
+/**
+ * @param {import('../../api/docs/docs.type.mjs').DocsIndex} index
+ * @returns {number}
+ */
+export function docsIndexBytes(index: import("../../api/docs/docs.type.mjs").DocsIndex): number;
+/**
+ * The sections a single read would return more than `budget` bytes for.
+ * @param {any[]} sections
+ * @param {number} [budget]
+ * @returns {{key: string, title: string, bytes: number}[]}
+ */
+export function oversizedDocSections(sections: any[], budget?: number): {
+    key: string;
+    title: string;
+    bytes: number;
+}[];
+/** The most one index or one section read may return, in bytes. */
+export const DOC_OUTPUT_BUDGET_BYTES: number;

package/foundation/discovery/docs-output-budget.mjs

@@ -0,0 +1,50 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file The most one progressive docs read may return.
+ *
+ * @input Docs payloads: one topic's section index, or one section.
+ * @output Their size in bytes as `--json` prints them, and the sections over
+ *   the budget.
+ * @position Shared by Doctor's docs checks and the authoring self-doc audit, so
+ *   both hold every read to the same limit.
+ */
+
+import {sectionKey} from './docs-section-key.mjs';
+
+/** The most one index or one section read may return, in bytes. */
+export const DOC_OUTPUT_BUDGET_BYTES = 32 * 1024;
+
+/**
+ * A payload's size as `--json` prints it: the envelope data, two-space
+ * indented, in UTF-8 bytes.
+ * @param {unknown} payload
+ * @returns {number}
+ */
+export function docPayloadBytes(payload) {
+  return Buffer.byteLength(JSON.stringify(payload, null, 2), 'utf8');
+}
+
+/**
+ * @param {import('../../api/docs/docs.type.mjs').DocsIndex} index
+ * @returns {number}
+ */
+export function docsIndexBytes(index) {
+  return docPayloadBytes({type: 'docs.index', data: index});
+}
+
+/**
+ * The sections a single read would return more than `budget` bytes for.
+ * @param {any[]} sections
+ * @param {number} [budget]
+ * @returns {{key: string, title: string, bytes: number}[]}
+ */
+export function oversizedDocSections(sections, budget = DOC_OUTPUT_BUDGET_BYTES) {
+  return sections
+    .map(section => ({
+      key: sectionKey(section),
+      title: section.title,
+      bytes: docPayloadBytes({type: 'docs.detail.section', data: section}),
+    }))
+    .filter(entry => entry.bytes > budget);
+}

package/foundation/discovery/docs-section-key.d.mts

@@ -0,0 +1,98 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in foundation/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * Record the authored title of a section whose visible title a translation
+ * overlay replaces.
+ * @template {object} T
+ * @param {T} section
+ * @param {string} title
+ * @returns {T}
+ */
+export function withSourceTitle<T extends object>(section: T, title: string): T;
+/**
+ * @param {any} section
+ * @returns {string}
+ */
+export function sourceTitle(section: any): string;
+/**
+ * The key a title derives: accents folded, `&` spelled out, and every other
+ * run of non-alphanumerics collapsed to one hyphen. Empty when the title has
+ * no Latin letters or digits to derive from.
+ * @param {unknown} title
+ * @returns {string}
+ */
+export function sectionTitleKey(title: unknown): string;
+/**
+ * The key a section is addressed by: its authored `id`, else the key its
+ * authored title derives.
+ * @param {any} section
+ * @returns {string}
+ */
+export function sectionKey(section: any): string;
+/**
+ * Problems with the keys of a topic's sections: an authored id that is not a
+ * stable key, a title no key derives from, and two sections sharing a key.
+ * Keys are never suffixed to make them unique, because readers link to them.
+ * @param {any[]} sections
+ * @returns {string[]}
+ */
+export function sectionKeyProblems(sections: any[]): string[];
+/**
+ * Stamp every section with the key it is addressed by. Runs only after
+ * extensions merge: a derived key must never take part in merge matching.
+ * @template {{sections: any[]}} T
+ * @param {T} doc
+ * @returns {T}
+ */
+export function withSectionKeys<T extends {
+    sections: any[];
+}>(doc: T): T;
+/**
+ * Find the section a reader asked for: by key, then by exact title (or the
+ * key the query derives), then by a title that contains the query. More than
+ * one match is refused rather than guessed.
+ * @param {any[]} sections
+ * @param {string} query
+ * @returns {{section: any | null, candidates: any[]}} `candidates` lists the
+ *   matches when the query is ambiguous, and is empty when nothing matches
+ */
+export function findDocSection(sections: any[], query: string): {
+    section: any | null;
+    candidates: any[];
+};
+/**
+ * One line that says what a section holds: its first prose or list text,
+ * whitespace collapsed, cut at a word boundary.
+ * @param {any} section
+ * @param {number} [max]
+ * @returns {string}
+ */
+export function sectionSummary(section: any, max?: number): string;
+/**
+ * The index a topic-only read returns: what the topic is, and one entry per
+ * section with the key to read it by.
+ * @param {{name: string, title: string, description: string, sections: any[]}} doc
+ * @returns {import('../../api/docs/docs.type.mjs').DocsIndex}
+ */
+export function buildDocsIndexData(doc: {
+    name: string;
+    title: string;
+    description: string;
+    sections: any[];
+}): import("../../api/docs/docs.type.mjs").DocsIndex;
+/**
+ * @file Stable section keys, section lookup, and the topic index.
+ *
+ * @input Reference-doc sections, each with an optional authored `id`.
+ * @output The key a section is addressed by (its `id`, else a kebab-case key
+ *   derived from its authored title), lookup by key or title, and the compact
+ *   index a topic-only docs read returns.
+ * @position Shared by docs discovery (which rejects colliding keys before a
+ *   reader sees them), the docs leaves (index, section, detail), and Doctor
+ *   (output budgets). Imports nothing from discovery, so both can use it.
+ */
+/** A stable key: lowercase letters and digits, joined by single hyphens. */
+export const SECTION_KEY_RE: RegExp;
+/** The longest summary an index entry carries, in characters. */
+export const SECTION_SUMMARY_MAX: 240;