@equinor/fusion-framework-cli-plugin-ai-index 3.0.6 → 3.0.7

package/src/utils/git/{file-changes.ts → get-file-status.ts}

@@ -1,87 +1,6 @@
 import { join, relative } from 'node:path';
-import type { ChangedFile, FileChangeStatus, GitDiffOptions } from './types.js';
-import { resolveProjectRoot, getGit } from './git-client.js';
-
-/**
- * Returns a list of files changed between `baseRef` and HEAD.
- *
- * Parses the output of `git diff --name-status` to classify each file as
- * `'new'`, `'modified'`, or `'removed'`. Renames are expanded into a
- * `'removed'` entry for the old path and a `'new'` entry for the new path.
- *
- * @param options - Configuration controlling the diff reference and working directory.
- * @returns Array of changed files with their status.
- * @throws {Error} If the working directory is not inside a git repository.
- */
-export const getChangedFiles = async (options: GitDiffOptions): Promise<ChangedFile[]> => {
-  const { diff, baseRef = 'HEAD~1', cwd = process.cwd() } = options;
-
-  if (!diff) {
-    return [];
-  }
-
-  const projectRoot = resolveProjectRoot(cwd);
-  if (!projectRoot) {
-    throw new Error('Not in a git repository. Cannot use --diff option.');
-  }
-
-  const { git } = getGit(cwd) ?? {};
-  if (!git) {
-    throw new Error('Failed to initialize git client');
-  }
-
-  try {
-    // Get changes since baseRef with status (A=added, M=modified, D=deleted)
-    try {
-      const diffResult = await git.diff([`${baseRef}`, '--name-status']);
-      const lines = diffResult.split('\n').filter((line) => line.trim() !== '');
-
-      const changedFiles: ChangedFile[] = [];
-
-      for (const line of lines) {
-        // Match status and file path
-        // Format: "A\tfile.ts" or "M\tfile.ts" or "D\tfile.ts"
-        // Also handle renames: "R100\told.ts\tnew.ts"
-        const renameMatch = line.match(/^R\d*\s+(.+?)\s+(.+)$/);
-        if (renameMatch) {
-          const [, oldFile, newFile] = renameMatch;
-          // Add both the removed old file and the new file
-          changedFiles.push({ filepath: `${projectRoot}/${oldFile}`, status: 'removed' });
-          changedFiles.push({ filepath: `${projectRoot}/${newFile}`, status: 'new' });
-          continue;
-        }
-
-        const match = line.match(/^([AMD])\s+(.+)$/);
-        if (match) {
-          const [, gitStatus, file] = match;
-          const fullPath = `${projectRoot}/${file}`;
-
-          let status: FileChangeStatus;
-          if (gitStatus === 'A') {
-            status = 'new';
-          } else if (gitStatus === 'M') {
-            status = 'modified';
-          } else if (gitStatus === 'D') {
-            status = 'removed';
-          } else {
-            // Skip unknown statuses (C=copied, etc.)
-            continue;
-          }
-
-          changedFiles.push({ filepath: fullPath, status });
-        }
-      }
-
-      return changedFiles;
-    } catch {
-      // Handle case where baseRef doesn't exist (e.g., first commit)
-      console.warn(`⚠️  Warning: Git reference '${baseRef}' not found. Processing all files.`);
-      return [];
-    }
-  } catch (error) {
-    throw new Error(`Git diff failed: ${error instanceof Error ? error.message : String(error)}`);
-  }
-};
+import type { ChangedFile } from './types.js';
+import { getGit } from './get-git.js';
 
 /**
  * Determines the git change status of a single file.
@@ -96,8 +15,8 @@ export const getChangedFiles = async (options: GitDiffOptions): Promise<ChangedF
  */
 export const getFileStatus = async (filePath: string): Promise<ChangedFile[]> => {
   const { git, gitRepoPath } = getGit(filePath) ?? {};
+  // Not in a git repository, assume new
   if (!git || !gitRepoPath) {
-    // Not in a git repository, assume new
     return [{ filepath: filePath, status: 'new' }];
   }
 
@@ -112,8 +31,8 @@ export const getFileStatus = async (filePath: string): Promise<ChangedFile[]> =>
       .then(() => true)
       .catch(() => false);
 
+    // File is tracked at this path, it's modified
     if (isTracked) {
-      // File is tracked at this path, it's modified
       return [{ filepath: filePath, status: 'modified' }];
     }
 
@@ -128,6 +47,7 @@ export const getFileStatus = async (filePath: string): Promise<ChangedFile[]> =>
       ]);
       const trimmed = fileStatusOutput.trim();
 
