@contentful/experience-design-system-cli 2.7.5-dev-build-752dc9c.0 → 2.10.1-dev-build-90df010.0

package/dist/src/program.d.ts

@@ -1,2 +1,19 @@
 import { Command } from 'commander';
+type SpawnedChild = {
+    on(event: 'error', listener: (err: unknown) => void): unknown;
+    on(event: 'exit', listener: (code: number | null) => void): unknown;
+};
+/**
+ * Run the spawn lifecycle for the build command. Extracted so the
+ * error-surfacing path is testable: previously `child.on('error', ...)`
+ * silently returned exit code 1 with no context, leaving the user
+ * staring at a generic non-zero exit when `pnpm` wasn't on PATH.
+ */
+export declare function runBuild(opts: {
+    spawnFn: () => SpawnedChild;
+    stderrWrite: (chunk: string) => void;
+}): Promise<{
+    exitCode: number;
+}>;
 export declare function createProgram(): Command;
+export {};

package/dist/src/program.js

@@ -12,6 +12,30 @@ import { registerImportCommand } from './import/command.js';
 import { registerSetupCommand } from './setup/command.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
+/**
+ * Run the spawn lifecycle for the build command. Extracted so the
+ * error-surfacing path is testable: previously `child.on('error', ...)`
+ * silently returned exit code 1 with no context, leaving the user
+ * staring at a generic non-zero exit when `pnpm` wasn't on PATH.
+ */
+export async function runBuild(opts) {
+    return new Promise((resolvePromise) => {
+        const child = opts.spawnFn();
+        let settled = false;
+        const settle = (exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise({ exitCode });
+        };
+        child.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            opts.stderrWrite(`Error: failed to spawn build subprocess: ${message}\n`);
+            settle(1);
+        });
+        child.on('exit', (code) => settle(code ?? 1));
+    });
+}
 function registerBuildCommand(program) {
     program
         .command('build')
@@ -19,10 +43,9 @@ function registerBuildCommand(program) {
         .action(async () => {
         const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
         process.stderr.write('⚙  Building from source...\n');
-        const exitCode = await new Promise((resolvePromise) => {
-            const child = spawn('pnpm', ['build'], { cwd: pkgRoot, stdio: 'inherit' });
-            child.on('error', () => resolvePromise(1));
-            child.on('exit', (code) => resolvePromise(code ?? 1));
+        const { exitCode } = await runBuild({
+            spawnFn: () => spawn('pnpm', ['build'], { cwd: pkgRoot, stdio: 'inherit' }),
+            stderrWrite: (s) => process.stderr.write(s),
         });
         process.exit(exitCode);
     });

package/dist/src/session/db.d.ts

@@ -53,6 +53,19 @@ export type RawComponentWithId = RawComponentDefinition & {
     component_id: string;
 };
 export declare function loadRawComponents(db: DatabaseSync, sessionId: string, allowedNames?: Set<string>): RawComponentWithId[];
+/**
+ * Rename empty-named slots in the DB to heuristic names before generation.
+ * The LLM classify_slot tool call is matched back to the DB row by name, so a
+ * row with name="" can never be updated by the LLM — renaming it here makes it
+ * classifiable. Returns one warning string per renamed slot.
+ */
+export declare function renameEmptySlots(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, slotCount: number): {
+    renames: Array<{
+        oldName: string;
+        newName: string;
+    }>;
+    warnings: string[];
+};
 export declare function storeCDFComponents(db: DatabaseSync, sessionId: string, components: Array<{
     key: string;
     entry: CDFComponentEntry;

package/dist/src/session/db.js

@@ -563,6 +563,45 @@ export function loadRawComponents(db, sessionId, allowedNames) {
         }),
     }));
 }
+/**
+ * Rename empty-named slots in the DB to heuristic names before generation.
+ * The LLM classify_slot tool call is matched back to the DB row by name, so a
+ * row with name="" can never be updated by the LLM — renaming it here makes it
+ * classifiable. Returns one warning string per renamed slot.
+ */
+export function renameEmptySlots(db, sessionId, componentId, componentName, slotCount) {
+    const emptySlots = db
+        .prepare(`SELECT name, position FROM raw_slots
+       WHERE session_id = ? AND component_id = ? AND trim(name) = ''
+       ORDER BY position`)
+        .all(sessionId, componentId);
+    if (emptySlots.length === 0)
+        return { renames: [], warnings: [] };
+    const renames = [];
+    const warnings = [];
+    const rename = db.prepare(`UPDATE raw_slots SET name = ? WHERE session_id = ? AND component_id = ? AND name = ? AND position = ?`);
+    // Multi-statement write — wrap in a transaction so a SIGINT or driver error
+    // mid-loop leaves raw_slots either fully renamed or fully untouched, never
+    // half-renamed (which would corrupt the prompt-vs-DB invariant the LLM
+    // relies on for classify_slot). Matches the existing BEGIN/COMMIT pattern
+    // throughout this file (see storeRawComponents, createStep, etc.).
+    db.exec('BEGIN');
+    try {
+        for (const slot of emptySlots) {
+            // Single unnamed slot → "children". Multiple → positional names.
+            const newName = slotCount === 1 ? 'children' : `slot_${slot.position}`;
+            rename.run(newName, sessionId, componentId, slot.name, slot.position);
+            renames.push({ oldName: slot.name, newName });
+            warnings.push(`${componentName}: slot at position ${slot.position} had empty name — renamed to "${newName}" for classification`);
+        }
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+    return { renames, warnings };
+}
 function groupBy(items, key) {
     const map = new Map();
     for (const item of items) {
@@ -676,6 +715,12 @@ export function loadCDFComponents(db, sessionId) {
             return null;
         const $properties = {};
         for (const p of compProps) {
+            // Hallucination insurance: drop any prop whose name didn't survive trim.
+            // The pre-generate rename guard catches empty-named slots, but if the LLM
+            // hallucinated a classify_prop with an empty name into the DB, surface
+            // nothing to the manifest builder rather than emitting "$properties: { '': ... }".
+            if (!p.name.trim())
+                continue;
             const av = allowedValuesByProp.get(`${component_id}::${p.name}`);
             const propDef = {
                 $type: p.cdf_type,
@@ -702,6 +747,11 @@ export function loadCDFComponents(db, sessionId) {
         const compSlots = slotsByComponent.get(component_id) ?? [];
         const $slots = {};
         for (const s of compSlots) {
+            // Hallucination insurance: same as $properties — drop empty-named slots
+            // before they reach buildManifest, which faithfully passes empty keys
+            // through and triggers a 422 from the preview API.
+            if (!s.name.trim())
+                continue;
             const ac = allowedComponentsBySlot.get(`${component_id}::${s.name}`);
             const slotDef = {};
             if (s.description !== null)

package/dist/src/types.d.ts

@@ -1,5 +1,5 @@
 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 ExtractionValidationIssueCode = 'EMPTY_COMPONENT_NAME' | 'EMPTY_PROP_NAME' | 'EMPTY_SLOT_NAME' | 'PROP_SLOT_NAME_COLLISION' | 'DUPLICATE_COMPONENT_NAME' | 'EMPTY_COMPONENT' | 'SERVER_VALIDATION_FAILED';
 export type ExtractionValidationIssue = {
     severity: 'error' | 'warning';
     code: ExtractionValidationIssueCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.7.5-dev-build-752dc9c.0",
+  "version": "2.10.1-dev-build-90df010.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.5-dev-build-752dc9c.0"
+    "@contentful/experience-design-system-types": "2.10.1-dev-build-90df010.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",

package/skills/generate-components.md

@@ -251,6 +251,8 @@ For each `RawSlotDefinition`:
   - `false` if clearly optional (icon slot, footer slot with a default, decorative slot)
   - Default to `true` when the source gives no signal
 
+**Pre-named slots:** If the input contains a slot whose `name` was already inferred by the pipeline (e.g. `"children"`, `"slot_0"`), treat it as you would any named slot — classify it normally. The pipeline renames empty-named slots to heuristic names before passing them to you; your job is to confirm or enrich the classification (set `required`, `description`, `allowed_components`), not to rename again.
+
 ---
 
 ## Examples