browser-debugger-cli 0.12.0 → 0.13.0

package/dist/commands/dom/query.d.ts

@@ -2,13 +2,30 @@
  * `bdg dom query` — find elements by CSS selector and populate the query cache.
  */
 import type { DomQueryCommandOptions } from '../shared/optionTypes.js';
+import type { DomQueryResult } from '../../types.js';
+/** Matches `dom query` lists without `--limit` (human output) */
+export declare const QUERY_LIST_LIMIT = 50;
 /**
  * Handle `bdg dom query <selector>`.
  *
- * Runs the selector, caches the result set so later commands can reference
- * elements by index, and renders the result either as JSON or human output.
+ * Runs the selector, caches the described matches so later commands can
+ * reference elements by index, and lists the first `--limit` of them (50,
+ * or {@link QUERY_CACHE_LIMIT} with `--json`; 0 = all) with the total count.
  * No match exits 83, like `dom get` and `dom a11y`, and clears the cache so
  * indices of an earlier query are not used by mistake.
  */
 export declare function handleDomQuery(selector: string, options: DomQueryCommandOptions): Promise<void>;
+/**
+ * The matches to list: the first `limit` (all with 0), with how many were
+ * left out and, when not every match was described, how many can be used by
+ * index. Nothing is added when the limit cut nothing (a match that could not
+ * be described is just missing, as before). When more than
+ * {@link VIEWPORT_HINT_LIMIT} are listed, `viewportChecked` says that only
+ * the first ones have a viewport position.
+ *
+ * @param result - Query result with every described match
+ * @param limit - Matches to list (0 = all)
+ * @returns Result to output
+ */
+export declare function listedMatches(result: DomQueryResult, limit: number): DomQueryResult;
 //# sourceMappingURL=query.d.ts.map

package/dist/commands/dom/query.js

@@ -1,22 +1,28 @@
 /**
  * `bdg dom query` — find elements by CSS selector and populate the query cache.
  */
-import { noMatchesError, queryDOMElements } from './helpers/index.js';
+import { noMatchesError, pageDocumentId, queryDOMElements } from './helpers/index.js';
+import { QUERY_CACHE_LIMIT, VIEWPORT_HINT_LIMIT } from './helpers/query.js';
 import { runCommand } from '../shared/CommandRunner.js';
 import { QueryCacheManager } from '../../session/QueryCacheManager.js';
 import { formatDomQuery } from '../../ui/formatters/dom.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
+/** Matches `dom query` lists without `--limit` (human output) */
+export const QUERY_LIST_LIMIT = 50;
 /**
  * Handle `bdg dom query <selector>`.
  *
- * Runs the selector, caches the result set so later commands can reference
- * elements by index, and renders the result either as JSON or human output.
+ * Runs the selector, caches the described matches so later commands can
+ * reference elements by index, and lists the first `--limit` of them (50,
+ * or {@link QUERY_CACHE_LIMIT} with `--json`; 0 = all) with the total count.
  * No match exits 83, like `dom get` and `dom a11y`, and clears the cache so
  * indices of an earlier query are not used by mistake.
  */
 export async function handleDomQuery(selector, options) {
+    const limit = options.limit ?? (options.json ? QUERY_CACHE_LIMIT : QUERY_LIST_LIMIT);
     await runCommand(async () => {
-        const result = await queryDOMElements(selector);
+        const document = await pageDocumentId();
+        const result = await queryDOMElements(selector, limit);
         const cache = QueryCacheManager.getInstance();
         if (result.count === 0) {
             await cache.clear();
@@ -28,8 +34,33 @@ export async function handleDomQuery(selector, options) {
                 errorContext: { suggestion: err.suggestion },
             };
         }
-        await cache.set(result);
-        return { success: true, data: result };
+        await cache.set(result, document);
+        return { success: true, data: listedMatches(result, limit) };
     }, options, formatDomQuery);
 }
