browser-debugger-cli 0.7.1 → 0.8.0

package/dist/commands/dom/query.js

@@ -0,0 +1,36 @@
+/**
+ * `bdg dom query` — find elements by CSS selector and populate the query cache.
+ */
+import { queryDOMElements } from './helpers/index.js';
+import { runCommand } from '../shared/CommandRunner.js';
+import { noNodesFoundError } from '../../errors/messages.js';
+import { QueryCacheManager } from '../../session/QueryCacheManager.js';
+import { formatDomQuery } from '../../ui/formatters/dom.js';
+import { EXIT_CODES } from '../../utils/exitCodes.js';
+/**
+ * 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.
+ * 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) {
+    await runCommand(async () => {
+        const result = await queryDOMElements(selector);
+        const cache = QueryCacheManager.getInstance();
+        if (result.count === 0) {
+            await cache.clear();
+            const err = noNodesFoundError(selector);
+            return {
+                success: false,
+                error: err.message,
+                exitCode: EXIT_CODES.RESOURCE_NOT_FOUND,
+                errorContext: { suggestion: err.suggestion },
+            };
+        }
+        await cache.set(result);
+        return { success: true, data: result };
+    }, options, formatDomQuery);
+}
+//# sourceMappingURL=query.js.map

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

@@ -0,0 +1,21 @@
+/**
+ * `bdg dom screenshot` — capture page, element, or frame-sequence screenshots.
+ */
+import type { DomScreenshotCommandOptions } from '../shared/optionTypes.js';
+/**
+ * Pick the image format for a file: `--format` if given, else the extension.
+ *
+ * @param outputPath - File to write
+ * @param requested - `--format` value
+ * @returns Format to capture in
+ * @throws CommandError (81) when the extension and `--format` disagree or the
+ *   extension names a format Chrome cannot capture
+ */
+export declare function resolveImageFormat(outputPath: string, requested?: 'png' | 'jpeg'): 'png' | 'jpeg';
+/**
+ * Handle `bdg dom screenshot <path>`.
+ *
+ * Dispatches to page, element, or sequence capture based on flags.
+ */
+export declare function handleDomScreenshot(outputPath: string, options: DomScreenshotCommandOptions): Promise<void>;
+//# sourceMappingURL=screenshot.d.ts.map

package/dist/commands/dom/screenshot.js

