@astryxdesign/cli 0.6.3-canary.f22695a → 0.6.3

package/api/docs/_adapter.mjs

@@ -7,27 +7,25 @@
  *   packages/cli/assets/docs/{topic}.doc.mjs plus every topic the configured
  *   integrations contribute — and, when a --dense/--zh overlay is requested,
  *   the sibling {topic}.doc.dense.mjs / {topic}.doc.zh.mjs.
- * @output Catalog access, the compiler input for a topic, and the compiled
- *   node for it: lowered (overlaid, extensions merged, keys stamped) or linked
- *   (token references resolved too), memoized per catalog.
- * @position Sits beside docs.mjs (api/docs/). Loads authored files and hands
- *   them to foundation/doc-compiler, so no leaf, doctor check or search loads,
- *   merges, or resolves docs on its own. Discovery itself lives in
- *   foundation/discovery/docs-discovery, which the catalog comes from.
+ * @output Catalog access, overlay- and extension-merged reference-doc data,
+ *   and a combined resolve step ({catalog, docsData}) that the detail and
+ *   section leaves share.
+ * @position Sits beside docs.mjs (api/docs/). Owns everything ≥2 leaves need so
+ *   no leaf re-implements resolution, overlay merging, or unknown-topic
+ *   handling. Discovery itself lives in foundation/discovery/docs-discovery,
+ *   which api/search and the agent-docs block read through the same catalog.
  */
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import {pathToFileURL} from 'node:url';
 import {Project} from '../../foundation/config/project.mjs';
-import {DocsCatalog} from '../../foundation/discovery/docs-discovery.mjs';
 import {
-  linkReferenceTopic,
-  lowerReferenceTopic,
-} from '../../foundation/doc-compiler/compile.mjs';
+  DocsCatalog,
+  mergeTopic,
+} from '../../foundation/discovery/docs-discovery.mjs';
 import {AstryxError} from '../error.mjs';
 import {ERROR_CODES} from '../../foundation/response/error-codes.mjs';
-import {parseDoc} from '../../authoring/doctypes/parse.mjs';
 
 /**
  * The project's topics: the built-in ones plus whatever the configured
@@ -51,176 +49,93 @@ export async function loadDocsCatalog(cwd = process.cwd()) {
   }
 }
 
-/** The localized overlays a docs read can apply. */
-export const OVERLAY_LANGUAGES = ['zh', 'dense'];
-
 /**
- * Where the `lang` overlay of a doc file lives: `{topic}.doc.{lang}.mjs`.
  * @param {string} docPath
- * @param {string} lang
- * @returns {string}
- */
-function overlayPath(docPath, lang) {
-  return path.join(
-    path.dirname(docPath),
-    `${path.basename(docPath, '.doc.mjs')}.doc.${lang}.mjs`,
-  );
-}
-
-/**
- * The overlay languages a topic ships for its own file or any extension.
- * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
- * @returns {string[]}
+ * @param {{lang?: string|null}} [opts]
+ * @returns {Promise<import('./docs.type.mjs').DocsDetailResponse['data']>}
  */
