@contentful/experience-design-system-cli 2.6.2-dev-build-864e323.0 → 2.7.1-dev-build-02830eb.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.6.2-dev-build-864e323.0",
+  "version": "2.7.1-dev-build-02830eb.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/analyze/command.js

@@ -153,7 +153,7 @@ export function registerAnalyzeCommand(program) {
                 propCount: c.props.length,
                 slotCount: c.slots.length,
                 warnings: allWarnings.filter((w) => w.startsWith(c.name + ':')),
-                extractionConfidence: c.extractionConfidence ?? 100,
+                extractionConfidence: c.extractionConfidence ?? null,
                 needsReview: c.needsReview ?? false,
             })),
             totalWarnings: allWarnings.length,

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

@@ -1,7 +1,8 @@
 import type { RawComponentDefinition } from '../../types.js';
+export type ExtractionConfidence = 1 | 2 | 3 | 4 | 5;
 export type ExtractionScore = {
-    confidence: number;
+    confidence: ExtractionConfidence;
     reasons: string[];
 };
 export declare function computeExtractionScore(component: RawComponentDefinition): ExtractionScore;
-export declare function deriveNeedsReview(confidence: number): boolean;
+export declare function deriveNeedsReview(confidence: ExtractionConfidence): boolean;

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

@@ -41,47 +41,64 @@ function isWidePrimitiveUnion(type) {
     const nullability = new Set(['null', 'undefined']);
     const baseCount = parts.filter((p) => basePrimitives.has(p)).length;
     const nullabilityCount = parts.filter((p) => nullability.has(p)).length;
-    // Wide only when there are 3+ base primitives, or 2+ base primitives combined with nullability modifiers
     return baseCount >= 3 || (baseCount >= 2 && nullabilityCount > 0 && baseCount + nullabilityCount >= 3);
 }
-export function computeExtractionScore(component) {
-    let confidence = 100;
+// Count the number of issues found for scoring
+function countIssues(component) {
+    let count = 0;
     const reasons = [];
-    // No props and no slots — extractor likely missed something or component is a wrapper
     if (component.props.length === 0 && component.slots.length === 0) {
-        confidence -= 15;
+        count++;
         reasons.push('no-props-or-slots');
     }
+    if (component.props.length > 50) {
+        count++;
+        reasons.push(`high-prop-count:${component.props.length}`);
+    }
     for (const prop of component.props) {
-        // Opaque types — extractor couldn't resolve the real type
         if (OPAQUE_TYPES.has(prop.type.trim())) {
-            confidence -= 20;
+            count++;
             reasons.push(`opaque-type:${prop.name}`);
-            break; // only penalise once per component
+            break;
         }
-        // Wide primitive union — hard for the AI agent to classify meaningfully
         if (isWidePrimitiveUnion(prop.type)) {
-            confidence -= 10;
+            count++;
             reasons.push(`wide-union:${prop.name}`);
-            break; // only penalise once
+            break;
         }
-        // Non-obvious prop name with no description
         if (!prop.description && !OBVIOUS_PROP_NAMES.has(prop.name)) {
-            confidence -= 10;
+            count++;
             reasons.push('props-missing-description');
-            break; // only penalise once
+            break;
         }
     }
-    // High prop count — possible DOM inflation near-miss or overly broad extraction
-    if (component.props.length > 50) {
-        confidence -= 20;
-        reasons.push(`high-prop-count:${component.props.length}`);
-    }
+    return { count, reasons: [...new Set(reasons)] };
+}
+// Maps issue count to a 1–5 confidence scale:
+//   0 issues → 5 (clean)
+//   1 issue  → 4 (minor concern)
+//   2 issues → 3 (moderate concern)
+//   3 issues → 2 (significant concern)
+//   4+ issues → 1 (likely wrong)
+function issueCountToConfidence(count) {
+    if (count === 0)
+        return 5;
+    if (count === 1)
+        return 4;
+    if (count === 2)
+        return 3;
+    if (count === 3)
+        return 2;
+    return 1;
+}
+export function computeExtractionScore(component) {
+    const { count, reasons } = countIssues(component);
     return {
-        confidence: Math.max(0, Math.min(100, confidence)),
-        reasons: [...new Set(reasons)], // deduplicate
+        confidence: issueCountToConfidence(count),
+        reasons,
     };
 }
+// Flag components scoring 2 or below for human review
 export function deriveNeedsReview(confidence) {
-    return confidence < 70;
+    return confidence <= 2;
 }