@@ -0,0 +1,248 @@
+/**
+ * `bdg dom screenshot` — capture page, element, or frame-sequence screenshots.
+ */
+import { extname } from 'path';
+import { DomElementResolver } from './DomElementResolver.js';
+import { capturePageScreenshot, captureElementScreenshot, resolveSelector, } from './helpers/index.js';
+import { runCommand } from '../shared/CommandRunner.js';
+import { assertFilePath, outputPathError } from '../shared/outputFile.js';
+import { positiveIntRule } from '../shared/validation.js';
+import { CommandError } from '../../errors/index.js';
+import { conflictingOptionsMessage, genericError } from '../../errors/messages.js';
+import { missingArgumentError } from '../../errors/messages.js';
+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 { getErrorMessage } from '../../utils/errors.js';
+import { EXIT_CODES } from '../../utils/exitCodes.js';
+import { filterDefined } from '../../utils/objects.js';
+const log = createLogger('dom');
+/** Image format of each file extension Chrome can write */
+const EXTENSION_FORMATS = {
+    '.png': 'png',
+    '.jpg': 'jpeg',
+    '.jpeg': 'jpeg',
+};
+/** Image extensions Chrome cannot capture (writing PNG bytes to them would mislead) */
+const UNSUPPORTED_EXTENSIONS = new Set(['.gif', '.webp', '.bmp', '.tif', '.tiff', '.avif', '.svg']);
+/**
+ * Pick the image format for a file: `--format` if given, else the extension.
+ *
+ * @param outputPath - File to write
+ * @param requested - `--format` value
+ * @returns Format to capture in
+ * @throws CommandError (81) when the extension and `--format` disagree or the
+ *   extension names a format Chrome cannot capture
+ */
+export function resolveImageFormat(outputPath, requested) {
+    const extension = extname(outputPath).toLowerCase();
+    const fromExtension = EXTENSION_FORMATS[extension];
+    if (UNSUPPORTED_EXTENSIONS.has(extension) ||
+        (requested && fromExtension && requested !== fromExtension)) {
+        throw new CommandError(`Cannot write ${requested ?? 'a screenshot'} to a ${extension} file`, {
+            suggestion: 'Screenshots are png or jpeg: use a .png or .jpg file name (or --format to match it)',
+        }, EXIT_CODES.INVALID_ARGUMENTS);
+    }
+    return requested ?? fromExtension ?? 'png';
+}
+function buildPageScreenshotOptions(options) {
+    return filterDefined({
+        format: options.format,
+        quality: options.quality,
+        fullPage: options.fullPage,
+        noResize: options.resize === false,
+        scroll: options.scroll,
+    });
+}
+function buildElementScreenshotOptions(options) {
+    return filterDefined({
+        format: options.format,
+        quality: options.quality,
+        noResize: options.resize === false,
+    });
+}
+function hasElementTarget(options) {
+    return options.selector !== undefined || options.index !== undefined;
+}
+async function resolveElementNodeId(options) {
+    if (options.index !== undefined) {
+        const resolver = DomElementResolver.getInstance();
+        const node = await resolver.getNodeIdForIndex(options.index);
+        return { backendNodeId: node.nodeId };
+    }
+    if (options.selector !== undefined) {
+        return resolveSelector(options.selector);
+    }
+    const err = missingArgumentError('--selector "css-selector" or --index N from a previous query');
+    throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+}
+function addElementInfo(result, options) {
+    const bounds = result.element?.bounds ?? {
+        x: 0,
+        y: 0,
+        width: result.width,
+        height: result.height,
+    };
+    return {
+        ...result,
+        element: {
+            ...(options.selector !== undefined && { selector: options.selector }),
+            ...(options.index !== undefined && { index: options.index }),
+            bounds,
+        },
+    };
+}
+/**
+ * Make sure `--follow` has a directory to write frames to.
+ *
+ * @param dirPath - Directory the user gave
+ * @param fs - File system module
+ * @throws CommandError (81) when the path is a file, or naming the problem when it cannot be created
+ */
+function ensureDirectory(dirPath, fs) {
+    if (fs.existsSync(dirPath) && !fs.statSync(dirPath).isDirectory()) {
+        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 });
+    }
+    catch (error) {
+        throw outputPathError(dirPath, error);
+    }
+}
+function formatFrameFilename(frameNumber, format) {
+    return `${String(frameNumber).padStart(3, '0')}.${format}`;
+}
+async function handlePageScreenshot(outputPath, options) {
+    await runCommand(async () => {
+        const screenshotOptions = buildPageScreenshotOptions(options);
+        const result = await capturePageScreenshot(outputPath, screenshotOptions);
+        return { success: true, data: result };
+    }, options, formatDomScreenshot);
+}
+async function handleElementScreenshot(outputPath, options) {
+    await runCommand(async () => {
+        const nodeRef = await resolveElementNodeId(options);
+        const screenshotOptions = buildElementScreenshotOptions(options);
+        const result = await captureElementScreenshot(outputPath, nodeRef, screenshotOptions);
+        const elementResult = addElementInfo(result, options);
+        return { success: true, data: elementResult };
+    }, options, formatDomScreenshot);
+}
+async function captureSequenceFrame(outputPath, options) {
+    if (hasElementTarget(options)) {
+        const nodeRef = await resolveElementNodeId(options);
+        const elementOptions = buildElementScreenshotOptions(options);
+        await captureElementScreenshot(outputPath, nodeRef, elementOptions);
+    }
+    else {
+        const pageOptions = buildPageScreenshotOptions(options);
+        await capturePageScreenshot(outputPath, pageOptions);
+    }
+}
+async function handleSequenceCapture(outputDir, options) {
+    const fs = await import('fs');
+    const path = await import('path');
+    const absoluteDir = path.resolve(outputDir);
+    ensureDirectory(absoluteDir, fs);
+    const intervalRule = positiveIntRule({ name: '--interval', min: 100, max: 60000, default: 1000 });
+    const limitRule = positiveIntRule({ name: '--limit', min: 1, max: 10000, required: false });
+    const interval = intervalRule.validate(options.interval);
+    const limit = options.limit ? limitRule.validate(options.limit) : 0;
+    const format = options.format ?? 'png';
+    let frameCount = 0;
+    let stopping = false;
+    process.once('SIGINT', () => {
+        stopping = true;
+    });
+    console.error(`Capturing to ${absoluteDir} every ${interval}ms...`);
+    while (!stopping) {
+        frameCount++;
+        const filename = formatFrameFilename(frameCount, format);
+        const outputPath = path.join(absoluteDir, filename);
+        try {
+            await captureSequenceFrame(outputPath, options);
+        }
+        catch (error) {
+            reportSequenceError(error, frameCount - 1, options.json ?? false);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(buildSuccessResponse({ frame: frameCount, path: outputPath })));
+        }
+        else {
+            log.info(`Frame ${frameCount}: ${filename}`);
+        }
+        if (limit > 0 && frameCount >= limit)
+            break;
+        await delay(interval);
+    }
+    console.error(`Captured ${frameCount} frames`);
+    process.exit(EXIT_CODES.SUCCESS);
+}
+/**
+ * End a capture sequence on an error (e.g. the element disappeared): print
+ * it (one JSON line with `--json`, like the frames) and exit with its code.
+ *
+ * @param error - Capture error
+ * @param captured - Frames captured before it
+ * @param json - JSON output
+ */
+function reportSequenceError(error, captured, json) {
+    const exitCode = error instanceof CommandError ? error.exitCode : EXIT_CODES.SOFTWARE_ERROR;
+    const suggestion = error instanceof CommandError && typeof error.metadata['suggestion'] === 'string'
+        ? error.metadata['suggestion']
+        : undefined;
+    const message = getErrorMessage(error);
+    if (json) {
+        console.log(JSON.stringify(OutputBuilder.buildJsonError(message, { exitCode, ...(suggestion && { suggestion }) })));
+    }
+    else {
+        console.error(genericError(message));
+        if (suggestion)
+            console.error(suggestion);
+    }
+    console.error(`Captured ${captured} frames`);
+    process.exit(exitCode);
+}
+/**
+ * Reject options that would be ignored: `--selector` with `--index` (the
+ * index already names an element), and `--quality` for a PNG.
+ *
+ * @param outputPath - File to write
+ * @param options - Command options
+ * @throws CommandError (81) for a conflict
+ */
+function assertScreenshotOptions(outputPath, options) {
+    let message;
+    if (options.selector !== undefined && options.index !== undefined) {
+        message = conflictingOptionsMessage('--selector', '--index');
+    }
+    else if (options.quality !== undefined &&
+        !options.follow &&
+        resolveImageFormat(outputPath, options.format) === 'png') {
+        message = '--quality applies to JPEG only; this screenshot is a PNG';
+    }
+    if (message)
+        throw new CommandError(message, {}, EXIT_CODES.INVALID_ARGUMENTS);
+}
+/**
+ * Handle `bdg dom screenshot <path>`.
+ *
+ * Dispatches to page, element, or sequence capture based on flags.
+ */
+export async function handleDomScreenshot(outputPath, options) {
+    assertScreenshotOptions(outputPath, options);
+    if (options.follow) {
+        await handleSequenceCapture(outputPath, options);
+        return;
+    }
+    assertFilePath(outputPath);
+    const captureOptions = { ...options, format: resolveImageFormat(outputPath, options.format) };
+    if (hasElementTarget(captureOptions)) {
+        await handleElementScreenshot(outputPath, captureOptions);
+        return;
+    }
+    await handlePageScreenshot(outputPath, captureOptions);
+}
+//# sourceMappingURL=screenshot.js.map

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

