@contentful/experience-design-system-types 2.42.1-dev-build-f69db6bf.0 → 2.43.0-alpha.0

package/dist/src/cdf/validate.js

@@ -1,6 +1,12 @@
 import { Ajv } from 'ajv';
 import { cdfJsonSchema, CDF_SCHEMA_URL } from './schema.js';
 import { DESIGN_TOKEN_TYPES } from '../dtcg/token-types.js';
+import { CDFComponentSchema } from './types.js';
+import { validateCDFProperty } from './property-validation.js';
+import { validateRepresentationClosure } from './representation-validation.js';
+import { jsonValueIssue } from '../property-contract/json-value.js';
+import { componentDefinitionImportIssues } from '../property-contract/definition-import-rules.js';
+import { validateImportPrerequisites } from '../property-contract/import-prerequisites.js';
 const ajv = new Ajv({ allErrors: true });
 const validate = ajv.compile(cdfJsonSchema);
 const TOKEN_TYPE_SET = new Set(DESIGN_TOKEN_TYPES);
@@ -93,6 +99,9 @@ function entryErrors(node, prefix) {
     return errors;
 }
 export function validateCDF(input) {
+    const unsafe = jsonValueIssue(input);
+    if (unsafe)
+        return { valid: false, errors: [unsafe], components: [], tokens: [] };
     const valid = validate(input);
     if (!valid) {
         const focused = typeof input === 'object' && input !== null ? entryErrors(input, '') : [];
@@ -116,5 +125,26 @@ export function validateCDF(input) {
         };
     }
     const { components, tokens } = parseCDFComponents(file);
-    return { valid: true, errors: [], components, tokens };
+    const errors = [];
+    for (const component of components) {
+        if (!CDFComponentSchema.safeParse(component.entry).success) {
+            errors.push({ path: '/' + component.key, message: 'Invalid complete component metadata or source ownership' });
+            continue;
+        }
+        for (const [key, property] of Object.entries(component.entry.$properties)) {
+            for (const issue of validateCDFProperty(property).issues)
+                errors.push({ path: `/${component.key}/$properties/${key}${issue.path}`, message: issue.message });
+        }
+        errors.push(...componentDefinitionImportIssues(component.entry).map(({ path, message }) => ({
+            path: `/${component.key}${path}`,
+            message,
+        })));
+    }
+    errors.push(...validateRepresentationClosure(components));
+    if (!errors.length) {
+        const prerequisites = validateImportPrerequisites({ components, tokens });
+        if (!prerequisites.valid)
+            errors.push(...prerequisites.errors);
+    }
+    return { valid: !errors.length, errors, components, tokens };
 }

package/dist/src/cdf/vocabularies.d.ts

@@ -1,2 +1,2 @@
-export declare const CDF_PROPERTY_TYPES: readonly ["string", "richtext", "number", "media", "link", "enum", "token", "boolean"];
+export declare const CDF_PROPERTY_TYPES: readonly ["string", "richtext", "number", "media", "link", "token", "boolean", "array", "record", "Integer", "DateTime", "Literal", "RichText", "JSON", "ResourceLink", "DiscriminatedUnion"];
 export declare const CDF_PROPERTY_CATEGORIES: readonly ["content", "design", "state", "unattached"];

package/dist/src/cdf/vocabularies.js

@@ -4,8 +4,16 @@ export const CDF_PROPERTY_TYPES = [
     'number',
     'media',
     'link',
-    'enum',
     'token',
     'boolean',
+    'array',
+    'record',
+    'Integer',
+    'DateTime',
+    'Literal',
+    'RichText',
+    'JSON',
+    'ResourceLink',
+    'DiscriminatedUnion',
 ];
 export const CDF_PROPERTY_CATEGORIES = ['content', 'design', 'state', 'unattached'];

package/dist/src/config/index.js

@@ -18,11 +18,14 @@ export const configFilePath = () => join(configRoot(), 'config.json');
 export const runsFilePath = () => join(configRoot(), 'state', 'runs.json');
 export const debugSessionsDir = () => join(configRoot(), 'debug', 'sessions');
 export async function readSettings() {
+    const path = configFilePath();
     try {
-        return JSON.parse(await readFile(configFilePath(), 'utf8'));
+        return JSON.parse(await readFile(path, 'utf8'));
     }
-    catch {
-        return {};
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw new Error(`Unable to read settings at ${path}. Check the file contents and permissions.`, { cause: error });
     }
 }
 // Write-then-rename so a crash can never leave a half-written config.

