@contentful/experience-design-system-cli 2.12.4-dev-build-ff57340.0 → 2.13.1-dev-build-fa478b3.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.12.4-dev-build-ff57340.0",
+  "version": "2.13.1-dev-build-fa478b3.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -37,16 +37,13 @@
     "lint:fix": "nx lint:fix experience-design-system-cli"
   },
   "dependencies": {
+    "@contentful/experience-design-system-extraction": "workspace:*",
     "@contentful/experience-design-system-types": "workspace:*",
-    "@vue/compiler-sfc": "^3.5.31",
     "commander": "^13.1.0",
     "ink": "^4.4.1",
     "react": "^18.3.1",
     "react-devtools-core": "^4.19.1",
-    "react-dom": "^18.3.1",
-    "svelte": "^5.56.4",
-    "ts-morph": "^27.0.2",
-    "typescript": "^5.9.3"
+    "react-dom": "^18.3.1"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",

package/dist/src/analyze/command.js

@@ -2,17 +2,11 @@ import { createElement } from 'react';
 import { render } from 'ink';
 import { mkdir, readdir, stat } from 'node:fs/promises';
 import { isAbsolute, join, relative, resolve } from 'node:path';
-import { extractComponents } from './extract/pipeline.js';
+import { extractComponents, preClassifyComponent, isNonAuthorableComponent, computeExtractionScore, deriveNeedsReview, describeReviewReasons, inspectComponentSource, validateExtractedComponents, } from '@contentful/experience-design-system-extraction';
 import { AnalyzeView } from './tui/AnalyzeView.js';
 import { registerAnalyzeEditCommand } from './select/command.js';
 import { registerAnalyzeSelectAgentCommand } from './select-agent/command.js';
-import { openPipelineDb, getOrCreateSession, createStep, updateStep, storeRawComponents, storeScannedFiles, storeSlotCycles, } from '../session/db.js';
-import { findSlotCycles, suggestCycleBreakEdge } from './cycle-detection.js';
-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';
+import { openPipelineDb, getOrCreateSession, createStep, updateStep, storeRawComponents, storeScannedFiles, } from '../session/db.js';
 import { buildAnalyzeViewRows, partitionGlobalWarnings } from './build-analyze-view-rows.js';
 const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.svelte', '.ts', '.tsx', '.vue']);
 const IGNORED_DIRECTORY_NAMES = new Set([
@@ -192,20 +186,6 @@ export function registerAnalyzeCommand(program) {
         }
         const validatedComponents = validateExtractedComponents(filteredComponents);
         storeRawComponents(db, sessionId, validatedComponents);
-        // INTEG-4401: post-extract slot-dependency cycle detection. The apply
-        // worker rejects cyclic slot graphs at push time, so we surface the
-        // same violation locally as a soft warning here (TUI reads
-        // slot_cycles) and as a hard block at manifest finalization.
-        const cycleInput = validatedComponents.map((c) => ({
-            name: c.name,
-            slots: c.slots.map((s) => ({ name: s.name, allowedComponents: s.allowedComponents })),
-        }));
-        const cycles = findSlotCycles(cycleInput);
-        const withBreaks = cycles.map((cycle) => ({
-            ...cycle,
-            suggestedBreak: suggestCycleBreakEdge(cycle, cycles),
-        }));
-        storeSlotCycles(db, sessionId, withBreaks);
         storeScannedFiles(db, sessionId, sourceFiles.map((f) => relative(projectRoot, f)));
         updateStep(db, stepId, 'complete', { sessionId });
         db.close();

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

@@ -6,7 +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, formatExclusionWarning, } from '../extract/validate.js';
+import { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, } from '@contentful/experience-design-system-extraction';
 const SAFE_PATH_RE = /^[a-zA-Z0-9_.$[\]=]+$/;
 const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function applyDotPath(obj, path, value) {

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

@@ -1,5 +1,4 @@
 import React from 'react';
-import { findSlotCycles, type ComponentSlotInfo } from '../../../cycle-detection.js';
 /** Per-prop / per-component metadata captured by the extractor + generate phase.
  * Optional; when omitted, the FieldEditor renders without rationale/source
  * affordances (backwards-compatible with mounts that pre-date Feature 1). */
@@ -64,28 +63,6 @@ type FieldEditorProps = {
      * description editors, string default editors, and value-list text entry.
      */
     onTextEntryActiveChange?: (active: boolean) => void;
-    /**
-     * INTEG-4401: project-wide slot graph. When supplied, the
-     * $allowedComponents add-mode shows a cycle-filtered picker. Optional.
-     */
-    projectSlotGraph?: ComponentSlotInfo[];
-    /**
-     * INTEG-4401: name of the component being edited. Self-loop guard +
-     * self-entry replacement in the cycle simulation.
-     */
-    currentComponentName?: string;
 };
-/** Simulate adding a candidate to a slot; replaces self-entry with live edits. */
-export declare function simulateGraphWithCandidate(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, candidate: string): ComponentSlotInfo[];
-/** True iff `next` contains a cycle whose canonical edge set is absent in `before`. */
-export declare function introducesNewCycle(before: ReturnType<typeof findSlotCycles>, next: ReturnType<typeof findSlotCycles>): boolean;
-/** Candidate names that can be added to a slot without creating a new cycle. */
-export declare function computeAllowedComponentCandidates(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string): string[];
-export declare function FieldEditor({ value, width, height, active, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, onToggleComponentRationale, onToggleSourceExternal, onTextEntryActiveChange, projectSlotGraph, currentComponentName, }: FieldEditorProps): React.ReactElement;
+export declare function FieldEditor({ value, width, height, active, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, onToggleComponentRationale, onToggleSourceExternal, onTextEntryActiveChange, }: FieldEditorProps): React.ReactElement;
 export {};

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

@@ -4,7 +4,6 @@ import { Box, Text } from 'ink';
 import { CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, DESIGN_TOKEN_TYPES, } from '@contentful/experience-design-system-types';
 import { useImmediateInput } from '../hooks/useImmediateInput.js';
 import { computeNextScrollOffset } from '../hooks/scroll-offset.js';
-import { findSlotCycles } from '../../../cycle-detection.js';
 // Section indices for top-level navigation
 // 0 = component $description row
 // 1 = $properties header (then props[0..n-1])
@@ -202,34 +201,18 @@ function PropRow({ prop, selected, activeField, textCursor, valueCursor, cursorV
                         return (_jsx(Box, { gap: 1, paddingLeft: 2, children: _jsx(Text, { color: isActiveCursor ? 'cyan' : 'white', children: isActiveCursor ? `▶ ${v}` : `  ${v}` }) }, i));
                     }), editingValue?.mode === 'add' && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: '+ ' }), _jsx(Text, { children: valueText }), _jsx(Text, { inverse: cursorVisible, children: " " })] }))] }))] }));
 }