@@ -0,0 +1,44 @@
+/**
+ * Shared utilities for rendering semantic (a11y + DOM context) output.
+ *
+ * Used by both `dom query` and `dom get` to format accessibility nodes with
+ * their surrounding DOM context and to fall back gracefully when only one
+ * of the two data sources is available.
+ */
+import { type DomContext } from './helpers/index.js';
+import type { A11yNode } from '../../types.js';
+/**
+ * Accessibility node paired with its surrounding DOM context for display.
+ */
+export interface SemanticNodeWithContext {
+    node: A11yNode;
+    domContext: DomContext | null;
+}
+/**
+ * Format a semantic node together with DOM context for human-readable output.
+ *
+ * @param data - Accessibility node and optional DOM context
+ * @returns One-line formatted string
+ */
+export declare function formatSemanticNodeWithContext(data: SemanticNodeWithContext): string;
+/**
+ * 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.
+ *
+ * @param a11yNode - Accessibility node, if any
+ * @param domContext - DOM context, if any
+ * @param nodeId - CDP nodeId for synthesis
+ */
+export declare function resolveNodeWithFallback(a11yNode: A11yNode | null, domContext: DomContext | null, nodeId: number | undefined): A11yNode | null;
+/**
+ * Look up a single element by selector to produce its nodeId and DOM context.
+ *
+ * Used by `dom get` (semantic mode) when the accessibility tree has no node
+ * for the selector — the selector-based DOM context allows us to synthesize
+ * one.
+ */
+export declare function queryDomContextBySelector(selector: string): Promise<{
+    nodeId: number | undefined;
+    domContext: DomContext | null;
+}>;
+//# sourceMappingURL=semanticUtils.d.ts.map

