@contentful/experience-design-system-generation 2.36.2-dev-build-d983d04c.0 → 2.36.2-dev-build-dc6fb2aa.0

package/dist/src/services/parsing/parse-prop-tool-calls.js

@@ -0,0 +1,91 @@
+import { readToolCallObjects } from './helpers/read-tool-call-objects.js';
+const VALID_TOOL_NAMES = new Set(['classify_prop', 'exclude_prop', 'classify_component', 'classify_slot']);
+const VALID_CDF_TYPES = new Set(['string', 'richtext', 'media', 'enum', 'token', 'boolean']);
+const VALID_CATEGORIES = new Set(['content', 'design', 'state']);
+export function parsePropToolCallLines(stdout) {
+    const calls = [];
+    const { objects, warnings } = readToolCallObjects(stdout);
+    for (const rec of objects) {
+        if (!VALID_TOOL_NAMES.has(rec.tool)) {
+            warnings.push(`unknown tool: ${String(rec.tool)}`);
+            continue;
+        }
+        const tool = rec.tool;
+        if (tool === 'classify_prop') {
+            if (typeof rec.prop !== 'string' || !rec.prop) {
+                warnings.push('classify_prop missing prop name — skipped');
+                continue;
+            }
+            if (typeof rec.cdf_type !== 'string' || !VALID_CDF_TYPES.has(rec.cdf_type)) {
+                warnings.push(`classify_prop '${rec.prop}': invalid cdf_type '${String(rec.cdf_type)}' — skipped`);
+                continue;
+            }
+            if (typeof rec.cdf_category !== 'string' || !VALID_CATEGORIES.has(rec.cdf_category)) {
+                warnings.push(`classify_prop '${rec.prop}': invalid cdf_category '${String(rec.cdf_category)}' — skipped`);
+                continue;
+            }
+            const call = {
+                tool: 'classify_prop',
+                prop: rec.prop,
+                cdf_type: rec.cdf_type,
+                cdf_category: rec.cdf_category,
+            };
+            if (Array.isArray(rec.values) && rec.values.every((v) => typeof v === 'string'))
+                call.values = rec.values;
+            if (typeof rec.token_kind === 'string')
+                call.token_kind = rec.token_kind;
+            if (typeof rec.required === 'boolean')
+                call.required = rec.required;
+            if (typeof rec.description === 'string')
+                call.description = rec.description;
+            if (typeof rec.default === 'string' || typeof rec.default === 'boolean')
+                call.default = rec.default;
+            if (typeof rec.reason === 'string')
+                call.reason = rec.reason;
+            calls.push(call);
+        }
+        else if (tool === 'exclude_prop') {
+            if (typeof rec.prop !== 'string' || !rec.prop) {
+                warnings.push('exclude_prop missing prop name — skipped');
+                continue;
+            }
+            calls.push({ tool: 'exclude_prop', prop: rec.prop, reason: typeof rec.reason === 'string' ? rec.reason : '' });
+        }
+        else if (tool === 'classify_component') {
+            const call = { tool: 'classify_component' };
+            if (typeof rec.description === 'string')
+                call.description = rec.description;
+            if (typeof rec.rationale === 'object' && rec.rationale !== null) {
+                const r = rec.rationale;
+                const rationale = {};
+                if (typeof r.description === 'string')
+                    rationale.description = r.description;
+                if (typeof r.props === 'string')
+                    rationale.props = r.props;
+                if (typeof r.slots === 'string')
+                    rationale.slots = r.slots;
+                if (Object.keys(rationale).length > 0)
+                    call.rationale = rationale;
+            }
+            calls.push(call);
+        }
+        else if (tool === 'classify_slot') {
+            if (typeof rec.slot !== 'string' || !rec.slot) {
+                warnings.push('classify_slot missing slot name — skipped');
+                continue;
+            }
+            const call = { tool: 'classify_slot', slot: rec.slot };
+            if (typeof rec.required === 'boolean')
+                call.required = rec.required;
+            if (Array.isArray(rec.allowed_components) && rec.allowed_components.every((v) => typeof v === 'string')) {
+                call.allowed_components = rec.allowed_components;
+            }
+            if (typeof rec.description === 'string')
+                call.description = rec.description;
+            if (typeof rec.rationale === 'string')
+                call.rationale = rec.rationale;
+            calls.push(call);
+        }
+    }
+    return { calls, warnings };
+}

