@contentful/experience-design-system-cli 2.26.1-dev-build-a852362.0 → 2.26.1-dev-build-f03f014.0

package/dist/src/analyze/command.js

@@ -1,599 +0,0 @@
-import { createElement } from 'react';
-import { render } from 'ink';
-import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { isAbsolute, join, relative, resolve } from 'node:path';
-import { addAgentModelOptions } from '../lib/agent-model-options.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, getCliCacheVersion, lookupCompositionCache, storeCompositionCache, } from '../session/db.js';
-import { findSlotCycles, suggestCycleBreakEdge } from './cycle-detection.js';
-import { resolveCompositionMode } from '../lib/composition-mode.js';
-import { resolveMapping } from './composition/resolve-mapping.js';
-import { loadUserMap, resolveCompositionSources } from './composition/resolve-mapping-cli.js';
-import { selectCandidateFiles, capCandidatesToPromptBudget } from './composition/candidate-files.js';
-import { critiqueCandidates } from './composition/candidate-critic.js';
-import { buildDirCriticPrompt, parseDirCriticReply } from './composition/candidate-critic-agent.js';
-import { buildCompositionInputHash } from './composition/composition-cache-key.js';
-import { collectManifestDocEdges } from './composition/manifest-doc-evidence.js';
-import { runParserInSandbox } from './composition/agent-parser/sandbox.js';
-import { resolveViaAgentParser } from './composition/agent-parser/resolve-via-parser.js';
-import { parsePromptOverrides, resolvePromptOverride } from '../lib/prompt-overrides.js';
-import { DEFAULT_AGENT_NAME, isAgentName, runAgent, } from '@contentful/experience-design-system-generation';
-import { readExperiencesCredentials } from '../credentials-store.js';
-import { buildAnalyzeViewRows, partitionGlobalWarnings } from './build-analyze-view-rows.js';
-import { getInteractiveTerminalSupport } from '../lib/terminal-capabilities.js';
-import { bindAnalyticsSessionId, emitSessionStarted, enrichCommandResult, exitWithAnalytics, isPipelineAnalyticsChild, } from '../analytics/index.js';
-import { getDebugLogger } from '../lib/debug-logger.js';
-const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.svelte', '.ts', '.tsx', '.vue']);
-/**
- * `.json`/`.md` are scanned too (Figma `manifest.json`, `AGENTS.md`-style
- * docs, and other design/composition-adjacent files we don't yet have a name
- * for) — gated by a denylist rather than an allowlist, so coverage isn't
- * capped at a couple of exact filenames. Their content is never inlined into
- * an LLM prompt by virtue of being scanned here; that's a separate gate (see
- * `selectCandidateFiles` in candidate-files.ts) which still only admits files
- * matching its own name/content-marker heuristics. Deterministic parsing
- * (manifest-doc-evidence.ts) reads this full set directly, with no LLM
- * involved, which is the actual prompt-injection safeguard for that signal.
- */
-const DENYLIST_GATED_EXTENSIONS = new Set(['.json', '.md']);
-const DENYLISTED_EXACT_FILE_NAMES = new Set([
-    'package.json',
-    'package-lock.json',
-    'npm-shrinkwrap.json',
-    'nx.json',
-    'project.json',
-    'turbo.json',
-    'lerna.json',
-    'jsconfig.json',
-]);
-/** Config-file families that vary by suffix (`tsconfig.build.json`, `.eslintrc.cjs.json`, ...) plus common repo docs. */
-const DENYLISTED_FILE_NAME_PATTERNS = [
-    /^tsconfig(\..+)?\.json$/,
-    /^\.?eslintrc(\..+)?\.json$/,
-    /^\.?prettierrc(\..+)?\.json$/,
-    /^(readme|changelog|contributing|code_of_conduct|license|security)(\..+)?\.md$/i,
-];
-function isDenylistedNoiseFile(name) {
-    return DENYLISTED_EXACT_FILE_NAMES.has(name) || DENYLISTED_FILE_NAME_PATTERNS.some((pattern) => pattern.test(name));
-}
-const IGNORED_DIRECTORY_NAMES = new Set([
-    '.changeset',
-    '.git',
-    '.github',
-    '.idea',
-    '.next',
-    '.nuxt',
-    '.vscode',
-    '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',
-]);
-function pluralize(count, singular, plural = `${singular}s`) {
-    return `${count} ${count === 1 ? singular : plural}`;
-}
-function resolveFromProjectRoot(projectRoot, inputPath) {
-    return isAbsolute(inputPath) ? inputPath : resolve(projectRoot, inputPath);
-}
-function wrapperConfidenceToIssueCount(confidence) {
-    if (confidence >= 4)
-        return 2;
-    if (confidence === 3)
-        return 1;
-    return 0;
-}
-async function pathExists(path) {
-    return Boolean(await stat(path).catch(() => null));
-}
-export async function collectSourceFiles(directory, onProgress) {
-    const files = [];
-    async function visit(currentDirectory) {
-        const entries = await readdir(currentDirectory, { withFileTypes: true });
-        const subdirs = [];
-        for (const entry of entries) {
-            const fullPath = join(currentDirectory, entry.name);
-            if (entry.isDirectory()) {
-                if (!IGNORED_DIRECTORY_NAMES.has(entry.name)) {
-                    subdirs.push(fullPath);
-                }
-                continue;
-            }
-            if (!entry.isFile()) {
-                continue;
-            }
-            const extension = entry.name.slice(entry.name.lastIndexOf('.'));
-            const isCodeFile = SCANNED_FILE_EXTENSIONS.has(extension) && !entry.name.endsWith('.d.ts');
-            const isNoiseGatedFile = DENYLIST_GATED_EXTENSIONS.has(extension) && !isDenylistedNoiseFile(entry.name);
-            if (!isCodeFile && !isNoiseGatedFile) {
-                continue;
-            }
-            if ([...IGNORED_FILE_SUFFIXES].some((suffix) => entry.name.endsWith(suffix))) {
-                continue;
-            }
-            files.push(fullPath);
-            onProgress?.(files.length);
-        }
-        await Promise.all(subdirs.map((subdir) => visit(subdir)));
-    }
-    await visit(directory);
-    return files.sort();
-}
-/** Read the persisted default composition mode; missing config is fine. */
-async function safeReadCompositionMode() {
-    try {
-        return (await readExperiencesCredentials()).compositionMode;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Build a { version, groups } interchange skeleton (spec T1) from the resolved
- * components' slot allowedComponents — reflecting BOTH typed-slot edges the
- * extractor found and anything the mapping resolver added.
- */
-export function componentsToInterchangeMap(components) {
-    const groups = {};
-    for (const c of components) {
-        const children = new Set();
-        for (const slot of c.slots) {
-            for (const child of slot.allowedComponents ?? [])
-                children.add(child);
-        }
-        if (children.size > 0)
-            groups[c.name] = [...children].sort();
-    }
-    const sorted = {};
-    for (const parent of Object.keys(groups).sort())
-        sorted[parent] = groups[parent];
-    return { version: 1, groups: sorted };
-}
-/** Resolve which coding-agent runs mapping resolution: `--agent` flag > env > default. */
-function resolveCompositionAgentName(flagValue) {
-    if (flagValue && isAgentName(flagValue))
-        return flagValue;
-    const env = process.env['EDS_COMPOSITION_AGENT'];
-    if (env && isAgentName(env))
-        return env;
-    return DEFAULT_AGENT_NAME;
-}
-/**
- * Read the source files of the extracted components plus nearby mapping/meta
- * files, so the candidate pre-filter (T3) can pick the relevant ones. Reads
- * each unique `sourcePath` once; missing files are skipped.
- */
-async function readCandidateFiles(components, extraFiles = []) {
-    const paths = new Set(extraFiles);
-    for (const c of components) {
-        if (c.sourcePath)
-            paths.add(c.sourcePath);
-    }
-    const out = [];
-    await Promise.all([...paths].map(async (p) => {
-        try {
-            const content = await readFile(p, 'utf8');
-            out.push({ path: p, content });
-        }
-        catch {
-            void 0;
-        }
-    }));
-    return out;
-}
-export function registerAnalyzeCommand(program) {
-    const analyze = program
-        .command('analyze')
-        .description('Extract component definitions from a project, or correct analysis output');
-    const extractCmd = analyze
-        .command('extract')
-        .description('Extract component definitions from a project')
-        .requiredOption('--project <path>', 'Path to the project root')
-        .option('--dir <path>', 'Path to the component source directory relative to the project root')
-        .option('--resolve-unreachable <mode>', "Retry pass for unresolved Svelte Props types: 'auto' (default), 'always', or 'never'", 'auto')
-        .option('--composite', 'Resolve embedded-component composition (opt in; default is atomic)')
-        .option('--atomic', 'Skip composition resolution — flat components only (default)')
-        .option('--composition-map <path>', 'Consume a hand-authored parent→children interchange map (implies --composite)')
-        .option('--composition-agent', 'Opt into agentic mapping resolution when deterministic sources find no groups (implies --composite)')
-        .option('--composition-refresh', 'Force the mapping agent to run even where deterministic sources answered (implies --composite)')
-        .option('--generate-map <path>', 'Write a skeleton interchange map from resolved composition (implies --composite)')
-        .option('--prompt <stage=value>', 'Override a stage prompt (repeatable). value is a file path or literal text, e.g. --prompt composition=./p.md', (v, acc) => [...acc, v], []);
-    addAgentModelOptions(extractCmd, {
-        includeModel: false,
-        agentDescription: 'Coding agent for composition mapping resolution (claude|codex|opencode|cursor)',
-    })
-        .option('--composition-agent-mode <mode>', "Agent resolution mode: 'parser' (agent writes a sandboxed parser — deterministic, default) or 'edges' (agent lists edges directly)", 'parser')
-        .action(async (opts) => {
-        const resolveUnreachable = (() => {
-            const v = opts.resolveUnreachable ?? 'auto';
-            if (v !== 'auto' && v !== 'always' && v !== 'never') {
-                process.stderr.write(`Error: --resolve-unreachable must be one of 'auto', 'always', 'never' (got '${v}')\n`);
-                process.exit(1);
-            }
-            return v;
-        })();
-        const projectRoot = resolve(opts.project);
-        const outDir = join(projectRoot, '.contentful');
-        let sourceDirectory;
-        if (opts.dir !== undefined) {
-            sourceDirectory = resolveFromProjectRoot(projectRoot, opts.dir);
-            if (!(await pathExists(sourceDirectory))) {
-                process.stderr.write(`Error: source directory does not exist: ${sourceDirectory}\n`);
-                process.exit(1);
-            }
-        }
-        else {
-            const srcPath = resolveFromProjectRoot(projectRoot, 'src');
-            sourceDirectory = (await pathExists(srcPath)) ? srcPath : projectRoot;
-        }
-        const sourceFiles = await collectSourceFiles(sourceDirectory, (count) => {
-            if (!process.stdout.isTTY) {
-                process.stderr.write(`progress=scan:${count}\n`);
-            }
-        });
-        const extraction = await extractComponents(sourceFiles, ({ filesProcessed, componentsFound }) => {
-            if (!process.stdout.isTTY) {
-                process.stderr.write(`progress=extract:${filesProcessed}/${sourceFiles.length}:${componentsFound}\n`);
-            }
-        }, { resolveUnreachable, projectRoot });
-        await mkdir(outDir, { recursive: true });
-        const db = openPipelineDb();
-        const { sessionId } = getOrCreateSession(db, undefined, undefined, {
-            command: 'analyze extract',
-            inputPath: projectRoot,
-            outDir,
-        });
-        await bindAnalyticsSessionId(sessionId);
-        if (!isPipelineAnalyticsChild()) {
-            await emitSessionStarted('analyze_extract');
-        }
-        const stepId = createStep(db, sessionId, 'analyze extract', {
-            project: projectRoot,
-        });
-        const classifiedComponents = extraction.components.map(preClassifyComponent);
-        const inspectedComponents = await Promise.all(classifiedComponents.map(async (component) => ({
-            component,
-            inspection: await inspectComponentSource(component),
-        })));
-        const filteredComponents = [];
-        const filterWarnings = [];
-        for (const { component, inspection } of inspectedComponents) {
-            const verdict = isNonAuthorableComponent(component);
-            const keepDespiteZeroSurface = verdict.skip && verdict.reason === 'component has no props and no slots' && inspection.keepDespiteZeroSurface;
-            const retainedForReview = verdict.skip && !keepDespiteZeroSurface;
-            if (retainedForReview) {
-                filterWarnings.push(`${component.name}: requires operator review (${verdict.reason})`);
-            }
-            if (keepDespiteZeroSurface) {
-                filterWarnings.push(`${component.name}: retained despite 0 props/slots because the source renders visible or compositional UI`);
-            }
-            if (inspection.reviewReasons.length > 0) {
-                const reviewNotes = describeReviewReasons(inspection.reviewReasons)
-                    .filter((note) => note !== 'high-confidence data-fetch wrapper')
-                    .join('; ');
-                if (reviewNotes) {
-                    filterWarnings.push(`${component.name}: ${reviewNotes}`);
-                }
-            }
-            // Preserve any extractor-level review reasons (e.g. `props-type-unresolved`
-            // from the Svelte parser) by merging them into the post-processing recompute.
-            // Without this, recomputing here clobbers the per-extractor signal.
-            const extractorReasons = component.reviewReasons ?? [];
-            const nonAuthorableReason = retainedForReview ? [`non-authorable:${verdict.reason}`] : [];
-            const { confidence, reasons } = computeExtractionScore(component, {
-                additionalIssueCount: wrapperConfidenceToIssueCount(inspection.wrapperConfidence) +
-                    extractorReasons.length +
-                    nonAuthorableReason.length,
-                additionalReasons: [...extractorReasons, ...inspection.reviewReasons, ...nonAuthorableReason],
-            });
-            filteredComponents.push({
-                ...component,
-                extractionConfidence: confidence,
-                reviewReasons: reasons,
-                needsReview: deriveNeedsReview(confidence) ||
-                    inspection.wrapperConfidence >= 4 ||
-                    inspection.keepDespiteZeroSurface ||
-                    retainedForReview ||
-                    // An extractor-level type-resolution failure is a strong signal regardless
-                    // of the otherwise-derived confidence threshold; force review.
-                    extractorReasons.includes('props-type-unresolved') ||
-                    (component.needsReview ?? false),
-            });
-        }
-        let validatedComponents = validateExtractedComponents(filteredComponents);
-        // Composition mapping resolution (spec U2). Only in composite mode and
-        // only when a source is provided (user map / agent opt-in).
-        // Atomic (default) never resolves — it would only be stripped later.
-        const compositionMode = resolveCompositionMode(opts, (await safeReadCompositionMode()) ?? undefined);
-        if (compositionMode === 'composite') {
-            const sources = resolveCompositionSources(opts);
-            const { overrides: promptOverrides, errors: promptErrors } = parsePromptOverrides(opts.prompt ?? []);
-            for (const err of promptErrors) {
-                process.stderr.write(`Error: ${err}\n`);
-                process.exit(1);
-            }
-            let compositionPrompt;
-            const compositionOverride = promptOverrides.get('composition');
-            if (compositionOverride) {
-                try {
-                    compositionPrompt = await resolvePromptOverride(compositionOverride);
-                }
-                catch (e) {
-                    process.stderr.write(`Error: ${e instanceof Error ? e.message : String(e)}\n`);
-                    process.exit(1);
-                }
-            }
-            let userMap;
-            if (opts.compositionMap) {
-                const loaded = await loadUserMap(opts.compositionMap);
-                if (!loaded.ok) {
-                    process.stderr.write(`Error: ${loaded.error}\n`);
-                    process.exit(1);
-                }
-                userMap = loaded.map;
-            }
-            const hasSource = !!userMap || sources.useAgent || sources.forceAgent;
-            if (hasSource || opts.generateMap) {
-                // Composition progress mirrors the scan/extract progress convention:
-                // emit `progress=composition:<phase>` on stderr so the wizard can
-                // render a second progress line during the (potentially slow, agent-
-                // backed) resolution instead of appearing frozen.
-                const emitCompositionProgress = (phase) => {
-                    if (!process.stdout.isTTY)
-                        process.stderr.write(`progress=composition:${phase}\n`);
-                };
-                emitCompositionProgress('resolving');
-                const allFiles = await readCandidateFiles(validatedComponents, sourceFiles);
-                // Decouple the two file sets (design: candidate-heuristic fragility):
-                //  - `promptFiles`: a bounded candidate SAMPLE inlined into the agent
-                //    prompt so it sees the convention without ingesting the whole repo.
-                //  - `allFiles`: EVERY scanned file, handed to the authored parser at
-                //    runtime. The parser is deterministic code — give it everything so
-                //    a candidate-filter miss can never starve it of a definition file.
-                const selectedCandidates = selectCandidateFiles(allFiles).map((c) => ({ path: c.path, content: c.content }));
-                // Cap the inlined set so a large design system can't overflow the
-                // agent's context window and fail resolution outright (see the budget
-                // constant). The runtime parser still sees EVERY file.
-                const capped = capCandidatesToPromptBudget(selectedCandidates);
-                let promptFiles = capped.kept;
-                if (capped.dropped.length > 0) {
-                    process.stderr.write(`Warning: composition — ${capped.dropped.length} candidate file(s) omitted from the agent prompt to fit the context budget; resolution runs on the ${promptFiles.length} highest-value files.\n`);
-                }
-                const runtimeFiles = allFiles.map((c) => ({ path: c.path, content: c.content }));
-                const resolverAgent = resolveCompositionAgentName(opts.agent);
-                const parserMode = (opts.compositionAgentMode ?? 'parser') !== 'edges';
-                const componentNameSet = new Set(validatedComponents.map((c) => c.name));
-                const cacheVersion = await getCliCacheVersion();
-                // Tracks the exit code of the most recent spawnAgent call so the
-                // caching sites can refuse to persist a failed run (a non-zero exit —
-                // e.g. a context-window overflow — otherwise poisons the cache and
-                // replays the error on every subsequent run).
-                let lastAgentExitCode = 0;
-                const spawnAgent = async (prompt) => {
-                    const res = await runAgent({
-                        agent: resolverAgent,
-                        prompt,
-                        timeoutMs: 120_000,
-                        promptViaStdin: true,
-                        onDebugEvent: (name, payload) => getDebugLogger().event('agent', name, payload),
-                    });
-                    lastAgentExitCode = res.exitCode;
-                    if (res.exitCode !== 0 && res.stderr.trim()) {
-                        process.stderr.write(`Warning: composition — agent exited ${res.exitCode}: ${res.stderr.trim()}\n`);
-                    }
-                    return res.stdout;
-                };
-                // Completeness critic: let the agent flag composition-relevant dirs
-                // the keyword filter missed (by path/name alone — cheap). It can only
-                // ADD to the prompt sample. Runs ONLY on a genuine authoring pass (see
-                // the cache-miss branch below) so a parser cache hit pays nothing.
-                const runCandidateCritic = async () => {
-                    const critic = await critiqueCandidates(runtimeFiles, promptFiles, async (dirs) => parseDirCriticReply(await spawnAgent(buildDirCriticPrompt(dirs)), dirs));
-                    if (critic.addedDirs.length > 0) {
-                        promptFiles = critic.files;
-                        if (process.env['EDS_DEBUG']) {
-                            process.stderr.write(`[composition-debug] critic added dirs: ${critic.addedDirs.join(', ')}\n`);
-                        }
-                    }
-                };
-                // Agent-authored parser path (default): the agent writes a sandboxed
-                // (ctx) => Edge[] parser we run deterministically, cached by parser
-                // SOURCE. Falls back to direct edge-emission if authoring fails.
-                let parserEdges;
-                if (sources.useAgent && parserMode) {
-                    const parserCacheKey = buildCompositionInputHash({
-                        files: runtimeFiles,
-                        agent: resolverAgent,
-                        kind: 'parser',
-                    });
-                    const cachedSource = opts.compositionRefresh
-                        ? null
-                        : lookupCompositionCache(db, parserCacheKey, cacheVersion);
-                    if (cachedSource !== null) {
-                        emitCompositionProgress('cache-hit');
-                        const ran = await runParserInSandbox(cachedSource, {
-                            files: runtimeFiles,
-                            componentNames: [...componentNameSet],
-                        });
-                        if (!ran.error) {
-                            parserEdges = ran.edges.filter((e) => e.parent !== e.child && componentNameSet.has(e.parent) && componentNameSet.has(e.child));
-                        }
-                    }
-                    if (parserEdges === undefined) {
-                        await runCandidateCritic();
-                        const pr = await resolveViaAgentParser({
-                            files: promptFiles,
-                            runtimeFiles,
-                            componentNames: componentNameSet,
-                            runAgentFn: ({ prompt }) => spawnAgent(prompt),
-                            ...(compositionPrompt ? { instructionOverride: compositionPrompt } : {}),
-                            onPhase: (phase) => emitCompositionProgress(phase),
-                            // The candidate filter selected these files because they carry
-                            // composition markers, so a clean 0-edge parse is suspicious —
-                            // let the resolver spend its one repair round on it.
-                            retryOnEmpty: promptFiles.length > 0,
-                        });
-                        for (const w of pr.warnings)
-                            process.stderr.write(`Warning: composition — ${w}\n`);
-                        if (!pr.usedFallback) {
-                            parserEdges = pr.edges;
-                            if (pr.parserSource && lastAgentExitCode === 0) {
-                                storeCompositionCache(db, parserCacheKey, cacheVersion, pr.parserSource);
-                            }
-                        }
-                        else {
-                            process.stderr.write('Warning: composition — parser mode failed; falling back to edge emission\n');
-                        }
-                    }
-                }
-                if (process.env['EDS_DEBUG'] && parserEdges) {
-                    process.stderr.write(`[composition-debug] prompt files: ${promptFiles.length}; runtime files: ${runtimeFiles.length}; componentNames: ${componentNameSet.size}; parser edges: ${parserEdges.length}\n`);
-                    for (const e of parserEdges)
-                        process.stderr.write(`[composition-debug]   edge ${e.parent} -> ${e.child}\n`);
-                }
-                // Manifest (Figma `manifest.json`)/doc (`AGENTS.md`) evidence — rank
-                // 4/5, deterministic (no LLM), runs over the FULL file set
-                // regardless of composition mode/agent settings since it's cheap
-                // and code/design-adjacent rather than agent-derived.
-                const manifestDocEdges = collectManifestDocEdges(runtimeFiles, validatedComponents, componentNameSet);
-                const extraEdges = [...(parserEdges ?? []), ...manifestDocEdges];
-                // Edge-emission cache (used for both explicit edges-mode and the
-                // parser-mode fallback). Keyed on prompt files + agent identity — the
-                // agent emits edges directly from what it reads in the prompt.
-                const agentCacheKey = buildCompositionInputHash({
-                    files: promptFiles,
-                    agent: resolverAgent,
-                    kind: 'edges',
-                });
-                const useEdgeEmission = sources.useAgent && parserEdges === undefined;
-                const result = await resolveMapping({
-                    components: validatedComponents,
-                    ...(userMap ? { userMap } : {}),
-                    ...(extraEdges.length > 0 ? { extraEdges } : {}),
-                    useAgent: useEdgeEmission,
-                    forceAgent: sources.forceAgent && useEdgeEmission,
-                    files: promptFiles,
-                    ...(compositionPrompt ? { promptOverride: compositionPrompt } : {}),
-                    runAgentFn: async ({ prompt }) => {
-                        if (!opts.compositionRefresh) {
-                            const cached = lookupCompositionCache(db, agentCacheKey, cacheVersion);
-                            if (cached !== null) {
-                                emitCompositionProgress('cache-hit');
-                                return cached;
-                            }
-                        }
-                        emitCompositionProgress(`agent:${resolverAgent}`);
-                        const stdout = await spawnAgent(prompt);
-                        if (lastAgentExitCode === 0) {
-                            storeCompositionCache(db, agentCacheKey, cacheVersion, stdout);
-                        }
-                        return stdout;
-                    },
-                });
-                emitCompositionProgress('done');
-                for (const w of result.warnings)
-                    process.stderr.write(`Warning: composition — ${w}\n`);
-                for (const c of result.conflicts) {
-                    process.stderr.write(`Warning: composition conflict on ${c.parent}→${c.child}: kept ${c.winner}, dropped ${c.loser}\n`);
-                }
-                validatedComponents = result.components;
-                if (opts.generateMap) {
-                    // Reflect the FULL resolved composition — typed-slot edges already
-                    // on the extracted components PLUS anything the resolver added — not
-                    // just the resolver's own contributed edges.
-                    const skeleton = componentsToInterchangeMap(validatedComponents);
-                    await writeFile(opts.generateMap, JSON.stringify(skeleton, null, 2) + '\n');
-                    process.stderr.write(`Wrote composition map skeleton to ${opts.generateMap}\n`);
-                }
-            }
-        }
-        storeRawComponents(db, sessionId, validatedComponents);
-        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 });
-        enrichCommandResult({ extracted_component_count: validatedComponents.length });
-        db.close();
-        const allWarnings = [...extraction.warnings, ...filterWarnings];
-        const { rows: componentRows, totalErrors } = buildAnalyzeViewRows(filteredComponents, validatedComponents, allWarnings);
-        // Split warnings: per-component (those whose prefix matches a surviving component name)
-        // are rendered under that component in the TUI; global ones (retry summaries,
-        // non-authorable skips, anything else) are rendered at the top of the warnings panel
-        // so they don't disappear into the count. `partitionGlobalWarnings` shares its
-        // matching rule with `buildAnalyzeViewRows` to keep the two halves symmetric.
-        const globalWarnings = partitionGlobalWarnings(allWarnings, componentRows.map((r) => r.name));
-        const analyzeResult = {
-            sourceDirectory,
-            sessionId,
-            fileCount: sourceFiles.length,
-            components: componentRows,
-            totalWarnings: allWarnings.length,
-            totalErrors,
-            globalWarnings,
-        };
-        if (getInteractiveTerminalSupport().supported) {
-            const { waitUntilExit } = render(createElement(AnalyzeView, {
-                result: analyzeResult,
-                onExit: () => void exitWithAnalytics(0),
-            }));
-            await waitUntilExit();
-        }
-        else {
-            const sessionLine = `session=${sessionId}\n`;
-            process.stdout.write(sessionLine);
-            const summaryLines = [
-                `Scanned ${pluralize(sourceFiles.length, 'source file')} in ${sourceDirectory}`,
-                `Extracted ${pluralize(extraction.components.length, 'component')}`,
-            ];
-            if (totalErrors > 0) {
-                summaryLines.push(`Errors (${totalErrors}):`);
-                for (const c of componentRows) {
-                    for (const e of c.errors) {
-                        summaryLines.push(`- ${c.name}: ${e}`);
-                    }
-                }
-            }
-            if (allWarnings.length > 0) {
-                summaryLines.push(`Warnings (${allWarnings.length}):`);
-                summaryLines.push(...allWarnings.map((w) => `- ${w}`));
-            }
-            else if (totalErrors === 0) {
-                summaryLines.push('Warnings: none');
-            }
-            process.stderr.write(summaryLines.join('\n') + '\n');
-            await exitWithAnalytics(0);
-        }
-    });
-    registerAnalyzeEditCommand(analyze);
-    registerAnalyzeSelectAgentCommand(analyze);
-}

