dreative 0.5.1 → 0.5.2

package/dist/shared/ruleSystem.test.js

@@ -0,0 +1,187 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { validateRuleControls } from "./ruleSystem.js";
+const registry = JSON.parse(fs.readFileSync(path.resolve("skill/dreative/references/RULES.json"), "utf-8"));
+const reflex = JSON.parse(fs.readFileSync(path.resolve("skill/dreative/references/REFLEX_FONTS.json"), "utf-8"));
+const planned = "2026-01-01T00:00:00.000Z";
+const started = "2026-01-01T01:00:00.000Z";
+function basePlan(tier = "award") {
+    return {
+        version: 2,
+        doctrineVersion: 2,
+        request: "Create an ambitious archival experience",
+        createdAt: planned,
+        implementationStartedAt: started,
+        tier,
+        depth: "reimagine",
+        skills: ["ux", "mobile", "motion", "media"],
+        skillPolicy: { mode: "hybrid", global: ["ux", "mobile"], routingApproved: true, userAssignments: [] },
+        designRead: { register: "archival editorial", concept: "living catalog", signature: "transforming specimen" },
+        fontDecision: {
+            selected: "Source Serif 4",
+            candidates: [
+                { name: "Source Serif 4", reflex: false, rationale: "Variable optical sizes support the archival scale shifts." },
+                { name: "Newsreader", reflex: false, rationale: "Editorial contrast supports document-led hierarchy." },
+                { name: "Archivo", reflex: false, rationale: "Catalog labeling connects directly to the archival subject." },
+            ],
+            recentDisplayFonts: [],
+        },
+        creativeStrategy: {
+            path: "diversity",
+            mechanisms: ["variable-type morph", "depth-stack", "drag-inertia", "mask-dissolve"],
+            drivers: ["scroll", "pointer", "time"],
+        },
+        pages: [
+            {
+                id: "home",
+                name: "Home",
+                skills: ["ux", "mobile", "motion", "media"],
+                sections: [
+                    {
+                        id: "hero",
+                        name: "Hero",
+                        layoutFamily: "archival-index",
+                        skills: ["ux", "mobile", "motion", "media"],
+                        interactions: ["drag specimen"],
+                        mobile: "stacked specimen",
+                        fallback: "static catalog",
+                        verification: ["Signature responds to input"],
+                        assets: [],
+                        status: "shipped",
+                    },
+                ],
+            },
+        ],
+        preservationManifest: ".dreative/preservation.json",
+        decisionLedger: ".dreative/ledger.json",
+    };
+}
+function verification(...ids) {
+    return {
+        version: 1,
+        generatedAt: started,
+        evidence: ids.map((id) => ({
+            id,
+            criterion: id,
+            status: "pass",
+            evidence: "Captured runtime behavior in the production build.",
+            proof: { timestamp: started, testedUrl: "http://localhost:3000", consoleErrorCount: 0 },
+        })),
+    };
+}
+test("valid default award plan", () => {
+    assert.deepEqual(validateRuleControls(basePlan(), registry, reflex, verification()), []);
+});
+test("valid 3D substitution using spatial typography", () => {
+    const plan = basePlan();
+    plan.ruleExceptions = [
+        {
+            ruleId: "award.spatialSignature",
+            decision: "substituted",
+            declaredAt: planned,
+            reason: "The archival concept has no physical subject, so a product-like prop would misrepresent the material.",
+            alternative: "A persistent variable-type specimen becomes index, spatial architecture, and interactive control across four chapters.",
+            successCriteria: ["The specimen appears in three materially different roles", "Pointer and scroll input visibly reshape its depth"],
+            evidenceIds: ["spatial-type-desktop", "spatial-type-mobile"],
+        },
+    ];
+    assert.deepEqual(validateRuleControls(plan, registry, reflex, verification("spatial-type-desktop", "spatial-type-mobile")), []);
+});
+test("invalid vague 3D exception", () => {
+    const plan = basePlan();
+    plan.ruleExceptions = [
+        {
+            ruleId: "award.spatialSignature",
+            decision: "substituted",
+            declaredAt: planned,
+            reason: "It did not fit",
+            alternative: "Typography felt better",
+            successCriteria: ["Looks good", "Feels spatial"],
+            evidenceIds: ["type"],
+        },
+    ];
+    const errors = validateRuleControls(plan, registry, reflex, verification("type"));
+    assert.ok(errors.some((error) => error.includes("vague")));
+});
+test("attempted hard-gate exception", () => {
+    const plan = basePlan();
+    plan.ruleExceptions = [
+        {
+            ruleId: "preservation.noLoss",
+            decision: "substituted",
+            declaredAt: planned,
+            reason: "The old form was intentionally removed to simplify the new conversion route for this campaign.",
+            alternative: "A replacement conversion control carries the same submitted data into the existing backend workflow.",
+            successCriteria: ["Users can submit the same required fields", "The existing backend receives an equivalent payload"],
+            evidenceIds: ["form"],
+        },
+    ];
+    assert.ok(validateRuleControls(plan, registry, reflex, verification("form")).some((error) => error.includes("cannot be substituted")));
+});
+test("valid diversity plan", () => {
+    const plan = basePlan("expressive");
+    assert.deepEqual(validateRuleControls(plan, registry, reflex, verification()), []);
+});
+test("valid development plan", () => {
+    const plan = basePlan();
+    plan.creativeStrategy = {
+        path: "development",
+        signatureMechanism: "An archival sheet transforms across the complete journey",
+        states: ["Loose sheets form a catalog index", "Sheets become a draggable research surface", "Sheets collapse into a spatial tunnel"],
+        secondaryMechanisms: ["kinetic labels", "material lighting"],
+        drivers: ["scroll", "pointer"],
+    };
+    assert.deepEqual(validateRuleControls(plan, registry, reflex, verification()), []);
+});
+test("invalid repeated-mechanism plan", () => {
+    const plan = basePlan();
+    plan.creativeStrategy = { path: "diversity", mechanisms: ["fade", "fade", "fade", "fade"], drivers: ["scroll", "scroll", "scroll"] };
+    const errors = validateRuleControls(plan, registry, reflex, verification());
+    assert.ok(errors.some((error) => error.includes("distinct mechanisms")));
+});
+test("valid reflex-font justification", () => {
+    const plan = basePlan("premium");
+    plan.fontDecision = {
+        selected: "Inter",
+        candidates: [
+            { name: "Inter", reflex: true, rationale: "Existing authenticated product metrics and density depend on it." },
+            { name: "Switzer", reflex: false, rationale: "Comparable product clarity with more character." },
+            { name: "Source Sans 3", reflex: false, rationale: "Broad language support and efficient variable delivery." },
+        ],
+        recentDisplayFonts: [],
+        reasonKinds: ["existing-brand", "design-system-metrics"],
+        justification: "Inter is embedded throughout the authenticated product, preserves established density metrics, and avoids layout regressions across translated views.",
+    };
+    assert.deepEqual(validateRuleControls(plan, registry, reflex, verification()), []);
+});
+test("invalid generic font justification", () => {
+    const plan = basePlan("premium");
+    plan.fontDecision = {
+        selected: "Inter",
+        candidates: [
+            { name: "Inter", reflex: true, rationale: "A familiar interface choice." },
+            { name: "Switzer", reflex: false, rationale: "A product-oriented alternative." },
+            { name: "Source Sans 3", reflex: false, rationale: "A broad-language alternative." },
+        ],
+        recentDisplayFonts: [],
+        reasonKinds: [],
+        justification: "Inter looks clean and modern for this interface.",
+    };
+    assert.ok(validateRuleControls(plan, registry, reflex, verification()).some((error) => error.includes("non-generic")));
+});
+test("experimental exploration selects only two shipped provocations", () => {
+    const plan = basePlan("expressive");
+    plan.skills.push("experimental");
+    plan.pages[0].skills.push("experimental");
+    plan.experimentalPlan = {
+        majorSectionIds: ["hero", "archive", "closing"],
+        candidates: [
+            { id: "p1", sectionId: "hero", idea: "The title behaves as a physical catalog drawer opened by drag.", selected: true },
+            { id: "p2", sectionId: "archive", idea: "Research sheets reorganize into a navigable spatial evidence wall.", selected: true },
+            { id: "p3", sectionId: "closing", idea: "The final mark briefly assembles from all prior catalog coordinates.", selected: false },
+        ],
+    };
+    assert.deepEqual(validateRuleControls(plan, registry, reflex, verification()), []);
+});