package/dist/src/services/parsing/parse-select-tool-calls.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedSelectToolCalls } from '../../types/tool-calls.js';
+export declare function parseSelectToolCallLines(stdout: string): ParsedSelectToolCalls;

package/dist/src/services/parsing/parse-select-tool-calls.js

@@ -0,0 +1,27 @@
+import { readToolCallObjects } from './helpers/read-tool-call-objects.js';
+const VALID_SELECT_TOOL_NAMES = new Set(['select_component', 'reject_component']);
+export function parseSelectToolCallLines(stdout) {
+    const calls = [];
+    const { objects, warnings } = readToolCallObjects(stdout);
+    for (const rec of objects) {
+        if (!VALID_SELECT_TOOL_NAMES.has(rec.tool))
+            continue;
+        if (typeof rec.name !== 'string' || !rec.name) {
+            warnings.push(`${String(rec.tool)} missing name — skipped`);
+            continue;
+        }
+        const call = { tool: rec.tool, name: rec.name };
+        if (typeof rec.reason === 'string')
+            call.reason = rec.reason;
+        if (typeof rec.confidence === 'number' && rec.confidence >= 1 && rec.confidence <= 5) {
+            if (call.tool === 'select_component') {
+                call.confidence = rec.confidence;
+            }
+            else {
+                call.confidence = rec.confidence;
+            }
+        }
+        calls.push(call);
+    }
+    return { calls, warnings };
+}

package/dist/src/services/parsing/parse-token-tool-calls.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedTokenToolCalls } from '../../types/tool-calls.js';
+export declare function parseTokenToolCallLines(stdout: string): ParsedTokenToolCalls;

package/dist/src/services/parsing/parse-token-tool-calls.js

@@ -0,0 +1,39 @@
+import { readToolCallObjects } from './helpers/read-tool-call-objects.js';
+const VALID_TOKEN_TOOL_NAMES = new Set(['set_token', 'set_group']);
+export function parseTokenToolCallLines(stdout) {
+    const calls = [];
+    const { objects, warnings } = readToolCallObjects(stdout);
+    for (const rec of objects) {
+        if (!VALID_TOKEN_TOOL_NAMES.has(rec.tool))
+            continue;
+        if (rec.tool === 'set_token') {
+            if (typeof rec.path !== 'string' || !rec.path) {
+                warnings.push('set_token missing path — skipped');
+                continue;
+            }
+            if (typeof rec.type !== 'string' || !rec.type) {
+                warnings.push(`set_token '${rec.path}': missing type — skipped`);
+                continue;
+            }
+            if (!('value' in rec)) {
+                warnings.push(`set_token '${rec.path}': missing value — skipped`);
+                continue;
+            }
+            const call = { tool: 'set_token', path: rec.path, type: rec.type, value: rec.value };
+            if (typeof rec.description === 'string')
+                call.description = rec.description;
+            calls.push(call);
+        }
+        else if (rec.tool === 'set_group') {
+            if (typeof rec.path !== 'string' || !rec.path) {
+                warnings.push('set_group missing path — skipped');
+                continue;
+            }
+            const call = { tool: 'set_group', path: rec.path };
+            if (typeof rec.description === 'string')
+                call.description = rec.description;
+            calls.push(call);
+        }
+    }
+    return { calls, warnings };
+}

package/dist/src/services/prompts/build-prompt.d.ts

@@ -0,0 +1,4 @@
+import type { PromptOptions, Skill } from '../../types/prompt.js';
+export { resolveSkillPath, formatCustomPromptBanner } from './helpers/resolve-skill-file.js';
+export type { Skill };
+export declare function buildPrompt(options: PromptOptions): Promise<string>;

package/dist/src/services/prompts/build-prompt.js

@@ -0,0 +1,8 @@
+import { readSkillFile } from './helpers/resolve-skill-file.js';
+import { buildPreamble } from './helpers/build-preamble.js';
+export { resolveSkillPath, formatCustomPromptBanner } from './helpers/resolve-skill-file.js';
+export async function buildPrompt(options) {
+    const skillContent = options.skillContentOverride ?? (await readSkillFile(options.skill, options.skillPathOverride));
+    const preamble = buildPreamble(options);
+    return `${preamble}\n\nSkill instructions follow:\n---\n${skillContent}`;
+}

