@contentful/experience-design-system-cli 2.35.1-dev-build-fa950e44.0 → 2.35.1-dev-build-236b6909.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.35.1-dev-build-fa950e44.0",
+  "version": "2.35.1-dev-build-236b6909.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

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

@@ -16,7 +16,6 @@ interface PipelineResult {
 }
 export interface SpawnV1ImportOptions {
     project?: string;
-    tokens?: string;
     onProgress?: (line: string) => void;
 }
 export interface SpawnV1ImportResult {

package/dist/src/tui/import/steps/index.d.ts

@@ -1,2 +1 @@
 export { WelcomeScreen } from './01-welcome/screen.js';
-export { TokenInputScreen } from './02-token-input/screen.js';

package/legacy/dist/src/analyze/controller/run-analyze-extract.d.ts

@@ -0,0 +1,12 @@
+export interface AnalyzeExtractOptions {
+    project: string;
+    dir?: string;
+    resolveUnreachable?: string;
+    compositionRefresh?: boolean;
+    cache?: boolean;
+    noCache?: boolean;
+    prompt?: string[];
+    agent?: string;
+    bedrock?: boolean;
+}
+export declare function runAnalyzeExtract(opts: AnalyzeExtractOptions): Promise<void>;

package/legacy/dist/src/analyze/extract-command.d.ts

@@ -1,7 +1,4 @@
 import type { Command } from 'commander';
-export declare function resolveExtractNoCache(opts: {
-    cache?: boolean;
-    noCache?: boolean;
-}): boolean;
-export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;
+export { resolveExtractNoCache } from './helpers/resolve-no-cache.js';
+export { collectSourceFiles } from './services/collect-source-files.js';
 export declare function registerInternalExtractCommand(program: Command): void;

package/legacy/dist/src/analyze/helpers/resolve-composition-agent.d.ts

@@ -0,0 +1,9 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+export declare function resolveCompositionAgentName(flagValue?: string): AgentName;
+export declare function readCandidateFiles(components: Array<{
+    sourcePath?: string;
+    source?: string;
+}>, extraFiles?: string[]): Promise<Array<{
+    path: string;
+    content: string;
+}>>;

package/legacy/dist/src/analyze/helpers/resolve-no-cache.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveExtractNoCache(opts: {
+    cache?: boolean;
+    noCache?: boolean;
+}): boolean;

package/legacy/dist/src/analyze/helpers/resolve-unreachable-mode.d.ts

@@ -0,0 +1 @@
+export declare function resolveUnreachableMode(value: string | undefined): 'auto' | 'always' | 'never';

package/legacy/dist/src/analyze/helpers/retry-db-write.d.ts

@@ -0,0 +1 @@
+export declare function retryDatabaseWrite<T>(operation: () => T, attempts?: number): Promise<T>;

package/legacy/dist/src/analyze/orchestrator/execute-analyze-extract.d.ts

@@ -0,0 +1,21 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+export interface AnalyzeExtractOrchestratorRequest {
+    projectRoot: string;
+    sourceDirectory: string;
+    outDir: string;
+    noCache: boolean;
+    forceAgent: boolean;
+    agent: AgentName;
+    compositionPrompt?: string;
+    resolveUnreachable: 'auto' | 'always' | 'never';
+    onScanProgress?: (count: number) => void;
+    onCompositionProgress?: (phase: string) => void;
+    onSessionCreated?: (sessionId: string) => void | Promise<void>;
+}
+export interface AnalyzeExtractOrchestratorResult {
+    sessionId: string;
+    sourceFileCount: number;
+    componentCount: number;
+    warnings: string[];
+}
+export declare function executeAnalyzeExtractOrchestrator(request: AnalyzeExtractOrchestratorRequest): Promise<AnalyzeExtractOrchestratorResult>;

package/legacy/dist/src/analyze/services/collect-source-files.d.ts

@@ -0,0 +1 @@
+export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;

package/legacy/dist/src/analyze/services/extract-with-cache.d.ts

@@ -0,0 +1,17 @@
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+export interface ExtractionWithCacheOptions {
+    db: ReturnType<typeof openPipelineDb>;
+    sourceFiles: string[];
+    noCache: boolean;
+    resolveUnreachable?: 'auto' | 'always' | 'never';
+    projectRoot?: string;
+    cacheVersion: string;
+    onProgress?: (filesProcessed: number) => void;
+}
+export interface ExtractionWithCacheResult {
+    components: RawComponentDefinition[];
+    warnings: string[];
+    cacheHits: number;
+}
+export declare function runExtractionWithCache(options: ExtractionWithCacheOptions): Promise<ExtractionWithCacheResult>;

package/legacy/dist/src/analyze/services/persist-extract-results.d.ts

@@ -0,0 +1,11 @@
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+export interface PersistExtractResultsOptions {
+    db: ReturnType<typeof openPipelineDb>;
+    sessionId: string;
+    stepId: number;
+    projectRoot: string;
+    sourceFiles: string[];
+    components: RawComponentDefinition[];
+}
+export declare function persistExtractResults(options: PersistExtractResultsOptions): Promise<void>;

package/legacy/dist/src/analyze/services/resolve-composition-mapping.d.ts

@@ -0,0 +1,22 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+export interface CompositionMappingOptions {
+    db: ReturnType<typeof openPipelineDb>;
+    components: RawComponentDefinition[];
+    allFiles: Array<{
+        path: string;
+        content: string;
+    }>;
+    noCache: boolean;
+    forceAgent: boolean;
+    agent: AgentName;
+    promptOverride?: string;
+    cacheVersion: string;
+    onProgress?: (phase: string) => void;
+}
+export interface CompositionMappingResult {
+    components: RawComponentDefinition[];
+    warnings: string[];
+}
+export declare function resolveCompositionMapping(options: CompositionMappingOptions): Promise<CompositionMappingResult>;

package/legacy/dist/src/analyze/services/resolve-source-directory.d.ts

@@ -0,0 +1 @@
+export declare function resolveSourceDirectory(projectRoot: string, dir: string | undefined): Promise<string>;

package/legacy/dist/src/apply/command.d.ts

@@ -1,43 +1,5 @@
 import type { Command } from 'commander';
-import type { CDFComponentEntry, CDFTokenEntry, CDFValidationError, DTCGTokenEntry } from '@contentful/experience-design-system-types';
-import { findSlotCycles } from '../analyze/cycle-detection.js';
-import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
-export declare function readTokensFromPath(flag: string, p: string): Promise<DTCGTokenEntry[]>;
-/** Adapts flat DTCGTokenEntry[] (path alongside the leaf) into the
- * {path, entry} pairs buildCDF/buildFilteredCDF expect. */
-export declare function toCDFTokens(tokens: DTCGTokenEntry[]): Array<{
-    path: string;
-    entry: CDFTokenEntry;
-}>;
-export declare function detectSlotCycles(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): ReturnType<typeof findSlotCycles>;
-export declare function formatSlotCycleReport(cycles: ReturnType<typeof findSlotCycles>): string[];
-export declare function assertNoSlotCycles(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): Promise<void>;
-/**
- * Client-side pre-flight for `$allowedComponents` references that are absent
- * from this document, so a typo'd or renamed reference fails fast instead of
- * waiting on the `previewImport`/`applyImport` round-trip. Only catches
- * document-internal misses — a name that resolves against an *existing*
- * target-environment Component still needs the network round-trip to
- * confirm, so this cannot replace the server-side check.
- *
- * `validateSlotReferences` is the detection step (shared with
- * `WizardApp.tsx` via `formatUnresolvedSlotReferences` below, mirroring how
- * `detectSlotCycles`/`formatSlotCycleReport` split for the cycle check).
- */
-export declare function formatUnresolvedSlotReferences(errors: CDFValidationError[]): string[];
-export declare function assertNoUnresolvedSlotReferences(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): Promise<void>;
-export declare function extractComponents(cdf: Record<string, unknown> | null | undefined): Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>;
-export declare function hasBreakingChangesWithImpact(preview: ServerPreviewResponse): boolean;
+export { readTokensFromPath, toCDFTokens } from './helpers/read-token-files.js';
+export { detectSlotCycles, formatSlotCycleReport, assertNoSlotCycles, formatUnresolvedSlotReferences, assertNoUnresolvedSlotReferences, extractComponents, } from './helpers/slot-validation.js';
+export { hasBreakingChangesWithImpact } from './helpers/has-breaking-changes.js';
 export declare function registerApplyCommand(program: Command): void;

package/legacy/dist/src/apply/controller/run-apply.d.ts

@@ -0,0 +1 @@
+export declare function runApply(file: string): Promise<void>;

package/legacy/dist/src/apply/helpers/build-apply-output.d.ts

@@ -0,0 +1,55 @@
+import type { ApplyOperationResponse, ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare function buildPreviewOutput(preview: ServerPreviewResponse, spaceId: string, environmentId: string): {
+    spaceId: string;
+    environmentId: string;
+    components: {
+        new: number;
+        changed: number;
+        unchanged: number;
+        removed: number;
+        breaking: number;
+        draftOverwrites: number;
+    };
+    tokens: {
+        new: number;
+        changed: number;
+        unchanged: number;
+        removed: number;
+        draftOverwrites: number;
+    };
+    taxonomies: {
+        new: number;
+        changed: number;
+        unchanged: number;
+        removed: number;
+    };
+};
+export declare function buildApplyOutput(operation: ApplyOperationResponse, spaceId: string, environmentId: string, host: string | undefined): {
+    status: import("@contentful/experience-design-system-types").ApplyOperationStatus;
+    operationId: string;
+    spaceId: string;
+    environmentId: string;
+    summary: {
+        total: number;
+        pending: number;
+        succeeded: number;
+        failed: number;
+    };
+    componentTypes: {
+        created: number;
+        updated: number;
+        failed: number;
+    };
+    designTokens: {
+        created: number;
+        updated: number;
+        failed: number;
+    };
+    viewUrl: string;
+    tokensUrl: string;
+    failures: {
+        entityType: "ComponentType" | "DesignToken";
+        entityId: string;
+        error: string;
+    }[];
+};

package/legacy/dist/src/apply/helpers/has-breaking-changes.d.ts

@@ -0,0 +1,2 @@
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare function hasBreakingChangesWithImpact(preview: ServerPreviewResponse): boolean;

package/legacy/dist/src/apply/helpers/poll-apply-operation.d.ts

@@ -0,0 +1,9 @@
+import { ApiError, ImportApiClient } from '../api-client.js';
+import type { ApplyOperationResponse } from '@contentful/experience-design-system-types';
+export interface PollApplyOptions {
+    acknowledgeBreakingChanges: boolean;
+    onProgress?: (status: 'applying' | 'polling', operationId?: string) => void;
+    onStarted?: (operationId: string) => void;
+    onApiError: (error: ApiError) => Promise<void> | void;
+}
+export declare function pollApplyOperation(client: ImportApiClient, cdf: Parameters<ImportApiClient['applyImport']>[0], options: PollApplyOptions): Promise<ApplyOperationResponse | null>;

package/legacy/dist/src/apply/helpers/read-token-files.d.ts

@@ -0,0 +1,7 @@
+import type { CDFTokenEntry, DTCGTokenEntry } from '@contentful/experience-design-system-types';
+export declare function readJsonFile(flag: string, p: string): Promise<unknown>;
+export declare function readTokensFromPath(flag: string, p: string): Promise<DTCGTokenEntry[]>;
+export declare function toCDFTokens(tokens: DTCGTokenEntry[]): Array<{
+    path: string;
+    entry: CDFTokenEntry;
+}>;

package/legacy/dist/src/apply/helpers/slot-validation.d.ts

@@ -0,0 +1,20 @@
+import type { CDFComponentEntry, CDFValidationError } from '@contentful/experience-design-system-types';
+import { findSlotCycles } from '../../analyze/cycle-detection.js';
+export declare function detectSlotCycles(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): ReturnType<typeof findSlotCycles>;
+export declare function formatSlotCycleReport(cycles: ReturnType<typeof findSlotCycles>): string[];
+export declare function assertNoSlotCycles(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): Promise<void>;
+export declare function formatUnresolvedSlotReferences(errors: CDFValidationError[]): string[];
+export declare function assertNoUnresolvedSlotReferences(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>): Promise<void>;
+export declare function extractComponents(cdf: Record<string, unknown> | null | undefined): Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>;

package/legacy/dist/src/apply/services/apply-interactive.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ImportApiClient } from '../api-client.js';
+export interface ApplyInteractiveOptions {
+    client: ImportApiClient;
+    cdf: Parameters<ImportApiClient['applyImport']>[0];
+    spaceId: string;
+    environmentId: string;
+    host?: string;
+    acknowledgeBreakingChanges: boolean;
+    rerender: (element: React.ReactElement) => void;
+    onDone: () => void;
+}
+export declare function applyInteractive(options: ApplyInteractiveOptions): Promise<void>;

package/legacy/dist/src/apply/services/apply-non-interactive.d.ts

@@ -0,0 +1,10 @@
+import { ImportApiClient } from '../api-client.js';
+export interface ApplyNonInteractiveOptions {
+    client: ImportApiClient;
+    cdf: Parameters<ImportApiClient['applyImport']>[0];
+    spaceId: string;
+    environmentId: string;
+    host?: string;
+    acknowledgeBreakingChanges: boolean;
+}
+export declare function applyNonInteractive(options: ApplyNonInteractiveOptions): Promise<void>;

package/legacy/dist/src/apply/services/resolve-apply-inputs.d.ts

@@ -0,0 +1,14 @@
+import type { CDFComponentEntry, DTCGTokenEntry } from '@contentful/experience-design-system-types';
+import { ImportApiClient } from '../api-client.js';
+export interface ApplyInputs {
+    components: Array<{
+        key: string;
+        entry: CDFComponentEntry;
+    }>;
+    tokens: DTCGTokenEntry[];
+    client: ImportApiClient;
+    spaceId: string;
+    environmentId: string;
+    host?: string;
+}
+export declare function resolveApplyInputsOrDie(file: string): Promise<ApplyInputs>;

package/legacy/dist/src/generate/command.d.ts

@@ -1,2 +1,20 @@
 import type { Command } from 'commander';
+export interface GenerateSubcommandOptions {
+    agent?: string;
+    model?: string;
+    bedrock?: boolean;
+    session?: string;
+    rawTokens?: string;
+    tokens?: string;
+    tokenMap?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    cache?: boolean;
+    generatePromptPath?: string;
+    prompt?: string[];
+    existingEntitiesPath?: string;
+    cacheStatus?: boolean;
+    restoreCache?: boolean;
+    cachedComponents?: string;
+}
 export declare function registerInternalGenerateCommand(program: Command): void;

package/legacy/dist/src/generate/controller/run-generate-components.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateSubcommandOptions } from '../command.js';
+export declare function runGenerateComponents(opts: GenerateSubcommandOptions, verbose: boolean): Promise<void>;

package/legacy/dist/src/generate/controller/run-generate-tokens.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateSubcommandOptions } from '../command.js';
+export declare function runGenerateTokens(opts: GenerateSubcommandOptions, _verbose: boolean): Promise<void>;

package/legacy/dist/src/generate/helpers/assert-file-exists.d.ts

@@ -0,0 +1 @@
+export declare function assertFileExists(flag: string, p: string): Promise<void>;

package/legacy/dist/src/generate/helpers/normalize-component-for-cache.d.ts

@@ -0,0 +1,6 @@
+import type { RawComponentDefinition } from '../../types.js';
+export declare function normalizeComponentForCache(component: RawComponentDefinition & {
+    component_id?: string;
+}): RawComponentDefinition & {
+    component_id?: string;
+};

package/legacy/dist/src/generate/helpers/parse-precomputed-cached-names.d.ts

@@ -0,0 +1 @@
+export declare function parsePrecomputedCachedNames(value: string | undefined): Set<string>;

package/legacy/dist/src/generate/helpers/print-fallback-instructions.d.ts

@@ -0,0 +1,6 @@
+import type { Skill } from '@contentful/experience-design-system-generation';
+export declare function printFallbackInstructions(options: {
+    agent: string;
+    skill: Skill;
+    sessionId: string;
+}): void;