package/dist/shared/skillSystem.js

@@ -0,0 +1,173 @@
+export const SKILL_DEFINITIONS = [
+    {
+        name: "ux",
+        description: "Working navigation, forms, states, keyboard access, focus, and interaction audits.",
+        dependencies: [],
+        signature: /\b(ux|accessib|a11y|forms?|navigation|keyboard|focus|states?|dashboard|product ui)\b/i,
+    },
+    {
+        name: "mobile",
+        description: "Mobile-native composition, touch ergonomics, responsive effects, and phone verification.",
+        dependencies: ["ux"],
+        signature: /\b(mobile|phone|tablet|responsive|touch|thumb|small screen)\b/i,
+    },
+    {
+        name: "refined",
+        description: "Premium clean business, DTC, and commerce design with restraint and strong photography.",
+        dependencies: ["ux", "mobile"],
+        signature: /\b(clean (and )?(modern|professional)|modern clean|business (site|website|use)|corporate|professional look|premium (minimal|clean)|dtc|d2c|e[- ]?commerce|ecommerce|shopify|calm|understated)\b/i,
+    },
+    {
+        name: "motion",
+        description: "Scroll choreography, entrances, kinetic type, springs, parallax, and transitions.",
+        dependencies: ["ux", "mobile"],
+        signature: /\b(animat|motion|parallax|scroll[- ]?(driven|trigger|story|choreo)|gsap|framer|lenis|marquee|kinetic|stagger|reveal|transition)\b/i,
+    },
+    {
+        name: "interaction",
+        description: "Hover craft, magnetic controls, cursor effects, tactile feedback, and state morphs.",
+        dependencies: ["ux", "mobile"],
+        signature: /\b(micro[- ]?interaction|hover (effect|state)s?|cursor|magnetic|tilt|spotlight|glow|ripple|tactile|interactive|draggable)\b/i,
+    },
+    {
+        name: "media",
+        description: "Generated and sourced image/video production, grading, motion treatments, and media planes.",
+        dependencies: ["ux", "mobile"],
+        signature: /\b(generated? (image|video|media)|hero video|image treatment|media plane|gallery|photography|video loop|distortion|living thumbnail)\b/i,
+    },
+    {
+        name: "3d",
+        description: "Three.js/R3F, WebGL, shaders, particles, models, lighting, and robust fallbacks.",
+        dependencies: ["ux", "mobile"],
+        signature: /\b(3d|three\.?js|webgl|r3f|shader|glsl|particles?|point ?cloud|globe|mesh gradient|orbit|spline)\b/i,
+    },
+    {
+        name: "immersive",
+        description: "Persistent spatial stages, preloaders, scene transitions, and scroll-as-journey.",
+        dependencies: ["motion", "interaction", "media", "ux", "mobile"],
+        signature: /\b(immersive|award[- ]?(site|winning)|awwwards|spatial|scene[- ]?based|world|camera (move|travel|path)|preloader|scroll (journey|story|as travel)|explorable|experience site)\b/i,
+    },
+    {
+        name: "cinematic",
+        description: "Shader-graded experiential interfaces, living surfaces, gesture exploration, and sound.",
+        dependencies: ["motion", "interaction", "media", "ux", "mobile"],
+        signature: /\b(cinematic|experiential|unseen\.co|fluid (sim(ulation)?|distortion)|gpgpu|drag[- ]to[- ]explore|click ?(&|and) ?hold|film grain|graded|velocity[- ]reactive|sound design|ambient (audio|sound))\b/i,
+    },
+    {
+        name: "experimental",
+        description: "Unconventional composition, material shifts, provocations, and high-variance creative direction.",
+        dependencies: ["motion", "interaction", "media", "ux", "mobile"],
+        signature: /\b(experimental|crazy|bizarre|never seen before|more creative|wow factor|unconventional|unexpected|provocation)\b/i,
+    },
+];
+const BY_NAME = new Map(SKILL_DEFINITIONS.map((skill) => [skill.name, skill]));
+export function detectSpecialistSkills(texts) {
+    const haystack = texts.filter(Boolean).join("\n");
+    return SKILL_DEFINITIONS.filter((skill) => skill.signature.test(haystack)).map((skill) => skill.name);
+}
+export function resolveSkillDependencies(requested) {
+    const resolved = new Set(["ux", "mobile"]);
+    const visit = (name) => {
+        if (resolved.has(name))
+            return;
+        for (const dependency of BY_NAME.get(name)?.dependencies ?? [])
+            visit(dependency);
+        resolved.add(name);
+    };
+    for (const name of requested)
+        visit(name);
+    return SKILL_DEFINITIONS.map((skill) => skill.name).filter((name) => resolved.has(name));
+}
+function skillScore(name, texts) {
+    const definition = BY_NAME.get(name);
+    if (!definition)
+        return 0;
+    const haystack = texts.filter(Boolean).join("\n");
+    const flags = definition.signature.flags.includes("g") ? definition.signature.flags : `${definition.signature.flags}g`;
+    return [...haystack.matchAll(new RegExp(definition.signature.source, flags))].length;
+}
+/**
+ * Hybrid multi-page routing: user selection is authoritative, explicit page
+ * assignments are locked, and only selected-but-unassigned treatments are
+ * placed automatically. Detected unselected skills are returned as suggestions
+ * and never activated silently.
+ */
+export function routeSkillsAcrossPages(request) {
+    const selected = [...new Set(request.selected)];
+    const resolved = resolveSkillDependencies(selected);
+    const byPageSets = new Map(request.pages.map((page) => [page.id, new Set(["ux", "mobile"])]));
+    for (const [pageId, skills] of Object.entries(request.assignments ?? {})) {
+        const target = byPageSets.get(pageId);
+        if (!target)
+            continue;
+        for (const skill of skills) {
+            if (!resolved.includes(skill))
+                continue;
+            for (const dependency of resolveSkillDependencies([skill]))
+                target.add(dependency);
+        }
+    }
+    const optionalSelected = selected.filter((skill) => skill !== "ux" && skill !== "mobile");
+    const unassigned = optionalSelected.filter((skill) => ![...byPageSets.values()].some((skills) => skills.has(skill)));
+    if (request.autoRouteUnassigned !== false && request.pages.length > 0) {
+        for (const skill of unassigned) {
+            const ranked = request.pages
+                .map((page, index) => ({
+                page,
+                index,
+                score: skillScore(skill, page.texts),
+                load: [...(byPageSets.get(page.id) ?? [])].filter((name) => name !== "ux" && name !== "mobile").length,
+            }))
+                .sort((a, b) => b.score - a.score || a.load - b.load || a.index - b.index);
+            const target = byPageSets.get(ranked[0].page.id);
+            for (const dependency of resolveSkillDependencies([skill]))
+                target.add(dependency);
+        }
+    }
+    const suggestions = {};
+    for (const page of request.pages) {
+        suggestions[page.id] = detectSpecialistSkills(page.texts).filter((skill) => !resolved.includes(skill));
+    }
+    const byPage = Object.fromEntries(request.pages.map((page) => [
+        page.id,
+        SKILL_DEFINITIONS.map((definition) => definition.name).filter((name) => byPageSets.get(page.id)?.has(name)),
+    ]));
+    return {
+        selected,
+        resolved,
+        byPage,
+        suggestions,
+        unassigned: request.autoRouteUnassigned === false ? unassigned : [],
+    };
+}
+export function resolveAmbitionTier(input) {
+    const haystack = [input.aesthetic, ...(input.texts ?? [])].filter(Boolean).join(" ");
+    if (/\b(award|awwwards|immersive|cinematic|experimental|unseen\.co)\b/i.test(haystack) || input.motion >= 9)
+        return "award";
+    if (input.motion >= 7 || input.variance >= 8)
+        return "expressive";
+    if (input.motion >= 4 || input.variance >= 5)
+        return "premium";
+    return "solid";
+}
+export const TIER_REQUIREMENTS = {
+    solid: [
+        "All existing behavior is preserved and the UX audit passes.",
+        "Desktop and mobile layouts are verified with keyboard and reduced-motion coverage.",
+    ],
+    premium: [
+        "Solid-tier requirements pass.",
+        "The page has a clear design read, one signature detail, and a completed craft pass.",
+        "Media is intentionally cropped/graded and interaction states are designed.",
+    ],
+    expressive: [
+        "Premium-tier requirements pass.",
+        "At least three distinct, purposeful motion or interaction moments ship with fallbacks.",
+        "Heavy effects are measured on desktop and translated deliberately for mobile.",
+    ],
+    award: [
+        "Expressive-tier requirements pass.",
+        "The experience has a distinctive spatial or media system, not isolated decoration.",
+        "Runtime, asset-weight, frame-time, occlusion, and fallback evidence is recorded.",
+    ],
+};