package/dist/src/analyze/composition/agent-parser/author-prompt.js

@@ -1,22 +0,0 @@
-import { loadPrompt } from './load-prompt.js';
-/**
- * Build the prompt that asks the agent to WRITE a pure parser function (spec:
- * agent-authored-parser, Phase 2) rather than list edges. The static
- * instruction + contract live in `prompts/composition-parser.md`; this
- * appends the dynamic candidate files + component names. The authored parser
- * runs in the sandbox (sandbox.ts), so the contract forbids all I/O.
- */
-const PROMPT_FILE = 'composition-parser.md';
-export function buildAuthorPrompt(files, componentNames, instructionOverride) {
-    const fileBlocks = files.map((f) => `--- ${f.path} ---\n${f.content}`).join('\n\n');
-    const instruction = instructionOverride?.trim() ? instructionOverride.trim() : loadPrompt(PROMPT_FILE).trim();
-    return [
-        instruction,
-        '',
-        'Component names (use ONLY these):',
-        componentNames.join(', '),
-        '',
-        'Candidate files:',
-        fileBlocks,
-    ].join('\n');
-}

package/dist/src/analyze/composition/agent-parser/extract-parser.js

@@ -1,44 +0,0 @@
-/**
- * Pull the parser function source out of the agent's stdout (spec:
- * agent-authored-parser, Phase 2). Agents typically wrap code in a fenced
- * block, but often emit a non-parser block first (a JSON sample, prose). We
- * return the first block that is actually SHAPED like the contract — a
- * default-exported function taking one param — so a stray sample never reaches
- * the sandbox. Lenient by design: no parser-shaped source → null → caller
- * falls back.
- */
-const FENCE = /```(?:[a-zA-Z]+)?\n([\s\S]*?)```/g;
-/**
- * Cheap structural check that source matches the parser contract:
- * `export default` of a function (declaration or arrow) that takes at least
- * one parameter. Not a full parse — just enough to reject JSON samples, prose,
- * and no-arg functions before we spend a sandbox spawn on them.
- */
-export function looksLikeParser(source) {
-    const s = source.trim();
-    if (!/export\s+default\b/.test(s))
-        return false;
-    // export default function [name] (param...) { ... }
-    const fnDecl = /export\s+default\s+(?:async\s+)?function\b[^(]*\(\s*[A-Za-z_$][\w$]*/;
-    // export default (param...) => ...   OR   export default param => ...
-    const arrow = /export\s+default\s+(?:async\s+)?(?:\(\s*[A-Za-z_$][\w$]*|[A-Za-z_$][\w$]*\s*=>)/;
-    return fnDecl.test(s) || arrow.test(s);
-}
-export function extractParserSource(stdout) {
-    FENCE.lastIndex = 0;
-    let m;
-    while ((m = FENCE.exec(stdout)) !== null) {
-        const candidate = m[1].trim();
-        if (candidate !== '' && looksLikeParser(candidate))
-            return candidate;
-    }
-    // No parser-shaped fenced block — accept bare source only if it, too, is
-    // shaped like the contract.
-    const idx = stdout.indexOf('export default');
-    if (idx !== -1) {
-        const bare = stdout.slice(idx).trim();
-        if (looksLikeParser(bare))
-            return bare;
-    }
-    return null;
-}