@contentful/experience-design-system-cli 2.7.4-dev-build-595febb.0 → 2.7.5-dev-build-752dc9c.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.7.4-dev-build-595febb.0",
+  "version": "2.7.5-dev-build-752dc9c.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/analyze/command.js

@@ -11,6 +11,7 @@ import { preClassifyComponent } from './pre-classify.js';
 import { isNonAuthorableComponent } from './extract/non-authorable-filter.js';
 import { computeExtractionScore, deriveNeedsReview } from './extract/scoring.js';
 import { describeReviewReasons, inspectComponentSource } from './extract/source-inspection.js';
+import { validateExtractedComponents } from './extract/validate.js';
 const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.ts', '.tsx', '.vue']);
 const IGNORED_DIRECTORY_NAMES = new Set([
     '.git',
@@ -168,7 +169,8 @@ export function registerAnalyzeCommand(program) {
                 needsReview: deriveNeedsReview(confidence) || inspection.wrapperConfidence >= 4 || inspection.keepDespiteZeroSurface,
             });
         }
-        storeRawComponents(db, sessionId, filteredComponents);
+        const validatedComponents = validateExtractedComponents(filteredComponents);
+        storeRawComponents(db, sessionId, validatedComponents);
         storeScannedFiles(db, sessionId, sourceFiles.map((f) => relative(projectRoot, f)));
         updateStep(db, stepId, 'complete', { sessionId });
         db.close();

package/dist/src/analyze/extract/validate.d.ts

@@ -0,0 +1,4 @@
+import type { RawComponentDefinition } from '../../types.js';
+export type { ExtractionValidationIssue } from '../../types.js';
+export declare function validateExtractedComponents(components: RawComponentDefinition[]): RawComponentDefinition[];
+export declare function shouldExcludeDueToValidation(component: RawComponentDefinition): boolean;

package/dist/src/analyze/extract/validate.js

@@ -0,0 +1,67 @@
+export function validateExtractedComponents(components) {
+    const nameCounts = new Map();
+    for (const component of components) {
+        const key = component.name.trim();
+        nameCounts.set(key, (nameCounts.get(key) ?? 0) + 1);
+    }
+    return components.map((component) => {
+        const issues = [];
+        if (!component.name.trim()) {
+            issues.push({
+                severity: 'error',
+                code: 'EMPTY_COMPONENT_NAME',
+                message: 'Component name must not be empty',
+            });
+        }
+        for (let i = 0; i < component.props.length; i++) {
+            if (!component.props[i].name.trim()) {
+                issues.push({
+                    severity: 'error',
+                    code: 'EMPTY_PROP_NAME',
+                    message: `Prop at index ${i} has an empty name`,
+                    field: `props[${i}].name`,
+                });
+            }
+        }
+        for (let i = 0; i < component.slots.length; i++) {
+            if (!component.slots[i].name.trim()) {
+                issues.push({
+                    severity: 'error',
+                    code: 'EMPTY_SLOT_NAME',
+                    message: `Slot at index ${i} has an empty name`,
+                    field: `slots[${i}].name`,
+                });
+            }
+        }
+        const propNames = new Set(component.props.map((p) => p.name));
+        for (let i = 0; i < component.slots.length; i++) {
+            if (component.slots[i].name && propNames.has(component.slots[i].name)) {
+                issues.push({
+                    severity: 'error',
+                    code: 'PROP_SLOT_NAME_COLLISION',
+                    message: `"${component.slots[i].name}" is used as both a prop name and a slot name`,
+                    field: `slots[${i}].name`,
+                });
+            }
+        }
+        const nameKey = component.name.trim();
+        if (nameKey && (nameCounts.get(nameKey) ?? 0) > 1) {
+            issues.push({
+                severity: 'warning',
+                code: 'DUPLICATE_COMPONENT_NAME',
+                message: `Component name "${component.name}" appears more than once in the extracted set`,
+            });
+        }
+        if (component.props.length === 0 && component.slots.length === 0) {
+            issues.push({
+                severity: 'warning',
+                code: 'EMPTY_COMPONENT',
+                message: 'Component has no props or slots and will be filtered out during generation',
+            });
+        }
+        return { ...component, validationIssues: issues };
+    });
+}
+export function shouldExcludeDueToValidation(component) {
+    return (component.validationIssues ?? []).some((i) => i.severity === 'error');
+}

