@contentful/experience-design-system-cli 2.37.1-dev-build-799db3ac.0 → 2.37.1-dev-build-e5882940.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.37.1-dev-build-799db3ac.0",
+  "version": "2.37.1-dev-build-e5882940.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -25,7 +25,8 @@
   "files": [
     "bin/",
     "dist/",
-    "legacy/"
+    "legacy/",
+    "skills/"
   ],
   "scripts": {
     "build": "nx build experience-design-system-cli",
@@ -38,6 +39,7 @@
   },
   "dependencies": {
     "@contentful/experience-design-system-backend-pipeline": "workspace:*",
+    "@contentful/experience-design-system-generation": "workspace:*",
     "@contentful/experience-design-system-types": "workspace:*",
     "@inkjs/ui": "^2.0.0",
     "@segment/analytics-node": "^3.0.0",

package/dist/src/tui/import/spawn-v1-import.d.ts

@@ -1,5 +1,5 @@
 import { type ImportOptions } from '../../commands/import-options.js';
-import type { TokenStrategy } from './steps/05-token-reuse/logic.js';
+import { type ImportHandoff } from '@contentful/experience-design-system-types/handoff';
 interface StepResult {
     step: string;
     status: 'complete' | 'failed' | 'skipped';
@@ -20,8 +20,8 @@ export interface SpawnV1ImportOptions extends Partial<ImportOptions> {
     projectPath?: string;
     tokens?: string;
     filePaths?: string[];
-    skipCredentials?: boolean;
-    tokenStrategy?: TokenStrategy;
+    /** What the CLI already settled and did; the legacy wizard starts from it. */
+    handoff?: ImportHandoff;
     onProgress?: (line: string) => void;
 }
 export interface SpawnV1ImportResult {

package/dist/src/tui/import/steps/05-token-reuse/logic.d.ts

@@ -1,4 +1,4 @@
-export type TokenStrategy = 'reuse' | 'regenerate' | 'generate';
+export type { TokenStrategy } from '../06-extraction/types.js';
 export type TokensState = {
     kind: 'none';
 } | {
@@ -19,4 +19,3 @@ export declare function gateText({ tokensPath, sourceChanged }: {
     summary: string;
     context?: string;
 };
-export {};

package/dist/src/tui/import/steps/06-extraction/logic.d.ts

@@ -0,0 +1,69 @@
+import type { CompositionPhase, ExtractionProgress } from './types.js';
+/** One line of the extract subprocess's stderr, decoded. Lines it does not recognise are ignored. */
+export type ProgressEvent = {
+    kind: 'scan';
+    scanned: number;
+} | {
+    kind: 'scan-done';
+    total: number;
+} | {
+    kind: 'extract';
+    totalFiles: number;
+} | {
+    kind: 'composition';
+    phase: CompositionPhase;
+};
+/** `progress=scan:12`, `progress=scan-done:40`, `progress=extract:3/40:7`, `progress=composition:cache-hit`. */
+export declare function parseProgressLine(line: string): ProgressEvent | null;
+/** `session=<id>` on the extract subprocess's stdout. It arrives before composition finishes, which is when selection starts. */
+export declare function parseSessionLine(line: string): string | null;
+/** The first `session=<id>` anywhere in a command's stdout. */
+export declare function findSession(stdout: string): string | null;
+/** `Extracted 7 components` in the extract command's stderr; 0 when it never printed one. */
+export declare function parseExtractedCount(stderr: string): number;
+/** `(12 tokens` in the output of `print tokens`. */
+export declare function parsePrintTokensCount(stdout: string): number;
+/**
+ * Every job the stage will run starts on the first frame, so no row appears later as a surprise. A job that does not
+ * apply stays 'idle' and has no row: existing entities need credentials, token definitions need a raw tokens file, and
+ * reused tokens are already complete.
+ */
+export declare function initialProgress(input: {
+    hasCredentials: boolean;
+    hasRawTokens: boolean;
+    reuseTokens: boolean;
+}): ExtractionProgress;
+export declare function applyProgressEvent(progress: ExtractionProgress, event: ProgressEvent): ExtractionProgress;
+/** The rows the screen shows, in the order the wizard showed them. Rows that do not apply are left out. */
+export declare function progressRows(progress: ExtractionProgress, agent: string): Array<{
+    text: string;
+    complete: boolean;
+}>;
+/** True when every job is already done, so the screen would only flash. The wizard shows nothing in this case. */
+export declare function isFullCacheHit(progress: ExtractionProgress): boolean;
+/**
+ * The wizard's step counts: three fixed steps, one more when there is a token stage, two more when components are
+ * imported, and one more when the tokens can be mapped (not known yet at this stage, so it adds nothing here).
+ * Extraction is step 2 when there is a token stage, otherwise step 1.
+ */
+export declare function stepNumbers(input: {
+    hasRawTokens: boolean;
+    skipComponents?: boolean;
+    mapTokensEligible?: boolean | null;
+}): {
+    stepNumber: number;
+    totalSteps: number;
+};
+export declare function noComponentsMessage(projectPath: string): string;
+export declare function agentAuthMessage(agent: string, status: 'not-found' | 'unauthenticated'): string;
+/**
+ * The agent and model the import runs with: what was typed after `--agent` (either `agent` or `agent:model`), else
+ * what `experiences setup` saved, else Claude with no model. Same chain the legacy import command uses.
+ */
+export declare function resolveAgentChoice(flag: string | undefined, stored: {
+    agent?: unknown;
+    agentModel?: unknown;
+}): {
+    agent: string;
+    agentModel?: string;
+};

package/dist/src/tui/import/steps/06-extraction/processes.d.ts

@@ -0,0 +1,45 @@
+/** The legacy commands the stage drives, started the way the wizard starts them. */
+export interface SpawnedResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface ExtractCommand {
+    projectPath: string;
+    agent: string;
+    promptOverrides: string[];
+    noCache: boolean;
+}
+export interface TokenGenerationInput {
+    rawTokensPath: string;
+    outDir: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    noCache: boolean;
+}
+export type TokenGenerationResult = {
+    ok: true;
+    tokensPath: string;
+    tokenSessionId: string | null;
+    tokenCount: number;
+} | {
+    ok: false;
+    step: 'generate tokens' | 'print tokens';
+    message: string;
+};
+/** Splits a stream into lines as chunks arrive, holding back a trailing partial line until the next chunk completes it. */
+export declare function lineSplitter(onLine: (line: string) => void): (chunk: string) => void;
+/** Arguments for `__extract`, in the order the wizard passes them. The extract command takes an agent but no model. */
+export declare function buildExtractArgs(cliPath: string, command: ExtractCommand): string[];
+/** Arguments for `__generate tokens`, in the order the wizard passes them. */
+export declare function buildGenerateTokensArgs(cliPath: string, input: TokenGenerationInput): string[];
+/** Arguments for `print tokens`, which writes the generated catalog next to the project. */
+export declare function buildPrintTokensArgs(tokensPath: string, tokenSessionId: string | null): string[];
+/** `node <legacy cli> __extract …`, with stderr and stdout delivered line by line while it runs. */
+export declare function spawnExtract(command: ExtractCommand, handlers: {
+    onStderrLine: (line: string) => void;
+    onStdoutLine: (line: string) => void;
+}): Promise<SpawnedResult>;
+/** `__generate tokens`, then `print tokens` to write `<outDir>/tokens.json`. */
+export declare function runTokenGeneration(input: TokenGenerationInput): Promise<TokenGenerationResult>;

package/dist/src/tui/import/steps/06-extraction/run.d.ts

@@ -0,0 +1,24 @@
+import { checkAgentAuth } from '@contentful/experience-design-system-generation';
+import { runTokenGeneration, spawnExtract } from './processes.js';
+import { runSelection } from './selection.js';
+import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
+/** The outside world the stage talks to, so the order of events can be tested without a network, an agent or a CLI. */
+export interface ExtractionDeps {
+    checkAgentAuth: typeof checkAgentAuth;
+    fetchEntities: (credentials: NonNullable<ExtractionInput['credentials']>, outDir: string) => Promise<string | null>;
+    spawnExtract: typeof spawnExtract;
+    runTokenGeneration: typeof runTokenGeneration;
+    runSelection: typeof runSelection;
+}
+/**
+ * Runs the stage. The jobs overlap exactly as they do in the legacy wizard:
+ *
+ *   entities fetch ───────┐
+ *   __extract ── session= ┴─ selection agent (waits for the fetch) ──┐
+ *        └──────────────────────────────── exits (composition done) ─┴─ result
+ *   __generate tokens → print tokens   (only when the tokens are not being reused)
+ *
+ * Selection starts the moment the session id is printed, so it overlaps with composition. When more than one job
+ * fails, the error reported is the first of: extract, no components, selection, token generation.
+ */
+export declare function runExtraction(input: ExtractionInput, onProgress: (progress: ExtractionProgress) => void, deps?: ExtractionDeps): Promise<ExtractionResult>;

package/dist/src/tui/import/steps/06-extraction/screen.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ExtractionProgress } from './types.js';
+interface ExtractionScreenProps {
+    progress: ExtractionProgress;
+    agent: string;
+    stepNumber: number;
+    totalSteps: number;
+}
+export declare function ExtractionScreen({ progress, agent, stepNumber, totalSteps, }: ExtractionScreenProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/06-extraction/selection.d.ts

@@ -0,0 +1,18 @@
+import { type AgentName } from '@contentful/experience-design-system-generation';
+export interface SelectionOptions {
+    sessionId: string;
+    agent: AgentName;
+    model?: string;
+    promptText?: string;
+    promptPath?: string;
+    noCache: boolean;
+}
+/**
+ * The selection agent run, as the legacy wizard ran it.
+ *
+ * Reads the extracted components from the session database and skips the ones already decided (cache keyed by
+ * component hash, prompt hash and CLI version). It asks the agent about the rest, then writes accepted or rejected to
+ * raw_components and stores the new decisions in the cache in one transaction. Throws on a timeout, a non-zero exit,
+ * or a database error.
+ */
+export declare function runSelection(options: SelectionOptions): Promise<void>;

package/dist/src/tui/import/steps/06-extraction/types.d.ts

@@ -0,0 +1,44 @@
+import type { ExtractionHandoff, ImportHandoff } from '@contentful/experience-design-system-types/handoff';
+export type TokenStrategy = ImportHandoff['tokens']['strategy'];
+export interface ExtractionInput {
+    projectPath: string;
+    /** Raw tokens file the user pointed at (always set: v2 asks for one). */
+    rawTokensPath: string;
+    /** From the token reuse step. 'reuse' skips token generation entirely. */
+    tokenStrategy: TokenStrategy;
+    /** Null when the user skipped credentials: no existing-entities fetch happens. */
+    credentials: {
+        spaceId: string;
+        environmentId: string;
+        cmaToken: string;
+        host: string;
+    } | null;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    noCache: boolean;
+}
+export type CompositionPhase = 'resolving' | 'cache-hit' | 'done' | `agent:${string}`;
+type JobStatus = 'idle' | 'running' | 'complete' | 'failed';
+/** Everything the extracting screen shows. One field per row. */
+export interface ExtractionProgress {
+    scan: {
+        scanned: number;
+        total: number | null;
+    } | null;
+    composition: CompositionPhase;
+    selection: 'running' | 'complete';
+    existingEntities: JobStatus;
+    tokens: JobStatus;
+}
+/** The label the error screen shows, as the wizard labelled it. */
+type ExtractionStepName = 'analyze extract' | 'selection agent' | 'generate tokens' | 'print tokens' | `${string} auth check`;
+export type ExtractionResult = {
+    ok: true;
+    extraction: ExtractionHandoff;
+} | {
+    ok: false;
+    step: ExtractionStepName;
+    message: string;
+};
+export {};

package/dist/src/tui/import/steps/06-extraction/use-extraction.d.ts

@@ -0,0 +1,14 @@
+import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
+export type ExtractionState = {
+    status: 'running';
+    progress: ExtractionProgress;
+} | {
+    status: 'done';
+    result: ExtractionResult;
+};
+/**
+ * Runs the extraction stage once for the given input and reports its progress. Passing a different input starts a new
+ * run; passing nothing leaves the stage idle. A run that finishes after the input changed or the screen went away is
+ * ignored.
+ */
+export declare function useExtraction(input: ExtractionInput | undefined): ExtractionState | undefined;

package/dist/src/tui/import/steps/07-scope-gate/cache-check.d.ts

@@ -0,0 +1,29 @@
+export interface CacheCheckInput {
+    sessionId: string;
+    tokensPath: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    existingEntitiesPath: string | null;
+    noCache: boolean;
+}
+interface CacheCheckProcess {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/** Runs the legacy CLI with these arguments and waits for it to exit. */
+export type RunLegacyCli = (args: string[]) => Promise<CacheCheckProcess>;
+/**
+ * The arguments of `generate components --cache-status --restore-cache`, in the order the wizard built them: the
+ * generate arguments first, then the two cache flags. Arguments are not shell-quoted; they go straight to `node`.
+ */
+export declare function buildCacheCheckArgs(input: CacheCheckInput): string[];
+/** The names on the `cache-components=["A","B"]` line. Anything missing or unreadable is an empty list. */
+export declare function parseCacheComponents(stdout: string): string[];
+/**
+ * Never throws: any failure (spawn error, non-zero exit, no output line, bad JSON) resolves to an empty list. With the
+ * cache off there is nothing to restore, so the command is not run at all.
+ */
+export declare function checkGenerationCache(input: CacheCheckInput, run?: RunLegacyCli): Promise<string[]>;
+export {};

package/{legacy/dist/src/import/tui/scope-gate-columns.d.ts → dist/src/tui/import/steps/07-scope-gate/columns.d.ts}

@@ -1,9 +1,9 @@
-import type { Closure } from '../../analyze/composite-closure.js';
+import type { Closure } from './graph/composite-closure.js';
 /** Structural subset of ScopeComponent needed by these helpers. */
 export interface ScopeComponentLike {
     name: string;
 }
-export type Decision = 'accepted' | 'rejected' | 'undecided';
+import type { Decision } from './types.js';
 export declare const SCOPE_GATE_MAIN_COLUMN_WIDTH = 54;
 export declare const ACCEPTED_COMPONENTS_COLUMN_WIDTH = 36;
 export interface ScopeGatePanelLayout {
@@ -34,3 +34,23 @@ export declare function computeCounters(components: ScopeComponentLike[], closur
     groups: number;
     total: number;
 };
+export declare function sideColumnLabelStyle(input: {
+    isCycle: boolean;
+    isSelected: boolean;
+    focused: boolean;
+}): {
+    nameColor: string | undefined;
+    nameBold: boolean;
+    nameInverse: boolean;
+    nameUnderline: boolean;
+    suffixColor: string | undefined;
+    suffixDim: boolean;
+    suffixInverse: boolean;
+    suffixUnderline: boolean;
+};
+export declare function computeColumnWindow(total: number, cursor: number, visibleCount: number): {
+    start: number;
+    end: number;
+    above: number;
+    below: number;
+};

package/dist/src/tui/import/steps/07-scope-gate/graph/composite-closure.d.ts

@@ -0,0 +1,26 @@
+export interface ComponentGraphNode {
+    name: string;
+    slots: Array<{
+        name: string;
+        allowedComponents?: string[];
+    }>;
+}
+interface ClosureNode {
+    name: string;
+    depth: number;
+    path: string[];
+    parents: string[];
+}
+export interface Closure {
+    root: string;
+    nodes: ClosureNode[];
+    containsCycle: boolean;
+    cyclePath?: string[];
+}
+export type NodeStatus = 'ok' | 'warning' | 'error';
+export declare function findRoots(components: ComponentGraphNode[], selected?: Set<string>): string[];
+export declare function computeClosure(root: string, components: ComponentGraphNode[]): Closure;
+export declare function computeAllClosures(components: ComponentGraphNode[], selected?: Set<string>): Map<string, Closure>;
+export declare function aggregateStatus(closure: Closure, perNodeStatus: Map<string, NodeStatus>): NodeStatus;
+export declare function findSharedDeps(closures: Map<string, Closure>): Map<string, string[]>;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/graph/cycle-detection.d.ts

@@ -0,0 +1,22 @@
+/** A directed edge in the slot-dependency graph. */
+export interface SlotEdge {
+    fromComponent: string;
+    slotName: string;
+    toComponent: string;
+}
+/** A single elementary cycle, with `path[0] === path[path.length - 1]`. */
+export interface SlotCycle {
+    path: string[];
+    edges: SlotEdge[];
+}
+/** Input shape mirroring the slot definition on CDFComponentEntry. */
+export interface ComponentSlotInfo {
+    name: string;
+    slots: Array<{
+        name: string;
+        allowedComponents?: string[];
+    }>;
+}
+export declare function findSlotCycles(components: ComponentSlotInfo[]): SlotCycle[];
+export declare function suggestCycleBreakEdge(cycle: SlotCycle, allCycles: SlotCycle[]): SlotEdge;
+export declare function formatCyclePath(cycle: SlotCycle, maxHops?: number): string;

package/dist/src/tui/import/steps/07-scope-gate/graph/fuzzy-search.d.ts

@@ -0,0 +1,3 @@
+export declare function fuzzyMatches(query: string, text: string): boolean;
+export declare function fuzzyScore(query: string, text: string): number | null;
+export declare function fuzzyFilter(query: string, candidates: string[]): string[];

package/dist/src/tui/import/steps/07-scope-gate/graph/index.d.ts

@@ -0,0 +1,33 @@
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+import type { ScopeComponent } from '../types.js';
+import { type Closure, type ComponentGraphNode, type NodeStatus } from './composite-closure.js';
+import { type SlotCycle } from './cycle-detection.js';
+export interface ScopeGraph {
+    /** The slot dependency graph, one node per component. */
+    nodes: ComponentGraphNode[];
+    /** Every slot cycle. A graph that cannot be searched for cycles has none, as in legacy. */
+    cycles: SlotCycle[];
+    /** Names in at least one cycle. */
+    cycleParticipants: Set<string>;
+    /** For each cycle member, the whole set of members that has to be accepted or rejected with it. */
+    cycleUnits: Map<string, Set<string>>;
+    /** For each root, what it needs. A root with more than one node is a group. */
+    closures: Map<string, Closure>;
+}
+export interface SidebarItem {
+    key: string;
+    entry: CDFComponentEntry;
+    status: NodeStatus;
+}
+/** What the sidebar draws a row from: an entry standing in for the component (its slots are what matter), and its status. */
+export declare function sidebarItems(components: ScopeComponent[]): SidebarItem[];
+export declare function buildScopeGraph(components: ScopeComponent[]): ScopeGraph;
+/** Names that change when `target` is accepted. Pulls in everything it needs, whole cycles together. */
+export declare function acceptCascade(graph: ScopeGraph, target: string): string[];
+/** Rejecting rejects every ancestor and deselects the descendants. The screen asks first when it is 2 or more. */
+export declare function rejectCascade(graph: ScopeGraph, target: string): {
+    toReject: string[];
+    toDeselect: string[];
+};
+/** Everything reachable from the seeds, including the cycles they depend on. Used by "toggle all" and "accept non-flagged". */
+export declare function reachableCycleMembers(graph: ScopeGraph, seeds: string[]): string[];

package/dist/src/tui/import/steps/07-scope-gate/graph/lineage.d.ts

@@ -0,0 +1,29 @@
+import type { ComponentGraphNode } from './composite-closure.js';
+export interface LineageParentEdge {
+    parent: string;
+    slotName: string;
+}
+export interface LineageEdge {
+    from: string;
+    slotName: string;
+    to: string;
+}
+export type LineageChain = LineageEdge[];
+export declare function findDirectParents(target: string, components: ComponentGraphNode[]): LineageParentEdge[];
+export declare function findAllAncestors(target: string, components: ComponentGraphNode[]): Set<string>;
+export declare function findAllAncestorChains(target: string, components: ComponentGraphNode[]): LineageChain[];
+export interface AncestorTreeNode {
+    name: string;
+    incomingSlotName?: string;
+    depth: number;
+    shared: boolean;
+    cycle: boolean;
+    parents: AncestorTreeNode[];
+}
+export declare function buildAncestorTree(target: string, components: ComponentGraphNode[]): AncestorTreeNode;
+export interface AncestorTreeLine {
+    text: string;
+    jumpTarget?: string;
+    depth: number;
+}
+export declare function renderAncestorTree(node: AncestorTreeNode): AncestorTreeLine[];

package/dist/src/tui/import/steps/07-scope-gate/graph/search-neighborhood.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentGraphNode } from './composite-closure.js';
+export declare function computeDirectNeighborhood(matches: Iterable<string>, graph: ComponentGraphNode[]): Set<string>;
+export declare function findAllAncestors(target: string, graph: ComponentGraphNode[]): Set<string>;

package/dist/src/tui/import/steps/07-scope-gate/graph/slot-graph.d.ts

@@ -0,0 +1,11 @@
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+import type { ComponentGraphNode } from './composite-closure.js';
+export interface SlotGraphInput {
+    key: string;
+    entry: CDFComponentEntry;
+    status?: string;
+}
+export interface BuildOptions {
+    stripRejectedEdges?: boolean;
+}
+export declare function buildComponentGraph(components: SlotGraphInput[], opts?: BuildOptions): ComponentGraphNode[];

package/dist/src/tui/import/steps/07-scope-gate/keymap.d.ts

@@ -0,0 +1,84 @@
+export type GateMode = 'help' | 'reject-prompt' | 'search' | 'cycles' | 'flags' | 'main';
+export interface KeyPress {
+    input: string;
+    upArrow?: boolean;
+    downArrow?: boolean;
+    return?: boolean;
+    escape?: boolean;
+    tab?: boolean;
+    shiftTab?: boolean;
+    ctrl?: boolean;
+}
+/** What legacy looked at besides the key and the open panel. */
+export interface GateContext {
+    focusedColumn: 'main' | 'added-components';
+    /** The layout has only the main column, so Tab has nowhere to go. */
+    singleColumn: boolean;
+    hasCycles: boolean;
+    /** Some component was flagged by the AI with a reason to show. */
+    hasFlagReasons: boolean;
+    /** A jump filter is on, so Esc clears it before it quits. */
+    jumpFilterActive: boolean;
+    /** Search text is set, so Esc clears it before it quits. */
+    searchActive: boolean;
+    /** The list in the focused column has no rows, so the arrows have nothing to move. */
+    focusedListEmpty: boolean;
+}
+export type GateAction = {
+    type: 'none';
+} | {
+    type: 'quit';
+} | {
+    type: 'confirm';
+} | {
+    type: 'close-help';
+} | {
+    type: 'answer-reject-prompt';
+    confirm: boolean;
+} | {
+    type: 'close-panel';
+} | {
+    type: 'close-search';
+} | {
+    type: 'submit-search';
+} | {
+    type: 'search-input';
+} | {
+    type: 'clear-jump-filter';
+} | {
+    type: 'clear-search';
+} | {
+    type: 'move';
+    delta: -1 | 1;
+} | {
+    type: 'jump-to-selected';
+} | {
+    type: 'accept';
+} | {
+    type: 'reject';
+} | {
+    type: 'toggle-all';
+} | {
+    type: 'accept-unflagged';
+} | {
+    type: 'toggle-group';
+} | {
+    type: 'expand-all';
+} | {
+    type: 'collapse-all';
+} | {
+    type: 'switch-column';
+    delta: -1 | 1;
+} | {
+    type: 'open-panel';
+    panel: 'cycles' | 'flags' | 'help' | 'search';
+} | {
+    type: 'toggle-dependencies';
+} | {
+    type: 'toggle-cycle-filter';
+} | {
+    type: 'toggle-jump-filter';
+} | {
+    type: 'toggle-view';
+};
+export declare function resolveKey(mode: GateMode, key: KeyPress, ctx: GateContext): GateAction;

package/dist/src/tui/import/steps/07-scope-gate/load.d.ts

@@ -0,0 +1,8 @@
+import type { ScopeGateLoad } from './types.js';
+/**
+ * Reads the components for the gate, once, before the screen renders. Replaces legacy's database read inside render
+ * (and its "remember the last list" workaround for the resize that happened after confirming): with nothing written
+ * until the wizard saves the decisions, the list cannot change under the screen.
+ * Uses `loadScopeComponents` from backend-pipeline, which is identical to legacy's.
+ */
+export declare function loadScopeGate(sessionId: string): ScopeGateLoad;

package/dist/src/tui/import/steps/07-scope-gate/panels/added-column.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type AddedComponentEntry } from '../columns.js';
+interface AddedColumnProps {
+    title: string;
+    width: number;
+    height: number;
+    entries: AddedComponentEntry[];
+    cursor: number;
+    focused: boolean;
+    aiFlaggedByKey?: Map<string, boolean>;
+    visibleCount: number;
+}
+/** The accepted components, cycle members first. Rejecting from here is the only decision it allows. */
+export declare function AddedColumn(props: AddedColumnProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/panels/cycles-panel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { SlotCycle } from '../graph/cycle-detection.js';
+interface CyclesPanelProps {
+    cycles: SlotCycle[];
+    cursor: number;
+}
+export declare function CyclesPanel({ cycles, cursor }: CyclesPanelProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/panels/reject-prompt.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { PendingRejectCascade } from '../use-scope-gate.js';
+export declare function RejectPrompt({ pending }: {
+    pending: PendingRejectCascade;
+}): React.ReactElement;

package/dist/src/tui/import/steps/07-scope-gate/screen.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ScopeComponent, ScopeDecisions } from './types.js';
+interface ScopeGateScreenProps {
+    components: ScopeComponent[];
+    onConfirm: (decisions: ScopeDecisions) => void;
+    onQuit: () => void;
+}
+export declare function ScopeGateScreen(props: ScopeGateScreenProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/autocomplete.d.ts

@@ -0,0 +1,5 @@
+export interface AutocompleteResult {
+    completion: string;
+    candidates: string[];
+}
+export declare function computeAutocomplete(query: string, names: string[]): AutocompleteResult;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/CompactControlBar.d.ts

@@ -0,0 +1,4 @@
+export declare function CompactControlBar({ hasGroupRoots, searchActive }: {
+    hasGroupRoots: boolean;
+    searchActive: boolean;
+}): import("react/jsx-runtime").JSX.Element;