package/dist/src/exploration/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const COMPONENT_SCOPES: readonly ["components-1", "components-2", "components-3", "components-4", "components-5", "components-6", "components-7"];
+export declare const CANDIDATE_FREE_SCOPES: readonly ["components-6", "components-7"];
+export declare const DETAIL_SCOPES: readonly ["full-inventory-1", "full-inventory-2", "full-inventory-3"];
+export declare const EXPLORE_SCOPES: readonly ["components-1", "components-2", "components-3", "components-4", "components-5", "components-6", "components-7", "full-inventory-1", "full-inventory-2", "full-inventory-3"];
+export declare const EXPLORE_MAX_ATTEMPTS = 6;
+/** @alias Shared agent-call limit under its general stage name. */
+export declare const AGENT_CALL_MAX_ATTEMPTS = 6;
+export declare const SUPERMAJORITY = 0.75;
+export declare const SLOT_THRESHOLD = 0.6;
+export declare const ABSENT = "__absent__";

package/dist/src/exploration/constants.js

@@ -0,0 +1,18 @@
+export const COMPONENT_SCOPES = [
+    'components-1',
+    'components-2',
+    'components-3',
+    'components-4',
+    'components-5',
+    'components-6',
+    'components-7',
+];
+export const CANDIDATE_FREE_SCOPES = ['components-6', 'components-7'];
+export const DETAIL_SCOPES = ['full-inventory-1', 'full-inventory-2', 'full-inventory-3'];
+export const EXPLORE_SCOPES = [...COMPONENT_SCOPES, ...DETAIL_SCOPES];
+export const EXPLORE_MAX_ATTEMPTS = 6;
+/** @alias Shared agent-call limit under its general stage name. */
+export const AGENT_CALL_MAX_ATTEMPTS = EXPLORE_MAX_ATTEMPTS;
+export const SUPERMAJORITY = 0.75;
+export const SLOT_THRESHOLD = 0.6;
+export const ABSENT = '__absent__';

package/dist/src/exploration/index.d.ts

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './types.js';
+export * from './schemas.js';

package/dist/src/exploration/index.js

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './types.js';
+export * from './schemas.js';