-export function overlayLanguages(entry) {
-  const files = [entry.path, ...entry.extensions.map(ext => ext.path)];
-  return OVERLAY_LANGUAGES.filter(lang =>
-    files.some(file => fs.existsSync(overlayPath(file, lang))),
-  );
-}
-
-/**
- * The overlay a read applies: none for the authored language.
- * @param {string | null | undefined} lang
- * @returns {string | null}
- */
-function overlayLanguage(lang) {
-  return lang && lang !== 'en' ? lang : null;
-}
-
-/**
- * Load one authored file and the overlay for `lang`. A failure is recorded on
- * the result, not thrown, so the compiler reports it in reading order.
- * @param {string} docPath
- * @param {string | null} lang
- * @returns {Promise<import('../../foundation/doc-compiler/compile.mjs').AuthoredFile>}
- */
-async function loadAuthoredFile(docPath, lang) {
-  const file = path.basename(docPath);
-  let doc;
-  try {
-    const mod = await import(pathToFileURL(docPath).href);
-    doc = parseDoc(mod.docs ?? mod.default, file);
-  } catch (error) {
-    return {file, error};
-  }
-  if (!lang) return {file, doc};
-  const translationPath = overlayPath(docPath, lang);
-  if (!fs.existsSync(translationPath)) return {file, doc};
-  try {
-    const translationMod = await import(pathToFileURL(translationPath).href);
-    return {
-      file,
-      doc,
-      overlay: translationMod.docsZh || translationMod.docsDense || null,
-    };
-  } catch (overlayError) {
-    return {file, doc, overlayError};
+export async function loadReferenceDocs(docPath, {lang} = {}) {
+  const mod = await import(pathToFileURL(docPath).href);
+  const docs = mod.docs ?? mod.default;
+  if (!lang || lang === 'en') return docs;
+
+  const dir = path.dirname(docPath);
+  const base = path.basename(docPath, '.doc.mjs');
+  const locale = lang === 'dense' ? 'dense' : lang;
+  const translationPath = path.join(dir, `${base}.doc.${locale}.mjs`);
+  if (!fs.existsSync(translationPath)) return docs;
+
+  const translationMod = await import(pathToFileURL(translationPath).href);
+  const translation = translationMod.docsZh || translationMod.docsDense;
+  if (!translation) return docs;
+
+  // Overlays are keyed to a base section by title (`section`), not by array
+  // position. Position-keying silently grafted each overlay title onto whatever
+  // base section happened to share its index, so an overlay that omitted or
+  // reordered a section corrupted every section after it — `docs tokens --dense`
+  // printed the colour table under a "Spacing" heading (#2182). An overlay may
+  // now cover any subset of sections, in any order; sections it does not name
+  // keep their base content.
+  /** @type {Map<string, any>} */
+  const bySection = new Map();
+  for (const ts of translation.sections ?? []) {
+    if (ts?.section != null) bySection.set(ts.section, ts);
   }
-}
 
-/**
- * Everything the compiler needs for one topic, read from disk.
- * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
- * @param {string | null} lang
- * @returns {Promise<import('../../foundation/doc-compiler/compile.mjs').ReferenceTopicInput>}
- */
-async function loadCompilerInput(entry, lang) {
-  const extensions = [];
-  for (const extension of entry.extensions) {
-    extensions.push({
-      ...(await loadAuthoredFile(extension.path, lang)),
-      provider: extension.package,
-    });
-  }
   return {
-    id: entry.name,
-    provider: entry.package,
-    replaces: entry.replaces ?? null,
-    lang,
-    base: await loadAuthoredFile(entry.path, lang),
-    extensions,
+    ...docs,
+    description: translation.description || docs.description,
+    sections: docs.sections.map(
+      (/** @type {import('@astryxdesign/cli/authoring').ReferenceSection} */ section) => {
+        const ts = bySection.get(section.title);
+        if (!ts) return section;
+        return {
+          ...section,
+          title: ts.title || section.title,
+          content: section.content.map(
+            (
+              /** @type {import('@astryxdesign/cli/authoring').ReferenceContentBlock} */ block,
+              /** @type {number} */ bi,
+            ) => {
+              const tb = ts.content?.[bi];
+              if (!tb) return block;
+              if (tb.type === 'prose' && block.type === 'prose') return {...block, text: tb.text};
+              if (tb.type === 'list' && block.type === 'list') return {...block, items: tb.items};
+              return block;
+            },
+          ),
+        };
+      },
+    ),
   };
 }
 
-/** @type {WeakMap<DocsCatalog, Map<string, Promise<import('../../foundation/doc-compiler/compile.mjs').CompiledReferenceNode>>>} */
-const loweredByCatalog = new WeakMap();
-
 /**
- * One topic, lowered for `lang`: overlaid, extensions merged, keys stamped.
- * Memoized per catalog, so a read that references a topic twice loads it once.
- * Every read of the catalog shares the memoized node, so it is frozen; the
- * lenses hand readers copies.
- * @param {DocsCatalog} catalog
+ * Load one catalog entry: its own doc, plus any extension an integration
+ * merged onto it, in configuration order.
+ *
+ * A localization overlay applies to each file before the extensions are
+ * merged, so an extension written in the base language stays readable under
+ * `--dense`/`--zh` (it replaces its own sections and leaves the rest
+ * translated) rather than being dropped.
+ *
  * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
- * @param {string | null} [lang]
- * @returns {Promise<import('../../foundation/doc-compiler/compile.mjs').CompiledReferenceNode>}
- */
-export function lowerTopic(catalog, entry, lang = null) {
-  const overlay = overlayLanguage(lang);
-  let cache = loweredByCatalog.get(catalog);
-  if (!cache) {
-    cache = new Map();
-    loweredByCatalog.set(catalog, cache);
-  }
-  const key = `${entry.name.toLowerCase()}\u0000${overlay ?? ''}`;
-  let lowered = cache.get(key);
-  if (!lowered) {
-    lowered = loadCompilerInput(entry, overlay).then(input =>
-      deepFreeze(lowerReferenceTopic(input)),
-    );
-    cache.set(key, lowered);
-  }
-  return lowered;
-}
-
-/**
- * Freeze a value and everything in it.
- * @template T
- * @param {T} value
- * @returns {T}
+ * @param {{lang?: string|null}} [opts]
+ * @returns {Promise<import('./docs.type.mjs').DocsDetailResponse['data']>}
  */
-function deepFreeze(value) {
-  if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
-    Object.freeze(value);
-    for (const child of Object.values(value)) deepFreeze(child);
+export async function loadTopicDoc(entry, {lang} = {}) {
+  let doc = await loadReferenceDocs(entry.path, {lang});
+  for (const extension of entry.extensions) {
+    doc = mergeTopic(doc, await loadReferenceDocs(extension.path, {lang}));
   }
-  return value;
-}
-
-/**
- * How a token reference finds its target: the topic it names in `catalog`,
- * lowered for the same language.
- * @param {DocsCatalog} catalog
- * @param {string | null} lang
- * @returns {(topic: string) => Promise<import('../../foundation/doc-compiler/compile.mjs').CompiledReferenceNode | null>}
- */
-export function referenceTargets(catalog, lang) {
-  return async topic => {
-    const target = catalog.resolve(topic);
-    return target ? lowerTopic(catalog, target, lang) : null;
-  };
-}
-
-/**
- * One topic, compiled for `lang`: lowered, then every token reference linked.
- * @param {DocsCatalog} catalog
- * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
- * @param {string | null} [lang]
- * @returns {Promise<import('../../foundation/doc-compiler/compile.mjs').CompiledReferenceNode>}
- */
-export async function compileTopic(catalog, entry, lang = null) {
-  return linkReferenceTopic(
-    await lowerTopic(catalog, entry, lang),
-    referenceTargets(catalog, lang),
-  );
+  return doc;
 }
 
 /**
  * Resolve `topic` against the project's catalog (throwing `ERR_UNKNOWN_TOPIC`
- * when unmatched) and lower it with any --dense/--zh overlay and any
- * integration extension applied. Shared by the leaves so topic normalization
- * and unknown-topic handling live in exactly one place.
+ * when unmatched), and load it with any --dense/--zh overlay and any
+ * integration extension applied. Shared by the detail and section leaves so
+ * topic normalization and unknown-topic handling live in exactly one place.
  *
  * @param {string} topic
  * @param {object} [options]
@@ -230,8 +145,7 @@ export async function compileTopic(catalog, entry, lang = null) {
  * @param {string} [options.cwd]
  * @returns {Promise<{
  *   catalog: DocsCatalog,
- *   node: import('../../foundation/doc-compiler/compile.mjs').CompiledReferenceNode,
- *   lang: string | null,
+ *   docsData: import('./docs.type.mjs').DocsDetailResponse['data'],
  * }>}
  */
 export async function resolveTopicDocs(topic, options = {}) {
@@ -251,6 +165,6 @@ export async function resolveTopicDocs(topic, options = {}) {
     );
   }
 
-  const node = await lowerTopic(catalog, entry, effectiveLang);
-  return {catalog, node, lang: effectiveLang};
+  const docsData = await loadTopicDoc(entry, {lang: effectiveLang});
+  return {catalog, docsData};
 }

package/api/docs/detail/detail.mjs

@@ -3,17 +3,69 @@
 /**
  * @file docs.detail leaf — load one topic's full reference doc.
  *
- * @input A topic name plus optional {lang, zh, dense, cwd}. Resolves the topic
- *   via the shared adapter and compiles it with its token references linked.
+ * @input A topic name plus optional {lang, zh, dense}. Resolves and loads the
+ *   topic via the shared adapter, then inlines any token-ref blocks.
  * @output { type: 'docs.detail', data: ReferenceDoc } — the full doc with
- *   token-refs inlined, matching `astryx --json docs <topic>`.
- * @position Leaf under api/docs. Reads the compiled node through the detail
- *   lens; resolution, overlays and extensions happen in the compiler.
+ *   token-refs resolved, matching `xds --json docs <topic>`.
+ * @position Leaf under api/docs. Owns resolveTokenRefs (used only here); shares
+ *   discovery/loading/topic-resolution with the section leaf via _adapter.mjs.
  */
 
-import {linkReferenceTopic} from '../../../foundation/doc-compiler/compile.mjs';
-import {detailView} from '../../../foundation/doc-compiler/lenses.mjs';
-import {referenceTargets, resolveTopicDocs} from '../_adapter.mjs';
+import {loadTopicDoc, resolveTopicDocs} from '../_adapter.mjs';
+
+/**
+ * Resolve token-ref blocks by inlining the referenced section's table.
+ * This allows section docs to reference token tables without duplicating data.
+ *
+ * The reference is resolved through the catalog, so a topic may point at one
+ * an integration contributed (or replaced) rather than only at a built-in.
+ * @param {import('../docs.type.mjs').DocsDetailResponse['data']} docsData
+ * @param {import('../../../foundation/discovery/docs-discovery.mjs').DocsCatalog} catalog
+ * @returns {Promise<import('../docs.type.mjs').DocsDetailResponse['data']>}
+ */
+async function resolveTokenRefs(docsData, catalog) {
+  const resolved = {...docsData, sections: [...docsData.sections]};
+  for (let si = 0; si < resolved.sections.length; si++) {
+    const section = resolved.sections[si];
+    /** @type {import('@astryxdesign/cli/authoring').ReferenceContentBlock[]} */
+    const newContent = [];
+    for (const block of section.content) {
+      if (block.type === 'token-ref') {
+        const refEntry = catalog.resolve(block.topic);
+        if (!refEntry) {
+          newContent.push({type: 'prose', text: `[token-ref: unknown topic "${block.topic}"]`});
+          continue;
+        }
+        const refDocs = await loadTopicDoc(refEntry);
+        const refSection = refDocs.sections.find(
+          (/** @type {import('@astryxdesign/cli/authoring').ReferenceSection} */ s) =>
+            s.title.toLowerCase() === block.section.toLowerCase(),
+        );
+        if (!refSection) {
+          newContent.push({type: 'prose', text: `[token-ref: section "${block.section}" not found in "${block.topic}"]`});
+          continue;
+        }
+        // Inline the referenced section's content blocks (tables, prose, etc.)
+        // and carry over the previewType
+        for (const refBlock of refSection.content) {
+          newContent.push(refBlock);
+        }
+        // If the referenced section has a previewType, attach it to our section
+        if (refSection.previewType && !section.previewType) {
+          resolved.sections[si] = {...section, previewType: refSection.previewType, content: newContent};
+        }
+      } else {
+        newContent.push(block);
+      }
+    }
+    if (resolved.sections[si] === section) {
+      resolved.sections[si] = {...section, content: newContent};
+    } else {
+      resolved.sections[si].content = newContent;
+    }
+  }
+  return resolved;
+}
 
 /**
  * @param {string} topic
@@ -25,10 +77,7 @@ import {referenceTargets, resolveTopicDocs} from '../_adapter.mjs';
  * @returns {Promise<import('../docs.type.mjs').DocsDetailResponse>}
  */
 export async function detail(topic, options = {}) {
-  const {catalog, node, lang} = await resolveTopicDocs(topic, options);
-  const linked = await linkReferenceTopic(
-    node,
-    referenceTargets(catalog, lang),
-  );
-  return {type: 'docs.detail', data: detailView(linked)};
+  const {catalog, docsData} = await resolveTopicDocs(topic, options);
+  const resolved = await resolveTokenRefs(docsData, catalog);
+  return {type: 'docs.detail', data: resolved};
 }

package/api/docs/detail/section/section.d.mts

@@ -3,7 +3,7 @@
 
 /**
  * @param {string} topic
- * @param {string} sectionName a section key, or a title (or part of one)
+ * @param {string} sectionName
  * @param {object} [options]
  * @param {string} [options.lang]
  * @param {boolean} [options.zh]

package/api/docs/detail/section/section.mjs

@@ -1,36 +1,25 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates.
 
 /**
- * @file docs.detail.section leaf — load a single section of a topic.
+ * @file docs.detail.section leaf — load a single named section of a topic.
  *
  * @input A topic name, a section query, and optional {lang, zh, dense}. Resolves
- *   the topic via the shared adapter, finds the section in its lowered compiled
- *   node by its stable key, then by exact title, then by a title that contains
- *   the query, and links only that section.
- * @output { type: 'docs.detail.section', data: ReferenceSection } with any
- *   token-ref blocks inlined — matching `astryx --json docs <topic> <section>`.
- *   Throws ERR_UNKNOWN_SECTION when nothing matches, or when the query matches
- *   more than one section (the candidates come back as suggestions).
- * @position Leaf nested under api/docs/detail. Shares topic resolution with the
- *   detail leaf via _adapter.mjs and reads through the compiler's lenses.
+ *   and loads the topic via the shared adapter, then finds the first section
+ *   whose title contains the (case-insensitive) query.
+ * @output { type: 'docs.detail.section', data: ReferenceSection } — matching
+ *   `xds --json docs <topic> <section>`. Throws ERR_UNKNOWN_SECTION when no
+ *   section title matches.
+ * @position Leaf nested under api/docs/detail. Shares discovery/loading/
+ *   topic-resolution with the detail leaf via _adapter.mjs.
  */
 
 import {AstryxError} from '../../../error.mjs';
 import {ERROR_CODES} from '../../../../foundation/response/error-codes.mjs';
-import {
-  findDocSection,
-  sectionKey,
-} from '../../../../foundation/discovery/docs-section-key.mjs';
-import {linkReferenceSection} from '../../../../foundation/doc-compiler/compile.mjs';
-import {
-  readerSections,
-  sectionView,
-} from '../../../../foundation/doc-compiler/lenses.mjs';
-import {referenceTargets, resolveTopicDocs} from '../../_adapter.mjs';
+import {resolveTopicDocs} from '../../_adapter.mjs';
 
 /**
  * @param {string} topic
- * @param {string} sectionName a section key, or a title (or part of one)
+ * @param {string} sectionName
  * @param {object} [options]
  * @param {string} [options.lang]
  * @param {boolean} [options.zh]
@@ -39,9 +28,10 @@ import {referenceTargets, resolveTopicDocs} from '../../_adapter.mjs';
  * @returns {Promise<import('../../docs.type.mjs').DocsDetailSectionResponse>}
  */
 export async function section(topic, sectionName, options = {}) {
-  // An empty section name must error, not resolve to the first section. The
-  // docs() dispatcher routes a falsy section to the topic, but the leaf must be
-  // safe on its own; a non-string would otherwise throw a raw TypeError.
+  // An empty section name must error, not resolve to the first section via
+  // `.includes('')`. The docs() dispatcher routes a falsy section to detail, but
+  // the leaf must be safe on its own. A non-string would also throw a raw
+  // TypeError below (`.toLowerCase()`) → downgrades to ERR_UNKNOWN.
   if (typeof sectionName !== 'string' || !sectionName.trim()) {
     throw new AstryxError(
       'A section name is required',
@@ -49,30 +39,16 @@ export async function section(topic, sectionName, options = {}) {
       ERROR_CODES.ERR_UNKNOWN_SECTION,
     );
   }
+  const {docsData} = await resolveTopicDocs(topic, options);
 
-  const {catalog, node, lang} = await resolveTopicDocs(topic, options);
-  const sections = readerSections(node);
-  const {section: match, candidates} = findDocSection(sections, sectionName);
+  const normalizedSection = sectionName.toLowerCase();
+  const match = docsData.sections.find(s => s.title.toLowerCase().includes(normalizedSection));
   if (!match) {
-    const ambiguous = candidates.length > 1;
     throw new AstryxError(
-      ambiguous
-        ? `Section "${sectionName}" matches ${candidates.length} sections in "${topic}". Read one by its key.`
-        : `Section "${sectionName}" not found in "${topic}"`,
-      (ambiguous ? candidates : sections).map(s => ({
-        name: sectionKey(s),
-        reason: s.title,
-      })),
+      `Section "${sectionName}" not found in "${topic}"`,
+      docsData.sections.map(s => ({name: s.title, reason: 'available section'})),
       ERROR_CODES.ERR_UNKNOWN_SECTION,
     );
   }
-
-  // A section read on its own inlines its token refs, as the whole topic does;
-  // otherwise a section that is only a token-ref prints blank. Only this
-  // section is linked, so a broken reference elsewhere cannot fail the read.
-  const linked = await linkReferenceSection(
-    match,
-    referenceTargets(catalog, lang),
-  );
-  return {type: 'docs.detail.section', data: sectionView(node, linked)};
+  return {type: 'docs.detail.section', data: match};
 }

package/api/docs/detail/section/section.test.mjs

@@ -10,7 +10,6 @@
 import {describe, it, expect} from 'vitest';
 import {section} from './section.mjs';
 import {AstryxError} from '../../../error.mjs';
-import {loadDocsCatalog, lowerTopic} from '../../_adapter.mjs';
 
 const SLOW = 30_000;
 
@@ -40,44 +39,4 @@ describe('docs.detail.section leaf', () => {
       code: 'ERR_UNKNOWN_SECTION',
     });
   }, SLOW);
-
-  it('reads a section by its stable key', async () => {
-    const catalog = await loadDocsCatalog();
-    const {doc} = await lowerTopic(catalog, catalog.resolve('theme'));
-    const target = doc.sections[doc.sections.length - 1];
-    const res = await section('theme', target.id);
-    expect(res.data.title).toBe(target.title);
-    expect(res.data.id).toBe(target.id);
-  }, SLOW);
-
-  it('refuses a query that matches more than one section', async () => {
-    const err = await section('theme', 'e').catch(e => e);
-    expect(err).toBeInstanceOf(AstryxError);
-    expect(err.code).toBe('ERR_UNKNOWN_SECTION');
-    expect(err.message).toMatch(/matches \d+ sections/);
-    expect(err.suggestions.length).toBeGreaterThan(1);
-  }, SLOW);
-
-  it.each([null, 'zh', 'dense'])(
-    'inlines token refs when a section is read on its own (lang %s)',
-    async lang => {
-      const catalog = await loadDocsCatalog();
-      let checked = 0;
-      for (const entry of catalog.entries()) {
-        const {doc} = await lowerTopic(catalog, entry);
-        for (const own of doc.sections) {
-          if (!own.content.some(block => block.type === 'token-ref')) continue;
-          const res = await section(entry.name, own.id, lang ? {lang} : {});
-          expect(res.data.content.length).toBeGreaterThan(0);
-          expect(res.data.content.some(block => block.type === 'token-ref')).toBe(
-            false,
-          );
-          expect(JSON.stringify(res.data.content)).not.toContain('[token-ref:');
-          checked += 1;
-        }
-      }
-      expect(checked).toBeGreaterThan(0);
-    },
-    SLOW,
-  );
 });

