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

package/api/docs/integrationDocs.test.mjs

@@ -102,7 +102,7 @@ describe('integration-contributed topics', () => {
     // The built-in topics keep their own owner.
     expect(listed.data.find(t => t.topic === 'tokens').package).toBe('@astryxdesign/cli');
 
-    const detail = await docs('deploying', undefined, {cwd: tmpDir});
+    const detail = await docs('deploying', undefined, {cwd: tmpDir, full: true});
     expect(detail.type).toBe('docs.detail');
     expect(detail.data.sections[0].content[0].text).toBe('Push the button.');
 
@@ -129,7 +129,7 @@ describe('integration-contributed topics', () => {
       }),
     });
 
-    const detail = await docs('getting-started', undefined, {cwd: tmpDir});
+    const detail = await docs('getting-started', undefined, {cwd: tmpDir, full: true});
     expect(detail.data.sections.map(s => s.title)).toEqual(['Install']);
     expect(detail.data.sections[0].content[0].text).toBe('yarn add @acme/widgets');
 
@@ -146,14 +146,14 @@ describe('integration-contributed topics', () => {
     scaffold({
       'setup.doc.mjs': topic({name: 'setup', replaces: 'getting-started'}),
     });
-    const byOldName = await docs('getting-started', undefined, {cwd: tmpDir});
-    const byNewName = await docs('setup', undefined, {cwd: tmpDir});
+    const byOldName = await docs('getting-started', undefined, {cwd: tmpDir, full: true});
+    const byNewName = await docs('setup', undefined, {cwd: tmpDir, full: true});
     expect(byOldName.data.name).toBe('setup');
     expect(byNewName.data.name).toBe('setup');
   }, SLOW);
 
   it('merges an extension into the topic it extends', async () => {
-    const builtin = await docs('theme');
+    const builtin = await docs('theme', undefined, {full: true});
     const baseSectionTitle = builtin.data.sections[0].title;
     scaffold({
       'theme-internal.doc.mjs': topic({
@@ -166,7 +166,7 @@ describe('integration-contributed topics', () => {
       }),
     });
 
-    const extended = await docs('theme', undefined, {cwd: tmpDir});
+    const extended = await docs('theme', undefined, {cwd: tmpDir, full: true});
     // The extension is not a topic of its own.
     expect((await docs(undefined, undefined, {cwd: tmpDir})).data.some(
       t => t.topic === 'theme-internal',
@@ -177,13 +177,119 @@ describe('integration-contributed topics', () => {
     expect(extended.data.sections.length).toBe(builtin.data.sections.length + 1);
   }, SLOW);
 
+  it('migrates a real built-in section to a stable ID without duplicating it', async () => {
+    const builtin = await docs('theme', undefined, {full: true});
+    // Readers see a key on every section; the migration case is one whose
+    // source authors no id.
+    const {docs: authored} = await import('../../assets/docs/theme.doc.mjs');
+    const target = authored.sections.find(section => section.id == null);
+    expect(target).toBeDefined();
+    scaffold({
+      'theme-internal.doc.mjs': topic({
+        name: 'theme-internal',
+        extends: 'theme',
+        sections: [
+          {
+            id: 'acme-theme-setup',
+            title: target.title,
+            content: [{type: 'prose', text: 'Use the Acme theme.'}],
+          },
+        ],
+      }),
+    });
+
+    const extended = await docs('theme', undefined, {cwd: tmpDir, full: true});
+    expect(extended.data.sections).toHaveLength(builtin.data.sections.length);
+    const matches = extended.data.sections.filter(
+      section => section.title === target.title,
+    );
+    expect(matches).toEqual([
+      expect.objectContaining({
+        id: 'acme-theme-setup',
+        content: [{type: 'prose', text: 'Use the Acme theme.'}],
+      }),
+    ]);
+  }, SLOW);
+
+  it('replaces a real built-in section by the key its index shows', async () => {
+    const index = await docs('theme', undefined, {index: true});
+    const target = index.data.sections[0];
+    scaffold({
+      'theme-internal.doc.mjs': topic({
+        name: 'theme-internal',
+        extends: 'theme',
+        sections: [
+          {
+            id: target.id,
+            title: `${target.title} with Acme`,
+            content: [{type: 'prose', text: 'Acme first.'}],
+          },
+        ],
+      }),
+    });
+
+    const extended = await docs('theme', undefined, {cwd: tmpDir, full: true});
+    expect(extended.data.sections).toHaveLength(index.data.sections.length);
+    expect(extended.data.sections.filter(s => s.id === target.id)).toEqual([
+      expect.objectContaining({content: [{type: 'prose', text: 'Acme first.'}]}),
+    ]);
+    const read = await docs('theme', target.id, {cwd: tmpDir});
+    expect(read.data.title).toBe(`${target.title} with Acme`);
+  }, SLOW);
+
+  it.each(['zh', 'dense'])(
+    'replaces translated real sections by their authored titles under --%s',
+    async lang => {
+      const english = await docs('theme', undefined, {full: true});
+      const englishTitles = english.data.sections.map(section => section.title);
+      expect(englishTitles).toEqual(
+        expect.arrayContaining(['Quick Start', 'Theme Props']),
+      );
+      scaffold({
+        'theme-internal.doc.mjs': topic({
+          name: 'theme-internal',
+          extends: 'theme',
+          sections: [
+            {
+              id: 'acme-quick-start',
+              title: 'Quick Start',
+              content: [{type: 'prose', text: 'Acme quick start.'}],
+            },
+            {
+              title: 'Theme Props',
+              content: [{type: 'prose', text: 'Acme props.'}],
+            },
+          ],
+        }),
+      });
+
+      const base = await docs('theme', undefined, {lang, full: true});
+      expect(base.data.sections.map(section => section.title)).not.toEqual(
+        englishTitles,
+      );
+      const extended = await docs('theme', undefined, {cwd: tmpDir, lang, full: true});
+      expect(extended.data.sections).toHaveLength(base.data.sections.length);
+      expect(
+        extended.data.sections.filter(
+          section => section.id === 'acme-quick-start',
+        ),
+      ).toHaveLength(1);
+      expect(
+        extended.data.sections.filter(
+          section => section.content[0]?.text === 'Acme props.',
+        ),
+      ).toHaveLength(1);
+    },
+    SLOW,
+  );
+
   it('offers the contributed topics as suggestions on an unknown one', async () => {
     scaffold({'deploying.doc.mjs': topic()});
-    await expect(docs('nope-not-a-topic', undefined, {cwd: tmpDir})).rejects.toBeInstanceOf(
+    await expect(docs('nope-not-a-topic', undefined, {cwd: tmpDir, full: true})).rejects.toBeInstanceOf(
       AstryxError,
     );
     try {
-      await docs('nope-not-a-topic', undefined, {cwd: tmpDir});
+      await docs('nope-not-a-topic', undefined, {cwd: tmpDir, full: true});
     } catch (err) {
       expect(err.suggestions.map(s => s.name)).toContain('deploying');
     }

package/api/docs/list/list.mjs

@@ -8,14 +8,14 @@
  *   English `description` is read from its file; a contributed topic already
  *   carries the one discovery read. The listing never applies --dense/--zh
  *   overlays.
- * @output { type: 'docs.list', data: DocsListEntry[] } — one entry per topic in
- *   read order, each naming the package that owns it, matching
- *   `astryx --json docs`.
+ * @output { type: 'docs.list', data: DocsListEntry[] } — one entry per topic
+ *   in read order, then one per top-level docs-tree namespace, each naming the
+ *   package that owns it, matching `astryx --json docs`.
  * @position Leaf under api/docs. Sibling of detail; both share _adapter.mjs.
  */
 
-import {pathToFileURL} from 'node:url';
-import {loadDocsCatalog} from '../_adapter.mjs';
+import {loadTopicFile} from '../../../foundation/doc-compiler/read.mjs';
+import {holdsOwnName, loadDocsCatalog, projectTree} from '../_adapter.mjs';
 
 /**
  * @param {object} [options]
@@ -24,17 +24,17 @@ import {loadDocsCatalog} from '../_adapter.mjs';
  */
 export async function list({cwd} = {}) {
   const catalog = await loadDocsCatalog(cwd);
+  const tree = await projectTree(catalog);
   /** @type {Array<import('../docs.type.mjs').DocsListEntry>} */
   const entries = [];
   for (const entry of catalog.entries()) {
+    // A topic whose name opens another doc is not listed (spec:AST-046
+    // FR11); `astryx doctor` names the clash.
+    if (!holdsOwnName(tree, catalog, entry)) continue;
     let description = entry.description ?? '';
     if (entry.description == null) {
-      try {
-        const mod = await import(pathToFileURL(entry.path).href);
-        description = (mod.docs ?? mod.default)?.description ?? '';
-      } catch {
-        description = '';
-      }
+      const file = await loadTopicFile(entry.path, null);
+      description = file.doc?.description ?? '';
     }
     /** @type {import('../docs.type.mjs').DocsListEntry} */
     const listed = {
@@ -45,5 +45,21 @@ export async function list({cwd} = {}) {
     if (entry.replaces != null) listed.replaces = entry.replaces;
     entries.push(listed);
   }
-  return {type: 'docs.list', data: entries};
+  // The docs tree's top-level namespaces, the CLI's and each integration's,
+  // each the way into a whole branch (spec:AST-046 FR7). They go in `meta`,
+  // so `data` stays the topic list 0.6 returned: every entry reads as a topic.
+  const namespaces = tree.roots().map(root => ({
+    topic: root.route,
+    description: root.summary,
+    package: root.provider,
+  }));
+  /** @type {NonNullable<import('../docs.type.mjs').DocsListResponse['meta']>} */
+  const meta = {};
+  if (namespaces.length > 0) meta.namespaces = namespaces;
+  // A package whose docs did not load is named, so its author knows why its
+  // topics are missing.
+  if (catalog.issues.length > 0) meta.notLoaded = [...catalog.issues];
+  return Object.keys(meta).length === 0
+    ? {type: 'docs.list', data: entries}
+    : {type: 'docs.list', data: entries, meta};
 }

package/api/docs/node/node.d.mts

@@ -0,0 +1,43 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in api/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * @typedef {import('../../../foundation/doc-compiler/tree.mjs').DocsTree} DocsTree
+ * @typedef {import('../../../foundation/doc-compiler/tree.mjs').TreeNode} TreeNode
+ */
+/**
+ * The docs.node view of one tree node.
+ * @param {import('../../../foundation/discovery/docs-discovery.mjs').DocsCatalog} catalog
+ * @param {DocsTree} tree
+ * @param {TreeNode} node
+ * @returns {Promise<import('../docs.type.mjs').DocsNode>}
+ */
+export function nodeView(catalog: import("../../../foundation/discovery/docs-discovery.mjs").DocsCatalog, tree: DocsTree, node: TreeNode): Promise<import("../docs.type.mjs").DocsNode>;
+/**
+ * The typed edges a doc declares (spec:AST-047 FR5), resolved to routes: a
+ * function doc's `command` and `related`, and a command doc's `fn` and
+ * `related`. A bare name resolves among the kinds its field allows; a name
+ * that matches docs of more than one allowed kind is an error, never a silent
+ * pick. A `command` resolves to the command doc its leading words name, so
+ * `integration add theme` (the `integration add` command with its kind
+ * argument) opens `integration add`. Every name that resolves to no doc, or to
+ * more than one, is returned in `unresolved`; the graph walk test fails on it,
+ * so no edge a doc declares can go stale.
+ * @param {DocsTree} tree
+ * @param {TreeNode} node
+ * @returns {{routes: string[], unresolved: string[]}}
+ */
+export function typedEdges(tree: DocsTree, node: TreeNode): {
+    routes: string[];
+    unresolved: string[];
+};
+/**
+ * @param {string} route
+ * @param {{cwd?: string}} [options]
+ * @returns {Promise<import('../docs.type.mjs').DocsNodeResponse>}
+ */
+export function node(route: string, options?: {
+    cwd?: string;
+}): Promise<import("../docs.type.mjs").DocsNodeResponse>;
+export type DocsTree = import("../../../foundation/doc-compiler/tree.mjs").DocsTree;
+export type TreeNode = import("../../../foundation/doc-compiler/tree.mjs").TreeNode;

package/api/docs/node/node.mjs

@@ -0,0 +1,192 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file docs.node leaf — one namespace or typed doc in the docs tree.
+ *
+ * @input A route the docs tree resolves: a namespace such as `cli/api`, or a
+ *   typed doc such as `cli/api/functions/search`, plus {cwd}.
+ * @output { type: 'docs.node', data: DocsNode } — the node's identity, title
+ *   and summary, the namespaces above it, and either its slots with their
+ *   children (a namespace) or its content (a typed doc). A namespace never
+ *   lists its grandchildren, so a reader goes down one level at a time.
+ *   Matches `astryx --json docs <route>`.
+ * @position Leaf under api/docs, beside the topic leaves. A guide the tree
+ *   places is a topic: the detail leaf reads it by its route.
+ */
+
+import {
+  nodeContent,
+  placeLinks,
+  resolveDocsArgument,
+  unknownTopicError,
+} from '../_adapter.mjs';
+
+/**
+ * @typedef {import('../../../foundation/doc-compiler/tree.mjs').DocsTree} DocsTree
+ * @typedef {import('../../../foundation/doc-compiler/tree.mjs').TreeNode} TreeNode
+ */
+
+/**
+ * The docs.node view of one tree node.
+ * @param {import('../../../foundation/discovery/docs-discovery.mjs').DocsCatalog} catalog
+ * @param {DocsTree} tree
+ * @param {TreeNode} node
+ * @returns {Promise<import('../docs.type.mjs').DocsNode>}
+ */
+export async function nodeView(catalog, tree, node) {
+  const {content} = await nodeContent(catalog, tree, node);
+  return {
+    id: node.id,
+    route: node.route,
+    kind: node.kind,
+    package: node.provider,
+    title: node.title,
+    summary: node.summary,
+    breadcrumb: tree
+      .ancestors(node)
+      .map(ancestor => ({route: ancestor.route, title: ancestor.title})),
+    slots: node.slots
+      .filter(slot => slot.children.length > 0)
+      .map(slot => ({
+        name: slot.name,
+        title: slot.title,
+        children: slot.children.map(route => {
+          const child = /** @type {TreeNode} */ (tree.get(route));
+          return {
+            route: child.route,
+            name: child.route.slice(child.route.lastIndexOf('/') + 1),
+            kind: child.kind,
+            title: child.title,
+            summary: child.summary,
+          };
+        }),
+      })),
+    content,
+    links: nodeLinks(tree, node),
+  };
+}
+
+/**
+ * The moves a node offers (spec:AST-047): up to the level it sits in (the
+ * topic list, for a top-level namespace), and across to the nodes before and
+ * after it in its parent's slot.
+ * @param {DocsTree} tree
+ * @param {TreeNode} node
+ * @returns {import('../docs.type.mjs').DocsLinks}
+ */
+function nodeLinks(tree, node) {
+  const links = placeLinks(tree, node);
+  const related = typedEdges(tree, node).routes;
+  if (related.length > 0) {
+    links.related = related.map(
+      route =>
+        /** @type {import('../docs.type.mjs').DocsCommand} */ (
+          `astryx docs ${route}`
+        ),
+    );
+  }
+  return links;
+}
+
+/** @type {WeakMap<DocsTree, Map<string, string>>} */
+const routeIndexes = new WeakMap();
+
+/**
+ * The route of each node, by its kind and name.
+ * @param {DocsTree} tree
+ * @returns {Map<string, string>}
+ */
+function routeIndex(tree) {
+  let routes = routeIndexes.get(tree);
+  if (!routes) {
+    routes = new Map();
+    for (const each of tree.nodes.values()) {
+      routes.set(`${each.kind}\u0000${each.name}`, each.route);
+    }
+    routeIndexes.set(tree, routes);
+  }
+  return routes;
+}
+
+/**
+ * The kinds of doc each typed field may name. A bare name in one of these
+ * fields names a doc of the same provider and one of these kinds, so it is a
+ * doc identity (spec:AST-047 FR9).
+ */
+const EDGE_KINDS = {
+  function: {command: ['command'], related: ['function']},
+  command: {fn: ['function'], related: ['command']},
+};
+
+/**
+ * The typed edges a doc declares (spec:AST-047 FR5), resolved to routes: a
+ * function doc's `command` and `related`, and a command doc's `fn` and
+ * `related`. A bare name resolves among the kinds its field allows; a name
+ * that matches docs of more than one allowed kind is an error, never a silent
+ * pick. A `command` resolves to the command doc its leading words name, so
+ * `integration add theme` (the `integration add` command with its kind
+ * argument) opens `integration add`. Every name that resolves to no doc, or to
+ * more than one, is returned in `unresolved`; the graph walk test fails on it,
+ * so no edge a doc declares can go stale.
+ * @param {DocsTree} tree
+ * @param {TreeNode} node
+ * @returns {{routes: string[], unresolved: string[]}}
+ */
+export function typedEdges(tree, node) {
+  const doc = /** @type {any} */ (node.ref)?.selfDoc;
+  /** @type {string[]} */
+  const routes = [];
+  /** @type {string[]} */
+  const unresolved = [];
+  const fields = /** @type {Record<string, string[]> | undefined} */ (
+    /** @type {any} */ (EDGE_KINDS)[node.kind]
+  );
+  if (!doc || !fields) return {routes, unresolved};
+  const index = routeIndex(tree);
+  /** @param {string[]} kinds @param {string} name */
+  const among = (kinds, name) =>
+    kinds
+      .map(kind => index.get(`${kind}\u0000${name}`))
+      .filter(route => typeof route === 'string');
+  for (const [field, kinds] of Object.entries(fields)) {
+    const value = doc[field];
+    const names = Array.isArray(value) ? value : value == null ? [] : [value];
+    for (const name of names) {
+      if (typeof name !== 'string' || name.trim() === '') continue;
+      let found = among(kinds, name);
+      if (found.length === 0 && field === 'command') {
+        const words = name.trim().split(/\s+/);
+        for (let n = words.length - 1; n > 0 && found.length === 0; n--) {
+          found = among(kinds, words.slice(0, n).join(' '));
+        }
+      }
+      if (found.length === 1) routes.push(/** @type {string} */ (found[0]));
+      else if (found.length === 0) {
+        unresolved.push(`${field} "${name}" names no ${kinds.join(' or ')} doc`);
+      } else {
+        unresolved.push(
+          `${field} "${name}" names more than one doc (${found.join(', ')})`,
+        );
+      }
+    }
+  }
+  return {
+    routes: [...new Set(routes)].filter(route => route !== node.route),
+    unresolved,
+  };
+}
+
+/**
+ * @param {string} route
+ * @param {{cwd?: string}} [options]
+ * @returns {Promise<import('../docs.type.mjs').DocsNodeResponse>}
+ */
+export async function node(route, options = {}) {
+  const found = await resolveDocsArgument(route, options);
+  if (found.kind !== 'node')
+    throw await unknownTopicError(route, found.catalog);
+  return {
+    type: 'docs.node',
+    data: await nodeView(found.catalog, found.tree, found.node),
+  };
+}

package/api/doctor/doctor.d.mts

@@ -68,7 +68,13 @@ export function checkAgentDocs(ctx: DoctorContext): DoctorCheck;
  */
 export function checkPeerDeps(ctx: DoctorContext): DoctorCheck;
 /**
- * Check 9 — report the detected package manager, and say so when the project's
+ * Summarize the combined integration graph, including cross-package warnings.
+ * @param {DoctorContext} ctx
+ * @returns {DoctorCheck}
+ */
+export function checkIntegrationIssues(ctx: DoctorContext): DoctorCheck;
+/**
+ * Check 10 — report the detected package manager, and say so when the project's
  * own declaration disagrees with what is on disk.
  *
  * Two states are worth surfacing rather than guessing past, because in both the
@@ -84,6 +90,71 @@ export function checkPeerDeps(ctx: DoctorContext): DoctorCheck;
  * @returns {DoctorCheck}
  */
 export function checkPackageManager(ctx: DoctorContext): DoctorCheck;
+/**
+ * Check 6b — every contributing integration owns its provider identity.
+ *
+ * Artifact and document IDs are provider-scoped, so a package that claims a
+ * provider ID an earlier-loaded package already holds is loaded inert: its
+ * components, templates, themes, docs, and codemods are withdrawn while the
+ * earlier package keeps contributing. That can be a deliberate transition
+ * (a renamed package installed beside its predecessor), so it warns rather
+ * than fails, but it is never allowed to happen quietly.
+ *
+ * @param {DoctorContext} ctx
+ * @returns {DoctorCheck}
+ */
+export function checkProviderIdentity(ctx: DoctorContext): DoctorCheck;
+/**
+ * Every authoring self-doc is reachable from `astryx docs authoring`, loads,
+ * and fits in one read, and every type `@astryxdesign/cli/authoring` exports
+ * has its doc there: the self-doc beside the module that declares it. The
+ * audits are imported here, inside the try, so a malformed self-doc is
+ * reported rather than taking Doctor down.
+ * @param {DoctorContext} [_ctx]
+ * @param {{root?: string, sources?: string[], topicKeys?: Set<string> | null}} [options]
+ *   Another authoring tree, list, or topic index to audit (for tests).
+ * @returns {Promise<DoctorCheck>}
+ */
+export function checkAuthoringDocs(_ctx?: DoctorContext, options?: {
+    root?: string;
+    sources?: string[];
+    topicKeys?: Set<string> | null;
+}): Promise<DoctorCheck>;
+/**
+ * Every command, API function, schema, and enum doc the CLI ships declares a
+ * namespace, and something reads it: the docs tree under `astryx docs cli`
+ * for `cli/commands` and `cli/api`, `astryx docs authoring` for `authoring`.
+ * @param {DoctorContext | Partial<DoctorContext>} _ctx
+ * @param {{root?: string, sources?: string[], authoringSources?: string[]}} [options]
+ *   test seams: the CLI root, the docs to audit, and the authoring topic's list
+ * @returns {Promise<DoctorCheck>}
+ */
+export function checkCliDocs(_ctx: DoctorContext | Partial<DoctorContext>, options?: {
+    root?: string;
+    sources?: string[];
+    authoringSources?: string[];
+}): Promise<DoctorCheck>;
+/**
+ * The docs tree builds with no error, and every CLI typed doc in a `cli/...`
+ * group has a route in it (spec:AST-046): each placement names a namespace of
+ * its own package and a slot that accepts it, exactly one namespace adopts
+ * each doc, and each route belongs to one doc.
+ * @param {DoctorContext | Partial<DoctorContext>} _ctx
+ * @param {{tree?: import('../../foundation/doc-compiler/tree.mjs').DocsTree}} [options]
+ *   test seam: a tree to check instead of the CLI's own
+ * @returns {Promise<DoctorCheck>}
+ */
+export function checkDocsTree(_ctx: DoctorContext | Partial<DoctorContext>, options?: {
+    tree?: import("../../foundation/doc-compiler/tree.mjs").DocsTree;
+}): Promise<DoctorCheck>;
+/**
+ * Every topic reads progressively, in every language it ships: it loads, its
+ * section index and each of its sections fit in one read, and no contributed
+ * doc is invalid.
+ * @param {DoctorContext | Partial<DoctorContext>} ctx
+ * @returns {Promise<DoctorCheck>}
+ */
+export function checkDocsProgressiveDisclosure(ctx: DoctorContext | Partial<DoctorContext>): Promise<DoctorCheck>;
 /**
  * Run all diagnostic checks and return a structured report.
  *
@@ -169,9 +240,36 @@ export type DoctorContext = {
      * read at all.
      */
     integrations?: import("../../foundation/integrations/integrations.mjs").LoadedIntegration[] | null | undefined;
+    /**
+     * - The topics a docs read sees.
+     */
+    docsCatalog?: DocsCatalog | null | undefined;
+    /**
+     * `invalid_doc` issues from the project's contributed docs.
+     */
+    docsCatalogIssues?: {
+        package?: string;
+        code: string;
+        message: string;
+    }[] | undefined;
+    /**
+     * - Why the project's docs catalog
+     * could not be built, when it could not.
+     */
+    docsCatalogError?: string | null | undefined;
+    /**
+     * Combined project-level integration issues, including cross-package template replacement warnings.
+     */
+    integrationIssues?: {
+        package: string;
+        code: string;
+        severity: "warning" | "error";
+        message: string;
+    }[] | null | undefined;
     /**
      * - Error thrown while resolving the config
      * path (e.g. multiple config files present), surfaced by checkConfig as a FAIL.
      */
     configError?: Error | null | undefined;
 };
+import { DocsCatalog } from '../../foundation/discovery/docs-discovery.mjs';

package/api/doctor/doctor.doc.mjs

@@ -11,6 +11,7 @@ export const doc = {
   type: 'function',
   kind: 'api',
   name: 'doctor',
+  namespace: 'cli/api',
   displayName: 'doctor()',
   summary: 'Read-only project + environment health check.',
   description: