@dereekb/dbx-cli 13.11.18 → 13.12.1

package/src/lib/mcp-scan/scan/pipes-cli.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `scan-pipes` subcommand entry point.
+ *
+ * Thin wrapper around {@link runScanCliBase} that supplies the pipes
+ * domain config.
+ */
+import { type BuildPipesGlobber } from './pipes-build-manifest.js';
+import { type RunScanCliBaseInput, type RunScanCliResult, type ScanCliBaseLogger, type ScanCliBaseReadFile, type ScanCliBaseWriteFile } from './scan-cli-base.js';
+/**
+ * Function shape used to read text files during `--check`.
+ */
+export type PipesScanCliReadFile = ScanCliBaseReadFile;
+/**
+ * Function shape used to write the produced manifest in write mode.
+ */
+export type PipesScanCliWriteFile = ScanCliBaseWriteFile;
+/**
+ * Console-shaped sink for stdout and stderr lines.
+ */
+export type PipesScanCliLogger = ScanCliBaseLogger;
+/**
+ * Input to {@link runPipesScanCli}.
+ */
+export type RunPipesScanCliInput = RunScanCliBaseInput<BuildPipesGlobber>;
+/**
+ * Result of one CLI invocation.
+ */
+export type RunPipesScanCliResult = RunScanCliResult;
+/**
+ * Runs one invocation of `scan-pipes`. Never throws on user errors — every
+ * failure path returns a structured exit code so callers can wire this
+ * into `process.exit` without try/catch.
+ *
+ * @param input - Argv plus injectable I/O hooks.
+ * @returns The CLI's exit code (0 on success, 1 on drift / build failure, 2 on usage error)
+ */
+export declare function runPipesScanCli(input: RunPipesScanCliInput): Promise<RunPipesScanCliResult>;

package/src/lib/mcp-scan/scan/pipes-extract.d.ts

@@ -0,0 +1,90 @@
+/**
+ * AST extraction for the `scan-pipes` generator.
+ *
+ * Walks every source file in the supplied ts-morph `Project` looking for
+ * top-level exported class declarations tagged with the `@dbxPipe` JSDoc
+ * marker. Each match is normalised into an {@link ExtractedPipeEntry} that
+ * {@link buildPipesManifest} assembles into a `PipeManifest` entry.
+ *
+ * `@Pipe({ name, pure })` decorator metadata, the `transform()` method
+ * signature, and `@param` JSDoc tags on `transform()` are auto-extracted;
+ * JSDoc tags only supply registry metadata that can't be derived from
+ * source (slug, category, related slugs, skill refs).
+ */
+import { type Project } from 'ts-morph';
+import type { PipeArgEntry, PipeEntry } from '../manifest/pipes-schema.js';
+/**
+ * One pipe entry extracted from a source file. Mirrors {@link PipeEntry}
+ * minus `module` (derived from the package being scanned in build-manifest).
+ * `filePath` and `line` are kept for in-process warnings and never persisted.
+ */
+export interface ExtractedPipeEntry {
+    readonly slug: string;
+    readonly category: PipeEntry['category'];
+    readonly pipeName: string;
+    readonly className: string;
+    readonly inputType: string;
+    readonly outputType: string;
+    readonly purity: PipeEntry['purity'];
+    readonly description: string;
+    readonly args: readonly PipeArgEntry[];
+    readonly relatedSlugs?: readonly string[];
+    readonly skillRefs?: readonly string[];
+    readonly example: string;
+    readonly deprecated?: boolean | string;
+    readonly since?: string;
+    readonly filePath: string;
+    readonly line: number;
+}
+/**
+ * Discriminated union of the non-fatal events the extractor emits when an
+ * entry can't be assembled. Build-manifest collates these into a structured
+ * warning array so missing/invalid tag combinations surface during
+ * generation rather than silently dropping entries.
+ */
+export type PipeExtractWarning = {
+    readonly kind: 'missing-required-tag';
+    readonly className: string;
+    readonly tag: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'unknown-category';
+    readonly className: string;
+    readonly category: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'missing-pipe-decorator';
+    readonly className: string;
+    readonly filePath: string;
+    readonly line: number;
+} | {
+    readonly kind: 'missing-transform-method';
+    readonly className: string;
+    readonly filePath: string;
+    readonly line: number;
+};
+/**
+ * Input to {@link extractPipeEntries}. The caller is responsible for adding
+ * source files to `project`.
+ */
+export interface ExtractPipeEntriesInput {
+    readonly project: Project;
+}
+/**
+ * Result of {@link extractPipeEntries}.
+ */
+export interface ExtractPipeEntriesResult {
+    readonly entries: readonly ExtractedPipeEntry[];
+    readonly warnings: readonly PipeExtractWarning[];
+}
+/**
+ * Walks the supplied project and returns every class tagged with the
+ * `@dbxPipe` JSDoc marker. Order is stable: source files in the order
+ * ts-morph reports them, declarations within a file in source order.
+ *
+ * @param input - The ts-morph project to scan.
+ * @returns The extracted entries plus any non-fatal warnings.
+ */
+export declare function extractPipeEntries(input: ExtractPipeEntriesInput): ExtractPipeEntriesResult;

package/src/lib/mcp-scan/scan/pipes-scan-config-schema.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Arktype schema for the `pipes` section of `dbx-mcp.scan.json`.
+ *
+ * Pipes scanning lives next to the existing semantic-types, ui-components,
+ * and forge-fields sections — all use the same `dbx-mcp.scan.json`
+ * filename so a project that opts into multiple pipelines keeps a single
+ * config file. The CLI subcommand `scan-pipes` reads only the `pipes`
+ * field; sibling subcommands continue to read their own top-level fields
+ * unchanged.
+ */
+/**
+ * Inner config that drives one pipes scan run. `source` becomes the
+ * manifest's `source` label (used for collision detection across loaded
+ * sources); `module` becomes the npm package name attached to every produced
+ * entry. Both default to the project's `package.json#name` when omitted.
+ */
+export declare const PipesScanSection: import("arktype/internal/variants/object.ts").ObjectType<{
+    include: string[];
+    source?: string | undefined;
+    module?: string | undefined;
+    exclude?: string[] | undefined;
+    out?: string | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link PipesScanSection}.
+ */
+export type PipesScanSection = typeof PipesScanSection.infer;
+/**
+ * Top-level shape used by the pipes builder. Only the `pipes` key is
+ * consumed; the rest of the document is ignored so a single
+ * `dbx-mcp.scan.json` can house all the scan sections side-by-side.
+ */
+export declare const PipesScanConfig: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    pipes: {
+        include: string[];
+        source?: string | undefined;
+        module?: string | undefined;
+        exclude?: string[] | undefined;
+        out?: string | undefined;
+    };
+}, {}>;
+/**
+ * Static type inferred from {@link PipesScanConfig}.
+ */
+export type PipesScanConfig = typeof PipesScanConfig.infer;
+/**
+ * Default value used when the scan config does not specify `out`.
+ * Lives next to the scan config in the project root.
+ */
+export declare const DEFAULT_PIPES_SCAN_OUT_PATH = "pipes.mcp.generated.json";
+/**
+ * Filename the loader looks for at `${projectRoot}/`. Re-exported here so
+ * the pipes CLI does not have to import from a sibling scan config module.
+ */
+export declare const PIPES_SCAN_CONFIG_FILENAME = "dbx-mcp.scan.json";

