rafters 0.0.38 → 0.0.40

package/dist/index.js

@@ -60352,6 +60352,10 @@ var TOOL_DEFINITIONS = [
         category: {
           type: "string",
           description: 'Token category (required for create). E.g., "color", "spacing", "font".'
+        },
+        dark: {
+          type: "string",
+          description: 'Dark mode color reference as "family-position" (e.g., "neutral-950"). For semantic tokens, sets dependsOn[1] so the CSS dark mode layer uses this reference instead of the light value.'
         }
       },
       required: ["name"]
@@ -61050,6 +61054,19 @@ var RaftersToolHandler = class _RaftersToolHandler {
     }
   }
   // ==================== Token Write Operations ====================
+  static VALID_SCALE_POSITIONS = /^(50|100|200|300|400|500|600|700|800|900|950)$/;
+  /**
+   * Parse "family-position" string (e.g., "neutral-950") into { family, position }.
+   * Returns null if the string is not a valid color reference.
+   */
+  static parseColorRef(ref) {
+    const lastDash = ref.lastIndexOf("-");
+    if (lastDash <= 0) return null;
+    const position = ref.slice(lastDash + 1);
+    const family = ref.slice(0, lastDash);
+    if (!_RaftersToolHandler.VALID_SCALE_POSITIONS.test(position)) return null;
+    return { family, position };
+  }
   /**
    * Handle set, create, and reset actions for rafters_token.
    * Loads the full registry, mutates, cascades, persists, and regenerates outputs.
@@ -61058,6 +61075,7 @@ var RaftersToolHandler = class _RaftersToolHandler {
     const name2 = args.name;
     const reason = args.reason;
     const value2 = args.value;
+    const dark = args.dark;
     if (!reason) {
       return {
         content: [
@@ -61103,14 +61121,64 @@ var RaftersToolHandler = class _RaftersToolHandler {
               isError: true
             };
           }
+          if (dark) {
+            if (existing.namespace !== "semantic") {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      error: `The "dark" parameter only applies to semantic color tokens. Token "${name2}" is in the "${existing.namespace}" namespace.`
+                    })
+                  }
+                ],
+                isError: true
+              };
+            }
+            if (!_RaftersToolHandler.parseColorRef(dark)) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify({
+                      error: `Invalid dark reference "${dark}". Use format "family-position" (e.g., "neutral-950"). Valid positions: 50, 100-900 by 100, 950.`
+                    })
+                  }
+                ],
+                isError: true
+              };
+            }
+          }
           const previousValue = existing.value;
           existing.userOverride = {
             previousValue: typeof previousValue === "string" ? previousValue : JSON.stringify(previousValue),
             reason
           };
-          await registry2.set(name2, value2);
+          const parsed = existing.namespace === "semantic" && typeof value2 === "string" ? _RaftersToolHandler.parseColorRef(value2) : null;
+          if (existing.namespace === "semantic" && typeof value2 === "string" && !parsed) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    error: `Semantic token "${name2}" requires a color reference in "family-position" format (e.g., "neutral-50"), not "${value2}". Use rafters_vocabulary to find available color families.`
+                  })
+                }
+              ],
+              isError: true
+            };
+          }
+          if (parsed) {
+            existing.value = parsed;
+            const lightRefStr = `${parsed.family}-${parsed.position}`;
+            const darkRef = dark ?? existing.dependsOn?.[1] ?? lightRefStr;
+            existing.dependsOn = [lightRefStr, darkRef];
+          } else {
+            existing.value = value2;
+          }
+          await registry2.setToken(existing);
           const affected = this.getAffectedTokens(registry2, name2);
-          await this.regenerateOutputs(registry2);
+          const outputFiles = await this.regenerateOutputs(registry2);
           return {
             content: [
               {
@@ -61120,7 +61188,13 @@ var RaftersToolHandler = class _RaftersToolHandler {
                   action: "set",
                   name: name2,
                   reason,
-                  cascaded: affected
+                  persisted: {
+                    value: existing.value,
+                    dependsOn: existing.dependsOn,
+                    namespace: existing.namespace
+                  },
+                  cascaded: affected,
+                  outputFiles
                 })
               }
             ]
@@ -61177,7 +61251,7 @@ var RaftersToolHandler = class _RaftersToolHandler {
           };
           registry2.add(newToken);
           await this.adapter.save(registry2.list());
-          await this.regenerateOutputs(registry2);
+          const outputFiles = await this.regenerateOutputs(registry2);
           return {
             content: [
               {
@@ -61187,7 +61261,13 @@ var RaftersToolHandler = class _RaftersToolHandler {
                   action: "create",
                   name: name2,
                   namespace,
-                  reason
+                  reason,
+                  persisted: {
+                    value: newToken.value,
+                    dependsOn: newToken.dependsOn,
+                    namespace: newToken.namespace
+                  },
+                  outputFiles
                 })
               }
             ]
@@ -61204,8 +61284,9 @@ var RaftersToolHandler = class _RaftersToolHandler {
             };
           }
           await registry2.set(name2, COMPUTED);
+          const resolved = registry2.get(name2);
           const affected = this.getAffectedTokens(registry2, name2);
-          await this.regenerateOutputs(registry2);
+          const outputFiles = await this.regenerateOutputs(registry2);
           return {
             content: [
               {
@@ -61215,7 +61296,13 @@ var RaftersToolHandler = class _RaftersToolHandler {
                   action: "reset",
                   name: name2,
                   reason,
-                  cascaded: affected
+                  persisted: {
+                    value: resolved?.value,
+                    dependsOn: resolved?.dependsOn,
+                    namespace: resolved?.namespace
+                  },
+                  cascaded: affected,
+                  outputFiles
                 })
               }
             ]
@@ -61251,10 +61338,11 @@ var RaftersToolHandler = class _RaftersToolHandler {
     return affected;
   }
   /**
-   * Regenerate output files (CSS, TS, DTCG) from registry state
+   * Regenerate output files (CSS, TS, DTCG) from registry state.
+   * Returns list of files written so callers can report what changed.
    */
   async regenerateOutputs(registry2) {
-    if (!this.projectRoot) return;
+    if (!this.projectRoot) return [];
     const paths = getRaftersPaths(this.projectRoot);
     const config3 = await this.loadConfig();
     const exports = config3?.exports ?? {
@@ -61264,20 +61352,28 @@ var RaftersToolHandler = class _RaftersToolHandler {
       compiled: false
     };
     const shadcn = config3?.shadcn ?? false;
+    const written = [];
     await mkdir4(paths.output, { recursive: true });
     if (exports.tailwind) {
       const darkMode = config3?.darkMode ?? "class";
       const css3 = registryToTailwind(registry2, { includeImport: !shadcn, darkMode });
-      await writeFile4(join10(paths.output, "rafters.css"), css3);
+      const cssPath = join10(paths.output, "rafters.css");
+      await writeFile4(cssPath, css3);
+      written.push(relative2(this.projectRoot, cssPath));
     }
     if (exports.typescript) {
       const ts = registryToTypeScript(registry2, { includeJSDoc: true });
-      await writeFile4(join10(paths.output, "rafters.ts"), ts);
+      const tsPath = join10(paths.output, "rafters.ts");
+      await writeFile4(tsPath, ts);
+      written.push(relative2(this.projectRoot, tsPath));
     }
     if (exports.dtcg) {
       const json3 = toDTCG(registry2.list());
-      await writeFile4(join10(paths.output, "rafters.json"), JSON.stringify(json3, null, 2));
+      const jsonPath = join10(paths.output, "rafters.json");
+      await writeFile4(jsonPath, JSON.stringify(json3, null, 2));
+      written.push(relative2(this.projectRoot, jsonPath));
     }
+    return written;
   }
   // ==================== Tool 6: Onboard ====================
   /**
@@ -61316,6 +61412,107 @@ var RaftersToolHandler = class _RaftersToolHandler {
     "highlight",
     "muted"
   ];
+  static SEMANTIC_FAMILY_SET = new Set(
+    _RaftersToolHandler.SEMANTIC_FAMILIES
+  );
+  /** Scale positions indexed 0-10, matching ColorValue.scale array indices */
+  static SCALE_POSITIONS = [
+    "50",
+    "100",
+    "200",
+    "300",
+    "400",
+    "500",
+    "600",
+    "700",
+    "800",
+    "900",
+    "950"
+  ];
+  static positionToIndex(position) {
+    const idx = _RaftersToolHandler.SCALE_POSITIONS.indexOf(
+      position
+    );
+    return idx >= 0 ? idx : 5;
+  }
+  /**
+   * Find an accessible foreground position against a given background position.
+   * Tries AAA first (7:1), falls back to AA (4.5:1), keeps default if both pass.
+   */
+  static findAccessibleFgPosition(bgPosition, defaultFgPosition, aaaPairs, aaPairs) {
+    const bgIdx = _RaftersToolHandler.positionToIndex(bgPosition);
+    const fgIdx = _RaftersToolHandler.positionToIndex(defaultFgPosition);
+    const pairValid = (pairs) => pairs.some(([a2, b2]) => a2 === bgIdx && b2 === fgIdx || a2 === fgIdx && b2 === bgIdx);
+    if (pairValid(aaaPairs) || pairValid(aaPairs)) return defaultFgPosition;
+    const bestPair = aaaPairs.find(([a2]) => a2 === bgIdx) ?? aaPairs.find(([a2]) => a2 === bgIdx);
+    if (bestPair && bestPair[1] !== void 0) {
+      return _RaftersToolHandler.SCALE_POSITIONS[bestPair[1]] ?? defaultFgPosition;
+    }
+    return defaultFgPosition;
+  }
+  /**
+   * When a semantic family is mapped to a color, cascade to all surface tokens
+   * that reference that family. Uses precomputed accessibility data from the
+   * ColorValue to verify WCAG AAA (fall back to AA) compliance for fg/bg pairs.
+   */
+  cascadeSemanticFamily(registry2, familyName, colorFamilyName, results) {
+    const tokensToUpdate = [];
+    const colorFamilyToken = registry2.get(colorFamilyName);
+    const colorValue = colorFamilyToken?.value && typeof colorFamilyToken.value === "object" && "scale" in colorFamilyToken.value ? colorFamilyToken.value : null;
+    const aaaPairs = colorValue?.accessibility?.wcagAAA?.normal ?? [];
+    const aaPairs = colorValue?.accessibility?.wcagAA?.normal ?? [];
+    for (const [name2, mapping] of Object.entries(DEFAULT_SEMANTIC_COLOR_MAPPINGS)) {
+      const belongsToFamily = familyName === "neutral" ? mapping.light.family === "neutral" && mapping.dark.family === "neutral" : name2 === familyName || name2.startsWith(`${familyName}-`);
+      if (!belongsToFamily) continue;
+      const existing = registry2.get(name2);
+      if (!existing) continue;
+      if (existing.userOverride?.reason && !existing.userOverride.reason.startsWith("Auto-cascaded")) {
+        continue;
+      }
+      let lightPos = mapping.light.position;
+      let darkPos = mapping.dark.position;
+      const isForeground = name2.endsWith("-foreground");
+      const tokenFamily = isForeground ? "neutral" : colorFamilyName;
+      if (isForeground && colorValue) {
+        const bgName = name2.replace(/-foreground$/, "");
+        const bgMapping = DEFAULT_SEMANTIC_COLOR_MAPPINGS[bgName];
+        if (bgMapping) {
+          lightPos = _RaftersToolHandler.findAccessibleFgPosition(
+            bgMapping.light.position,
+            lightPos,
+            aaaPairs,
+            aaPairs
+          );
+          darkPos = _RaftersToolHandler.findAccessibleFgPosition(
+            bgMapping.dark.position,
+            darkPos,
+            aaaPairs,
+            aaPairs
+          );
+        }
+      }
+      const lightRef = { family: tokenFamily, position: lightPos };
+      const lightTokenName = `${tokenFamily}-${lightPos}`;
+      const darkTokenName = `${tokenFamily}-${darkPos}`;
+      tokensToUpdate.push({
+        ...existing,
+        value: lightRef,
+        dependsOn: [lightTokenName, darkTokenName],
+        userOverride: {
+          previousValue: typeof existing.value === "string" ? existing.value : JSON.stringify(existing.value),
+          reason: `Auto-cascaded from ${familyName} -> ${colorFamilyName}`
+        }
+      });
+      results.push({
+        source: familyName,
+        target: name2,
+        action: "cascade",
+        ok: true,
+        persisted: { value: lightRef, dependsOn: [lightTokenName, darkTokenName] }
+      });
+    }
+    return tokensToUpdate;
+  }
   /**
    * Handle rafters_onboard tool calls
    */
@@ -61666,14 +61863,8 @@ var RaftersToolHandler = class _RaftersToolHandler {
       const registry2 = new TokenRegistry(allTokens);
       registry2.setAdapter(this.adapter);
       const results = [];
-      const parseRef = (ref) => {
-        const lastDash = ref.lastIndexOf("-");
-        if (lastDash <= 0) return null;
-        const position = ref.slice(lastDash + 1);
-        const family = ref.slice(0, lastDash);
-        if (!/^(50|100|200|300|400|500|600|700|800|900|950)$/.test(position)) return null;
-        return { family, position };
-      };
+      const parseRef = _RaftersToolHandler.parseColorRef;
+      const allCascadeTokens = [];
       for (const mapping of mappings) {
         const { source, target, value: value2, reason, namespace, category } = mapping;
         const lightRef = mapping.light;
@@ -61776,25 +61967,20 @@ var RaftersToolHandler = class _RaftersToolHandler {
             reason: `Remapped from ${source}: ${reason}`
           };
           const newColorRef = { family: newLight.family, position: newLight.position };
-          await registry2.set(target, newColorRef);
-          const updated = registry2.get(target);
-          if (updated) {
-            updated.dependsOn = [lightTokenName, darkTokenName];
-          } else {
-            results.push({
-              source,
-              target,
-              action: "skipped",
-              ok: false,
-              error: `Token "${target}" was set but could not be retrieved from registry to update dependencies.`
-            });
-            continue;
-          }
+          await registry2.setToken({
+            ...existing,
+            value: newColorRef,
+            dependsOn: [lightTokenName, darkTokenName]
+          });
           results.push({
             source,
             target,
             action: "remap",
-            ok: true
+            ok: true,
+            persisted: {
+              value: newColorRef,
+              dependsOn: [lightTokenName, darkTokenName]
+            }
           });
           continue;
         }
@@ -61854,12 +62040,29 @@ var RaftersToolHandler = class _RaftersToolHandler {
           registry2.add(newToken);
           results.push({ source, target, action: "create", ok: true, enriched });
         }
+        if (_RaftersToolHandler.SEMANTIC_FAMILY_SET.has(target)) {
+          if (!enriched) {
+            results.push({
+              source,
+              target,
+              action: "skipped",
+              ok: false,
+              error: `Cascade skipped for "${target}": value was not enriched. Provide a CSS color value so the color family can be created with accessibility data.`
+            });
+          } else {
+            allCascadeTokens.push(...this.cascadeSemanticFamily(registry2, target, target, results));
+          }
+        }
+      }
+      if (allCascadeTokens.length > 0) {
+        await registry2.setTokens(allCascadeTokens);
       }
       await this.adapter.save(registry2.list());
-      await this.regenerateOutputs(registry2);
+      const outputFiles = await this.regenerateOutputs(registry2);
       const setCount = results.filter((r) => r.action === "set" && r.ok).length;
       const createCount = results.filter((r) => r.action === "create" && r.ok).length;
       const remapCount = results.filter((r) => r.action === "remap" && r.ok).length;
+      const cascadeCount = results.filter((r) => r.action === "cascade" && r.ok).length;
       const enrichedCount = results.filter((r) => r.enriched).length;
       const failCount = results.filter((r) => !r.ok).length;
       return {
@@ -61873,10 +62076,12 @@ var RaftersToolHandler = class _RaftersToolHandler {
                   set: setCount,
                   created: createCount,
                   remapped: remapCount,
+                  cascaded: cascadeCount,
                   enriched: enrichedCount,
                   failed: failCount
                 },
-                results
+                results,
+                outputFiles
               },
               null,
               2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rafters",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "description": "CLI for Rafters design system - scaffold tokens and add components",
   "license": "MIT",
   "type": "module",