+/**
+ * The matches to list: the first `limit` (all with 0), with how many were
+ * left out and, when not every match was described, how many can be used by
+ * index. Nothing is added when the limit cut nothing (a match that could not
+ * be described is just missing, as before). When more than
+ * {@link VIEWPORT_HINT_LIMIT} are listed, `viewportChecked` says that only
+ * the first ones have a viewport position.
+ *
+ * @param result - Query result with every described match
+ * @param limit - Matches to list (0 = all)
+ * @returns Result to output
+ */
+export function listedMatches(result, limit) {
+    const listed = limit === 0 || result.count <= limit
+        ? result
+        : {
+            ...result,
+            nodes: result.nodes.slice(0, limit),
+            omitted: result.count - Math.min(limit, result.nodes.length),
+            ...(result.nodes.length < result.count && { indexed: result.nodes.length }),
+        };
+    return listed.nodes.length > VIEWPORT_HINT_LIMIT
+        ? { ...listed, viewportChecked: VIEWPORT_HINT_LIMIT }
+        : listed;
+}
 //# sourceMappingURL=query.js.map

package/dist/commands/dom/screenshot.js

@@ -14,6 +14,7 @@ import { OutputBuilder, buildSuccessResponse } from '../../ui/OutputBuilder.js';
 import { formatDomScreenshot } from '../../ui/formatters/dom.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { delay } from '../../utils/async.js';
+import { makeDirectory } from '../../utils/directories.js';
 import { getErrorMessage } from '../../utils/errors.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 import { filterDefined } from '../../utils/objects.js';