-function SlotRow({ slot, selected, activeField, textCursor, valueCursor, cursorVisible, editingValue, valueText, width, pickerCandidates, pickerCursor, }) {
+function SlotRow({ slot, selected, activeField, textCursor, valueCursor, cursorVisible, editingValue, valueText, width, }) {
     const cursor = cursorVisible ? '█' : ' ';
     const bg = selected ? 'blue' : undefined;
     const nameDisplay = slot.name.length > 14 ? slot.name.slice(0, 13) + '…' : slot.name.padEnd(14);
-    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: selected ? 'white' : 'cyan', bold: selected, backgroundColor: bg, children: [' ', nameDisplay, ' '] }), _jsx(Text, { dimColor: !selected, children: "req:" }), activeField === 'required' ? (_jsx(Toggle, { value: slot.required, active: true })) : (_jsx(Toggle, { value: slot.required, active: false }))] }), !selected && (_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { dimColor: true, children: "allowed:" }), slot.allowedComponents.length === 0 ? (_jsx(Text, { dimColor: true, children: "(any)" })) : (_jsx(Text, { color: "cyan", children: slot.allowedComponents.join(', ') }))] })), selected && (_jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "allowed:" }), activeField === 'allowedComponents' && (_jsx(Text, { dimColor: true, children: '  [a]dd  [e]dit  [r]emove  [↑↓] navigate  [K/J] reorder' }))] }), slot.allowedComponents.length === 0 && !editingValue && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: activeField === 'allowedComponents' ? '(any — press [a] to add)' : '(any)' }) })), slot.allowedComponents.map((v, i) => {
+    return (_jsxs(Box, { flexDirection: "column", width: width, children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: selected ? 'white' : 'cyan', bold: selected, backgroundColor: bg, children: [' ', nameDisplay, ' '] }), _jsx(Text, { dimColor: !selected, children: "req:" }), activeField === 'required' ? (_jsx(Toggle, { value: slot.required, active: true })) : (_jsx(Toggle, { value: slot.required, active: false }))] }), selected && (_jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "allowed:" }), activeField === 'allowedComponents' && (_jsx(Text, { dimColor: true, children: '  [a]dd  [e]dit  [r]emove  [↑↓] navigate  [K/J] reorder' }))] }), slot.allowedComponents.length === 0 && !editingValue && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: activeField === 'allowedComponents' ? '(any — press [a] to add)' : '(any)' }) })), slot.allowedComponents.map((v, i) => {
                         const isActiveCursor = activeField === 'allowedComponents' && valueCursor === i;
                         const isBeingEdited = editingValue?.mode === 'edit' && editingValue.index === i;
                         if (isBeingEdited) {
                             return (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: '✎ ' }), _jsx(Text, { children: valueText }), _jsx(Text, { inverse: cursorVisible, children: " " })] }, i));
                         }
                         return (_jsx(Box, { gap: 1, paddingLeft: 2, children: _jsx(Text, { color: isActiveCursor ? 'cyan' : 'white', children: isActiveCursor ? `▶ ${v}` : `  ${v}` }) }, i));