package/dist/src/services/prompts/helpers/build-preamble.d.ts

@@ -0,0 +1,2 @@
+import type { PromptOptions } from '../../../types/prompt.js';
+export declare function buildPreamble(options: PromptOptions): string;

package/dist/src/services/prompts/helpers/build-preamble.js

@@ -0,0 +1,48 @@
+import { inferFenceLang, filterDesignTokenProps, buildTokenCandidateSections } from './format-token-candidates.js';
+import { formatSourceRefsSection } from './format-source-refs.js';
+import { buildComponentsAutonomousPreamble, buildSelectAutonomousPreamble, buildMapTokensAutonomousPreamble, buildTokensAutonomousPreamble, } from './build-skill-preambles.js';
+export function buildPreamble(options) {
+    const { skill, rawComponentsInline, rawTokensInline, rawTokensFilename, tokensInline, tokenMapInline, generatedCdf, tokenTree, componentSourceRefs, existingComponentsInline, existingTokensInline, componentAllowlistInline, } = options;
+    const sections = [];
+    if (existingComponentsInline) {
+        sections.push(`Existing components in the target Contentful space (JSON) — use for alignment, not as a hard filter:\n\`\`\`json\n${existingComponentsInline}\n\`\`\``);
+    }
+    if (existingTokensInline) {
+        sections.push(`Existing design tokens in the target Contentful space (JSON) — prefer binding to these paths over inventing new ones:\n\`\`\`json\n${existingTokensInline}\n\`\`\``);
+    }
+    if (componentAllowlistInline) {
+        sections.push(`Known component names for slot allowed_components (hard allowlist; never use any other name):\n\`\`\`json\n${componentAllowlistInline}\n\`\`\``);
+    }
+    if (rawComponentsInline) {
+        sections.push(`Raw component data (JSON):\n\`\`\`json\n${rawComponentsInline}\n\`\`\``);
+    }
+    if (rawTokensInline) {
+        const lang = inferFenceLang(rawTokensFilename);
+        const label = rawTokensFilename ? `Raw token source (${rawTokensFilename})` : 'Raw token source';
+        sections.push(`${label}:\n\`\`\`${lang}\n${rawTokensInline}\n\`\`\``);
+    }
+    if (tokensInline) {
+        sections.push(`DTCG token data (for token kind lookups):\n\`\`\`json\n${tokensInline}\n\`\`\``);
+    }
+    if (tokenMapInline) {
+        sections.push(`Token-name sidecar (raw name → DTCG path):\n\`\`\`json\n${tokenMapInline}\n\`\`\``);
+    }
+    const filteredTokenProps = generatedCdf ? filterDesignTokenProps(generatedCdf) : undefined;
+    if (filteredTokenProps && Object.keys(filteredTokenProps.filtered).length > 0) {
+        sections.push(`Generated CDF so far — design-category token props only (JSON):\n\`\`\`json\n${JSON.stringify(filteredTokenProps.filtered)}\n\`\`\``);
+    }
+    if (tokenTree) {
+        sections.push(...buildTokenCandidateSections(tokenTree, filteredTokenProps));
+    }
+    if (componentSourceRefs && componentSourceRefs.length > 0) {
+        sections.push(...formatSourceRefsSection(componentSourceRefs, skill));
+    }
+    const inputBlock = sections.length > 0 ? `\n\n${sections.join('\n\n')}` : '';
+    if (skill === 'components')
+        return buildComponentsAutonomousPreamble(inputBlock);
+    if (skill === 'select')
+        return buildSelectAutonomousPreamble(inputBlock);
+    if (skill === 'map-tokens')
+        return buildMapTokensAutonomousPreamble(inputBlock);
+    return buildTokensAutonomousPreamble(inputBlock);
+}

package/dist/src/services/prompts/helpers/build-skill-preambles.d.ts

@@ -0,0 +1,4 @@
+export declare function buildComponentsAutonomousPreamble(inputBlock: string): string;
+export declare function buildSelectAutonomousPreamble(inputBlock: string): string;
+export declare function buildMapTokensAutonomousPreamble(inputBlock: string): string;
+export declare function buildTokensAutonomousPreamble(inputBlock: string): string;