package/dist/shared/skillSystem.test.js

@@ -0,0 +1,110 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { detectSpecialistSkills, resolveAmbitionTier, resolveSkillDependencies, routeSkillsAcrossPages } from "./skillSystem.js";
+import { validatePlan, validatePreservationManifest, validateVerificationReport } from "./artifacts.js";
+test("detects every previously un-routed specialist family", () => {
+    assert.deepEqual(detectSpecialistSkills(["experimental mobile-first gallery with generated video"]), [
+        "mobile",
+        "media",
+        "experimental",
+    ]);
+});
+test("resolves universal and transitive skill dependencies", () => {
+    assert.deepEqual(resolveSkillDependencies(["cinematic"]), ["ux", "mobile", "motion", "interaction", "media", "cinematic"]);
+});
+test("resolves ambition without forcing award tier", () => {
+    assert.equal(resolveAmbitionTier({ variance: 3, motion: 2, aesthetic: "trust" }), "solid");
+    assert.equal(resolveAmbitionTier({ variance: 7, motion: 7 }), "expressive");
+    assert.equal(resolveAmbitionTier({ variance: 7, motion: 7, texts: ["Awwwards immersive world"] }), "award");
+});
+test("hybrid routing honors page pins and never activates unselected suggestions", () => {
+    const routed = routeSkillsAcrossPages({
+        pages: [
+            { id: "home", texts: ["cinematic hero with a video loop and 3d globe"] },
+            { id: "shop", texts: ["clean ecommerce catalog"] },
+        ],
+        selected: ["cinematic", "refined"],
+        assignments: { shop: ["refined"] },
+    });
+    assert.ok(routed.byPage.shop.includes("refined"));
+    assert.ok(routed.byPage.home.includes("cinematic"));
+    assert.ok(routed.byPage.home.includes("motion"));
+    assert.ok(!routed.byPage.home.includes("3d"));
+    assert.ok(!routed.byPage.shop.includes("3d"));
+    assert.ok(routed.suggestions.home.includes("3d"));
+});
+test("select all covers all skills across the build without putting all on every page", () => {
+    const all = ["ux", "mobile", "refined", "motion", "interaction", "media", "3d", "immersive", "cinematic", "experimental"];
+    const routed = routeSkillsAcrossPages({
+        pages: [
+            { id: "home", texts: ["cinematic immersive hero"] },
+            { id: "product", texts: ["3d product"] },
+            { id: "about", texts: ["experimental editorial"] },
+        ],
+        selected: [...all],
+    });
+    const used = new Set(Object.values(routed.byPage).flat());
+    assert.deepEqual([...all].filter((skill) => !used.has(skill)), []);
+    assert.ok(Object.values(routed.byPage).some((skills) => skills.length < all.length));
+});
+test("routing can be disabled while waiting for explicit page assignments", () => {
+    const routed = routeSkillsAcrossPages({
+        pages: [{ id: "home", texts: ["animated landing page"] }],
+        selected: ["motion"],
+        autoRouteUnassigned: false,
+    });
+    assert.deepEqual(routed.unassigned, ["motion"]);
+    assert.deepEqual(routed.byPage.home, ["ux", "mobile"]);
+});
+test("plan validator rejects unfinished sections", () => {
+    const errors = validatePlan({
+        version: 2,
+        request: "Redesign",
+        createdAt: new Date().toISOString(),
+        tier: "premium",
+        depth: "restructure",
+        skills: ["ux", "mobile"],
+        skillPolicy: { mode: "hybrid", global: ["ux", "mobile"], routingApproved: true, userAssignments: [] },
+        designRead: { register: "editorial", concept: "signal", signature: "rail" },
+        preservationManifest: ".dreative/preservation.json",
+        decisionLedger: ".dreative/ledger.json",
+        pages: [
+            {
+                id: "home",
+                name: "Home",
+                skills: ["ux", "mobile"],
+                sections: [
+                    {
+                        id: "hero",
+                        name: "Hero",
+                        layoutFamily: "split",
+                        skills: ["ux", "mobile"],
+                        interactions: [],
+                        mobile: "stack",
+                        fallback: "static",
+                        verification: ["Headline visible"],
+                        assets: [],
+                        status: "planned",
+                    },
+                ],
+            },
+        ],
+    });
+    assert.ok(errors.some((error) => error.includes("still planned")));
+});
+test("preservation validator requires reasons for intentional changes", () => {
+    const errors = validatePreservationManifest({
+        version: 1,
+        createdAt: new Date().toISOString(),
+        items: [{ id: "cta", kind: "link", file: "src/App.tsx", needle: "/buy", purpose: "Purchase", intentionallyChanged: true }],
+    });
+    assert.ok(errors.some((error) => error.includes("changeReason")));
+});
+test("verification rejects text-only self-reporting", () => {
+    const errors = validateVerificationReport({
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        evidence: [{ id: "mobile", criterion: "Works at 390px", status: "pass", evidence: "Tested at 390px" }],
+    });
+    assert.ok(errors.some((error) => error.includes("proof")));
+});