package/dist/commands/dom/semanticUtils.js

@@ -0,0 +1,102 @@
+/**
+ * Shared utilities for rendering semantic (a11y + DOM context) output.
+ *
+ * Used by both `dom query` and `dom get` to format accessibility nodes with
+ * their surrounding DOM context and to fall back gracefully when only one
+ * of the two data sources is available.
+ */
+import { getDomContext, resolveBackendNodeIds, } from './helpers/index.js';
+import { synthesizeA11yNode } from '../../telemetry/roleInference.js';
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function buildRoleText(node) {
+    if (node.role.toLowerCase() === 'heading' && node.properties?.['level'] !== undefined) {
+        const level = node.properties['level'];
+        const levelNum = typeof level === 'number' ? level : Number(level);
+        if (!isNaN(levelNum)) {
+            return `[Heading L${levelNum}]`;
+        }
+    }
+    return `[${capitalize(node.role)}]`;
+}
+function buildContextText(node, domContext) {
+    if (node.name) {
+        return ` "${node.name}"`;
+    }
+    if (domContext) {
+        const tagPart = `<${domContext.tag}`;
+        const classPart = domContext.classes && domContext.classes.length > 0
+            ? `.${domContext.classes.slice(0, 3).join('.')}`
+            : '';
+        const previewPart = domContext.preview ? ` "${domContext.preview}"` : '';
+        return ` ${tagPart}${classPart}>${previewPart}`;
+    }
+    return '';
+}
+function buildPropertiesText(node) {
+    const props = [];
+    if (node.value !== undefined && node.value !== '')
+        props.push(`value: "${node.value}"`);
+    const checked = node.properties?.['checked'];
+    if (checked !== undefined) {
+        props.push(checked === 'mixed' ? 'partly checked' : checked ? 'checked' : 'unchecked');
+    }
+    const expanded = node.properties?.['expanded'];
+    if (expanded !== undefined)
+        props.push(expanded ? 'expanded' : 'collapsed');
+    if (node.focusable)
+        props.push('focusable');
+    if (node.focused)
+        props.push('focused');
+    if (node.disabled)
+        props.push('disabled');
+    if (node.required)
+        props.push('required');
+    return props.length > 0 ? ` (${props.join(', ')})` : '';
+}
+/**
+ * Format a semantic node together with DOM context for human-readable output.
+ *
+ * @param data - Accessibility node and optional DOM context
+ * @returns One-line formatted string
+ */
+export function formatSemanticNodeWithContext(data) {
+    const { node, domContext } = data;
+    const roleText = buildRoleText(node);
+    const contextText = buildContextText(node, domContext);
+    const propsText = buildPropertiesText(node);
+    const inferredText = node.inferred ? ' (inferred from DOM)' : '';
+    return `${roleText}${contextText}${propsText}${inferredText}`;
+}
+/**
+ * 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.
+ *
+ * @param a11yNode - Accessibility node, if any
+ * @param domContext - DOM context, if any
+ * @param nodeId - CDP nodeId for synthesis
+ */
+export function resolveNodeWithFallback(a11yNode, domContext, nodeId) {
+    if (a11yNode)
+        return a11yNode;
+    if (domContext && nodeId)
+        return synthesizeA11yNode(domContext, nodeId);
+    return null;
+}
+/**
+ * Look up a single element by selector to produce its nodeId and DOM context.
+ *
+ * Used by `dom get` (semantic mode) when the accessibility tree has no node
+ * for the selector — the selector-based DOM context allows us to synthesize
+ * one.
+ */
+export async function queryDomContextBySelector(selector) {
+    const [backendNodeId] = await resolveBackendNodeIds([selector]);
+    if (backendNodeId === undefined) {
+        return { nodeId: undefined, domContext: null };
+    }
+    const domContext = await getDomContext({ backendNodeId });
+    return { nodeId: backendNodeId, domContext };
+}
+//# sourceMappingURL=semanticUtils.js.map