-                    }), editingValue?.mode === 'add' && activeField === 'allowedComponents' && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: '+ ' }), _jsx(Text, { children: valueText }), _jsx(Text, { inverse: cursorVisible, children: " " })] })), editingValue?.mode === 'add' && activeField === 'allowedComponents' && pickerCandidates !== null && (_jsx(Box, { paddingLeft: 2, flexDirection: "column", children: pickerCandidates.length === 0 ? (_jsx(Text, { dimColor: true, children: '(no valid components to add — all remaining candidates would create cycles)' })) : ((() => {
-                            const filtered = valueText.length === 0
-                                ? pickerCandidates
-                                : pickerCandidates.filter((n) => n.toLowerCase().includes(valueText.toLowerCase()));
-                            if (filtered.length === 0) {
-                                return _jsx(Text, { dimColor: true, children: '(no candidates match — Enter to add as free text)' });
-                            }
-                            const cursor = pickerCursor % filtered.length;
-                            const MAX_VISIBLE = 5;
-                            const start = Math.max(0, Math.min(filtered.length - MAX_VISIBLE, cursor - 2));
-                            const slice = filtered.slice(start, start + MAX_VISIBLE);
-                            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: '  candidates (↑↓ cycle, Enter to add):' }), slice.map((name, i) => {
-                                        const absIdx = start + i;
-                                        const isCursor = absIdx === cursor;
-                                        return (_jsx(Text, { color: isCursor ? 'cyan' : undefined, dimColor: !isCursor, children: isCursor ? `  ▶ ${name}` : `    ${name}` }, name));
-                                    })] }));
-                        })()) }))] })), selected && activeField === 'description' && (_jsxs(Box, { paddingLeft: 2, flexDirection: "row", children: [_jsx(Text, { dimColor: true, children: "desc:" }), _jsxs(Box, { flexGrow: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { children: slot.description.slice(0, textCursor) }), _jsx(Text, { inverse: cursorVisible, children: slot.description[textCursor] ?? cursor }), _jsx(Text, { children: slot.description.slice(textCursor + 1) })] })] })), selected && activeField !== 'description' && (_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { dimColor: true, children: "desc:" }), _jsx(Text, { color: "green", children: slot.description || '—' })] }))] }));
+                    }), editingValue?.mode === 'add' && activeField === 'allowedComponents' && (_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: "cyan", children: '+ ' }), _jsx(Text, { children: valueText }), _jsx(Text, { inverse: cursorVisible, children: " " })] }))] })), selected && activeField === 'description' && (_jsxs(Box, { paddingLeft: 2, flexDirection: "row", children: [_jsx(Text, { dimColor: true, children: "desc:" }), _jsxs(Box, { flexGrow: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { children: slot.description.slice(0, textCursor) }), _jsx(Text, { inverse: cursorVisible, children: slot.description[textCursor] ?? cursor }), _jsx(Text, { children: slot.description.slice(textCursor + 1) })] })] })), selected && activeField !== 'description' && (_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { dimColor: true, children: "desc:" }), _jsx(Text, { color: "green", children: slot.description || '—' })] }))] }));
 }
 // Field order is intentional: description is LAST so it's the "edge" of the
 // field cycle. The user reaches description by walking through type → category