package/src/lib/mcp-scan/scan/scan-angular-io.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Generic Angular `@Input`/`input()`/`@Output`/`output()` AST parsing.
+ *
+ * The five `*-extract.ts` modules each need to walk Angular class members and
+ * normalise inputs/outputs into a domain-specific entry shape. The mechanics
+ * of that walk (decorator vs. signal call detection, alias extraction, type
+ * fallback rules) are identical; only the resulting record shape and dedupe
+ * key differ. This module exposes that walk as a generic helper that takes a
+ * per-domain entry-builder callback.
+ */
+import { type ClassDeclaration, type PropertyDeclaration } from 'ts-morph';
+/**
+ * Normalised view of a single `@Input`-decorated property or signal `input()`
+ * call. Each `*-extract.ts` module maps this into its own domain entry shape
+ * via the {@link ExtractAngularInputsOptions.buildEntry} callback.
+ */
+export interface ParsedAngularInput {
+    readonly propertyName: string;
+    readonly alias: string;
+    readonly type: string;
+    readonly required: boolean;
+    readonly defaultValue?: string;
+    readonly description: string;
+}
+/**
+ * Normalised view of a single `@Output`-decorated property or signal
+ * `output()` call. Each `*-extract.ts` module maps this into its own domain
+ * entry shape via the {@link ExtractAngularOutputsOptions.buildEntry}
+ * callback.
+ */
+export interface ParsedAngularOutput {
+    readonly propertyName: string;
+    readonly name: string;
+    readonly type: string;
+    readonly description: string;
+}
+/**
+ * Options for {@link extractAngularInputs}. The caller supplies a
+ * per-domain entry builder and dedupe key extractor; everything else is
+ * defaulted.
+ */
+export interface ExtractAngularInputsOptions<TEntry> {
+    readonly buildEntry: (parsed: ParsedAngularInput, property: PropertyDeclaration) => TEntry;
+    readonly dedupeBy: (entry: TEntry) => string;
+    readonly propertySource?: (decl: ClassDeclaration) => Iterable<PropertyDeclaration>;
+    readonly skipProperty?: (property: PropertyDeclaration) => boolean;
+}
+/**
+ * Options for {@link extractAngularOutputs}. Mirrors
+ * {@link ExtractAngularInputsOptions} for the output side.
+ */
+export interface ExtractAngularOutputsOptions<TEntry> {
+    readonly buildEntry: (parsed: ParsedAngularOutput, property: PropertyDeclaration) => TEntry;
+    readonly dedupeBy: (entry: TEntry) => string;
+    readonly propertySource?: (decl: ClassDeclaration) => Iterable<PropertyDeclaration>;
+    readonly skipProperty?: (property: PropertyDeclaration) => boolean;
+}
+/**
+ * Walks the supplied class's properties looking for Angular inputs (either
+ * `@Input()` decorated or initialised with a signal `input()` call) and
+ * builds a per-domain entry for each visible match. Returns entries in
+ * source order with duplicates (per `dedupeBy`) dropped.
+ *
+ * @param decl - The Angular class declaration to scan.
+ * @param options - Per-domain entry builder, dedupe key extractor, and optional property-source/skip overrides.
+ * @returns The collected per-domain entries for each visible input.
+ */
+export declare function extractAngularInputs<TEntry>(decl: ClassDeclaration, options: ExtractAngularInputsOptions<TEntry>): readonly TEntry[];
+/**
+ * Walks the supplied class's properties looking for Angular outputs (either
+ * `@Output()` decorated or initialised with a signal `output()` call) and
+ * builds a per-domain entry for each visible match. Returns entries in
+ * source order with duplicates (per `dedupeBy`) dropped.
+ *
+ * @param decl - The Angular class declaration to scan.
+ * @param options - Per-domain entry builder, dedupe key extractor, and optional property-source/skip overrides.
+ * @returns The collected per-domain entries for each visible output.
+ */
+export declare function extractAngularOutputs<TEntry>(decl: ClassDeclaration, options: ExtractAngularOutputsOptions<TEntry>): readonly TEntry[];
+/**
+ * Walks `decl` and every reachable base class, returning their direct
+ * `getProperties()` in superclass-first ... err, subclass-first order, with
+ * cycle protection. Useful for {@link ExtractAngularInputsOptions.propertySource}
+ * when a domain wants to inherit decorated properties from base classes.
+ *
+ * @param decl - The class declaration to walk, including all base classes.
+ * @returns Properties from `decl` and every base class in subclass-first order with cycle protection.
+ */
+export declare function collectClassPropertiesWithInheritance(decl: ClassDeclaration): readonly PropertyDeclaration[];