@@ -110,7 +111,7 @@ function ensureDirectory(dirPath, fs) {
         throw new CommandError(`--follow needs a directory, but ${dirPath} is a file`, { suggestion: 'Give a directory for the frames, e.g. bdg dom screenshot ./frames --follow' }, EXIT_CODES.INVALID_ARGUMENTS);
     }
     try {
-        fs.mkdirSync(dirPath, { recursive: true });
+        makeDirectory(dirPath);
     }
     catch (error) {
         throw outputPathError(dirPath, error);

package/dist/commands/dom/semanticUtils.d.ts

@@ -21,10 +21,11 @@ export interface SemanticNodeWithContext {
  * link's href, a field's type and name), like `dom query` does, and is
  * followed by up to 500 characters of the element's text
  * (all of it with `dom get --full`) when it is longer than the one-line
- * preview, or, for an element without text or name, what it holds.
+ * preview or the role line shows an accessible name other than the text,
+ * or, for an element without text or name, what it holds.
  *
  * @param data - Accessibility node and optional DOM context
- * @returns Role line, plus a text line for elements with longer text
+ * @returns Role line, plus a text line for elements with longer or differently named text
  */
 export declare function formatSemanticNodeWithContext(data: SemanticNodeWithContext): string;
 /**

package/dist/commands/dom/semanticUtils.js

@@ -5,7 +5,7 @@
  * their surrounding DOM context and to fall back gracefully when only one
  * of the two data sources is available.
  */
-import { MASKED_VALUE } from '../../runtime/dom/elementInfo.js';
+import { MASKED_VALUE, isLabelClass } from '../../runtime/dom/elementInfo.js';
 import { synthesizeA11yNode } from '../../telemetry/roleInference.js';
 import { keyAttributeItems } from '../../ui/formatters/keyAttributes.js';
 import { joinLines } from '../../ui/formatting.js';
@@ -29,9 +29,8 @@ function buildContextText(node, domContext) {
     }
     if (domContext) {
         const tagPart = `<${domContext.tag}`;
-        const classPart = domContext.classes && domContext.classes.length > 0
-            ? `.${domContext.classes.slice(0, 3).join('.')}`
-            : '';
+        const classes = (domContext.classes ?? []).filter(isLabelClass).slice(0, 3);
+        const classPart = classes.length > 0 ? `.${classes.join('.')}` : '';
         const previewPart = domContext.preview && !domContext.text ? ` "${domContext.preview}"` : '';
         return ` ${tagPart}${classPart}>${previewPart}`;
     }
@@ -86,10 +85,11 @@ function buildPropertiesText(node) {
  * link's href, a field's type and name), like `dom query` does, and is
  * followed by up to 500 characters of the element's text
  * (all of it with `dom get --full`) when it is longer than the one-line
- * preview, or, for an element without text or name, what it holds.
+ * preview or the role line shows an accessible name other than the text,
+ * or, for an element without text or name, what it holds.
  *
  * @param data - Accessibility node and optional DOM context
- * @returns Role line, plus a text line for elements with longer text
+ * @returns Role line, plus a text line for elements with longer or differently named text
  */
 export function formatSemanticNodeWithContext(data) {
     const { node, domContext } = data;
@@ -99,13 +99,44 @@ export function formatSemanticNodeWithContext(data) {
     const propsText = buildPropertiesText(node);
     const inferredText = node.inferred ? ' (inferred from DOM)' : '';
     const line = `${roleText}${contextText}${keysText}${propsText}${inferredText}`;
-    if (domContext?.text)
-        return joinLines(line, elementTextLine(domContext.text));
+    const text = textNotOnRoleLine(node, domContext);
+    if (text)
+        return joinLines(line, elementTextLine(text));
     if (domContext?.childCount !== undefined && !node.name) {
-        return joinLines(line, emptyElementLine(domContext.children ?? [], domContext.childCount));
+        return joinLines(line, emptyElementLine(domContext.children ?? [], domContext.childCount, domContext.shadowChildren));
     }
     return line;
 }
+/**
+ * The element's text when the role line does not show it: text longer than
+ * the one-line preview, or the visible text of an element whose accessible
+ * name is something else (an editor named by its aria-label), unless its
+ * name or value shows that text (a long heading with inline children is
+ * named by all of it). Texts are compared ignoring case and whitespace.
+ * A sensitive field's text is never shown.
+ *
+ * @param node - Accessibility node
+ * @param domContext - DOM context with the text
+ * @returns Text for the text line, or undefined
+ */
+function textNotOnRoleLine(node, domContext) {
+    if (domContext?.sensitive)
+        return undefined;
+    const text = domContext?.text ?? (node.name ? domContext?.preview : undefined);
+    if (!text)
+        return undefined;
+    const shown = [node.name, node.value].map((value) => comparableText(value ?? ''));
+    return shown.includes(comparableText(text)) ? undefined : text;
+}
+/**
+ * Text in the form texts are compared in.
+ *
+ * @param text - Text
+ * @returns Lowercased text with whitespace collapsed
+ */
+function comparableText(text) {
+    return text.replace(/\s+/g, ' ').trim().toLowerCase();
+}
 /**
  * Resolve an a11y node, falling back to a DOM-synthesized one when only
  * DOM context is available. Returns null when neither source can produce one.

package/dist/commands/helpJson.d.ts

@@ -78,9 +78,30 @@ export interface CommandMetadata {
     arguments: ArgumentMetadata[];
     /** Command options */
     options: OptionMetadata[];
+    /** Text shown after the options in `--help` (examples, output legend) */
+    helpText?: string;
     /** Subcommands */
     subcommands: CommandMetadata[];
 }
+/**
+ * Command summary for the compact root help: one-line description, arguments
+ * and flags with their descriptions (behaviors, defaults and choices are in
+ * `bdg <command> --help --json`).
+ */
+export interface CompactCommand {
+    /** Command name */
+    name: string;
+    /** Command aliases (only when it has some) */
+    aliases?: readonly string[];
+    /** First line of the description */
+    description: string;
+    /** Arguments as in usage, e.g. "<selector> [index]" (only when it takes some) */
+    arguments?: string;
+    /** Visible options: flags to description */
+    options?: Record<string, string>;
+    /** Subcommands (only for command groups) */
+    subcommands?: CompactCommand[];
+}
 /**
  * Runtime state information for dynamic command availability.
  */
@@ -112,7 +133,7 @@ export interface Capabilities {
     };
 }
 /**
- * Root machine-readable help structure.
+ * Root machine-readable help structure (`bdg --help --json --full`).
  */
 export interface MachineReadableHelp {
     /** CLI name */
@@ -142,10 +163,34 @@ export interface MachineReadableHelp {
     capabilities: Capabilities;
 }
 /**
- * Generates machine-readable help from a Commander program.
+ * Compact root help (`bdg --help --json`): the full help with a command tree
+ * of names, one-line descriptions and flags.
+ */
+export interface CompactHelp extends Omit<MachineReadableHelp, 'command'> {
+    /** Where the details are */
+    details: string;
+    /** Root command summary */
+    command: CompactCommand;
+}
+/**
+ * Help for one command (`bdg <command> --help --json`): its full metadata
+ * (option behaviors, defaults, choices, help text), its subcommands in compact
+ * form, and the exit codes.
+ */
+export interface CommandHelp extends Pick<MachineReadableHelp, 'name' | 'version' | 'description' | 'exitCodes'> {
+    /** Full command path, e.g. "bdg dom query" */
+    path: string;
+    /** Command metadata; subcommands summarized (ask each for its details) */
+    command: Omit<CommandMetadata, 'subcommands'> & {
+        subcommands: CompactCommand[];
+    };
+}
+/**
+ * Generates the full machine-readable help from a Commander program
+ * (`bdg --help --json --full`).
  *
  * Includes comprehensive metadata for agent discovery:
- * - Command structure and options
+ * - Command structure and options with behaviors
  * - Exit codes with semantic meanings
  * - Task-to-command mappings with CDP alternatives
  * - Runtime state and command availability
@@ -154,34 +199,52 @@ export interface MachineReadableHelp {
  *
  * @param program - Commander program instance
  * @returns Machine-readable help structure
+ */
+export declare function generateMachineReadableHelp(program: Command): MachineReadableHelp;
+/**
+ * Generates the compact root help (`bdg --help --json`): the full help with
+ * the command tree reduced to names, one-line descriptions and flags.
+ *
+ * @param program - Commander program instance
+ * @returns Compact help structure
+ */
+export declare function generateCompactHelp(program: Command): CompactHelp;
+/**
+ * The command a command line addresses: follows the words that name
+ * subcommands and skips the others (option values, arguments), stopping at a
+ * command without subcommands.
+ *
+ * @param program - Root Commander program instance
+ * @param words - Command-line words, e.g. ['dom', 'query', '.item']
+ * @returns The addressed command (the program when no word names one)
  *
  * @example
  * ```typescript
- * import { program } from 'commander';
- * import { generateMachineReadableHelp } from './help/machineReadableHelp.js';
- *
- * const help = generateMachineReadableHelp(program);
- * console.log(JSON.stringify(help, null, 2));
+ * resolveCommand(program, ['--session', 'a', 'dom', 'query', '.item']).name(); // 'query'
  * ```
  */
-export declare function generateMachineReadableHelp(program: Command): MachineReadableHelp;
+export declare function resolveCommand(program: Command, words: string[]): Command;
 /**
- * Generates machine-readable help for a specific subcommand.
+ * Full command path, e.g. "bdg dom query".
  *
- * Returns the same structure as generateMachineReadableHelp but with
- * the command field focused on the requested subcommand. If the subcommand
- * is not found, falls back to full root help.
+ * @param command - Commander command instance
+ * @returns Names from the program down to the command
+ */
+export declare function commandPath(command: Command): string;
+/**
+ * Generates machine-readable help for one command: its full metadata,
+ * compact subcommands (a group lists them like the root help does) and the
+ * exit codes.
  *
  * @param program - Root Commander program instance
- * @param commandPath - Array of command names (e.g., ['dom', 'query'])
- * @returns Machine-readable help structure for the subcommand
+ * @param command - The command (from {@link resolveCommand})
+ * @returns Help for the command
  *
  * @example
  * ```typescript
- * // Get help for 'bdg dom query'
- * const help = generateSubcommandHelp(program, ['dom', 'query']);
- * console.log(help.command.name); // 'query'
+ * const help = generateCommandHelp(program, resolveCommand(program, ['dom', 'query']));
+ * console.log(help.path); // 'bdg dom query'
  * ```
  */
-export declare function generateSubcommandHelp(program: Command, commandPath: string[]): MachineReadableHelp;
+export declare function generateCommandHelp(program: Command, command: Command): CommandHelp;
 //# sourceMappingURL=helpJson.d.ts.map

package/dist/commands/helpJson.js

@@ -4,6 +4,7 @@
 import { getAllDomainSummaries } from '../cdp/schema.js';
 import { getOptionBehavior } from './optionBehaviors.js';
 import { readLiveDaemonPid } from '../session/cleanup/staleSession.js';
+import { helpJsonDetailsNote } from '../ui/messages/commands.js';
 import { getAllDecisionTrees } from '../utils/decisionTrees.js';
 import { EXIT_CODE_REGISTRY } from '../utils/exitCodes.js';
 import { getAllTaskMappings } from '../utils/taskMappings.js';
@@ -65,6 +66,21 @@ function convertArgument(argument) {
     }
     return metadata;
 }