package/dist/src/services/prompts/helpers/build-skill-preambles.js

@@ -0,0 +1,126 @@
+export function buildComponentsAutonomousPreamble(inputBlock) {
+    return `You are running as part of the experience-design-system-cli generate pipeline in AUTONOMOUS mode. The developer is not present to answer questions.
+
+Context: You are classifying a React component for **Contentful Experience Orchestration**. The result is a Component Type — a schema that tells Contentful what a marketer can configure. Properties fall into three categories:
+- **design**: controls how the component looks (variant, size, color, layout toggles)
+- **content**: the data a content editor fills in (text, images, URLs, rich text)
+- **state**: runtime behavioral flags (disabled, loading, expanded, identifiers)
+
+Your task: classify every prop and slot in the component below. Apply all judgment calls yourself — do not pause to ask for confirmation. Include a "description" field on each tool call to document your reasoning so the developer can review it afterward.
+
+All input data is provided inline below — do not read any additional files.${inputBlock}
+
+## Output protocol
+
+Do NOT write any files or emit any JSON blobs. Instead, emit one JSON object per line to stdout for each classification decision. The CLI reads your stdout line by line and writes each decision directly to the pipeline database.
+
+The four tool calls you may emit are:
+
+\`\`\`
+{"tool":"classify_component","description":"<optional component-level description>","rationale":{"description":"<why this component is classified the way it is>","props":"<why these props were chosen>","slots":"<why these slots were chosen>"}}
+
+{"tool":"classify_prop","prop":"<propName>","cdf_type":"<type>","cdf_category":"<category>","required":<bool>,"description":"<short customer-facing description>","reason":"<full internal rationale; not customer-facing>","values":["a","b"],"token_kind":"color","default":"<value>"}
+
+{"tool":"exclude_prop","prop":"<propName>","reason":"<why excluded>"}
+
+{"tool":"classify_slot","slot":"<slotName>","required":<bool>,"allowed_components":["ComponentName"],"description":"<reason>","rationale":"<why this slot was kept in the catalog>"}
+\`\`\`
+
+Rules:
+- Emit exactly one JSON object per line. No multi-line JSON. No markdown fences around the lines.
+- Every prop in the input must have exactly one call: either classify_prop or exclude_prop.
+- Every slot in the input must have exactly one classify_slot call.
+- Valid cdf_type values: string, richtext, media, enum, token, boolean
+- Valid cdf_category values: content, design, state
+- For enum type, always include \`values\` (non-empty string array of the variant names the prop accepts).
+- For token type, always include \`token_kind\` (DTCG \$type, e.g. "color"). **Never emit \`values\` for \`cdf_type: "token"\` props** — an enum prop's list holds variant names; a token prop's list holds design token paths, produced separately and never by you. Emitting \`values\` on a token prop makes the definition invalid.
+- Never emit both "values" and "token_kind" on one prop.
+- \`enum\` vs \`token\` is decided by three questions answered in order from the source shown — never from the TypeScript type. Q1: does the component look the value up, switch on it, or have a vocabulary for it (\`tokens[x]\`, \`switch (variant)\`, \`allowedValues\`)? yes → \`enum\`, stop.
+- Q2: is the value written straight into a style or attribute (\`rx={radius}\`, \`padding: \${padding}\`)? no → not \`token\`, apply the type rules.
+- Q3: is there a design-token reference at that use — a \`tokens.*\` parameter default, a \`tokenReference\`, an inline \`tokens.*\` / \`var(--*)\`? yes → \`token\` (cite both lines in "reason"); no → \`string\`. "Ambiguity resolves to \`enum\`" applies only when Q1–Q3 cannot be answered from the source shown.
+- CSS design props (className, style, styles, positional/geometric props: top, bottom, left, right, rotation, offset, etc.) → classify_prop, cdf_type: "string", cdf_category: "design".
+- For \`classify_slot.allowed_components\`, use only exact names from the hard allowlist provided below. Never invent a child from an import, JSX element, type name, icon name, or implementation helper; if a child is not listed, omit it.
+- On classify_component, "rationale" fields are operator-facing (read-only) but may surface in customer-facing exports. The "rationale.description" field is subject to the description content rules in the skill prompt (no internal initiative names). "rationale.props" and "rationale.slots" describe your reasoning about scope; "classify_slot.rationale" explains why each slot was kept.
+- On classify_prop, "reason" is REQUIRED and is the LLM's internal rationale — shown to the developer reviewing the import, never to end-users. "description" is the customer-facing copy and is subject to the description content rules in the skill prompt. Keep them distinct: "description" is short and customer-facing; "reason" explains your reasoning in detail.
+- You may emit prose lines (not starting with {) anywhere — they are ignored by the parser and serve as your reasoning log.`;
+}
+export function buildSelectAutonomousPreamble(inputBlock) {
+    return `You are running as part of the experience-design-system-cli import pipeline in AUTONOMOUS mode. The developer is not present to answer questions.
+
+Your task: review the components provided below and decide whether each belongs in Contentful Experience Orchestration as a Component Type. The input is a JSON array — you may receive 1–N components in a single message. Emit one tool call per input component, named after the component. Apply all judgment calls yourself — do not pause to ask for confirmation. Include a brief "reason" to document your reasoning for each decision.
+
+Key rule: accept any component that renders visible UI — atoms, molecules, and organisms are all valid Component Types in Contentful Experience Orchestration. Reject only components that produce zero visual output: React hooks, pure context providers, A/B testing or variant-routing wrappers, analytics trackers, and security utilities. Do NOT reject a component because it has few props, is low-level, or has some A/B testing or personalization-related props mixed in — those props are handled in the generate step.
+
+All input data is provided inline below — do not read any additional files.${inputBlock}
+
+## Output protocol
+
+Do NOT write any files or emit any JSON blobs. Instead, emit JSON tool calls one per line to stdout. The CLI reads your stdout line by line.
+
+The two tool calls — emit exactly one per input component:
+
+\`\`\`
+{"tool":"select_component","name":"<ComponentName>","reason":"<brief reason>"}
+
+{"tool":"reject_component","name":"<ComponentName>","reason":"<brief reason>"}
+\`\`\`
+
+Rules:
+- Emit exactly one JSON object per line. No multi-line JSON. No markdown fences.
+- Emit exactly one tool call per input component. The "name" field must match a component name from the input array exactly. Tool calls may appear in any order.
+- You may emit prose lines (not starting with {) to reason before each tool call — they are ignored by the parser.`;
+}
+export function buildMapTokensAutonomousPreamble(inputBlock) {
+    return `You are running as part of the experience-design-system-cli generate pipeline in AUTONOMOUS mode. The developer is not present to answer questions.
+
+Context: The components below already have design-category, token-typed props (\`$token.kind\` set). Your task is to decide, from source evidence, whether to narrow each one to a restricted subset (\`token_allowed\`) of the tokens matching its \`$token.kind\`. Apply all judgment calls yourself — do not pause to ask for confirmation.
+
+All input data is provided inline below — do not read any additional files.${inputBlock}
+
+## Output protocol
+
+Do NOT write any files or emit any JSON blobs. Instead, emit one JSON object per line to stdout for each prop you narrow. The CLI reads your stdout line by line and writes each decision directly to the pipeline database.
+
+The one tool call you may emit:
+
+\`\`\`
+{"tool":"map_token_prop","component":"<ComponentName>","prop":"<propName>","token_allowed":["colors.brand.primary","colors.brand.secondary"]}
+\`\`\`
+
+Rules:
+- Emit exactly one JSON object per line. No multi-line JSON. No markdown fences around the lines.
+- Only emit a call for a prop that appears in the "Generated CDF so far" section.
+- Each "Token path index" section below is already scoped to one \`$token.kind\` — a prop only draws candidates from the section matching its own \`$token.kind\` (or the "full tree" section, for a prop with no \`$token.kind\`). Never cross sections, never emit a group/prefix path, and never invent a path — every entry in \`token_allowed\` must exist verbatim in the matching section.
+- \`token_allowed\` is required and must be non-empty when the call is emitted.
+- For the judgment call of whether a prop should be narrowed at all, follow the decision tree in the map-tokens skill file: it explains defaults vs. restrictions, misclassified variant-name props, and when to emit nothing.
+- You may emit prose lines (not starting with \`{\`) anywhere — they are ignored by the parser and serve as your reasoning log.`;
+}
+export function buildTokensAutonomousPreamble(inputBlock) {
+    return `You are running as part of the experience-design-system-cli generate pipeline in AUTONOMOUS mode. The developer is not present to answer questions.
+
+Your task: classify every raw token from the input below into a DTCG token tree. Apply all judgment calls yourself — do not pause to ask for confirmation. Include a "description" field on each set_token call to document your reasoning.
+
+All input data is provided inline below — do not read any additional files.${inputBlock}
+
+## Output protocol
+
+Do NOT write any files or emit any JSON blobs. Instead, emit one JSON object per line to stdout for each token or group. The CLI reads your stdout line by line and writes each entry directly to the pipeline database.
+
+The two tool calls you may emit are:
+
+\`\`\`
+{"tool":"set_group","path":"<dot.notation.path>","description":"<optional group description>"}
+
+{"tool":"set_token","path":"<dot.notation.path>","type":"<DTCG type>","value":<value>,"description":"<reason>"}
+\`\`\`
+
+Rules:
+- Emit exactly one JSON object per line. No multi-line JSON. No markdown fences.
+- Emit a set_group call for every intermediate group node in the tree.
+- Emit a set_token call for every leaf token.
+- "path" is dot-notation, e.g. "colors.brand.primary" — no leading dots or slashes.
+- "type" must be one of the 13 valid DTCG types: color, dimension, fontFamily, fontWeight, duration, cubicBezier, number, strokeStyle, border, transition, shadow, gradient, typography.
+- "value" must be valid JSON (string, number, array, or object depending on the type). Do NOT wrap it in quotes if it is a complex type.
+- Emit set_group calls before the set_token calls that fall under them.
+- You may emit prose lines (not starting with {) anywhere — they are ignored by the parser and serve as your reasoning log.`;
+}

