@contentful/experience-design-system-cli 2.7.3-dev-build-2a7c81e.0 → 2.7.4-dev-build-595febb.0

package/dist/package.json

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

package/dist/src/analyze/command.js

@@ -1,12 +1,12 @@
 import { createElement } from 'react';
 import { render } from 'ink';
 import { mkdir, readdir, stat } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
+import { isAbsolute, join, relative, resolve } from 'node:path';
 import { extractComponents } from './extract/pipeline.js';
 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 } from '../session/db.js';
+import { openPipelineDb, getOrCreateSession, createStep, updateStep, storeRawComponents, storeScannedFiles, } from '../session/db.js';
 import { preClassifyComponent } from './pre-classify.js';
 import { isNonAuthorableComponent } from './extract/non-authorable-filter.js';
 import { computeExtractionScore, deriveNeedsReview } from './extract/scoring.js';
@@ -169,6 +169,7 @@ export function registerAnalyzeCommand(program) {
             });
         }
         storeRawComponents(db, sessionId, filteredComponents);
+        storeScannedFiles(db, sessionId, sourceFiles.map((f) => relative(projectRoot, f)));
         updateStep(db, stepId, 'complete', { sessionId });
         db.close();
         const allWarnings = [...extraction.warnings, ...filterWarnings];

package/dist/src/analyze/extract/source-inspection.js

@@ -103,18 +103,22 @@ export async function inspectComponentSource(component) {
     }
     const reviewReasons = [];
     let wrapperScore = 0;
+    const hasGeneratedQueryHook = GENERATED_IMPORT_PATTERN.test(sourceText) && GENERATED_QUERY_HOOK_PATTERN.test(sourceText);
+    const infraProps = infraPropNames(component);
+    const siblingImports = collectSiblingRendererImports(sourceText);
     if (GQL_FILENAME_PATTERN.test(component.source)) {
         reviewReasons.push('data-wrapper:gql-filename');
         wrapperScore += 1;
     }
-    if (GENERATED_IMPORT_PATTERN.test(sourceText) && GENERATED_QUERY_HOOK_PATTERN.test(sourceText)) {
+    if (hasGeneratedQueryHook) {
         reviewReasons.push('data-wrapper:generated-query-hook');
         wrapperScore += 3;
     }
-    const siblingImports = collectSiblingRendererImports(sourceText);
-    if (siblingImports.length > 0) {
+    // Require corroboration from a stronger signal before counting sibling imports —
+    // otherwise any composed component that imports two sub-components scores +1 here.
+    if (siblingImports.length > 0 && (hasGeneratedQueryHook || infraProps.length > 0)) {
         reviewReasons.push('data-wrapper:sibling-renderer-import');
-        wrapperScore += 2;
+        wrapperScore += 1;
     }
     if (hasSiblingForwardRender(sourceText, siblingImports)) {
         reviewReasons.push('data-wrapper:fetch-forward-render');
@@ -124,12 +128,11 @@ export async function inspectComponentSource(component) {
         reviewReasons.push('data-wrapper:contentful-runtime');
         wrapperScore += 1;
     }
-    const infraProps = infraPropNames(component);
     if (infraProps.length > 0) {
         reviewReasons.push('data-wrapper:infra-props');
         wrapperScore += 2;
     }
-    if (LOADING_NULL_GUARD_PATTERN.test(sourceText) || /return\s+null\b/.test(sourceText)) {
+    if (LOADING_NULL_GUARD_PATTERN.test(sourceText)) {
         reviewReasons.push('data-wrapper:loading-null-guard');
         wrapperScore += 1;
     }

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

@@ -1,5 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createRequire } from 'node:module';
 import { Box, Text } from 'ink';
+// createRequire is needed because this is an ESM package — require() doesn't
+// exist natively, but it's the simplest way to read a JSON file at runtime.
+const _require = createRequire(import.meta.url);
+const VERSION = _require('../../../../../package.json').version;
 export function TopBar({ subcommand, hints }) {
-    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: 'experience-design-system-cli  ' + subcommand }), _jsx(Text, { dimColor: true, children: hints.map((h) => `[${h.key}] ${h.label}`).join('  ') })] }));
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: 'experience-design-system-cli  ' + subcommand }), _jsxs(Text, { dimColor: true, children: [hints.map((h) => `[${h.key}] ${h.label}`).join('  '), '  v' + VERSION] })] }));
 }

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