package/src/lib/mcp-scan/scan/scan-cli-base.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Generic core for the per-domain scan CLIs (actions, filters, forge-fields,
+ * pipes, ui-components).
+ *
+ * Each domain CLI (`actions-cli.ts`, etc.) is a thin wrapper that supplies a
+ * subcommand label, USAGE block, build-manifest function, manifest
+ * serializer, and a domain-specific `formatExtractWarning`. The argv parser,
+ * outcome dispatcher, drift check, and exit-code mapping live here so the
+ * five domains do not duplicate ~100 lines of identical procedural code each.
+ *
+ * The semantic-types CLI (`cli.ts`) is intentionally not migrated to this
+ * base: it pre-dates the family pattern and would require touching its
+ * downstream wiring without removing meaningful additional duplication.
+ */
+/**
+ * Function shape used to read text files during `--check`.
+ */
+export type ScanCliBaseReadFile = (absolutePath: string) => Promise<string>;
+/**
+ * Function shape used to write the produced manifest in write mode.
+ */
+export type ScanCliBaseWriteFile = (absolutePath: string, data: string) => Promise<void>;
+/**
+ * Console-shaped sink for stdout and stderr lines.
+ */
+export type ScanCliBaseLogger = (message: string) => void;
+/**
+ * Result of one CLI invocation.
+ */
+export interface RunScanCliResult {
+    readonly exitCode: number;
+}
+/**
+ * Minimum manifest shape the base CLI needs — `entries.length` is reported in
+ * the success log.
+ */
+export interface ScanCliManifestLike {
+    readonly entries: readonly unknown[];
+}
+/**
+ * Success branch of a `buildManifest` outcome.
+ */
+export interface ScanCliBuildSuccess<TManifest extends ScanCliManifestLike, TWarning> {
+    readonly kind: 'success';
+    readonly manifest: TManifest;
+    readonly outPath: string;
+    readonly scannedFileCount: number;
+    readonly extractWarnings: readonly TWarning[];
+}
+/**
+ * Failure branches of a `buildManifest` outcome — shape shared verbatim by
+ * every domain build-manifest module today.
+ */
+export type ScanCliBuildFailure = {
+    readonly kind: 'no-config';
+    readonly configPath: string;
+} | {
+    readonly kind: 'invalid-scan-config';
+    readonly configPath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'no-package';
+    readonly packagePath: string;
+} | {
+    readonly kind: 'invalid-package';
+    readonly packagePath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'invalid-manifest';
+    readonly error: string;
+};
+/**
+ * Discriminated union returned by a domain's `buildManifest` function.
+ */
+export type ScanCliBuildOutcome<TManifest extends ScanCliManifestLike, TWarning> = ScanCliBuildSuccess<TManifest, TWarning> | ScanCliBuildFailure;
+/**
+ * Input passed to the domain's `buildManifest` function. Each domain accepts
+ * a structural superset of this (e.g. its own globber type), so the base
+ * threads `TGlobber` through as a generic parameter.
+ */
+export interface ScanCliBuildInput<TGlobber> {
+    readonly projectRoot: string;
+    readonly generator: string;
+    readonly readFile: ScanCliBaseReadFile;
+    readonly globber?: TGlobber;
+    readonly now?: () => Date;
+}
+/**
+ * Per-domain configuration for {@link runScanCliBase}.
+ */
+export interface ScanCliConfig<TManifest extends ScanCliManifestLike, TWarning, TGlobber> {
+    /**
+     * Subcommand label printed in the regenerate hint, e.g. `scan-actions`.
+     */
+    readonly subcommand: string;
+    /**
+     * Pre-rendered USAGE block printed for `--help` and on parse errors.
+     */
+    readonly usage: string;
+    /**
+     * Suffix appended to the no-config error guidance — e.g. `with an actions
+     * section.` The full message becomes
+     * `Create a dbx-mcp.scan.json file in the project root <hint>`.
+     */
+    readonly configSectionHint: string;
+    /**
+     * Domain build-manifest entry point.
+     */
+    readonly buildManifest: (input: ScanCliBuildInput<TGlobber>) => Promise<ScanCliBuildOutcome<TManifest, TWarning>>;
+    /**
+     * Serializes the validated manifest to the exact bytes written to disk
+     * (including trailing newline). Tests rely on byte-equality for `--check`.
+     */
+    readonly serialize: (manifest: TManifest) => string;
+    /**
+     * Formats one extract warning for the `extract-warning: ...` log line.
+     */
+    readonly formatExtractWarning: (warning: TWarning) => string;
+}
+/**
+ * Input to {@link runScanCliBase}.
+ */
+export interface RunScanCliBaseInput<TGlobber> {
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly generator: string;
+    readonly readFile?: ScanCliBaseReadFile;
+    readonly writeFile?: ScanCliBaseWriteFile;
+    readonly globber?: TGlobber;
+    readonly now?: () => Date;
+    readonly log?: ScanCliBaseLogger;
+    readonly errorLog?: ScanCliBaseLogger;
+}
+/**
+ * Runs one invocation of a scan subcommand. The function never throws on
+ * user errors — every failure path returns a structured exit code so callers
+ * can wire this into `process.exit` without try/catch.
+ *
+ * @param input - Argv plus injectable I/O hooks.
+ * @param config - Per-domain wiring (subcommand label, usage, build, serialize, warning formatter)
+ * @returns The CLI's exit code (0 on success, 1 on drift / build failure, 2 on usage error)
+ */
+export declare function runScanCliBase<TManifest extends ScanCliManifestLike, TWarning, TGlobber>(input: RunScanCliBaseInput<TGlobber>, config: ScanCliConfig<TManifest, TWarning, TGlobber>): Promise<RunScanCliResult>;
+type ParsedScanArgs = {
+    readonly kind: 'parsed';
+    readonly project: string | undefined;
+    readonly check: boolean;
+    readonly out: string | undefined;
+    readonly help: boolean;
+} | {
+    readonly kind: 'parse-error';
+    readonly message: string;
+};
+/**
+ * Parses the shared scan CLI argv vocabulary (`--project`, `--check`,
+ * `--out`, `--help`).
+ *
+ * @param argv - Argument tokens, excluding the node binary and script paths.
+ * @returns Either the parsed flag bag or a `parse-error` describing the first malformed token.
+ */
+export declare function parseScanArgs(argv: readonly string[]): ParsedScanArgs;
+export {};