package/dist/src/exploration/schemas.d.ts

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { type JsonValue } from '../property-contract/json-value.js';
+import type { CDFPropertyDefinition } from '../cdf/types.js';
+import { type RepresentationProposalDraft } from '../property-contract/representation-proposal.js';
+export declare const VerifyEvidenceSchema: z.ZodObject<{
+    source: z.ZodString;
+    line: z.ZodString;
+    quote: z.ZodString;
+}, z.core.$strip>;
+export declare const SlotRestrictionSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        declared: "declared";
+        enforced: "enforced";
+    }>;
+    applicable: z.ZodBoolean;
+    evidence: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        line: z.ZodString;
+        quote: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ExplorePropReportSchema: z.ZodObject<{
+    name: z.ZodString;
+    category: z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        design: "design";
+        state: "state";
+        unattached: "unattached";
+    }>>;
+    type: z.ZodOptional<z.ZodString>;
+    definition: z.ZodOptional<z.ZodCustom<CDFPropertyDefinition, CDFPropertyDefinition>>;
+    values: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    observedValues: z.ZodOptional<z.ZodArray<z.ZodCustom<JsonValue, JsonValue>>>;
+    tokenKind: z.ZodOptional<z.ZodString>;
+    tokenPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    description: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    representationProposal: z.ZodOptional<z.ZodCustom<RepresentationProposalDraft, RepresentationProposalDraft>>;
+}, z.core.$strict>;
+export declare const ExploreSlotEvidenceSchema: z.ZodObject<{
+    name: z.ZodString;
+    sourceInput: z.ZodOptional<z.ZodCustom<{
+        schemaVersion: 1;
+        componentId: string;
+        componentDeclarationId: string;
+        rootSymbolId: string;
+        inputName: string;
+        inputPath: string[];
+    }, {
+        schemaVersion: 1;
+        componentId: string;
+        componentDeclarationId: string;
+        rootSymbolId: string;
+        inputName: string;
+        inputPath: string[];
+    }>>;
+    isRealSlot: z.ZodBoolean;
+    allowedComponents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    restriction: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            declared: "declared";
+            enforced: "enforced";
+        }>;
+        applicable: z.ZodBoolean;
+        evidence: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            line: z.ZodString;
+            quote: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ExploreCompanionSchema: z.ZodObject<{
+    agentRole: z.ZodEnum<{
+        "components-1": "components-1";
+        "components-2": "components-2";
+        "components-3": "components-3";
+        "components-4": "components-4";
+        "components-5": "components-5";
+        "components-6": "components-6";
+        "components-7": "components-7";
+        "full-inventory-1": "full-inventory-1";
+        "full-inventory-2": "full-inventory-2";
+        "full-inventory-3": "full-inventory-3";
+    }>;
+    components: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodString;
+        componentId: z.ZodOptional<z.ZodString>;
+        included: z.ZodOptional<z.ZodBoolean>;
+        inclusionReasoning: z.ZodOptional<z.ZodString>;
+        modelingNotes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        props: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            category: z.ZodOptional<z.ZodEnum<{
+                content: "content";
+                design: "design";
+                state: "state";
+                unattached: "unattached";
+            }>>;
+            type: z.ZodOptional<z.ZodString>;
+            definition: z.ZodOptional<z.ZodCustom<CDFPropertyDefinition, CDFPropertyDefinition>>;
+            values: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            observedValues: z.ZodOptional<z.ZodArray<z.ZodCustom<JsonValue, JsonValue>>>;
+            tokenKind: z.ZodOptional<z.ZodString>;
+            tokenPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+            description: z.ZodOptional<z.ZodString>;
+            reasoning: z.ZodOptional<z.ZodString>;
+            representationProposal: z.ZodOptional<z.ZodCustom<RepresentationProposalDraft, RepresentationProposalDraft>>;
+        }, z.core.$strict>>>;
+        slots: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            sourceInput: z.ZodOptional<z.ZodCustom<{
+                schemaVersion: 1;
+                componentId: string;
+                componentDeclarationId: string;
+                rootSymbolId: string;
+                inputName: string;
+                inputPath: string[];
+            }, {
+                schemaVersion: 1;
+                componentId: string;
+                componentDeclarationId: string;
+                rootSymbolId: string;
+                inputName: string;
+                inputPath: string[];
+            }>>;
+            isRealSlot: z.ZodBoolean;
+            allowedComponents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            reasoning: z.ZodOptional<z.ZodString>;
+            restriction: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    declared: "declared";
+                    enforced: "enforced";
+                }>;
+                applicable: z.ZodBoolean;
+                evidence: z.ZodArray<z.ZodObject<{
+                    source: z.ZodString;
+                    line: z.ZodString;
+                    quote: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    rawTokenReferences: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tokenPath: z.ZodString;
+        file: z.ZodString;
+        line: z.ZodNumber;
+        property: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const TierHypothesisSchema: z.ZodObject<{
+    disagreementIds: z.ZodArray<z.ZodString>;
+    hypothesis: z.ZodString;
+    tier: z.ZodEnum<{
+        factual: "factual";
+        interpretive: "interpretive";
+    }>;
+    tierReason: z.ZodString;
+    gatedOn: z.ZodOptional<z.ZodLiteral<"category">>;
+}, z.core.$strip>;
+export declare const VerifiedItemSchema: z.ZodObject<{
+    itemId: z.ZodString;
+    component: z.ZodString;
+    source: z.ZodString;
+    outcome: z.ZodEnum<{
+        confirmed: "confirmed";
+        resolved: "resolved";
+        conflicting: "conflicting";
+    }>;
+    resolved: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strip>>>;
+    evidence: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        line: z.ZodString;
+        quote: z.ZodString;
+    }, z.core.$strip>>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const EvidenceCheckSchema: z.ZodObject<{
+    checkId: z.ZodString;
+    itemId: z.ZodString;
+    component: z.ZodString;
+    source: z.ZodString;
+    verdict: z.ZodEnum<{
+        supports: "supports";
+        "does-not-support": "does-not-support";
+        unclear: "unclear";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strip>;

package/dist/src/exploration/schemas.js

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { EXPLORE_SCOPES } from './constants.js';
+import { SourceInputAssociationSchema } from '../source-input-association.js';
+import { validatePropertyDecisionMetadata } from '../property-contract/property-decision.js';
+import { jsonValueIssue, jsonEqual, own } from '../property-contract/json-value.js';
+import { validateCDFProperty, containsCDFDefinitionType, cdfToTarget } from '../cdf/property-validation.js';
+import { validateTargetValue } from '../property-contract/target-definition.js';
+import { validateProposalDraft, } from '../property-contract/representation-proposal.js';
+export const VerifyEvidenceSchema = z.object({
+    source: z.string().min(1),
+    line: z.string().min(1),
+    quote: z.string().min(1),
+});
+export const SlotRestrictionSchema = z.object({
+    kind: z.enum(['declared', 'enforced']),
+    applicable: z.boolean(),
+    evidence: z.array(VerifyEvidenceSchema).min(1),
+});
+export const ExplorePropReportSchema = z
+    .object({
+    name: z.string().refine((value) => value.trim().length > 0),
+    category: z.enum(['content', 'design', 'state', 'unattached']).optional(),
+    type: z.string().optional(),
+    definition: z.custom((value) => validateCDFProperty(value).valid).optional(),
+    values: z
+        .array(z.union([z.string(), z.number(), z.boolean()]))
+        .nonempty()
+        .optional(),
+    observedValues: z.array(z.custom((value) => !jsonValueIssue(value))).optional(),
+    tokenKind: z.string().optional(),
+    tokenPaths: z.array(z.string()).optional(),
+    required: z.boolean().optional(),
+    default: z.unknown().optional(),
+    description: z.string().optional(),
+    reasoning: z.string().optional(),
+    representationProposal: z
+        .custom((value) => validateProposalDraft(value).length === 0)
+        .optional(),
+})
+    .strict()
+    .superRefine((report, ctx) => {
+    if (report.type === 'DiscriminatedUnion' || report.definition !== undefined) {
+        const definition = report.definition;
+        if (!definition ||
+            !validateCDFProperty(definition).valid ||
+            !containsCDFDefinitionType(definition, 'DiscriminatedUnion') ||
+            definition.$type !== report.type ||
+            definition.$category !== report.category ||
+            report.category !== 'content' ||
+            ['values', 'tokenKind', 'tokenPaths', 'representationProposal'].some((key) => own(report, key)) ||
+            (own(report, 'required') && report.required !== (definition.$required ?? false)) ||
+            (own(report, 'description') && report.description !== definition.$description) ||
+            (own(report, 'default') &&
+                (validateTargetValue(cdfToTarget(definition), report.default).length ||
+                    (own(definition, '$default') && !jsonEqual(report.default, definition.$default)))))
+            ctx.addIssue({
+                code: 'custom',
+                path: ['definition'],
+                message: 'Union decisions require one complete consistent content definition',
+            });
+    }
+    for (const issue of validatePropertyDecisionMetadata(report, {
+        definition: report.definition,
+        representationProposal: report.representationProposal,
+    }))
+        ctx.addIssue({
+            code: 'custom',
+            path: issue.path
+                .split('/')
+                .slice(1)
+                .map((key) => key.replace(/~1/g, '/').replace(/~0/g, '~')),
+            message: issue.message,
+        });
+});
+export const ExploreSlotEvidenceSchema = z.object({
+    name: z.string().refine((value) => value.trim().length > 0),
+    sourceInput: z
+        .custom((value) => SourceInputAssociationSchema.safeParse(value).success)
+        .optional(),
+    isRealSlot: z.boolean(),
+    allowedComponents: z.array(z.string().refine((value) => value.trim().length > 0)).optional(),
+    evidence: z.array(z.string().refine((value) => value.trim().length > 0)).optional(),
+    required: z.boolean().optional(),
+    reasoning: z.string().optional(),
+    restriction: SlotRestrictionSchema.optional(),
+});
+export const ExploreCompanionSchema = z.object({
+    agentRole: z.enum(EXPLORE_SCOPES),
+    components: z.array(z.object({
+        name: z.string().refine((value) => value.trim().length > 0),
+        source: z.string().refine((value) => value.trim().length > 0),
+        componentId: z.string().optional(),
+        included: z.boolean().optional(),
+        inclusionReasoning: z.string().optional(),
+        modelingNotes: z.array(z.string().refine((value) => value.trim().length > 0)).optional(),
+        props: z.array(ExplorePropReportSchema).optional(),
+        slots: z.array(ExploreSlotEvidenceSchema).optional(),
+    })),
+    rawTokenReferences: z
+        .array(z.object({ tokenPath: z.string(), file: z.string(), line: z.number().int().positive(), property: z.string() }))
+        .optional(),
+});
+export const TierHypothesisSchema = z.object({
+    disagreementIds: z.array(z.string().min(1)).min(1),
+    hypothesis: z.string(),
+    tier: z.enum(['factual', 'interpretive']),
+    tierReason: z.string(),
+    gatedOn: z.literal('category').optional(),
+});
+export const VerifiedItemSchema = z.object({
+    itemId: z.string().min(1),
+    component: z.string().min(1),
+    source: z.string().min(1),
+    outcome: z.enum(['confirmed', 'resolved', 'conflicting']),
+    resolved: z.array(z.object({ path: z.string().min(1), value: z.unknown() })).optional(),
+    evidence: z.array(VerifyEvidenceSchema),
+    reason: z.string(),
+});
+export const EvidenceCheckSchema = z.object({
+    checkId: z.string().min(1),
+    itemId: z.string().min(1),
+    component: z.string().min(1),
+    source: z.string().min(1),
+    verdict: z.enum(['supports', 'does-not-support', 'unclear']),
+    reason: z.string(),
+});