+      // Only inspect porcelain output when git actually reported something for this path
       if (trimmed.length > 0) {
         // If status shows ??, it's untracked (truly new)
         if (/^\?\?/.test(trimmed)) {
@@ -143,11 +63,14 @@ export const getFileStatus = async (filePath: string): Promise<ChangedFile[]> =>
     try {
       // Get full git status to check for renames (only if needed)
       const statusOutput = await git.raw(['status', '--porcelain']);
+      // Drop blank lines left by the trailing newline in git's output
       const lines = statusOutput.split('\n').filter((line) => line.trim() !== '');
 
+      // Scan every status line for a rename or copy that produced this file
       for (const line of lines) {
         // Check for rename format: "R100\told.ts\tnew.ts"
         const renameMatch = line.match(/^R\d+\s+(.+?)\s+(.+)$/);
+        // A rename line resolves this file only if it matches the new path
         if (renameMatch) {
           const [, oldPath, newPath] = renameMatch;
           const oldFullPath = join(gitRepoPath, oldPath);
@@ -164,6 +87,7 @@ export const getFileStatus = async (filePath: string): Promise<ChangedFile[]> =>
 
         // Check for copy format: "C100\told.ts\tnew.ts" (similar to rename)
         const copyMatch = line.match(/^C\d+\s+(.+?)\s+(.+)$/);
+        // A copy line resolves this file only if it matches the new path
         if (copyMatch) {
           const [, , newPath] = copyMatch;
           const newFullPath = join(gitRepoPath, newPath);
@@ -208,21 +132,3 @@ export const getFileStatus = async (filePath: string): Promise<ChangedFile[]> =>
     return [{ filepath: filePath, status: 'new' }];
   }
 };
-
-/**
- * Checks whether a file path appears in a list of changed files.
- *
- * When the changed-files list is empty (no diff filtering active), every
- * file is considered changed so that all files are processed.
- *
- * @param filePath - Absolute file path to look up.
- * @param changedFiles - Array of {@link ChangedFile} entries to search.
- * @returns `true` if the file has changed or if diff filtering is disabled.
- */
-export const isFileChanged = (filePath: string, changedFiles: ChangedFile[]): boolean => {
-  if (changedFiles.length === 0) {
-    return true; // If no diff filtering, process all files
-  }
-
-  return changedFiles.some((file) => file.filepath === filePath);
-};

package/src/utils/git/{status.ts → get-git-status.ts}

@@ -1,4 +1,5 @@
-import { resolveProjectRoot, getGit } from './git-client.js';
+import { resolveProjectRoot } from './resolve-project-root.js';
+import { getGit } from './get-git.js';
 
 /**
  * Retrieves a summary of the current git working-tree status.
@@ -21,11 +22,13 @@ export const getGitStatus = async (
   unstagedFiles: number;
 }> => {
   const projectRoot = resolveProjectRoot(cwd);
+  // Status can only be reported when cwd is inside a git repository
   if (!projectRoot) {
     throw new Error('Not in a git repository');
   }
 
   const { git } = getGit(cwd) ?? {};
+  // Fail fast if the git client could not be created for this repository
   if (!git) {
     throw new Error('Failed to initialize git client');
   }

package/src/utils/git/{git-client.ts → get-git.ts}

@@ -1,28 +1,8 @@
 import { simpleGit, type SimpleGit } from 'simple-git';
-import { findUpSync } from 'find-up';
-import { dirname, join } from 'node:path';
-import { existsSync } from 'node:fs';
 
-const gitCache = new Map<string, SimpleGit>();
+import { resolveProjectRoot } from './resolve-project-root.js';
 
-/**
- * Resolves the git repository root for a given file path.
- *
- * Walks up the directory tree looking for a `.git` directory or file
- * (to support worktrees) and returns the enclosing directory.
- *
- * @param filePath - Absolute file or directory path to resolve from.
- * @returns Absolute path to the repository root, or `undefined` if not inside a git repo.
- */
-export const resolveProjectRoot = (filePath: string): string | undefined => {
-  // if we are in the root of the git repository, return the root
-  if (existsSync(join(filePath, '.git'))) {
-    return filePath;
-  }
-  const gitRepoPath = findUpSync('.git', { cwd: dirname(filePath), type: 'both' });
-  const projectRoot = gitRepoPath?.replace(/\.git$/, '');
-  return projectRoot;
-};
+const gitCache = new Map<string, SimpleGit>();
 
 /**
  * Returns a cached `SimpleGit` instance scoped to the repository that
@@ -39,7 +19,9 @@ export const getGit = (
   filePath: string,
 ): { git: SimpleGit | undefined; gitRepoPath: string } | undefined => {
   const gitRepoPath = resolveProjectRoot(filePath);
+  // Only build/cache a client when the file is inside a git repository
   if (gitRepoPath) {
+    // Reuse an existing client for this repo root instead of spawning a new one
     if (!gitCache.has(gitRepoPath)) {
       gitCache.set(gitRepoPath, simpleGit(gitRepoPath));
     }

package/src/utils/git/index.ts

@@ -7,13 +7,16 @@ export type {
 } from './types.js';
 
 // Re-export git client utilities
-export { resolveProjectRoot, getGit } from './git-client.js';
+export { resolveProjectRoot } from './resolve-project-root.js';
+export { getGit } from './get-git.js';
 
 // Re-export metadata functions
-export { extractGitMetadata } from './metadata.js';
+export { extractGitMetadata } from './extract-git-metadata.js';
 
 // Re-export file change functions
-export { getChangedFiles, getFileStatus, isFileChanged } from './file-changes.js';
+export { getChangedFiles } from './get-changed-files.js';
+export { getFileStatus } from './get-file-status.js';
+export { isFileChanged } from './is-file-changed.js';
 
 // Re-export status functions
-export { getGitStatus } from './status.js';
+export { getGitStatus } from './get-git-status.js';

package/src/utils/git/is-file-changed.ts

@@ -0,0 +1,21 @@
+import type { ChangedFile } from './types.js';
+
+/**
+ * Checks whether a file path appears in a list of changed files.
+ *
+ * When the changed-files list is empty (no diff filtering active), every
+ * file is considered changed so that all files are processed.
+ *
+ * @param filePath - Absolute file path to look up.
+ * @param changedFiles - Array of {@link ChangedFile} entries to search.
+ * @returns `true` if the file has changed or if diff filtering is disabled.
+ */
+export const isFileChanged = (filePath: string, changedFiles: ChangedFile[]): boolean => {
+  // If no diff filtering, process all files
+  if (changedFiles.length === 0) {
+    return true;
+  }
+
+  // A file is considered changed when its path matches any entry in the list
+  return changedFiles.some((file) => file.filepath === filePath);
+};

package/src/utils/git/resolve-project-root.ts

@@ -0,0 +1,22 @@
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { findUpSync } from 'find-up';
+
+/**
+ * Resolves the git repository root for a given file path.
+ *
+ * Walks up the directory tree looking for a `.git` directory or file
+ * (to support worktrees) and returns the enclosing directory.
+ *
+ * @param filePath - Absolute file or directory path to resolve from.
+ * @returns Absolute path to the repository root, or `undefined` if not inside a git repo.
+ */
+export const resolveProjectRoot = (filePath: string): string | undefined => {
+  // if we are in the root of the git repository, return the root
+  if (existsSync(join(filePath, '.git'))) {
+    return filePath;
+  }
+  const gitRepoPath = findUpSync('.git', { cwd: dirname(filePath), type: 'both' });
+  const projectRoot = gitRepoPath?.replace(/\.git$/, '');
+  return projectRoot;
+};

package/src/utils/markdown/index.ts

@@ -2,4 +2,6 @@
 export type { MarkdownMetadata, MarkdownDocument } from './types.js';
 
 // Re-export parser functions
-export { isMarkdownFile, parseMarkdown, parseMarkdownFile } from './parser.js';
+export { isMarkdownFile } from './is-markdown-file.js';
+export { parseMarkdown } from './parse-markdown.js';
+export { parseMarkdownFile } from './parse-markdown-file.js';

package/src/utils/markdown/is-markdown-file.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks whether a file path has a Markdown (`.md`) or MDX (`.mdx`) extension.
+ *
+ * @param filePath - Absolute or relative file path.
+ * @returns `true` when the extension is `.md` or `.mdx`.
+ */
+export const isMarkdownFile = (filePath: string): boolean => {
+  return filePath.endsWith('.md') || filePath.endsWith('.mdx');
+};

package/src/utils/markdown/parse-markdown-file.ts

@@ -0,0 +1,36 @@
+import { readFileSync } from 'node:fs';
+import { assert } from 'node:console';
+
+import type { SourceFile } from '../types.js';
+import type { MarkdownDocument } from './types.js';
+import { isMarkdownFile } from './is-markdown-file.js';
+import { parseMarkdown } from './parse-markdown.js';
+
+/**
+ * Reads a Markdown or MDX file from disk and parses it into chunked documents.
+ *
+ * Delegates to {@link parseMarkdown} after reading the file content, then
+ * enriches each resulting document with the `rootPath` from the source file.
+ *
+ * @template T - Additional frontmatter attributes.
+ * @param file - Source file descriptor with path and optional project root.
+ * @returns Array of Markdown documents with root-path metadata.
+ * @throws {AssertionError} If the file does not have a `.md` or `.mdx` extension.
+ */
+export const parseMarkdownFile = async <
+  T extends Record<string, unknown> = Record<string, unknown>,
+>(
+  file: SourceFile,
+): Promise<MarkdownDocument<T>[]> => {
+  assert(isMarkdownFile(file.path), `File ${file.path} is not a markdown or MDX file`);
+  const content = readFileSync(file.path, 'utf8');
+  const result = await parseMarkdown<T>(content, file.relativePath ?? file.path);
+  // Enrich each parsed chunk with the file's project root for downstream path resolution
+  return result.map((document) => ({
+    ...document,
+    metadata: {
+      ...document.metadata,
+      rootPath: file.projectRoot,
+    },
+  }));
+};

package/src/utils/markdown/{parser.ts → parse-markdown.ts}

@@ -1,11 +1,7 @@
-import { readFileSync } from 'node:fs';
-import { assert } from 'node:console';
-
 import { default as grayMatter } from 'gray-matter';
 
 import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
 
-import type { SourceFile } from '../types.js';
 import type { MarkdownDocument, MarkdownMetadata } from './types.js';
 import { generateChunkId } from '../generate-chunk-id.js';
 
@@ -28,16 +24,6 @@ const markdownConfig = {
   keepSeparator: true,
 };
 
-/**
- * Checks whether a file path has a Markdown (`.md`) or MDX (`.mdx`) extension.
- *
- * @param filePath - Absolute or relative file path.
- * @returns `true` when the extension is `.md` or `.mdx`.
- */
-export const isMarkdownFile = (filePath: string): boolean => {
-  return filePath.endsWith('.md') || filePath.endsWith('.mdx');
-};
-
 /**
  * Validates that a text chunk contains meaningful content.
  *
@@ -49,6 +35,7 @@ export const isMarkdownFile = (filePath: string): boolean => {
  */
 const isValidChunk = (chunk: string): boolean => {
   const trimmed = chunk.trim();
+  // Skip empty or whitespace-only chunks
   if (!trimmed) return false;
   // Skip chunks that are only code fence markers
   if (/^`{3,}[\w-]*$/.test(trimmed)) return false;
@@ -72,6 +59,7 @@ export const parseMarkdown = async <T extends Record<string, unknown> = Record<s
   source: string,
 ): Promise<MarkdownDocument<T>[]> => {
   const { content: markdownContent, data } = grayMatter(content);
+  // Prefix each frontmatter key with `md_` to namespace it in the document metadata
   const markdownAttributes = Object.entries(data).reduce(
     (acc, [key, value]) => {
       acc[`md_${key}`] = value;
@@ -86,48 +74,25 @@ export const parseMarkdown = async <T extends Record<string, unknown> = Record<s
 
   // Filter out empty chunks and chunks that are just code fence markers
   const validChunks = chunks.filter((chunk) => {
+    // Discard invalid chunks; keep everything else
     if (!isValidChunk(chunk)) {
       return false;
     }
     return true;
   });
 
-  return validChunks.map(
-    (chunk, _index): MarkdownDocument<T> => ({
-      id: generateChunkId(source, _index),
-      pageContent: chunk,
-      metadata: {
-        source,
-        attributes: markdownAttributes as MarkdownMetadata<T>['attributes'],
-      },
-    }),
+  return (
+    validChunks
+      // Wrap each valid chunk into a vector-store-ready document
+      .map(
+        (chunk, _index): MarkdownDocument<T> => ({
+          id: generateChunkId(source, _index),
+          pageContent: chunk,
+          metadata: {
+            source,
+            attributes: markdownAttributes as MarkdownMetadata<T>['attributes'],
+          },
+        }),
+      )
   );
 };
-
-/**
- * Reads a Markdown or MDX file from disk and parses it into chunked documents.
- *
- * Delegates to {@link parseMarkdown} after reading the file content, then
- * enriches each resulting document with the `rootPath` from the source file.
- *
- * @template T - Additional frontmatter attributes.
- * @param file - Source file descriptor with path and optional project root.
- * @returns Array of Markdown documents with root-path metadata.
- * @throws {AssertionError} If the file does not have a `.md` or `.mdx` extension.
- */
-export const parseMarkdownFile = async <
-  T extends Record<string, unknown> = Record<string, unknown>,
->(
-  file: SourceFile,
-): Promise<MarkdownDocument<T>[]> => {
-  assert(isMarkdownFile(file.path), `File ${file.path} is not a markdown or MDX file`);
-  const content = readFileSync(file.path, 'utf8');
-  const result = await parseMarkdown<T>(content, file.relativePath ?? file.path);
-  return result.map((document) => ({
-    ...document,
-    metadata: {
-      ...document.metadata,
-      rootPath: file.projectRoot,
-    },
-  }));
-};

package/src/utils/{embedding-dimensions.ts → resolve-embedding-dimensions.ts}

@@ -26,8 +26,10 @@ const KNOWN_MODEL_DIMENSIONS: ReadonlyMap<string, number> = new Map([
  */
 export function resolveEmbeddingDimensions(model: string, configDimensions?: number): number {
   const known = KNOWN_MODEL_DIMENSIONS.get(model);
+  // Known models resolve directly from the lookup map.
   if (known !== undefined) return known;
 
+  // Unknown models fall back to an explicit dimensions override from config.
   if (configDimensions !== undefined) return configDimensions;
 
   const knownModels = [...KNOWN_MODEL_DIMENSIONS.keys()].join(', ');

package/src/utils/{package-resolver.ts → resolve-package.ts}

@@ -25,8 +25,10 @@ const packageMap = new Map<string, PackageJson>();
 export async function resolvePackage(filePath: string): Promise<PackageJson | undefined> {
   // Check cache: iterate through known package directories
   for (const packageRoot of packageMap.keys()) {
+    // A cached package root that is a prefix of filePath is the closest known package.
     if (filePath.startsWith(packageRoot)) {
       const packageJson = packageMap.get(packageRoot);
+      // Guard: satisfies TypeScript's strict Map#get return type despite the key check above.
       if (packageJson) {
         return packageJson;
       }
@@ -38,6 +40,7 @@ export async function resolvePackage(filePath: string): Promise<PackageJson | un
   const dirPath = dirname(filePath);
   const result = await readPackageUp({ cwd: dirPath, normalize: false });
 
+  // Cache the resolved package.json so future lookups under the same root are free.
   if (result) {
     // Cache using the package directory (where package.json is located)
     const packageDir = dirname(result.path);

package/src/utils/ts-doc/create-typescript-document.ts

@@ -0,0 +1,36 @@
+import type { SourceFile as ProjectSourceFile } from 'ts-morph';
+
+import { generateChunkId } from '../generate-chunk-id.js';
+import type { TypescriptDocument, ParseTsDocOptions } from './types.js';
+
+/**
+ * Creates a TypescriptDocument from the given parameters.
+ * @param sourceFile - The source file containing the node.
+ * @param pageContent - The content of the document.
+ * @param tsKind - The TypeScript node kind name.
+ * @param tsName - The name of the TypeScript node.
+ * @param options - Optional parsing configuration.
+ * @returns A TypeScript document with metadata.
+ */
+export const createTypescriptDocument = (
+  sourceFile: ProjectSourceFile,
+  pageContent: string,
+  tsKind: string,
+  tsName: string,
+  options?: ParseTsDocOptions,
+): TypescriptDocument => {
+  const source = sourceFile.getFilePath().replace(/^\/+/, '');
+  return {
+    id: generateChunkId(source),
+    pageContent,
+    metadata: {
+      source,
+      ...(options?.projectRoot && { rootPath: options.projectRoot }),
+      attributes: {
+        type: 'tsdoc',
+        ts_kind: tsKind,
+        ts_name: tsName,
+      },
+    },
+  };
+};

package/src/utils/ts-doc/extract-document-from-class-node.ts

@@ -0,0 +1,106 @@
+import { SyntaxKind, type SourceFile as ProjectSourceFile, type ClassDeclaration } from 'ts-morph';
+import type { MethodDeclaration, PropertyDeclaration } from 'ts-morph';
+
+import type { TypescriptDocument, ParseTsDocOptions } from './types.js';
+import { createTypescriptDocument } from './create-typescript-document.js';
+
+/**
+ * Extracts a vector-store document from a TypeScript class declaration.
+ *
+ * Collects the class-level TSDoc comment, constructor signature (if documented),
+ * and all public members with TSDoc into a single document whose `pageContent`
+ * mirrors a minimal class interface.
+ *
+ * @param classNode - The `ts-morph` {@link ClassDeclaration} node to inspect.
+ * @param sourceFile - The project source file that contains the class.
+ * @param _options - Optional parsing configuration.
+ * @returns A {@link TypescriptDocument}, or `null` when the class has no TSDoc.
+ */
+export const extractDocumentFromClassNode = (
+  classNode: ClassDeclaration,
+  sourceFile: ProjectSourceFile,
+  _options?: ParseTsDocOptions,
+): TypescriptDocument | null => {
+  // Find TSDoc comment (/** ... */); only the block comment counts, not plain `//` or `/* */` comments
+  const docCommentRange = classNode
+    .getLeadingCommentRanges()
+    .find((range) => range.getText().startsWith('/**'));
+
+  // Skip undocumented classes — nothing to index
+  if (!docCommentRange) {
+    return null;
+  }
+
+  const docComment = docCommentRange.getText();
+  const className = classNode.getName() || 'AnonymousClass';
+
+  // Start with class TSDoc and declaration (without body)
+  const classSignature = `${classNode.getText({ includeJsDocComments: false }).split('{')[0].trim()} {`;
+  let pageContent = `${docComment}\n${classSignature}`;
+
+  // Add constructor with TSDoc if present
+  const constructorNode = classNode.getConstructors()[0]; // Get the first constructor (if any)
+  // Only surface the constructor signature when it has documentation to show
+  if (constructorNode) {
+    // Only the TSDoc block comment counts, not plain `//` or `/* */` comments
+    const constructorDocCommentRange = constructorNode
+      .getLeadingCommentRanges()
+      .find((range) => range.getText().startsWith('/**'));
+    // Skip undocumented constructors — nothing to add to the page content
+    if (constructorDocCommentRange) {
+      const constructorDocComment = constructorDocCommentRange.getText();
+      const constructorSignature = constructorNode
+        .getText({ includeJsDocComments: false })
+        .split('{')[0]
+        .trim();
+      pageContent += `\n  ${constructorDocComment}\n  ${constructorSignature}`;
+    }
+  }
+
+  // Add public methods and properties with TSDoc
+  const publicMembers = [
+    ...classNode
+      .getMethods()
+      // Only public methods form part of the class's documented surface
+      .filter((m) => m.hasModifier(SyntaxKind.PublicKeyword)),
+    ...classNode
+      .getProperties()
+      // Only public properties form part of the class's documented surface
+      .filter((p) => p.hasModifier(SyntaxKind.PublicKeyword)),
+  ];
+
+  // Append each documented public member's TSDoc and signature to the page content
+  publicMembers.forEach((member) => {
+    const memberDocCommentRange = member
+      .getLeadingCommentRanges()
+      // Only the TSDoc block comment counts, not plain `//` or `/* */` comments
+      .find((range) => range.getText().startsWith('/**'));
+    // Skip undocumented members — nothing to add to the page content
+    if (memberDocCommentRange) {
+      const memberDocComment = memberDocCommentRange.getText();
+      let memberSignature = '';
+      // Methods and properties render their signature differently
+      if (member.getKind() === SyntaxKind.MethodDeclaration) {
+        memberSignature = (member as MethodDeclaration)
+          .getText({ includeJsDocComments: false })
+          .split('{')[0]
+          .trim();
+      } else if (member.getKind() === SyntaxKind.PropertyDeclaration) {
+        memberSignature = (member as PropertyDeclaration)
+          .getText({ includeJsDocComments: false })
+          .trim();
+      }
+      pageContent += `\n  ${memberDocComment}\n  ${memberSignature}`;
+    }
+  });
+
+  pageContent += '\n}';
+
+  return createTypescriptDocument(
+    sourceFile,
+    pageContent,
+    classNode.getKindName(),
+    className,
+    _options,
+  );
+};