package/src/lib/mcp-scan/scan/scan-config-schema.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Arktype schema for `dbx-mcp.scan.json`.
+ *
+ * The scan config lives at the root of any package or app that wants the
+ * `scan-semantic-types` generator to produce a manifest for its semantic
+ * types. One scan config produces one manifest; if a workspace ships two
+ * sources (e.g. `@dereekb/util` and `@dereekb/model`) each gets its own
+ * scan config in its own directory.
+ *
+ * The schema mirrors {@link SemanticTypeManifest} where it can — `source`
+ * and `topicNamespace` carry through verbatim — but also adds the inputs
+ * the generator needs to actually walk source code (`include`, `exclude`)
+ * and decide where to emit the manifest (`out`).
+ */
+/**
+ * Top-level scan config schema. `include` is required; everything else
+ * has a sensible default. The `declaredTopics` array advertises the
+ * namespaced topics this manifest will use — entries may still emit
+ * topics outside this list, but the loader uses it to decide which
+ * topics show up in `topics` field of the produced manifest.
+ */
+export declare const SemanticTypeScanConfig: import("arktype/internal/variants/object.ts").ObjectType<{
+    version: 1;
+    source: string;
+    topicNamespace: string;
+    include: string[];
+    exclude?: string[] | undefined;
+    out?: string | undefined;
+    declaredTopics?: string[] | undefined;
+}, {}>;
+/**
+ * Static type inferred from {@link SemanticTypeScanConfig}.
+ */
+export type SemanticTypeScanConfig = typeof SemanticTypeScanConfig.infer;
+/**
+ * Default value used when the scan config does not specify `out`.
+ * Lives next to the scan config in the project root.
+ */
+export declare const DEFAULT_SCAN_OUT_PATH = "semantic-types.mcp.generated.json";
+/**
+ * Filename the loader looks for at `${projectRoot}/`. Constant so tests
+ * and the CLI agree on the discovery path.
+ */
+export declare const SCAN_CONFIG_FILENAME = "dbx-mcp.scan.json";