package/api/docs/docs.d.mts

@@ -8,12 +8,9 @@
  * @param {string} [options.lang]
  * @param {boolean} [options.zh]
  * @param {boolean} [options.dense]
- * @param {boolean} [options.index] return the topic's section index instead of
- *   the whole doc
  * @param {string} [options.cwd]
  * @returns {Promise<
  *   import('./docs.type.mjs').DocsListResponse |
- *   import('./docs.type.mjs').DocsIndexResponse |
  *   import('./docs.type.mjs').DocsDetailResponse |
  *   import('./docs.type.mjs').DocsDetailSectionResponse
  * >}
@@ -22,11 +19,9 @@ export function docs(topic?: string, section?: string, options?: {
     lang?: string | undefined;
     zh?: boolean | undefined;
     dense?: boolean | undefined;
-    index?: boolean | undefined;
     cwd?: string | undefined;
-}): Promise<import("./docs.type.mjs").DocsListResponse | import("./docs.type.mjs").DocsIndexResponse | import("./docs.type.mjs").DocsDetailResponse | import("./docs.type.mjs").DocsDetailSectionResponse>;
+}): Promise<import("./docs.type.mjs").DocsListResponse | import("./docs.type.mjs").DocsDetailResponse | import("./docs.type.mjs").DocsDetailSectionResponse>;
 import { list } from './list/list.mjs';
-import { index } from './index/index.mjs';
 import { detail } from './detail/detail.mjs';
 import { section as sectionLeaf } from './detail/section/section.mjs';
-export { list, index, detail, sectionLeaf as section };
+export { list, detail, sectionLeaf as section };