package/dist/src/services/prompts/helpers/format-source-refs.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentSourceRef, Skill } from '../../../types/prompt.js';
+export declare function formatSourceRefsSection(refs: ComponentSourceRef[], skill: Skill): string[];

package/dist/src/services/prompts/helpers/format-source-refs.js

@@ -0,0 +1,31 @@
+import { inferFenceLang } from './format-token-candidates.js';
+function formatSourceRefBlock(ref) {
+    const mainBlock = `#### ${ref.component} (\`${ref.sourcePath}\`)\n\`\`\`${inferFenceLang(ref.sourcePath)}\n${ref.content}\n\`\`\``;
+    const siblingBlocks = (ref.siblingFiles ?? []).map((sibling) => `##### ${ref.component} — imported file \`${sibling.path}\`\n\`\`\`${inferFenceLang(sibling.path)}\n${sibling.content}\n\`\`\``);
+    const truncationNote = ref.truncatedSiblingCount && ref.truncatedSiblingCount > 0
+        ? [
+            `##### ${ref.component} — +${ref.truncatedSiblingCount} more imported file${ref.truncatedSiblingCount === 1 ? '' : 's'} not shown (evidence may be incomplete)`,
+        ]
+        : [];
+    const notShownNote = ref.usesNotShown && ref.usesNotShown.length > 0
+        ? [
+            `##### ${ref.component} — uses not shown: ${ref.usesNotShown.join(', ')}\n\nThe files above are excerpts, and each of these properties has at least one use that fell outside the excerpt budget. Treat their consumption as unknown, not absent: do not classify them \`token\` on what is shown, and do not conclude they are unread.`,
+        ]
+        : [];
+    return [mainBlock, ...siblingBlocks, ...truncationNote, ...notShownNote].join('\n\n');
+}
+export function formatSourceRefsSection(refs, skill) {
+    const sections = [];
+    const withContent = refs.filter((ref) => ref.content != null);
+    const withoutContent = refs.filter((ref) => ref.content == null);
+    if (withContent.length > 0) {
+        sections.push(`### Component source references\n\n${withContent.map(formatSourceRefBlock).join('\n\n')}`);
+    }
+    if (withoutContent.length > 0) {
+        const guidance = skill === 'components'
+            ? 'there is no consumption evidence for these, so `token` cannot be earned for any of their props — classify from the prop signature alone, and any prop that would otherwise be enum-versus-token is `enum` (or `string`)'
+            : 'there is no source evidence to narrow from — emit nothing for their props';
+        sections.push(`Component source unavailable for (JSON) — ${guidance}:\n\`\`\`json\n${JSON.stringify(withoutContent.map((ref) => ({ component: ref.component, sourcePath: ref.sourcePath })))}\n\`\`\``);
+    }
+    return sections;
+}