package/dist/commands/helpJson.d.ts

@@ -30,9 +30,11 @@ export interface OptionMetadata {
     flags: string;
     /** Option description */
     description: string;
-    /** Whether option is required */
+    /** Whether the option must be given (rare; most options are optional) */
     required: boolean;
-    /** Whether option has an optional value */
+    /** Whether the option takes a value (`--port <number>`) */
+    takesValue: boolean;
+    /** Whether the option's value may be omitted (`--flag [value]`) */
     optional: boolean;
     /** Default value if any */
     defaultValue?: unknown;

package/dist/commands/helpJson.js

@@ -2,12 +2,10 @@
  * Machine-readable help generation using Commander.js introspection API.
  */
 import { getAllDomainSummaries } from '../cdp/schema.js';
-import { getOptionBehavior } from '../commands/optionBehaviors.js';
-import { isDaemonRunning } from '../daemon/launcher.js';
-import { readPid } from '../session/pid.js';
+import { getOptionBehavior } from './optionBehaviors.js';
+import { readLiveDaemonPid } from '../session/cleanup/staleSession.js';
 import { getAllDecisionTrees } from '../utils/decisionTrees.js';
 import { EXIT_CODE_REGISTRY } from '../utils/exitCodes.js';
-import { isProcessAlive } from '../utils/process.js';
 import { getAllTaskMappings } from '../utils/taskMappings.js';
 /**
  * Converts a Commander Option to OptionMetadata.
@@ -24,7 +22,8 @@ function convertOption(option, commandName) {
     const metadata = {
         flags: option.flags,
         description: option.description,
-        required: option.required,
+        required: option.mandatory,
+        takesValue: option.required || option.optional,
         optional: option.optional,
     };
     if (option.defaultValue !== undefined) {
@@ -86,42 +85,23 @@ function convertCommand(command) {
         subcommands: command.commands.map(convertCommand),
     };
 }
-/**
- * Checks if a session is currently active.
- *
- * @returns True if session is active, false otherwise
- */
-function isSessionActive() {
-    const sessionPid = readPid();
-    if (sessionPid === null) {
-        return false;
-    }
-    return isProcessAlive(sessionPid);
-}
 /**
  * Generates runtime state information.
  *
- * Checks current daemon and session status to provide state-aware
- * command availability information.
+ * The daemon hosts exactly one session, so a live daemon means an active
+ * session. Uses daemon.pid verified by command line to keep help generation
+ * synchronous; nothing is signalled based on this.
  *
  * @returns Runtime state object
  */
 function generateRuntimeState() {
-    const daemonRunning = isDaemonRunning();
-    const sessionActive = isSessionActive();
-    const availableCommands = [];
-    if (!daemonRunning && !sessionActive) {
-        availableCommands.push('bdg <url>', 'cleanup', '--help', '--version');
-    }
-    else if (daemonRunning && sessionActive) {
-        availableCommands.push('peek', 'tail', 'details', 'dom', 'network', 'console', 'cdp', 'status', 'stop');
-    }
-    else if (daemonRunning && !sessionActive) {
-        availableCommands.push('bdg <url>', 'cleanup', 'status');
-    }
+    const sessionActive = readLiveDaemonPid() !== null;
+    const availableCommands = sessionActive
+        ? ['peek', 'tail', 'details', 'dom', 'network', 'console', 'cdp', 'status', 'stop']
+        : ['bdg <url>', 'cleanup', '--help', '--version'];
     return {
         sessionActive,
-        daemonRunning,
+        daemonRunning: sessionActive,
         availableCommands,
     };
 }

package/dist/commands/helpTopic.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `bdg help <command...>` topics and Commander usage-error hints.
+ */
+import type { Command } from 'commander';
+/**
+ * The command path of `bdg help <path...>`: the words before the first option.
+ *
+ * @param args - Arguments after `help`
+ * @returns Command words, e.g. ['dom', 'query']
+ */
+export declare function helpTopicPath(args: string[]): string[];
+/**
+ * Reject `bdg help <topic>` for a command that does not exist (instead of
+ * showing the general help and exiting 0). Stops at a command without
+ * subcommands (further words are its arguments) and at `help` itself.
+ *
+ * @param program - Root command with all commands registered
+ * @param topic - Command path after `help`
+ * @throws CommandError (81) naming the unknown command
+ */
+export declare function assertKnownHelpTopic(program: Command, topic: string[]): void;
+/**
+ * Split Commander's error text into the message and a "did you mean" suggestion.
+ *
+ * @param text - Commander error message
+ * @returns Message without the hint, and the hint as a suggestion
+ */
+export declare function splitCommanderHint(text: string): {
+    message: string;
+    suggestion?: string;
+};
+//# sourceMappingURL=helpTopic.d.ts.map

package/dist/commands/helpTopic.js

@@ -0,0 +1,58 @@
+/**
+ * `bdg help <command...>` topics and Commander usage-error hints.
+ */
+import { CommandError } from '../errors/index.js';
+import { unknownHelpTopicError } from '../errors/messages.js';
+import { EXIT_CODES } from '../utils/exitCodes.js';
+import { findSimilar } from '../utils/suggestions.js';
+/** Commander's typo hint on its own line, e.g. "(Did you mean query?)" */
+const COMMANDER_HINT = /\n?\(Did you mean (.+)\?\)\s*$/;
+/**
+ * The command path of `bdg help <path...>`: the words before the first option.
+ *
+ * @param args - Arguments after `help`
+ * @returns Command words, e.g. ['dom', 'query']
+ */
+export function helpTopicPath(args) {
+    const firstOption = args.findIndex((arg) => arg.startsWith('-'));
+    return firstOption === -1 ? args : args.slice(0, firstOption);
+}
+/**
+ * Reject `bdg help <topic>` for a command that does not exist (instead of
+ * showing the general help and exiting 0). Stops at a command without
+ * subcommands (further words are its arguments) and at `help` itself.
+ *
+ * @param program - Root command with all commands registered
+ * @param topic - Command path after `help`
+ * @throws CommandError (81) naming the unknown command
+ */
+export function assertKnownHelpTopic(program, topic) {
+    let command = program;
+    const path = [];
+    for (const word of topic) {
+        if (command.commands.length === 0 || word === 'help')
+            return;
+        const sub = command.commands.find((c) => c.name() === word || c.aliases().includes(word));
+        if (!sub) {
+            const [closest] = findSimilar(word, command.commands.map((c) => c.name()));
+            const err = unknownHelpTopicError([...path, word].join(' '), closest && [...path, closest].join(' '));
+            throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
+        }
+        path.push(sub.name());
+        command = sub;
+    }
+}
+/**
+ * Split Commander's error text into the message and a "did you mean" suggestion.
+ *
+ * @param text - Commander error message
+ * @returns Message without the hint, and the hint as a suggestion
+ */
+export function splitCommanderHint(text) {
+    const message = text.replace(/^error:\s*/i, '');
+    const hint = COMMANDER_HINT.exec(message);
+    if (!hint)
+        return { message };
+    return { message: message.slice(0, hint.index).trim(), suggestion: `Did you mean: ${hint[1]}?` };
+}
+//# sourceMappingURL=helpTopic.js.map