package/dist/src/analyze/select/command.d.ts

@@ -1,2 +1,12 @@
 import type { Command } from 'commander';
+import type { ReviewSessionSnapshot } from './types.js';
+/**
+ * Load components from the pipeline DB and re-run extraction validation.
+ *
+ * `validationIssues` is intentionally not persisted (the validator is pure
+ * and cheap to re-run), so any cold-start of `analyze select` from a prior
+ * `analyze extract` session needs to recompute it before building the
+ * review snapshot — otherwise the TUI sees no validation errors at all.
+ */
+export declare function loadAndValidateForReview(sessionId: string, projectRoot: string | undefined): Promise<ReviewSessionSnapshot>;
 export declare function registerAnalyzeEditCommand(program: Command): void;

package/dist/src/analyze/select/command.js

@@ -6,6 +6,7 @@ import { getRefineArtifactsRoot, ensureRefineSession, getRefineSessionPaths, sav
 import { loadReviewInput } from './parser.js';
 import { App } from './tui/App.js';
 import { openPipelineDb, loadRawComponents, storeRawComponents, createStep, updateStep } from '../../session/db.js';
+import { validateExtractedComponents, shouldExcludeDueToValidation } from '../extract/validate.js';
 const SAFE_PATH_RE = /^[a-zA-Z0-9_.$[\]=]+$/;
 const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function applyDotPath(obj, path, value) {
@@ -84,6 +85,9 @@ async function runNonInteractive(snapshot, opts, paths, sessionId) {
                 if (rejectPatterns.some((p) => nameLower.includes(p))) {
                     return { ...c, status: 'rejected' };
                 }
+                if (selectAll && opts.excludeInvalid && shouldExcludeDueToValidation(c.originalProposal)) {
+                    return { ...c, status: 'rejected' };
+                }
                 if (selectAll || selectPatterns.some((p) => nameLower.includes(p))) {
                     return { ...c, status: 'accepted' };
                 }
@@ -134,6 +138,26 @@ async function runNonInteractive(snapshot, opts, paths, sessionId) {
     }
     process.stderr.write(`Accepted: ${accepted.length}  Rejected: ${rejected.length}\n`);
 }
+/**
+ * Load components from the pipeline DB and re-run extraction validation.
+ *
+ * `validationIssues` is intentionally not persisted (the validator is pure
+ * and cheap to re-run), so any cold-start of `analyze select` from a prior
+ * `analyze extract` session needs to recompute it before building the
+ * review snapshot — otherwise the TUI sees no validation errors at all.
+ */
+export async function loadAndValidateForReview(sessionId, projectRoot) {
+    const db = openPipelineDb();
+    let rawComponents;
+    try {
+        rawComponents = loadRawComponents(db, sessionId);
+    }
+    finally {
+        db.close();
+    }
+    const validatedComponents = validateExtractedComponents(rawComponents);
+    return loadReviewInput(validatedComponents, { reviewRoot: projectRoot });
+}
 function resolveSessionId(sessionFlag) {
     if (sessionFlag)
         return sessionFlag;
@@ -170,17 +194,18 @@ export function registerAnalyzeEditCommand(program) {
         .option('--accept-all', 'Alias for --select-all', false)
         .option('--reject <pattern>', 'Alias for --deselect <pattern> (repeatable)', collect, [])
         .option('--patch <path>', 'Path to a JSON patch file for structured component overrides')
-        .action(async ({ session: sessionFlag, projectRoot, acceptAll, selectAll, reject, deselect, select, patch, }) => {
+        .option('--exclude-invalid', 'Auto-reject components with validation errors when bulk-selecting (no-op without --select-all)')
+        .action(async ({ session: sessionFlag, projectRoot, acceptAll, selectAll, reject, deselect, select, patch, excludeInvalid, }) => {
         const sessionId = resolveSessionId(sessionFlag);
         const db = openPipelineDb();
-        let rawComponents;
+        let rawComponentCount = 0;
         try {
-            rawComponents = loadRawComponents(db, sessionId);
+            rawComponentCount = loadRawComponents(db, sessionId).length;
         }
         finally {
             db.close();
         }
-        if (rawComponents.length === 0) {
+        if (rawComponentCount === 0) {
             process.stderr.write(`Error: session '${sessionId}' has no raw components. Run analyze extract first.\n`);
             process.exit(1);
             return;
@@ -195,9 +220,7 @@ export function registerAnalyzeEditCommand(program) {
         let paths;
         let snapshot;
         try {
-            snapshot = await loadReviewInput(rawComponents, {
-                reviewRoot: projectRoot,
-            });
+            snapshot = await loadAndValidateForReview(sessionId, projectRoot);
             paths = await getRefineSessionPaths(sessionId, artifactsRoot);
             if (!nonInteractive) {
                 snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
@@ -216,7 +239,17 @@ export function registerAnalyzeEditCommand(program) {
             const stepDb = openPipelineDb();
             const stepId = createStep(stepDb, sessionId, 'analyze select', { sessionId });
             try {
-                await runNonInteractive(snapshot, { session: sessionFlag, projectRoot, acceptAll, selectAll, reject, deselect, select, patch }, paths, sessionId);
+                await runNonInteractive(snapshot, {
+                    session: sessionFlag,
+                    projectRoot,
+                    acceptAll,
+                    selectAll,
+                    reject,
+                    deselect,
+                    select,
+                    patch,
+                    excludeInvalid,
+                }, paths, sessionId);
                 updateStep(stepDb, stepId, 'complete', { sessionId });
             }
             catch (err) {

package/dist/src/analyze/select/tui/App.js

@@ -4,7 +4,8 @@ import { Box, Text, useStdout } from 'ink';
 import { readFile } from 'node:fs/promises';
 import { createReviewSessionDetail } from '../types.js';
 import { TopBar } from './components/TopBar.js';
-import { Sidebar } from './components/Sidebar.js';
+import { Sidebar, sortComponentsForSidebar } from './components/Sidebar.js';
+import { countValidationIssues } from '../types.js';
 import { ComponentDetail } from './components/ComponentDetail.js';
 import { StatusBar } from './components/StatusBar.js';
 import { HelpOverlay } from './components/HelpOverlay.js';
@@ -316,22 +317,27 @@ export function App({ sessionId, artifactsRoot, reviewRoot }) {
         onToggleHelp: () => setShowHelp((prev) => !prev),
     });
     // Must be before early returns — Rules of Hooks
-    const sessionSummary = useMemo(() => (session?.components ?? [])
-        .map((c) => ({
-        id: c.id,
-        name: c.name,
-        status: c.status,
-        previewAnnotation: previewAnnotations[c.name],
-        extractionConfidence: c.originalProposal.extractionConfidence ?? null,
-        needsReview: c.originalProposal.needsReview ?? false,
-    }))
+    const sessionSummary = useMemo(() => sortComponentsForSidebar((session?.components ?? [])
+        .map((c) => {
+        const counts = countValidationIssues(c.originalProposal);
+        return {
+            id: c.id,
+            name: c.name,
+            status: c.status,
+            previewAnnotation: previewAnnotations[c.name],
+            extractionConfidence: c.originalProposal.extractionConfidence ?? null,
+            needsReview: c.originalProposal.needsReview ?? false,
+            validationErrorCount: counts.errors,
+            validationWarningCount: counts.warnings,
+        };
+    })
         .sort((a, b) => {
         const aF = a.needsReview && a.status === 'needs-review' ? 0 : 1;
         const bF = b.needsReview && b.status === 'needs-review' ? 0 : 1;
         if (aF !== bF)
             return aF - bF;
         return (a.extractionConfidence ?? 6) - (b.extractionConfidence ?? 6);
-    }), [session?.components, previewAnnotations]);
+    })), [session?.components, previewAnnotations]);
     if (loading) {
         return _jsx(Text, { children: "Loading session..." });
     }

package/dist/src/analyze/select/tui/components/Sidebar.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ReviewComponentSummary } from '../../types.js';
+import type { ReviewComponentSummary, ReviewComponentStatus } from '../../types.js';
 type SidebarProps = {
     components: ReviewComponentSummary[];
     selectedId: string | null;
@@ -11,5 +11,8 @@ type SidebarProps = {
     collapsed?: boolean;
     width?: number;
 };
+export declare function statusIcon(status: ReviewComponentStatus, validationErrorCount: number, validationWarningCount: number): string;
+export declare function statusColor(status: ReviewComponentStatus, validationErrorCount: number, validationWarningCount: number): string;
+export declare function sortComponentsForSidebar(components: ReviewComponentSummary[]): ReviewComponentSummary[];
 export declare function Sidebar({ components, selectedId, focused, scrollOffset, visibleCount, collapsed, width: widthProp, }: SidebarProps): React.ReactElement;
 export {};

package/dist/src/analyze/select/tui/components/Sidebar.js

@@ -1,6 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-function statusIcon(status) {
+export function statusIcon(status, validationErrorCount, validationWarningCount) {
+    if (validationErrorCount > 0 || validationWarningCount > 0)
+        return '⚠';
     switch (status) {
         case 'accepted':
             return '✓';
@@ -12,7 +14,11 @@ function statusIcon(status) {
             return '·';
     }
 }
-function statusColor(status) {
+export function statusColor(status, validationErrorCount, validationWarningCount) {
+    if (validationErrorCount > 0)
+        return 'red';
+    if (validationWarningCount > 0)
+        return 'yellow';
     switch (status) {
         case 'accepted':
             return 'green';
@@ -29,15 +35,22 @@ function truncateName(name, maxLen) {
         return name;
     return name.slice(0, maxLen) + '…';
 }
+export function sortComponentsForSidebar(components) {
+    const withErrors = components.filter((c) => c.validationErrorCount > 0);
+    const withWarnings = components.filter((c) => c.validationErrorCount === 0 && c.validationWarningCount > 0);
+    const clean = components.filter((c) => c.validationErrorCount === 0 && c.validationWarningCount === 0);
+    return [...withErrors, ...withWarnings, ...clean];
+}
 export function Sidebar({ components, selectedId, focused, scrollOffset, visibleCount, collapsed = false, width: widthProp, }) {
-    const visible = components.slice(scrollOffset, scrollOffset + visibleCount);
+    const sorted = sortComponentsForSidebar(components);
+    const visible = sorted.slice(scrollOffset, scrollOffset + visibleCount);
     const showScrollUp = scrollOffset > 0;
-    const showScrollDown = scrollOffset + visibleCount < components.length;
+    const showScrollDown = scrollOffset + visibleCount < sorted.length;
     const width = collapsed ? 3 : (widthProp ?? 18);
     return (_jsxs(Box, { flexDirection: "column", width: width, borderStyle: "single", borderColor: focused ? 'white' : undefined, children: [showScrollUp && !collapsed && _jsx(Text, { dimColor: true, children: "\u25B2" }), visible.map((component) => {
                 const isSelected = component.id === selectedId;
-                const icon = statusIcon(component.status);
-                const color = statusColor(component.status);
+                const icon = statusIcon(component.status, component.validationErrorCount, component.validationWarningCount);
+                const color = statusColor(component.status, component.validationErrorCount, component.validationWarningCount);
                 const maxNameLen = Math.max(1, width - 4);
                 const name = truncateName(component.name, maxNameLen);
                 if (collapsed) {

package/dist/src/analyze/select/types.d.ts

@@ -24,6 +24,8 @@ export type ReviewComponentSummary = {
     previewAnnotation?: PreviewAnnotation;
     extractionConfidence: number | null;
     needsReview: boolean;
+    validationErrorCount: number;
+    validationWarningCount: number;
 };
 export type ReviewSessionSnapshot = {
     components: ReviewComponentRecord[];
@@ -44,5 +46,9 @@ export type ReviewSessionPaths = {
     eventsPath: string;
     statePath: string;
 };
+export declare function countValidationIssues(component: RawComponentDefinition): {
+    errors: number;
+    warnings: number;
+};
 export declare function createReviewSessionSummary(session: ReviewSessionSnapshot): ReviewSessionSummary;
 export declare function createReviewSessionDetail(session: ReviewSessionSnapshot): ReviewSessionDetail;

package/dist/src/analyze/select/types.js

@@ -1,12 +1,29 @@
+export function countValidationIssues(component) {
+    const issues = component.validationIssues ?? [];
+    let errors = 0;
+    let warnings = 0;
+    for (const issue of issues) {
+        if (issue.severity === 'error')
+            errors++;
+        else if (issue.severity === 'warning')
+            warnings++;
+    }
+    return { errors, warnings };
+}
 export function createReviewSessionSummary(session) {
     return {
-        components: session.components.map((component) => ({
-            id: component.id,
-            name: component.name,
-            status: component.status,
-            extractionConfidence: component.originalProposal.extractionConfidence ?? null,
-            needsReview: component.originalProposal.needsReview ?? false,
-        })),
+        components: session.components.map((component) => {
+            const counts = countValidationIssues(component.originalProposal);
+            return {
+                id: component.id,
+                name: component.name,
+                status: component.status,
+                extractionConfidence: component.originalProposal.extractionConfidence ?? null,
+                needsReview: component.originalProposal.needsReview ?? false,
+                validationErrorCount: counts.errors,
+                validationWarningCount: counts.warnings,
+            };
+        }),
     };
 }
 export function createReviewSessionDetail(session) {

package/dist/src/analyze/select-agent/command.js

@@ -6,6 +6,7 @@ import { parseSelectToolCallLines, runAgent } from '../../generate/agent-runner.
 import { OutputFormatter, c } from '../../output/format.js';
 import { buildRepoContextIndex, buildSelectionContext } from './context-builder.js';
 import { isAbsolute, resolve } from 'node:path';
+import { validateExtractedComponents, shouldExcludeDueToValidation } from '../extract/validate.js';
 const VALID_AGENTS = new Set(['claude', 'codex', 'opencode', 'cursor']);
 const DEFAULT_TIMEOUT_MS = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 3 * 60 * 1000);
 const DEFAULT_CONCURRENCY = 5;
@@ -177,6 +178,7 @@ export function registerAnalyzeSelectAgentCommand(program) {
         .option('--model <name>', 'Model to use (defaults to a small/fast model per agent)')
         .option('--verbose', 'Show full agent output including reasoning text')
         .option('--dry-run', 'Print the prompt for the first component without invoking the agent')
+        .option('--exclude-invalid', 'Automatically reject components with validation errors (empty names, collisions)')
         .action(async (opts) => {
         if (!VALID_AGENTS.has(opts.agent)) {
             process.stderr.write(`Error: unknown agent '${opts.agent}'. Accepted values: claude, codex, opencode, cursor\n`);
@@ -201,6 +203,23 @@ export function registerAnalyzeSelectAgentCommand(program) {
             process.exit(1);
             return;
         }
+        // Re-run validation (not persisted to DB, so always recompute).
+        const validatedComponents = validateExtractedComponents(rawComponents);
+        // If --exclude-invalid, split out errored components before sending to LLM.
+        const invalidComponents = opts.excludeInvalid ? validatedComponents.filter(shouldExcludeDueToValidation) : [];
+        const componentsForAgent = opts.excludeInvalid
+            ? validatedComponents.filter((comp) => !shouldExcludeDueToValidation(comp))
+            : validatedComponents;
+        if (invalidComponents.length > 0) {
+            process.stderr.write(c.yellow(`Auto-rejecting ${invalidComponents.length} component(s) with validation errors (--exclude-invalid):\n`));
+            for (const comp of invalidComponents) {
+                const codes = (comp.validationIssues ?? [])
+                    .filter((i) => i.severity === 'error')
+                    .map((i) => i.code)
+                    .join(', ');
+                process.stderr.write(`  ✗  ${comp.name}  ${codes}\n`);
+            }
+        }
         if (selectionRoot && scannedFiles.length > 0) {
             scannedFiles = scannedFiles.map((f) => (isAbsolute(f) ? f : resolve(selectionRoot, f)));
         }
@@ -208,17 +227,22 @@ export function registerAnalyzeSelectAgentCommand(program) {
             process.stderr.write('warn: session has no scanned-files index (likely extracted on an older CLI version). ' +
                 'Re-run `analyze extract` to enable data-fetch wrapper detection during selection.\n');
         }
-        let selectionCandidates = rawComponents.map((component) => ({ component }));
+        let selectionCandidates = componentsForAgent.map((component) => ({ component }));
         if (selectionRoot && scannedFiles.length > 0) {
             const repoIndex = await buildRepoContextIndex(selectionRoot, scannedFiles).catch(() => null);
             if (repoIndex) {
-                selectionCandidates = rawComponents.map((component) => ({
+                selectionCandidates = componentsForAgent.map((component) => ({
                     component,
                     selectionContext: buildSelectionContext(repoIndex, component),
                 }));
             }
         }
         if (opts.dryRun) {
+            if (selectionCandidates.length === 0) {
+                process.stderr.write('No valid components to preview — all components were excluded due to validation errors.\n');
+                process.exit(0);
+                return;
+            }
             const first = selectionCandidates[0];
             const prompt = await buildPrompt({
                 skill: 'select',
@@ -231,14 +255,18 @@ export function registerAnalyzeSelectAgentCommand(program) {
             return;
         }
         const selectResults = await selectAllComponents(agent, opts.model, selectionCandidates, opts.verbose ?? false);
+        // Build decision map from results. Seed auto-rejections from validation exclusions first.
         const decisions = new Map();
+        for (const comp of invalidComponents) {
+            decisions.set(componentKey(comp), 'rejected');
+        }
         for (const r of selectResults) {
             decisions.set(r.componentKey, r.decision);
         }
         const artifactsRoot = getRefineArtifactsRoot();
         let snapshot;
         try {
-            snapshot = await loadReviewInput(rawComponents, {
+            snapshot = await loadReviewInput(validatedComponents, {
                 reviewRoot: selectionRoot ?? undefined,
             });
             snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);

package/dist/src/import/command.js

@@ -24,6 +24,7 @@ export function registerImportCommand(program) {
         .option('--no-cache', 'Re-run all steps even if output already exists')
         .option('--yes', 'Skip interactive confirmation in apply push')
         .option('--verbose', 'Show full agent output and all entity progress')
+        .option('--exclude-invalid', 'Automatically reject components with validation errors (empty names, collisions)')
         .option('--viewports <path>', 'JSON file with viewport array (passed to apply push)')
         .option('--host <url>', 'Override API base URL (passed to apply push)')
         .option('--dry-run', 'Print generate components prompt without invoking the agent')
@@ -84,6 +85,7 @@ export function registerImportCommand(program) {
             noCache: opts.cache === false,
             yes: opts.yes ?? false,
             verbose: opts.verbose ?? false,
+            excludeInvalid: opts.excludeInvalid ?? false,
             viewports: opts.viewports,
             host: opts.host,
             dryRun: opts.dryRun,

package/dist/src/import/orchestrator.d.ts

@@ -17,6 +17,7 @@ export interface PipelineOptions {
     viewports?: string;
     host?: string;
     dryRun?: boolean;
+    excludeInvalid?: boolean;
     selectAll?: boolean;
     select?: string[];
     deselect?: string[];

package/dist/src/import/orchestrator.js

@@ -128,6 +128,8 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
             editArgs = ['analyze', 'select-agent', '--session', extractSessionId, '--agent', opts.agent];
             if (opts.model)
                 editArgs.push('--model', opts.model);
+            if (opts.excludeInvalid)
+                editArgs.push('--exclude-invalid');
         }
         else {
             editArgs = ['analyze', 'select', '--session', extractSessionId];

package/dist/src/import/tui/steps/GenerateReviewStep.js

@@ -187,6 +187,8 @@ export function GenerateReviewStep({ extractSessionId, onFinalize, onQuit, }) {
         status: c.status,
         extractionConfidence: null,
         needsReview: false,
+        validationErrorCount: 0,
+        validationWarningCount: 0,
     }));
     const longestName = components.reduce((m, c) => Math.max(m, c.key.length), 0);
     const sidebarWidth = Math.min(Math.max(longestName + 4, 14), 22);

package/dist/src/types.d.ts

@@ -1,4 +1,11 @@
 import type { DesignTokenType } from '@contentful/experience-design-system-types';
+export type ExtractionValidationIssueCode = 'EMPTY_COMPONENT_NAME' | 'EMPTY_PROP_NAME' | 'EMPTY_SLOT_NAME' | 'PROP_SLOT_NAME_COLLISION' | 'DUPLICATE_COMPONENT_NAME' | 'EMPTY_COMPONENT';
+export type ExtractionValidationIssue = {
+    severity: 'error' | 'warning';
+    code: ExtractionValidationIssueCode;
+    message: string;
+    field?: string;
+};
 export interface RawTokenDefinition {
     name: string;
     value: string;
@@ -37,6 +44,7 @@ export interface RawComponentDefinition {
     extractionConfidence?: number | null;
     reviewReasons?: string[];
     needsReview?: boolean;
+    validationIssues?: ExtractionValidationIssue[];
 }
 export interface ComponentExtractionResult {
     components: RawComponentDefinition[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.7.4-dev-build-595febb.0",
+  "version": "2.7.5-dev-build-752dc9c.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
     "react-dom": "^18.3.1",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.7.4-dev-build-595febb.0"
+    "@contentful/experience-design-system-types": "2.7.5-dev-build-752dc9c.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",