package/dist/src/services/prompts/helpers/format-token-candidates.d.ts

@@ -0,0 +1,8 @@
+import type { GeneratedCdf } from '../../../types/prompt.js';
+export declare function inferFenceLang(filename: string | undefined): string;
+export declare function filterDesignTokenProps(cdf: GeneratedCdf): {
+    filtered: GeneratedCdf;
+    kinds: string[];
+    hasUnscoped: boolean;
+};
+export declare function buildTokenCandidateSections(tokenTree: Record<string, unknown>, filteredTokenProps?: ReturnType<typeof filterDesignTokenProps>): string[];

package/dist/src/services/prompts/helpers/format-token-candidates.js

@@ -0,0 +1,80 @@
+import { flattenDTCG } from '@contentful/experience-design-system-types';
+export function inferFenceLang(filename) {
+    if (!filename)
+        return 'json';
+    const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+    const map = {
+        js: 'js',
+        mjs: 'js',
+        cjs: 'js',
+        ts: 'ts',
+        mts: 'ts',
+        cts: 'ts',
+        tsx: 'tsx',
+        jsx: 'jsx',
+        vue: 'vue',
+        svelte: 'svelte',
+        astro: 'astro',
+        scss: 'scss',
+        sass: 'scss',
+        css: 'css',
+        json: 'json',
+        json5: 'json',
+    };
+    return map[ext] ?? 'text';
+}
+export function filterDesignTokenProps(cdf) {
+    const result = {};
+    const kinds = new Set();
+    let hasUnscoped = false;
+    for (const [componentName, component] of Object.entries(cdf)) {
+        const properties = component.$properties;
+        if (!properties)
+            continue;
+        const filteredProps = {};
+        for (const [propName, prop] of Object.entries(properties)) {
+            if (prop.$type === 'token' && prop.$category === 'design') {
+                const { '$token.allowed': _tokenAllowed, ...rest } = prop;
+                filteredProps[propName] = rest;
+                const kind = prop['$token.kind'];
+                if (typeof kind === 'string' && kind.length > 0) {
+                    kinds.add(kind);
+                }
+                else {
+                    hasUnscoped = true;
+                }
+            }
+        }
+        if (Object.keys(filteredProps).length > 0) {
+            result[componentName] = { ...component, $properties: filteredProps };
+        }
+    }
+    return { filtered: result, kinds: [...kinds].sort(), hasUnscoped };
+}
+export function buildTokenCandidateSections(tokenTree, filteredTokenProps) {
+    const index = flattenDTCG(tokenTree, '').sort((a, b) => a.path.localeCompare(b.path));
+    if (index.length === 0)
+        return [];
+    const sections = [];
+    const renderSection = (kind, entries) => {
+        const label = kind
+            ? `Token path index — ${kind} candidates only`
+            : 'Token path index — full tree (no $token.kind to scope by)';
+        const lines = entries.map((e) => `${e.path} · ${e.$type}`).join('\n');
+        return `${label}, one leaf token per line as \`path · type\`, no \`$value\`:\n${lines}`;
+    };
+    if (filteredTokenProps) {
+        const { kinds, hasUnscoped } = filteredTokenProps;
+        for (const kind of kinds) {
+            const scoped = index.filter((e) => e.$type === kind);
+            if (scoped.length > 0)
+                sections.push(renderSection(kind, scoped));
+        }
+        if (hasUnscoped)
+            sections.push(renderSection(null, index));
+    }
+    else {
+        sections.push(renderSection(null, index));
+    }
+    return sections;
+}