package/legacy/dist/src/generate/helpers/read-file-inline.d.ts

@@ -0,0 +1 @@
+export declare function readFileInline(path: string | undefined): Promise<string | undefined>;

package/legacy/dist/src/generate/services/invoke-all-component-agents.d.ts

@@ -0,0 +1,6 @@
+import type { RawComponentDefinition } from '../../types.js';
+import type { ComponentAgentOptions, ComponentRunResult } from './invoke-component-agent.js';
+export type { ComponentAgentOptions, ComponentRunResult };
+export declare function invokeAllComponentAgents(options: ComponentAgentOptions, components: Array<RawComponentDefinition & {
+    component_id: string;
+}>): Promise<ComponentRunResult[]>;

package/legacy/dist/src/generate/services/invoke-component-agent.d.ts

@@ -0,0 +1,36 @@
+import type { AgentInvoker, AgentName } from '@contentful/experience-design-system-generation';
+import type { RawComponentDefinition } from '../../types.js';
+import type { openPipelineDb } from '../../session/db.js';
+import type { ExistingContentfulEntities } from '../../helpers/fetch-existing-contentful-entities.js';
+export interface ComponentRunResult {
+    componentName: string;
+    classified: number;
+    excluded: number;
+    slots: number;
+    warnings: string[];
+    failed: boolean;
+    error?: string;
+    cached?: boolean;
+    renamedSlotsCount: number;
+}
+export interface ComponentAgentOptions {
+    agent: AgentName;
+    model: string | undefined;
+    invoker: AgentInvoker;
+    db: ReturnType<typeof openPipelineDb>;
+    sessionId: string;
+    tokensInline: string | undefined;
+    tokenMapInline: string | undefined;
+    verbose: boolean;
+    noCache: boolean;
+    skillPathOverride: string | undefined;
+    skillContentOverride: string | undefined;
+    promptHash: string;
+    existingContentfulEntities: ExistingContentfulEntities | undefined;
+    existingTokensInline: string | undefined;
+    precomputedCachedNames: ReadonlySet<string>;
+    allowedComponentNames: ReadonlySet<string>;
+}
+export declare function invokeComponentAgent(options: ComponentAgentOptions, component: RawComponentDefinition & {
+    component_id: string;
+}, index: number, total: number): Promise<ComponentRunResult>;