@@ -255,59 +238,8 @@ function propFields(prop) {
 // components is a list-typed field that swallows j/k similarly to enum $values
 // — placing it before description preserves description-as-last.
 const SLOT_FIELDS = ['required', 'allowedComponents', 'description'];
-// ── INTEG-4401: cycle-aware $allowedComponents picker helpers ─────────────
-/** Simulate adding a candidate to a slot; replaces self-entry with live edits. */
-export function simulateGraphWithCandidate(projectSlotGraph, selfName, currentSlots, targetSlotName, candidate) {
-    const selfEntry = {
-        name: selfName,
-        slots: currentSlots.map((s) => ({
-            name: s.name,
-            allowedComponents: s.name === targetSlotName ? [...s.allowedComponents, candidate] : [...s.allowedComponents],
-        })),
-    };
-    const withoutSelf = projectSlotGraph.filter((c) => c.name !== selfName);
-    return [...withoutSelf, selfEntry];
-}
-/** True iff `next` contains a cycle whose canonical edge set is absent in `before`. */
-export function introducesNewCycle(before, next) {
-    const key = (edges) => {
-        if (edges.length === 0)
-            return '';
-        const encoded = edges.map((e) => `${e.fromComponent}|${e.slotName}|${e.toComponent}`);
-        let minIdx = 0;
-        for (let i = 1; i < encoded.length; i += 1)
-            if (encoded[i] < encoded[minIdx])
-                minIdx = i;
-        return [...encoded.slice(minIdx), ...encoded.slice(0, minIdx)].join(';');
-    };
-    const beforeSet = new Set(before.map((c) => key(c.edges)));
-    for (const cycle of next)
-        if (!beforeSet.has(key(cycle.edges)))
-            return true;
-    return false;
-}
-/** Candidate names that can be added to a slot without creating a new cycle. */
-export function computeAllowedComponentCandidates(projectSlotGraph, selfName, currentSlots, targetSlotName) {
-    const targetSlot = currentSlots.find((s) => s.name === targetSlotName);
-    const alreadyAdded = new Set(targetSlot?.allowedComponents ?? []);
-    const universe = new Set();
-    for (const c of projectSlotGraph)
-        universe.add(c.name);
-    universe.delete(selfName);
-    for (const added of alreadyAdded)
-        universe.delete(added);
-    const baseline = findSlotCycles(simulateGraphWithCandidate(projectSlotGraph, selfName, currentSlots, '', ''));
-    const safe = [];
-    for (const candidate of universe) {
-        const nextCycles = findSlotCycles(simulateGraphWithCandidate(projectSlotGraph, selfName, currentSlots, targetSlotName, candidate));
-        if (!introducesNewCycle(baseline, nextCycles))
-            safe.push(candidate);
-    }
-    safe.sort((a, b) => a.localeCompare(b));
-    return safe;
-}
 // ── Main component ────────────────────────────────────────────────────────────
-export function FieldEditor({ value, width, height, active = true, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, onToggleComponentRationale, onToggleSourceExternal, onTextEntryActiveChange, projectSlotGraph, currentComponentName, }) {
+export function FieldEditor({ value, width, height, active = true, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, onToggleComponentRationale, onToggleSourceExternal, onTextEntryActiveChange, }) {
     const { state: initialState, error: parseError } = parseToState(value);
     const [editorState, setEditorState] = useState(initialState);
     const [parseErr] = useState(parseError);
@@ -359,8 +291,6 @@ export function FieldEditor({ value, width, height, active = true, onChange, onS
     // mode='add' — append on Enter; mode='edit' — replace at index on Enter.
     const [editingValue, setEditingValue] = useState(null);
     const [valueText, setValueText] = useState('');
-    // INTEG-4401: picker cursor for the cycle-filtered $allowedComponents list.
-    const [pickerCursor, setPickerCursor] = useState(0);
     const [validationError, setValidationError] = useState(null);
     const [cursorVisible] = useState(true);
     // Feature 1: source-view panel toggle. Opens with `s`, closes with `s` or Esc.
@@ -429,57 +359,11 @@ export function FieldEditor({ value, width, height, active = true, onChange, onS
         // same add/edit/remove/reorder list shape.
         const isPropValuesEntry = editingValue && currentProp && activeField === 'values' && !inSlots;
         const isSlotAllowedEntry = editingValue && currentSlot && activeField === 'allowedComponents' && inSlots;
-        // INTEG-4401: cycle-filtered candidates for slot-add.
-        const slotAddCandidates = isSlotAllowedEntry && editingValue?.mode === 'add' && projectSlotGraph && currentSlot && currentComponentName
-            ? computeAllowedComponentCandidates(projectSlotGraph, currentComponentName, slots, currentSlot.name)
-            : null;
-        const filteredCandidates = slotAddCandidates
-            ? valueText.length === 0
-                ? slotAddCandidates
-                : slotAddCandidates.filter((n) => n.toLowerCase().includes(valueText.toLowerCase()))
-            : null;
         if (isPropValuesEntry || isSlotAllowedEntry) {
             const vals = isPropValuesEntry ? currentProp.values : currentSlot.allowedComponents;
-            const pickerActive = isSlotAllowedEntry && editingValue?.mode === 'add' && slotAddCandidates !== null;
-            if (pickerActive && (key.upArrow || key.downArrow)) {
-                const len = filteredCandidates.length;
-                if (len > 0) {
-                    setPickerCursor((c) => (key.upArrow ? (c - 1 + len) % len : (c + 1) % len));
-                }
-                return;
-            }
             if (key.return) {
-                let chosen = null;
-                if (pickerActive && filteredCandidates && filteredCandidates.length > 0) {
-                    if (valueText.trim() === '') {
-                        chosen = filteredCandidates[pickerCursor % filteredCandidates.length] ?? null;
-                    }
-                    else {
-                        const exact = filteredCandidates.find((n) => n === valueText.trim());
-                        if (exact)
-                            chosen = exact;
-                    }
-                }
-                const trimmed = chosen ?? valueText.trim();
+                const trimmed = valueText.trim();
                 if (trimmed) {
-                    // Cycle-aware free-text validation. Picker path is safe by construction.
-                    if (isSlotAllowedEntry &&
-                        editingValue?.mode === 'add' &&
-                        projectSlotGraph &&
-                        currentSlot &&
-                        currentComponentName &&
-                        chosen === null) {
-                        if (trimmed === currentComponentName) {
-                            setValidationError(`"${trimmed}" cannot be added to its own slot (self-loop).`);
-                            return;
-                        }
-                        const baseline = findSlotCycles(simulateGraphWithCandidate(projectSlotGraph, currentComponentName, slots, '', ''));
-                        const next = findSlotCycles(simulateGraphWithCandidate(projectSlotGraph, currentComponentName, slots, currentSlot.name, trimmed));
-                        if (introducesNewCycle(baseline, next)) {
-                            setValidationError(`Adding "${trimmed}" to slot "${currentSlot.name}" would create a slot-dependency cycle. Choose a different component.`);
-                            return;
-                        }
-                    }
                     let nextVals;
                     let cursorAfter;
                     if (editingValue.mode === 'add') {
@@ -500,28 +384,22 @@ export function FieldEditor({ value, width, height, active = true, onChange, onS
                         commit({ ...editorState, slots: nextSlots });
                     }
                     setValueCursor(cursorAfter);
-                    setValidationError(null);
                 }
                 setEditingValue(null);
                 setValueText('');
-                setPickerCursor(0);
                 return;
             }
             if (key.escape) {
                 setEditingValue(null);
                 setValueText('');
-                setPickerCursor(0);
-                setValidationError(null);
                 return;
             }
             if (key.backspace) {
                 setValueText((t) => t.slice(0, -1));
-                setPickerCursor(0);
                 return;
             }
             if (input && input.length === 1 && !key.ctrl && !key.meta) {
                 setValueText((t) => t + input);
-                setPickerCursor(0);
                 return;
             }
             return;
@@ -1046,7 +924,10 @@ export function FieldEditor({ value, width, height, active = true, onChange, onS
     if (props.length === 0 && slots.length === 0) {
         return (_jsxs(Box, { flexDirection: "column", width: width, borderStyle: "single", borderColor: "yellow", children: [_jsx(Text, { bold: true, color: "yellow", children: "FIELD EDITOR \u2014 no fields" }), _jsx(Text, { color: "yellow", children: "⚠ No properties classified for this component. The LLM didn't find anything to classify." }), _jsx(Text, { dimColor: true, children: "You can add fields manually below or reject this component." }), _jsx(Text, { dimColor: true, children: "Ctrl+S to save \u00B7 Esc to discard" })] }));
     }
-    const hasEmptyProperties = props.length === 0 && slots.length === 0;
+    // When $properties is empty but $slots exist, surface the same warning
+    // prominently in the panel so the user understands why the component looks
+    // sparse — and can act on it (manually add a prop or reject).
+    const hasEmptyProperties = props.length === 0;
     const modeLabel = (() => {
         if (editingValue) {
             return editingValue.mode === 'add' ? 'Enter to add · Esc to cancel' : 'Enter to save edit · Esc to cancel';
@@ -1107,15 +988,7 @@ export function FieldEditor({ value, width, height, active = true, onChange, onS
                     // slot row
                     const s = slots[row.idx];
                     const isSelected = inSlots && row.idx === slotIdx;
-                    // INTEG-4401: compute picker candidates for selected slot in add-mode.
-                    const slotPickerCandidates = isSelected &&
-                        editingValue?.mode === 'add' &&
-                        activeField === 'allowedComponents' &&
-                        projectSlotGraph &&
-                        currentComponentName
-                        ? computeAllowedComponentCandidates(projectSlotGraph, currentComponentName, slots, s.name)
-                        : null;
-                    return (_jsx(SlotRow, { slot: s, selected: isSelected, activeField: isSelected && focusLevel === 'field' ? activeField : null, textCursor: textCursor, valueCursor: valueCursor, cursorVisible: cursorVisible, editingValue: isSelected ? editingValue : null, valueText: isSelected ? valueText : '', width: innerWidth, pickerCandidates: slotPickerCandidates, pickerCursor: pickerCursor }, `slot-${row.idx}`));
+                    return (_jsx(SlotRow, { slot: s, selected: isSelected, activeField: isSelected && focusLevel === 'field' ? activeField : null, textCursor: textCursor, valueCursor: valueCursor, cursorVisible: cursorVisible, editingValue: isSelected ? editingValue : null, valueText: isSelected ? valueText : '', width: innerWidth }, `slot-${row.idx}`));
                 }) }), sourceOpen &&
                 !onToggleSourceExternal &&
                 (() => {

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

@@ -11,7 +11,7 @@ import { OutputFormatter, c } from '../../output/format.js';
 import { buildRepoContextIndex, buildSelectionContext } from './context-builder.js';
 import { runShowRationale } from './show-rationale.js';
 import { isAbsolute, resolve } from 'node:path';
-import { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, } from '../extract/validate.js';
+import { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, } from '@contentful/experience-design-system-extraction';
 const VALID_AGENTS = new Set(['claude', 'codex', 'opencode', 'cursor']);
 const DEFAULT_TIMEOUT_MS = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 3 * 60 * 1000);
 export const DEFAULT_CONCURRENCY = 10;

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

@@ -1,39 +1,6 @@
 import type { Command } from 'commander';
-import type { CDFComponentEntry, DTCGTokenEntry } from '@contentful/experience-design-system-types';
-import { findSlotCycles } from '../analyze/cycle-detection.js';
+import type { DTCGTokenEntry } from '@contentful/experience-design-system-types';
 import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
 export declare function readTokensFromPath(flag: string, p: string): Promise<DTCGTokenEntry[]>;
-/**
- * Pure cycle detection — returns [] when the graph is acyclic. Callers own
- * how to react (CLI standalone uses `assertNoSlotCycles` which exits 1; the
- * wizard uses `detectSlotCycles` directly to route to an in-TUI error step
- * without ever POSTing to EDSI).
- */
-export declare function detectSlotCycles(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): ReturnType<typeof findSlotCycles>;
-/**
- * Build a stderr-style message block for a set of cycles. Extracted so the
- * wizard can render the same text in an in-TUI error panel and any future
- * headless surface can log identical output.
- */
-export declare function formatSlotCycleReport(cycles: ReturnType<typeof findSlotCycles>): string[];
-export declare function assertNoSlotCycles(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): void;
-/**
- * Reconstruct the `{key, entry}` shape from a built `ManifestPayload`. The
- * wizard's push path holds a serialized manifest rather than the underlying
- * CDF records, so we unwrap it here to feed `detectSlotCycles`. Skips the
- * `$schema` sentinel key. Safe on undefined/empty manifests (returns []).
- */
-export declare function extractComponentsFromManifest(manifest: {
-    componentsManifest?: Record<string, unknown>;
-} | null | undefined): Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>;
 export declare function hasBreakingChangesWithImpact(preview: ServerPreviewResponse): boolean;
 export declare function registerApplyCommand(program: Command): void;

package/dist/src/apply/command.js

@@ -5,7 +5,6 @@ import { join } from 'node:path';
 import { validateCDF, flattenDTCG, validateDTCG, buildManifest, buildFilteredManifest, } from '@contentful/experience-design-system-types';
 import { ApiError, ImportApiClient } from './api-client.js';
 import { openPipelineDb, loadCDFComponents } from '../session/db.js';
-import { findSlotCycles, suggestCycleBreakEdge, formatCyclePath } from '../analyze/cycle-detection.js';
 import { isEmptyPreview } from './preview-utils.js';
 import { ServerPreviewApp, ServerPreviewConfirm, ServerApplyProgress, ServerApplyDone } from './tui/ServerApplyView.js';
 import { SelectView, makeSelectKey } from './tui/SelectView.js';
@@ -171,75 +170,6 @@ async function resolveSharedInputs(opts) {
     });
     return { components, tokens, client };
 }
-// --- INTEG-4401: pre-push slot-cycle hard block ---
-//
-// The backend apply worker rejects cyclic slot graphs at topo-sort time, but
-// by then the request has already been serialized, transported, and partially
-// applied — leading to confusing partial-failure states. Detecting the same
-// violation locally lets us fail fast with a clear message and zero
-// side-effects. Called from the `apply push` and `apply select` flows AND
-// from the wizard's `experiences import` push path (via `detectSlotCycles`).
-// `apply preview` is read-only and still runs (its diff is used to warn but
-// not to block).
-/**
- * Pure cycle detection — returns [] when the graph is acyclic. Callers own
- * how to react (CLI standalone uses `assertNoSlotCycles` which exits 1; the
- * wizard uses `detectSlotCycles` directly to route to an in-TUI error step
- * without ever POSTing to EDSI).
- */
-export function detectSlotCycles(components) {
-    const cycleInput = components.map(({ key, entry }) => ({
-        name: key,
-        slots: Object.entries(entry.$slots ?? {}).map(([slotName, slotDef]) => ({
-            name: slotName,
-            allowedComponents: slotDef.$allowedComponents ?? [],
-        })),
-    }));
-    return findSlotCycles(cycleInput);
-}
-/**
- * Build a stderr-style message block for a set of cycles. Extracted so the
- * wizard can render the same text in an in-TUI error panel and any future
- * headless surface can log identical output.
- */
-export function formatSlotCycleReport(cycles) {
-    const lines = [];
-    lines.push(`Error: manifest:components/slot-cycles — ${cycles.length} slot dependency cycle(s) detected. Push refused.`);
-    for (let i = 0; i < cycles.length; i += 1) {
-        const cycle = cycles[i];
-        lines.push(`  Cycle ${i + 1}: ${formatCyclePath(cycle)}`);
-        const suggested = suggestCycleBreakEdge(cycle, cycles);
-        lines.push(`    Fix: remove '${suggested.toComponent}' from ${suggested.fromComponent}.$slots.${suggested.slotName}.$allowedComponents`);
-    }
-    return lines;
-}
-export function assertNoSlotCycles(components) {
-    const cycles = detectSlotCycles(components);
-    if (cycles.length === 0)
-        return;
-    process.stderr.write(formatSlotCycleReport(cycles).join('\n') + '\n');
-    process.exit(1);
-}
-/**
- * Reconstruct the `{key, entry}` shape from a built `ManifestPayload`. The
- * wizard's push path holds a serialized manifest rather than the underlying
- * CDF records, so we unwrap it here to feed `detectSlotCycles`. Skips the
- * `$schema` sentinel key. Safe on undefined/empty manifests (returns []).
- */
-export function extractComponentsFromManifest(manifest) {
-    const componentsManifest = manifest?.componentsManifest;
-    if (!componentsManifest)
-        return [];
-    const out = [];
-    for (const [key, value] of Object.entries(componentsManifest)) {
-        if (key === '$schema')
-            continue;
-        if (!value || typeof value !== 'object')
-            continue;
-        out.push({ key, entry: value });
-    }
-    return out;
-}
 // --- Output helpers ---
 export function hasBreakingChangesWithImpact(preview) {
     const allChanged = [...preview.components.changed, ...preview.tokens.changed];
@@ -515,12 +445,6 @@ export function registerApplyCommand(program) {
             throw e;
         }
         const { components, tokens, client } = inputs;
-        // INTEG-4401: refuse before spending any credentials or bytes on a
-        // manifest the backend will reject. Cycle detection is deterministic
-        // and cheap so we run it here (not just at extract time) — this also
-        // guards `apply push --components` where extract-time cycles are not
-        // in the session DB.
-        assertNoSlotCycles(components);
         try {
             await client.validateToken();
         }
@@ -699,11 +623,6 @@ export function registerApplyCommand(program) {
             throw e;
         }
         const { components, tokens, client } = inputs;
-        // INTEG-4401: same pre-push cycle block as `apply push`. Running the
-        // check on the FULL component set (not the filtered selection) is
-        // deliberate: partial selection cannot resolve a cycle whose
-        // participants are all still present in the target space.
-        assertNoSlotCycles(components);
         try {
             await client.validateToken();
         }

package/dist/src/import/tui/WizardApp.js

@@ -33,8 +33,6 @@ import { nextStateAfterPrint } from './run-print-files-helpers.js';
 import { PushDecisionGateStep } from './steps/PushDecisionGateStep.js';
 import { chooseGateAction } from './push-decision-gate-helpers.js';
 import { ImportApiClient, ApiError } from '../../apply/api-client.js';
-import { detectSlotCycles, extractComponentsFromManifest, formatSlotCycleReport } from '../../apply/command.js';
-import { parseEdsiError, formatParsedEdsiError } from '../../apply/error-parser.js';
 import { handlePreview422, applySkipValidationErrors, clearedValidationErrorState } from './wizard-422-helpers.js';
 import { parseGenerateStderrChunk } from './wizard-generate-progress.js';
 import { spawnGenerateChild } from './spawn-generate.js';
@@ -1036,23 +1034,6 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                 return;
             }
         }
-        // INTEG-4401 Fix A — pre-push slot-cycle hard block for the wizard's
-        // direct-API push path. The standalone `apply push` / `apply select`
-        // commands run `assertNoSlotCycles` before ever constructing an API
-        // client, but `experiences import` calls `client.applyImport` from here
-        // without shelling out — so the guard has to run again on this path.
-        // Otherwise a cyclic graph reaches EDSI and the operator sees a raw
-        // Lambda error dump (see Fix C) instead of the clear local report.
-        const cycles = detectSlotCycles(extractComponentsFromManifest(manifest));
-        if (cycles.length > 0) {
-            update({
-                step: 'error',
-                errorStep: 'apply push',
-                errorMessage: formatSlotCycleReport(cycles).join('\n'),
-                errorAllowCredentialRetry: false,
-            });
-            return;
-        }
         update({ step: 'pushing', pushProgress: null });
         try {
             const resolvedHost = resolveWizardHost(host);
@@ -1143,57 +1124,27 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                 };
             }
             else {
-                // API didn't return items. INTEG-4401 Fix B — do NOT report preview
-                // counts as "created": if the server said something failed, echo it
-                // truthfully so the summary can't lie. Historically this branch used
-                // preview.new/changed/removed as success counts and only surfaced
-                // failed:0, which meant a cycle rejection (summary: 0 succeeded /
-                // 11 failed, empty items) rendered as "Done ✓ 2 Component Types
-                // created" — the exact regression this fix guards against.
-                const summary = operation.summary ?? { total: 0, pending: 0, succeeded: 0, failed: 0 };
-                const anyFailure = summary.failed > 0 || operation.sys.status === 'failed' || operation.sys.status === 'partial';
+                // API didn't return items — fall back to summary + preview counts
                 pushResult = {
                     componentTypes: {
-                        created: anyFailure ? 0 : (preview?.components.new.length ?? 0),
-                        updated: anyFailure ? 0 : (preview?.components.changed.length ?? 0),
-                        removed: anyFailure ? 0 : (preview?.components.removed.length ?? 0),
-                        // Attribute failures to component types by default — without a
-                        // per-item breakdown we can't split components vs tokens, and
-                        // components are the dominant entity in an import.
-                        failed: summary.failed,
+                        created: preview?.components.new.length ?? 0,
+                        updated: preview?.components.changed.length ?? 0,
+                        removed: preview?.components.removed.length ?? 0,
+                        failed: 0,
                     },
                     designTokens: {
-                        created: anyFailure ? 0 : (preview?.tokens.new.length ?? 0),
-                        updated: anyFailure ? 0 : (preview?.tokens.changed.length ?? 0),
-                        removed: anyFailure ? 0 : (preview?.tokens.removed.length ?? 0),
+                        created: preview?.tokens.new.length ?? 0,
+                        updated: preview?.tokens.changed.length ?? 0,
+                        removed: preview?.tokens.removed.length ?? 0,
                         failed: 0,
                     },
-                    summary,
+                    summary: operation.summary,
                 };
             }
             update({ step: 'done', pushResult });
         }
         catch (e) {
-            // INTEG-4401 Fix C — parse EDSI error bodies into a `[CODE] message`
-            // block before handing off to ErrorStep, so cycle rejections and other
-            // structured failures don't render as raw Lambda log lines
-            // (timestamp / request-id / dd.trace_id / etc.).
-            let msg;
-            if (e instanceof ApiError) {
-                const parsed = parseEdsiError(e.body || e.message);
-                msg = formatParsedEdsiError(parsed, {
-                    verbose: process.env['EDSI_VERBOSE_ERRORS'] === '1',
-                    raw: e.body,
-                });
-                if (!msg)
-                    msg = e.message;
-            }
-            else if (e instanceof Error) {
-                msg = e.message;
-            }
-            else {
-                msg = 'Push failed';
-            }
+            const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : 'Push failed';
             update({
                 step: 'error',
                 errorStep: 'apply push',

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

@@ -37,6 +37,6 @@ type GenerateReviewStepProps = {
 export declare function sortComponentsForSidebar<T extends {
     key: string;
     entry: CDFComponentEntry;
-}>(components: T[], cycleParticipants?: Set<string>): T[];
+}>(components: T[]): T[];
 export declare function GenerateReviewStep({ extractSessionId, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }: GenerateReviewStepProps): React.ReactElement;
 export {};