package/dist/src/services/prompts/helpers/resolve-skill-file.d.ts

@@ -0,0 +1,4 @@
+import type { Skill } from '../../../types/prompt.js';
+export declare function resolveSkillPath(skill: Skill): string;
+export declare function formatCustomPromptBanner(skill: 'components' | 'select', path: string): string;
+export declare function readSkillFile(skill: Skill, override?: string): Promise<string>;

package/dist/src/services/prompts/helpers/resolve-skill-file.js

@@ -0,0 +1,49 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const SKILL_FILES = {
+    components: 'generate-components.md',
+    tokens: 'generate-tokens.md',
+    select: 'select-components.md',
+    'map-tokens': 'map-tokens.md',
+};
+export function resolveSkillPath(skill) {
+    if (!(skill in SKILL_FILES))
+        throw new Error(`Invalid skill: ${skill}`);
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    let dir = thisDir;
+    for (;;) {
+        const candidate = join(dir, 'skills');
+        if (existsSync(candidate))
+            return join(candidate, SKILL_FILES[skill]);
+        const parent = resolve(dir, '..');
+        if (parent === dir) {
+            throw new Error(`skill file missing from CLI installation (could not locate skills/ directory from: ${thisDir})`);
+        }
+        dir = parent;
+    }
+}
+export function formatCustomPromptBanner(skill, path) {
+    return (`WARNING: Custom prompt active for ${skill}: ${path}\n` +
+        `  Bundled invariants (utility-wrapper rejection, description content rules) do NOT apply.\n` +
+        `  You are responsible for the prompt's correctness.\n`);
+}
+export async function readSkillFile(skill, override) {
+    if (override) {
+        const skillPath = resolve(override);
+        try {
+            return await readFile(skillPath, 'utf8');
+        }
+        catch {
+            throw new Error(`custom prompt file not found (skill: ${skill}, path: ${skillPath})`);
+        }
+    }
+    const skillPath = resolveSkillPath(skill);
+    try {
+        return await readFile(skillPath, 'utf8');
+    }
+    catch {
+        throw new Error(`skill file missing from CLI installation — try reinstalling the CLI (looked for: ${skillPath})`);
+    }
+}