+/**
+ * The text a command adds after its options in `--help` (examples, output
+ * legend), collected from its `afterHelp` listeners. Commander's Command is an
+ * EventEmitter at runtime; its typings leave that out.
+ *
+ * @param command - Commander command instance
+ * @returns The text, or undefined when the command adds none
+ */
+function afterHelpText(command) {
+    const chunks = [];
+    const emitter = command;
+    emitter.emit('afterHelp', { error: false, command, write: (text) => chunks.push(text) });
+    const text = chunks.join('').trim();
+    return text || undefined;
+}
 /**
  * Recursively converts a Commander Command to CommandMetadata.
  *
@@ -75,6 +91,7 @@ function convertArgument(argument) {
  */
 function convertCommand(command) {
     const commandName = command.name();
+    const helpText = afterHelpText(command);
     return {
         name: commandName,
         aliases: command.aliases(),
@@ -82,9 +99,45 @@ function convertCommand(command) {
         usage: command.usage(),
         arguments: command.registeredArguments.map(convertArgument),
         options: command.options.map((opt) => convertOption(opt, commandName)),
+        ...(helpText && { helpText }),
         subcommands: command.commands.map(convertCommand),
     };
 }
+/**
+ * An argument as written in usage: `<name>`, `[name]`, `<name...>`.
+ *
+ * @param argument - Commander argument instance
+ * @returns Usage term
+ */
+function argumentTerm(argument) {
+    const name = `${argument.name()}${argument.variadic ? '...' : ''}`;
+    return argument.required ? `<${name}>` : `[${name}]`;
+}
+/**
+ * Recursively converts a Commander Command to its compact summary: first
+ * description line, arguments, and visible options with their descriptions.
+ * Empty fields are left out.
+ *
+ * @param command - Commander command instance
+ * @returns Compact command summary
+ */
+function convertCompactCommand(command) {
+    const aliases = command.aliases();
+    const args = command.registeredArguments.map(argumentTerm).join(' ');
+    const options = command.options.filter((option) => !option.hidden);
+    return {
+        name: command.name(),
+        ...(aliases.length > 0 && { aliases }),
+        description: command.description().split('\n')[0] ?? '',
+        ...(args && { arguments: args }),
+        ...(options.length > 0 && {
+            options: Object.fromEntries(options.map((option) => [option.flags, option.description])),
+        }),
+        ...(command.commands.length > 0 && {
+            subcommands: command.commands.map(convertCompactCommand),
+        }),
+    };
+}
 /**
  * Generates runtime state information.
  *
@@ -150,10 +203,11 @@ function generateCapabilities() {
     };
 }
 /**
- * Generates machine-readable help from a Commander program.
+ * Generates the full machine-readable help from a Commander program
+ * (`bdg --help --json --full`).
  *
  * Includes comprehensive metadata for agent discovery:
- * - Command structure and options
+ * - Command structure and options with behaviors
  * - Exit codes with semantic meanings
  * - Task-to-command mappings with CDP alternatives
  * - Runtime state and command availability
@@ -162,15 +216,6 @@ function generateCapabilities() {
  *
  * @param program - Commander program instance
  * @returns Machine-readable help structure
- *
- * @example
- * ```typescript
- * import { program } from 'commander';
- * import { generateMachineReadableHelp } from './help/machineReadableHelp.js';
- *
- * const help = generateMachineReadableHelp(program);
- * console.log(JSON.stringify(help, null, 2));
- * ```
  */
 export function generateMachineReadableHelp(program) {
     return {
@@ -186,56 +231,82 @@ export function generateMachineReadableHelp(program) {
     };
 }
 /**
- * Finds a subcommand by traversing the command path.
+ * Generates the compact root help (`bdg --help --json`): the full help with
+ * the command tree reduced to names, one-line descriptions and flags.
+ *
+ * @param program - Commander program instance
+ * @returns Compact help structure
+ */
+export function generateCompactHelp(program) {
+    return {
+        ...generateMachineReadableHelp(program),
+        details: helpJsonDetailsNote(),
+        command: convertCompactCommand(program),
+    };
+}
+/**
+ * The command a command line addresses: follows the words that name
+ * subcommands and skips the others (option values, arguments), stopping at a
+ * command without subcommands.
  *
  * @param program - Root Commander program instance
- * @param commandPath - Array of command names to traverse (e.g., ['dom', 'query'])
- * @returns The target Command if found, null otherwise
+ * @param words - Command-line words, e.g. ['dom', 'query', '.item']
+ * @returns The addressed command (the program when no word names one)
+ *
+ * @example
+ * ```typescript
+ * resolveCommand(program, ['--session', 'a', 'dom', 'query', '.item']).name(); // 'query'
+ * ```
  */
-function findSubcommand(program, commandPath) {
+export function resolveCommand(program, words) {
     let current = program;
-    for (const name of commandPath) {
-        const found = current.commands.find((cmd) => cmd.name() === name || cmd.aliases().includes(name));
-        if (!found) {
-            return null;
-        }
-        current = found;
+    for (const word of words) {
+        if (current.commands.length === 0)
+            break;
+        const found = current.commands.find((cmd) => cmd.name() === word || cmd.aliases().includes(word));
+        if (found)
+            current = found;
     }
     return current;
 }
 /**
- * Generates machine-readable help for a specific subcommand.
+ * Full command path, e.g. "bdg dom query".
  *
- * Returns the same structure as generateMachineReadableHelp but with
- * the command field focused on the requested subcommand. If the subcommand
- * is not found, falls back to full root help.
+ * @param command - Commander command instance
+ * @returns Names from the program down to the command
+ */
+export function commandPath(command) {
+    const names = [];
+    for (let level = command; level; level = level.parent)
+        names.unshift(level.name());
+    return names.join(' ');
+}
+/**
+ * Generates machine-readable help for one command: its full metadata,
+ * compact subcommands (a group lists them like the root help does) and the
+ * exit codes.
  *
  * @param program - Root Commander program instance
- * @param commandPath - Array of command names (e.g., ['dom', 'query'])
- * @returns Machine-readable help structure for the subcommand
+ * @param command - The command (from {@link resolveCommand})
+ * @returns Help for the command
  *
  * @example
  * ```typescript
- * // Get help for 'bdg dom query'
- * const help = generateSubcommandHelp(program, ['dom', 'query']);
- * console.log(help.command.name); // 'query'
+ * const help = generateCommandHelp(program, resolveCommand(program, ['dom', 'query']));
+ * console.log(help.path); // 'bdg dom query'
  * ```
  */
-export function generateSubcommandHelp(program, commandPath) {
-    const targetCommand = findSubcommand(program, commandPath);
-    if (!targetCommand) {
-        return generateMachineReadableHelp(program);
-    }
+export function generateCommandHelp(program, command) {
     return {
         name: program.name(),
         version: program.version() ?? 'unknown',
         description: program.description(),
-        command: convertCommand(targetCommand),
+        path: commandPath(command),
+        command: {
+            ...convertCommand(command),
+            subcommands: command.commands.map(convertCompactCommand),
+        },
         exitCodes: [...EXIT_CODE_DOCS],
-        taskMappings: getAllTaskMappings(),
-        runtimeState: generateRuntimeState(),
-        decisionTrees: getAllDecisionTrees(),
-        capabilities: generateCapabilities(),
     };
 }
 //# sourceMappingURL=helpJson.js.map

package/dist/commands/helpTopic.d.ts

@@ -1,7 +1,7 @@
 /**
  * `bdg help <command...>` topics and Commander usage-error hints.
  */
-import type { Command } from 'commander';
+import type { Command, CommanderError } from 'commander';
 /**
  * The command path of `bdg help <path...>`: the words before the first option.
  *
@@ -29,4 +29,19 @@ export declare function splitCommanderHint(text: string): {
     message: string;
     suggestion?: string;
 };
+/**
+ * Message and suggestion for a Commander usage error: a did-you-mean for an
+ * unknown option or command, otherwise a pointer to the command's `--help`.
+ * A word typed after a single dash (`-josn`) is matched against the long
+ * options.
+ *
+ * @param error - Commander error (not a help or version display)
+ * @param command - Command the error came from (see resolveCommand)
+ * @param argv - Process arguments (to name an option as typed)
+ * @returns Message and suggestion
+ */
+export declare function usageErrorDetails(error: CommanderError, command: Command, argv?: string[]): {
+    message: string;
+    suggestion: string;
+};
 //# sourceMappingURL=helpTopic.d.ts.map