package/legacy/dist/src/generate/services/load-accepted-names.d.ts

@@ -0,0 +1 @@
+export declare function loadAcceptedNames(sessionId: string): Promise<Set<string> | null>;

package/legacy/dist/src/generate/services/resolve-component-cache.d.ts

@@ -0,0 +1,13 @@
+import { lookupCache } from '../../session/db.js';
+import type { openPipelineDb } from '../../session/db.js';
+import type { RawComponentDefinition } from '../../types.js';
+export type ComponentCacheResolution = {
+    entry: NonNullable<ReturnType<typeof lookupCache>>;
+    humanEdited: boolean;
+};
+export declare function lookupComponentCache(db: ReturnType<typeof openPipelineDb>, component: RawComponentDefinition & {
+    component_id: string;
+}, promptHash: string): ReturnType<typeof lookupCache>;
+export declare function resolveComponentCache(db: ReturnType<typeof openPipelineDb>, component: RawComponentDefinition & {
+    component_id: string;
+}, promptHash: string, allowedComponentNames: ReadonlySet<string>): ComponentCacheResolution | null;

package/legacy/dist/src/generate/services/resolve-generate-agent.d.ts

@@ -0,0 +1,9 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+import { readExperiencesCredentials } from '../../credentials-store.js';
+import type { GenerateSubcommandOptions } from '../command.js';
+export interface ResolvedGenerateAgent {
+    agent: AgentName;
+    model: string | undefined;
+    savedCreds: Awaited<ReturnType<typeof readExperiencesCredentials>>;
+}
+export declare function resolveGenerateAgent(opts: Pick<GenerateSubcommandOptions, 'agent' | 'model' | 'bedrock'>): Promise<ResolvedGenerateAgent>;

package/legacy/dist/src/generate/services/show-generate-view.d.ts

@@ -0,0 +1,2 @@
+import type { GenerateViewResult } from '../tui/GenerateView.js';
+export declare function showGenerateView(result: GenerateViewResult): Promise<void>;

package/legacy/dist/src/generate/services/verify-agent-binary.d.ts

@@ -0,0 +1,2 @@
+import type { AgentName, Skill } from '@contentful/experience-design-system-generation';
+export declare function verifyAgentBinary(agent: AgentName, skill: Skill, sessionId: string): Promise<boolean>;