package/dist/src/types/agent.d.ts

@@ -0,0 +1,10 @@
+import type { AgentName } from '../agent-names.js';
+export type { AgentName };
+export interface AgentRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+export type AgentAuthStatus = 'ok' | 'unauthenticated' | 'not-found';
+export type AgentDebugEvent = (name: string, payload?: Record<string, unknown>) => void;

package/dist/src/types/agent.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/contract.d.ts

@@ -0,0 +1,24 @@
+import type { AgentName } from '../agent-names.js';
+import type { AgentAuthStatus, AgentDebugEvent } from './agent.js';
+import type { PromptOptions } from './prompt.js';
+export interface GenerationEndpointRequest {
+    readonly agent: AgentName;
+    readonly model?: string;
+    readonly bedrock?: boolean;
+    readonly promptOptions: PromptOptions;
+    readonly timeoutMs: number;
+    readonly onOutput?: (chunk: string) => void;
+}
+export interface GenerationEndpointResponse {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly timedOut: boolean;
+}
+export interface GenerationEndpointOptions {
+    onDebugEvent?: AgentDebugEvent;
+}
+export interface GenerationEndpoint {
+    run(request: GenerationEndpointRequest): Promise<GenerationEndpointResponse>;
+    checkAuth(agent: AgentName): Promise<AgentAuthStatus>;
+}

package/dist/src/types/contract.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/invoker.d.ts

@@ -0,0 +1,17 @@
+import type { AgentName } from '../agent-names.js';
+import type { AgentAuthStatus, AgentDebugEvent, AgentRunResult } from './agent.js';
+export interface InvokeAgentOptions {
+    agent: AgentName;
+    model?: string;
+    bedrock?: boolean;
+    prompt: string;
+    timeoutMs: number;
+    onOutput?: (chunk: string) => void;
+}
+export interface AgentInvoker {
+    invoke(options: InvokeAgentOptions): Promise<AgentRunResult>;
+    checkAuth(agent: AgentName): Promise<AgentAuthStatus>;
+}
+export interface LocalCliAgentInvokerOptions {
+    onDebugEvent?: AgentDebugEvent;
+}

package/dist/src/types/invoker.js

@@ -0,0 +1 @@
+export {};