package/src/lib/mcp-scan/scan/ui-components-build-manifest.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Orchestrator for the `scan-ui-components` generator.
+ *
+ * Composes a complete {@link UiComponentManifest} from a project root by
+ *
+ *   1. reading `dbx-mcp.scan.json` against {@link UiComponentsScanConfig}
+ *   2. reading `package.json` to derive the entry-level `module` field
+ *   3. resolving include/exclude globs against the project root
+ *   4. feeding matched files into a ts-morph project
+ *   5. extracting entries via {@link extractUiEntries}
+ *   6. assembling the manifest envelope and validating it against
+ *      {@link UiComponentManifest}
+ *
+ * I/O is fully injectable so tests drive every code path without
+ * touching the real filesystem.
+ */
+import { UiComponentManifest } from '../manifest/ui-components-schema.js';
+import { type ExtractWarning } from './ui-components-extract.js';
+import { type ScanGlobber, type ScanReadFile } from '../../scan-helpers/scan-io.js';
+export type BuildUiManifestReadFile = ScanReadFile;
+export type BuildUiManifestGlobber = ScanGlobber;
+/**
+ * Input to {@link buildUiComponentsManifest}.
+ */
+export interface BuildUiManifestInput {
+    readonly projectRoot: string;
+    readonly generator: string;
+    readonly now?: () => Date;
+    readonly readFile?: BuildUiManifestReadFile;
+    readonly globber?: BuildUiManifestGlobber;
+}
+/**
+ * Outcome of one generator run. The success payload carries everything
+ * the caller needs to write the manifest to disk or run a freshness
+ * diff against an existing on-disk version.
+ */
+export type BuildUiManifestOutcome = {
+    readonly kind: 'success';
+    readonly manifest: UiComponentManifest;
+    readonly outPath: string;
+    readonly scannedFileCount: number;
+    readonly extractWarnings: readonly ExtractWarning[];
+} | {
+    readonly kind: 'no-config';
+    readonly configPath: string;
+} | {
+    readonly kind: 'invalid-scan-config';
+    readonly configPath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'no-package';
+    readonly packagePath: string;
+} | {
+    readonly kind: 'invalid-package';
+    readonly packagePath: string;
+    readonly error: string;
+} | {
+    readonly kind: 'invalid-manifest';
+    readonly error: string;
+};
+/**
+ * Builds a {@link UiComponentManifest} from the supplied project root.
+ * The function is pure with respect to the injected I/O hooks, so unit
+ * tests can drive every branch without disk access.
+ *
+ * @param input - The project root + injection hooks for testing.
+ * @returns A discriminated outcome describing the result.
+ */
+export declare function buildUiComponentsManifest(input: BuildUiManifestInput): Promise<BuildUiManifestOutcome>;
+/**
+ * JSON-stringifies a manifest with stable key ordering and trailing
+ * newline so `--check` mode can byte-compare against a committed file
+ * without false-positive diffs from key reordering.
+ *
+ * @param manifest - The manifest to serialise.
+ * @returns The canonical string form.
+ */
+export declare function serializeUiComponentManifest(manifest: UiComponentManifest): string;

package/src/lib/mcp-scan/scan/ui-components-cli.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `scan-ui-components` subcommand entry point.
+ *
+ * Thin wrapper around {@link runScanCliBase} that supplies the
+ * ui-components domain config.
+ */
+import { type BuildUiManifestGlobber } from './ui-components-build-manifest.js';
+import { type RunScanCliBaseInput, type RunScanCliResult, type ScanCliBaseLogger, type ScanCliBaseReadFile, type ScanCliBaseWriteFile } from './scan-cli-base.js';
+/**
+ * Function shape used to read text files during `--check`.
+ */
+export type UiScanCliReadFile = ScanCliBaseReadFile;
+/**
+ * Function shape used to write the produced manifest in write mode.
+ */
+export type UiScanCliWriteFile = ScanCliBaseWriteFile;
+/**
+ * Console-shaped sink for stdout and stderr lines.
+ */
+export type UiScanCliLogger = ScanCliBaseLogger;
+/**
+ * Input to {@link runUiComponentsScanCli}.
+ */
+export type RunUiComponentsScanCliInput = RunScanCliBaseInput<BuildUiManifestGlobber>;
+/**
+ * Result of one CLI invocation.
+ */
+export type RunUiComponentsScanCliResult = RunScanCliResult;
+/**
+ * Runs one invocation of `scan-ui-components`. Never throws on user errors —
+ * every failure path returns a structured exit code so callers can wire
+ * this into `process.exit` without try/catch.
+ *
+ * @param input - Argv plus injectable I/O hooks.
+ * @returns The CLI's exit code (0 on success, 1 on drift / build failure, 2 on usage error)
+ */
+export declare function runUiComponentsScanCli(input: RunUiComponentsScanCliInput): Promise<RunUiComponentsScanCliResult>;