@@ -1,5 +1,4 @@
 import type { RawComponentDefinition } from '../../types.js';
-import type { SelectionAudit } from '../select-agent/consensus.js';
 export type PreviewAnnotation = 'new' | 'changed' | 'removed' | 'breaking';
 export type ReviewComponentStatus = 'needs-review' | 'reviewed' | 'accepted' | 'rejected';
 export type ReviewComponentRecord = {
@@ -10,7 +9,6 @@ export type ReviewComponentRecord = {
     originalProposal: RawComponentDefinition;
     editedProposal: RawComponentDefinition;
     status: ReviewComponentStatus;
-    selectionAudit?: SelectionAudit;
 };
 export type ReviewComponentDetail = {
     id: string;
@@ -18,7 +16,6 @@ export type ReviewComponentDetail = {
     originalProposal: RawComponentDefinition;
     editedProposal: RawComponentDefinition;
     status: ReviewComponentStatus;
-    selectionAudit?: SelectionAudit;
 };
 export type ReviewComponentSummary = {
     id: string;

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

@@ -17,7 +17,6 @@ export function createReviewSessionDetail(session) {
             originalProposal: component.originalProposal,
             editedProposal: component.editedProposal,
             status: component.status,
-            selectionAudit: component.selectionAudit,
         })),
     };
 }

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

@@ -1,17 +1,14 @@
-import { openPipelineDb, loadRawComponents, createStep, updateStep } from '../../session/db.js';
+import { openPipelineDb, loadRawComponents, loadScannedFiles, createStep, updateStep } from '../../session/db.js';
 import { appendReviewEvent, getRefineArtifactsRoot, ensureRefineSession, getRefineSessionPaths, saveReviewState, } from '../select/persistence.js';
 import { loadReviewInput } from '../select/parser.js';
 import { buildPrompt } from '../../generate/prompt-builder.js';
 import { parseSelectToolCallLines, runAgent } from '../../generate/agent-runner.js';
 import { OutputFormatter, c } from '../../output/format.js';
-import { DEFAULT_REVIEW_VOTE_COUNT, summarizeSelectionVotes, } from './consensus.js';
-import { buildRepoContextIndex, buildSelectionContext, summarizeSelectionContext, } from './context-builder.js';
-import { resolve } from 'node:path';
+import { buildRepoContextIndex, buildSelectionContext } from './context-builder.js';
+import { isAbsolute, resolve } from 'node:path';
 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;
-const REVIEW_VOTE_COUNT = Math.max(1, Number(process.env.EDS_SELECT_VOTE_COUNT ?? DEFAULT_REVIEW_VOTE_COUNT));
-const SINGLE_PASS_VOTE_COUNT = 1;
 function resolveSessionId(sessionFlag) {
     if (sessionFlag)
         return sessionFlag;
@@ -60,15 +57,6 @@ function buildComponentData(candidate) {
     }
     return payload;
 }
-function getSelectionVoteCount(component) {
-    if (component.needsReview === true) {
-        return REVIEW_VOTE_COUNT;
-    }
-    if (typeof component.extractionConfidence === 'number' && component.extractionConfidence <= 3) {
-        return REVIEW_VOTE_COUNT;
-    }
-    return SINGLE_PASS_VOTE_COUNT;
-}
 function resolveProjectRoot(sessionId, projectRootFlag) {
     if (projectRootFlag)
         return resolve(projectRootFlag);
@@ -94,8 +82,7 @@ function resolveProjectRoot(sessionId, projectRootFlag) {
     }
 }
 async function selectOneComponent(agent, model, candidate, index, total, verbose) {
-    const { component, selectionContext } = candidate;
-    const voteCount = getSelectionVoteCount(component);
+    const { component } = candidate;
     const prompt = await buildPrompt({
         skill: 'select',
         mode: 'autonomous',
@@ -103,71 +90,65 @@ async function selectOneComponent(agent, model, candidate, index, total, verbose
         outDir: process.cwd(),
     });
     const pos = c.dim(`[${index + 1}/${total}]`);
-    const votes = [];
-    const contextSummary = summarizeSelectionContext(selectionContext);
-    for (let attempt = 1; attempt <= voteCount; attempt++) {
-        let outputBuf = '';
-        const formatter = new OutputFormatter(verbose, (s) => {
-            outputBuf += s;
-        });
-        const result = await runAgent({
-            agent,
-            model,
-            prompt,
-            interactive: false,
-            timeoutMs: DEFAULT_TIMEOUT_MS,
-            onOutput: (chunk) => formatter.push(chunk),
-        });
-        formatter.flush();
-        if (verbose) {
-            process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.dim(`vote ${attempt}/${voteCount}`)}\n${outputBuf}`);
-        }
-        if (result.timedOut) {
-            votes.push({ attempt, decision: null, error: 'timed out' });
-            continue;
-        }
-        if (result.exitCode !== 0) {
-            votes.push({
-                attempt,
-                decision: null,
-                error: `agent exited with code ${result.exitCode}`,
-            });
-            continue;
-        }
-        const { calls, warnings } = parseSelectToolCallLines(result.stdout);
-        if (warnings.length > 0) {
-            for (const warning of warnings) {
-                process.stderr.write(`  ${c.yellow('⚠')}  ${component.name}: ${warning}\n`);
-            }
-        }
-        const call = calls.find((toolCall) => toolCall.name === component.name) ?? calls[0];
-        if (!call) {
-            votes.push({
-                attempt,
-                decision: null,
-                error: 'agent produced no tool call for this component',
-            });
-            continue;
+    let outputBuf = '';
+    const formatter = new OutputFormatter(verbose, (s) => {
+        outputBuf += s;
+    });
+    const result = await runAgent({
+        agent,
+        model,
+        prompt,
+        interactive: false,
+        timeoutMs: DEFAULT_TIMEOUT_MS,
+        onOutput: (chunk) => formatter.push(chunk),
+    });
+    formatter.flush();
+    if (verbose) {
+        process.stderr.write(`  ${pos}  ${c.bold(component.name)}\n${outputBuf}`);
+    }
+    if (result.timedOut) {
+        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.yellow('timed out')}\n`);
+        return {
+            componentKey: componentKey(component),
+            componentName: component.name,
+            decision: null,
+            failed: true,
+        };
+    }
+    if (result.exitCode !== 0) {
+        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.red(`agent exited with code ${result.exitCode}`)}\n`);
+        return {
+            componentKey: componentKey(component),
+            componentName: component.name,
+            decision: null,
+            failed: true,
+        };
+    }
+    const { calls, warnings } = parseSelectToolCallLines(result.stdout);
+    if (warnings.length > 0) {
+        for (const warning of warnings) {
+            process.stderr.write(`  ${c.yellow('⚠')}  ${component.name}: ${warning}\n`);
         }
-        votes.push({
-            attempt,
-            decision: call.tool === 'select_component' ? 'accepted' : 'rejected',
-            reason: call.reason,
-            confidence: call.confidence,
-        });
     }
-    const consensus = summarizeSelectionVotes(votes, contextSummary);
-    const finalColor = consensus.decision === 'accepted' ? c.green : consensus.decision === 'rejected' ? c.red : c.yellow;
-    const finalLabel = consensus.decision === 'accepted' ? 'accepted' : consensus.decision === 'rejected' ? 'rejected' : 'needs review';
-    const detail = consensus.audit.winningReason;
-    process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${finalColor(finalLabel)}${detail ? `  ${c.dim(detail)}` : ''}\n`);
+    const call = calls.find((toolCall) => toolCall.name === component.name) ?? calls[0];
+    if (!call) {
+        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.yellow('no tool call')}\n`);
+        return {
+            componentKey: componentKey(component),
+            componentName: component.name,
+            decision: null,
+            failed: true,
+        };
+    }
+    const decision = call.tool === 'select_component' ? 'accepted' : 'rejected';
+    const finalColor = decision === 'accepted' ? c.green : c.red;
+    process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${finalColor(decision)}${call.reason ? `  ${c.dim(call.reason)}` : ''}\n`);
     return {
         componentKey: componentKey(component),
         componentName: component.name,
-        decision: consensus.decision,
-        audit: consensus.audit,
-        reason: consensus.audit.winningReason,
-        failed: consensus.failed,
+        decision,
+        reason: call.reason,
+        failed: false,
     };
 }
 async function selectAllComponents(agent, model, components, verbose) {
@@ -207,8 +188,10 @@ export function registerAnalyzeSelectAgentCommand(program) {
         const selectionRoot = resolveProjectRoot(sessionId, opts.projectRoot);
         const db = openPipelineDb();
         let rawComponents;
+        let scannedFiles = [];
         try {
             rawComponents = loadRawComponents(db, sessionId);
+            scannedFiles = loadScannedFiles(db, sessionId);
         }
         finally {
             db.close();
@@ -218,9 +201,16 @@ export function registerAnalyzeSelectAgentCommand(program) {
             process.exit(1);
             return;
         }
+        if (selectionRoot && scannedFiles.length > 0) {
+            scannedFiles = scannedFiles.map((f) => (isAbsolute(f) ? f : resolve(selectionRoot, f)));
+        }
+        if (selectionRoot && scannedFiles.length === 0 && rawComponents.length > 0) {
+            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 }));
-        if (selectionRoot) {
-            const repoIndex = await buildRepoContextIndex(selectionRoot).catch(() => null);
+        if (selectionRoot && scannedFiles.length > 0) {
+            const repoIndex = await buildRepoContextIndex(selectionRoot, scannedFiles).catch(() => null);
             if (repoIndex) {
                 selectionCandidates = rawComponents.map((component) => ({
                     component,
@@ -241,14 +231,10 @@ export function registerAnalyzeSelectAgentCommand(program) {
             return;
         }
         const selectResults = await selectAllComponents(agent, opts.model, selectionCandidates, opts.verbose ?? false);
-        // Build decision map from results
         const decisions = new Map();
-        const audits = new Map();
         for (const r of selectResults) {
             decisions.set(r.componentKey, r.decision);
-            audits.set(r.componentKey, r.audit);
         }
-        // Load existing snapshot and apply decisions
         const artifactsRoot = getRefineArtifactsRoot();
         let snapshot;
         try {
@@ -268,23 +254,20 @@ export function registerAnalyzeSelectAgentCommand(program) {
             components: snapshot.components.map((comp) => {
                 const key = componentKey(comp.originalProposal);
                 const decision = decisions.get(key);
-                const selectionAudit = audits.get(key);
                 if (!decision)
                     return comp;
-                const status = decision === 'needs-review' ? 'needs-review' : decision;
-                return { ...comp, status, selectionAudit };
+                return { ...comp, status: decision };
             }),
         };
         await saveReviewState(paths.statePath, updated);
         await Promise.all(updated.components
-            .filter((component) => component.selectionAudit)
+            .filter((component) => component.status === 'accepted' || component.status === 'rejected')
             .map((component) => appendReviewEvent(paths.eventsPath, {
             type: 'select_agent_decision',
             payload: {
                 component: component.name,
                 source: component.originalProposal.source,
                 status: component.status,
-                selectionAudit: component.selectionAudit,
             },
         })));
         const accepted = updated.components.filter((comp) => comp.status === 'accepted');
@@ -294,10 +277,9 @@ export function registerAnalyzeSelectAgentCommand(program) {
         if (failed.length > 0) {
             process.stderr.write(c.red(`Failed (${failed.length}/${selectResults.length}):`) + '\n');
             for (const f of failed) {
-                process.stderr.write(`  ${c.red('✗')}  ${f.componentName}  ${c.dim('all votes failed')}\n`);
+                process.stderr.write(`  ${c.red('✗')}  ${f.componentName}\n`);
             }
         }
-        // Write step to DB
         const stepDb = openPipelineDb();
         const stepId = createStep(stepDb, sessionId, 'analyze select', {
             sessionId,

package/dist/src/analyze/select-agent/context-builder.d.ts

@@ -1,5 +1,10 @@
 import type { RawComponentDefinition } from '../../types.js';
-import type { SelectionContextSummary } from './consensus.js';
+export type SelectionContextSummary = {
+    boundaryRoot: string;
+    siblingFileCount: number;
+    resolverReferenceCount: number;
+    hasParentUsageSite: boolean;
+};
 export type SelectionImportSummary = {
     source: string;
     names: string[];
@@ -39,7 +44,7 @@ export type RepoContextIndex = {
     byDirectory: Map<string, IndexedFile[]>;
     filePaths: Set<string>;
 };
-export declare function buildRepoContextIndex(root: string): Promise<RepoContextIndex | null>;
+export declare function buildRepoContextIndex(root: string, filePaths: string[]): Promise<RepoContextIndex | null>;
 export declare function buildSelectionContext(index: RepoContextIndex, component: RawComponentDefinition): SelectionContext | undefined;
 export declare function summarizeSelectionContext(context: SelectionContext | undefined): SelectionContextSummary | undefined;
 export {};

package/dist/src/analyze/select-agent/context-builder.js

@@ -1,35 +1,6 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.ts', '.tsx', '.vue']);
-const IGNORED_DIRECTORY_NAMES = new Set([
-    '.git',
-    '.next',
-    '.nuxt',
-    'build',
-    'coverage',
-    'demo',
-    'demos',
-    'dist',
-    'example',
-    'examples',
-    'node_modules',
-    'out',
-    'storybook-static',
-]);
-const IGNORED_FILE_SUFFIXES = new Set([
-    '.stories.ts',
-    '.stories.tsx',
-    '.stories.js',
-    '.stories.jsx',
-    '.story.ts',
-    '.story.tsx',
-    '.story.js',
-    '.story.jsx',
-    '.spec.ts',
-    '.spec.tsx',
-    '.test.ts',
-    '.test.tsx',
-]);
 const IMPORT_PATTERN = /import\s+(?:type\s+)?(.+?)\s+from\s+['"]([^'"]+)['"]/g;
 const EXPORT_NAMED_PATTERN = /export\s+(?:const|function|class|type|interface|enum)\s+([A-Za-z0-9_]+)/g;
 const EXPORT_DEFAULT_PATTERN = /export\s+default\s+([A-Za-z0-9_]+)/g;
@@ -49,31 +20,6 @@ function isWithinRoot(path, root) {
     const relativePath = relative(root, path);
     return relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
 }
-async function collectSourceFiles(directory) {
-    const files = [];
-    async function visit(currentDirectory) {
-        const entries = await readdir(currentDirectory, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(currentDirectory, entry.name);
-            if (entry.isDirectory()) {
-                if (!IGNORED_DIRECTORY_NAMES.has(entry.name)) {
-                    await visit(fullPath);
-                }
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const extension = extname(entry.name);
-            if (!SCANNED_FILE_EXTENSIONS.has(extension) || entry.name.endsWith('.d.ts'))
-                continue;
-            if ([...IGNORED_FILE_SUFFIXES].some((suffix) => entry.name.endsWith(suffix)))
-                continue;
-            files.push(fullPath);
-        }
-    }
-    await visit(directory);
-    return files.sort();
-}
 function parseImportedNames(importClause) {
     const names = [];
     const parts = importClause.split(',').map((part) => part.trim());
@@ -195,12 +141,10 @@ function findParentUsageSite(root, files, componentName, currentFile) {
         snippet: extractSnippet(match.text, componentName, MAX_REFERENCE_CHARS),
     };
 }
-export async function buildRepoContextIndex(root) {
-    const resolvedRoot = resolve(root);
-    const rootStats = await stat(resolvedRoot).catch(() => null);
-    if (!rootStats?.isDirectory())
+export async function buildRepoContextIndex(root, filePaths) {
+    if (filePaths.length === 0)
         return null;
-    const filePaths = await collectSourceFiles(resolvedRoot);
+    const resolvedRoot = resolve(root);
     const files = await Promise.all(filePaths.map(async (absolutePath) => ({
         absolutePath,
         relativePath: relative(resolvedRoot, absolutePath),

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

@@ -106,6 +106,8 @@ export declare function computeTokenInputHash(rawTokenContent: string): string;
 export declare function lookupCache(db: DatabaseSync, inputHash: string, entityType: 'component' | 'token_set', entityId: string): CacheEntry | null;
 export declare function lookupCacheByEntity(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): CacheEntry | null;
 export declare function storeCache(db: DatabaseSync, inputHash: string, entityType: 'component' | 'token_set', entityId: string, sourceSessionId: string, humanEdited: boolean): void;
+export declare function storeScannedFiles(db: DatabaseSync, sessionId: string, filePaths: string[]): void;
+export declare function loadScannedFiles(db: DatabaseSync, sessionId: string): string[];
 export declare function markCacheHumanEdited(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): void;
 export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string): void;
 export declare function copyTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): void;

package/dist/src/session/db.js

@@ -127,6 +127,12 @@ CREATE TABLE IF NOT EXISTS generation_cache (
   PRIMARY KEY (input_hash, entity_type, entity_id)
 );
 
+CREATE TABLE IF NOT EXISTS scanned_files (
+  session_id  TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  path        TEXT NOT NULL,
+  PRIMARY KEY (session_id, path)
+);
+
 CREATE INDEX IF NOT EXISTS idx_steps_session            ON steps(session_id);
 CREATE INDEX IF NOT EXISTS idx_steps_command            ON steps(session_id, command);
 CREATE INDEX IF NOT EXISTS idx_raw_components_session   ON raw_components(session_id);
@@ -136,6 +142,7 @@ CREATE INDEX IF NOT EXISTS idx_raw_tokens_session       ON raw_tokens(session_id
 CREATE INDEX IF NOT EXISTS idx_raw_token_groups_session ON raw_token_groups(session_id);
 CREATE INDEX IF NOT EXISTS idx_generation_cache_entity  ON generation_cache(entity_type, entity_id);
 CREATE INDEX IF NOT EXISTS idx_generation_cache_session ON generation_cache(source_session_id);
+CREATE INDEX IF NOT EXISTS idx_scanned_files_session    ON scanned_files(session_id);
 `;
 export function getPipelineDbPath() {
     if (process.env.EDS_PIPELINE_DB_PATH) {
@@ -1067,6 +1074,25 @@ export function storeCache(db, inputHash, entityType, entityId, sourceSessionId,
        human_edited = CASE WHEN generation_cache.human_edited = 1 THEN 1 ELSE excluded.human_edited END,
        updated_at = excluded.updated_at`).run(inputHash, entityType, entityId, sourceSessionId, humanEdited ? 1 : 0, now, now);
 }
+export function storeScannedFiles(db, sessionId, filePaths) {
+    db.exec('BEGIN');
+    try {
+        db.prepare('DELETE FROM scanned_files WHERE session_id = ?').run(sessionId);
+        const insert = db.prepare('INSERT INTO scanned_files (session_id, path) VALUES (?, ?)');
+        for (const path of filePaths) {
+            insert.run(sessionId, path);
+        }
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        throw e;
+    }
+}
+export function loadScannedFiles(db, sessionId) {
+    const rows = db.prepare('SELECT path FROM scanned_files WHERE session_id = ? ORDER BY path').all(sessionId);
+    return rows.map((r) => r.path);
+}
 export function markCacheHumanEdited(db, entityType, entityId) {
     const now = new Date().toISOString();
     db.prepare(`UPDATE generation_cache SET human_edited = 1, updated_at = ? WHERE entity_type = ? AND entity_id = ?`).run(now, entityType, entityId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.7.3-dev-build-2a7c81e.0",
+  "version": "2.7.4-dev-build-595febb.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.3-dev-build-2a7c81e.0"
+    "@contentful/experience-design-system-types": "2.7.4-dev-build-595febb.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",

package/dist/src/analyze/select-agent/consensus.d.ts

@@ -1,32 +0,0 @@
-export type SelectionDecision = 'accepted' | 'rejected' | 'needs-review';
-export type SelectionVote = {
-    attempt: number;
-    decision: 'accepted' | 'rejected' | null;
-    reason?: string;
-    confidence?: number;
-    error?: string;
-};
-export type SelectionContextSummary = {
-    boundaryRoot: string;
-    siblingFileCount: number;
-    resolverReferenceCount: number;
-    hasParentUsageSite: boolean;
-};
-export type SelectionAudit = {
-    strategy: 'single-pass' | 'multi-vote-consensus';
-    voteCount: number;
-    acceptedVotes: number;
-    rejectedVotes: number;
-    failedVotes: number;
-    finalDecision: SelectionDecision;
-    winningReason?: string;
-    votes: SelectionVote[];
-    contextSummary?: SelectionContextSummary;
-};
-export type ConsensusResult = {
-    decision: SelectionDecision;
-    audit: SelectionAudit;
-    failed: boolean;
-};
-export declare const DEFAULT_REVIEW_VOTE_COUNT = 5;
-export declare function summarizeSelectionVotes(votes: SelectionVote[], contextSummary?: SelectionContextSummary): ConsensusResult;

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

@@ -1,60 +0,0 @@
-export const DEFAULT_REVIEW_VOTE_COUNT = 5;
-function preferredReason(votes, decision) {
-    const candidates = votes.filter((vote) => vote.decision === decision && vote.reason);
-    if (candidates.length === 0)
-        return undefined;
-    const ranked = new Map();
-    for (const vote of candidates) {
-        const reason = vote.reason;
-        const entry = ranked.get(reason) ?? { count: 0, bestConfidence: 0 };
-        entry.count += 1;
-        entry.bestConfidence = Math.max(entry.bestConfidence, vote.confidence ?? 0);
-        ranked.set(reason, entry);
-    }
-    return [...ranked.entries()].sort((a, b) => {
-        if (b[1].count !== a[1].count)
-            return b[1].count - a[1].count;
-        return b[1].bestConfidence - a[1].bestConfidence;
-    })[0]?.[0];
-}
-function decideFromVotes(votes, acceptedVotes, rejectedVotes) {
-    if (votes.length === 1) {
-        if (acceptedVotes === 1)
-            return 'accepted';
-        if (rejectedVotes === 1)
-            return 'rejected';
-        return 'needs-review';
-    }
-    // A 3-2 split is still too unstable for auto-selection.
-    if (votes.length >= DEFAULT_REVIEW_VOTE_COUNT &&
-        ((acceptedVotes === 3 && rejectedVotes === 2) || (acceptedVotes === 2 && rejectedVotes === 3))) {
-        return 'needs-review';
-    }
-    if (acceptedVotes > rejectedVotes)
-        return 'accepted';
-    if (rejectedVotes > acceptedVotes)
-        return 'rejected';
-    return 'needs-review';
-}
-export function summarizeSelectionVotes(votes, contextSummary) {
-    const acceptedVotes = votes.filter((vote) => vote.decision === 'accepted').length;
-    const rejectedVotes = votes.filter((vote) => vote.decision === 'rejected').length;
-    const failedVotes = votes.filter((vote) => vote.decision === null).length;
-    const decision = decideFromVotes(votes, acceptedVotes, rejectedVotes);
-    const winningReason = decision === 'accepted' || decision === 'rejected' ? preferredReason(votes, decision) : undefined;
-    return {
-        decision,
-        failed: failedVotes === votes.length,
-        audit: {
-            strategy: votes.length === 1 ? 'single-pass' : 'multi-vote-consensus',
-            voteCount: votes.length,
-            acceptedVotes,
-            rejectedVotes,
-            failedVotes,
-            finalDecision: decision,
-            winningReason,
-            votes,
-            contextSummary,
-        },
-    };
-}