design-constraint-validator 1.0.0 → 2.0.1

package/cli/commands/patch-apply.ts

@@ -1,80 +1,80 @@
-import { loadTokens, outputResult } from './utils.js';
-import type { PatchApplyOptions } from '../types.js';
-import type { TokenNode } from '../../core/flatten.js';
-import fs from 'node:fs';
-import { flattenTokens } from '../../core/flatten.js';
-import { createHash } from 'node:crypto';
-
-interface PatchDocumentV1 {
-  version: 1;
-  changes: Array<{ id: string; from: any; to: any; type: 'modify'|'add'|'remove' }>;
-  patch: Record<string, any>;
-  baseTokensHash?: string;
-}
-
-function applyChange(root: any, id: string, to: any, type: 'modify'|'add'|'remove') {
-  const parts = id.split('.');
-  let cur: any = root;
-  for (let i = 0; i < parts.length; i++) {
-    const p = parts[i];
-    if (i === parts.length - 1) {
-      if (type === 'remove') {
-        if (cur[p] && typeof cur[p] === 'object') {
-          delete cur[p].$value; // delete leaf value
-        }
-      } else {
-        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
-        cur[p].$value = to;
-      }
-    } else {
-      if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
-      cur = cur[p];
-    }
-  }
-}
-
-export async function patchApplyCommand(opts: PatchApplyOptions): Promise<void> {
-  const tokens: TokenNode = loadTokens(opts.tokens || 'tokens/tokens.example.json');
-  // Compute current base tokens hash for drift detection (same logic as buildPatch)
-  function computeBaseHash(toks: TokenNode): string {
-    const flat = flattenTokens(JSON.parse(JSON.stringify(toks))).flat as Record<string, any>;
-    const values: Record<string, any> = {};
-    Object.keys(flat).sort().forEach(id => { values[id] = flat[id]?.value; });
-    // Keep deterministic ordering
-    const ordered = Object.keys(values).sort().reduce((acc, k) => { acc[k] = values[k]; return acc; }, {} as Record<string, any>);
-    return createHash('sha256').update(JSON.stringify(ordered)).digest('hex');
-  }
-  // Parse patch
-  let patchDoc: PatchDocumentV1;
-  if (fs.existsSync(opts.patch)) {
-    patchDoc = JSON.parse(fs.readFileSync(opts.patch, 'utf8'));
-  } else if (opts.patch.trim().startsWith('{')) {
-    patchDoc = JSON.parse(opts.patch);
-  } else {
-    throw new Error(`Patch not found: ${opts.patch}`);
-  }
-  if (patchDoc.version !== 1) throw new Error('Unsupported patch version');
-  if (patchDoc.baseTokensHash) {
-    const currentHash = computeBaseHash(tokens);
-    if (currentHash !== patchDoc.baseTokensHash) {
-      console.warn(`⚠ Base tokens hash mismatch. Patch built against ${patchDoc.baseTokensHash} but current base is ${currentHash}. Proceeding (use --dry-run to inspect first).`);
-    }
-  }
-
-  // Apply changes
-  for (const c of patchDoc.changes) {
-    applyChange(tokens, c.id, c.to, c.type);
-  }
-
-  if (opts.dryRun) {
-    outputResult(tokens, 'json');
-    return;
-  }
-
-  if (opts.output) {
-    fs.writeFileSync(opts.output, JSON.stringify(tokens, null, 2));
-    if (!opts.quiet) console.log(`✔ Patch applied to ${opts.output}`);
-  } else {
-    outputResult(tokens, 'json');
-  }
-}
+import { loadTokens, outputResult } from './utils.js';
+import type { PatchApplyOptions } from '../types.js';
+import type { TokenNode } from '../../core/flatten.js';
+import fs from 'node:fs';
+import { flattenTokens } from '../../core/flatten.js';
+import { createHash } from 'node:crypto';
+
+interface PatchDocumentV1 {
+  version: 1;
+  changes: Array<{ id: string; from: any; to: any; type: 'modify'|'add'|'remove' }>;
+  patch: Record<string, any>;
+  baseTokensHash?: string;
+}
+
+function applyChange(root: any, id: string, to: any, type: 'modify'|'add'|'remove') {
+  const parts = id.split('.');
+  let cur: any = root;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (i === parts.length - 1) {
+      if (type === 'remove') {
+        if (cur[p] && typeof cur[p] === 'object') {
+          delete cur[p].$value; // delete leaf value
+        }
+      } else {
+        if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+        cur[p].$value = to;
+      }
+    } else {
+      if (!cur[p] || typeof cur[p] !== 'object') cur[p] = {};
+      cur = cur[p];
+    }
+  }
+}
+
+export async function patchApplyCommand(opts: PatchApplyOptions): Promise<void> {
+  const tokens: TokenNode = loadTokens(opts.tokens || 'tokens/tokens.example.json');
+  // Compute current base tokens hash for drift detection (same logic as buildPatch)
+  function computeBaseHash(toks: TokenNode): string {
+    const flat = flattenTokens(JSON.parse(JSON.stringify(toks))).flat as Record<string, any>;
+    const values: Record<string, any> = {};
+    Object.keys(flat).sort().forEach(id => { values[id] = flat[id]?.value; });
+    // Keep deterministic ordering
+    const ordered = Object.keys(values).sort().reduce((acc, k) => { acc[k] = values[k]; return acc; }, {} as Record<string, any>);
+    return createHash('sha256').update(JSON.stringify(ordered)).digest('hex');
+  }
+  // Parse patch
+  let patchDoc: PatchDocumentV1;
+  if (fs.existsSync(opts.patch)) {
+    patchDoc = JSON.parse(fs.readFileSync(opts.patch, 'utf8'));
+  } else if (opts.patch.trim().startsWith('{')) {
+    patchDoc = JSON.parse(opts.patch);
+  } else {
+    throw new Error(`Patch not found: ${opts.patch}`);
+  }
+  if (patchDoc.version !== 1) throw new Error('Unsupported patch version');
+  if (patchDoc.baseTokensHash) {
+    const currentHash = computeBaseHash(tokens);
+    if (currentHash !== patchDoc.baseTokensHash) {
+      console.warn(`⚠ Base tokens hash mismatch. Patch built against ${patchDoc.baseTokensHash} but current base is ${currentHash}. Proceeding (use --dry-run to inspect first).`);
+    }
+  }
+
+  // Apply changes
+  for (const c of patchDoc.changes) {
+    applyChange(tokens, c.id, c.to, c.type);
+  }
+
+  if (opts.dryRun) {
+    outputResult(tokens, 'json');
+    return;
+  }
+
+  if (opts.output) {
+    fs.writeFileSync(opts.output, JSON.stringify(tokens, null, 2));
+    if (!opts.quiet) console.log(`✔ Patch applied to ${opts.output}`);
+  } else {
+    outputResult(tokens, 'json');
+  }
+}

package/cli/commands/patch.ts

@@ -1,22 +1,22 @@
-import type { TokenNode } from '../../core/flatten.js';
-import { loadTokens, outputResult } from './utils.js';
-import { buildPatch } from '../../core/patch.js';
-import type { PatchOptions } from '../types.js';
-
-export async function patchCommand(opts: PatchOptions): Promise<void> {
-  const tokens: TokenNode = loadTokens(opts.tokens || 'tokens/tokens.example.json');
-  // For now just accept a flat overrides JSON file if provided
-  let overrides: Record<string, any> | undefined;
-  if (opts.overrides) {
-    const fs = await import('node:fs');
-    if (fs.existsSync(opts.overrides)) {
-      overrides = JSON.parse(fs.readFileSync(opts.overrides, 'utf8'));
-    } else if (opts.overrides.startsWith('{')) {
-      overrides = JSON.parse(opts.overrides);
-    } else {
-      throw new Error(`Overrides not found: ${opts.overrides}`);
-    }
-  }
-  const patchDoc = buildPatch({ tokens, overrides, baseFile: opts.tokens });
-  outputResult(patchDoc, opts.format || 'json', opts.output);
-}
+import type { TokenNode } from '../../core/flatten.js';
+import { loadTokens, outputResult } from './utils.js';
+import { buildPatch } from '../../core/patch.js';
+import type { PatchOptions } from '../types.js';
+
+export async function patchCommand(opts: PatchOptions): Promise<void> {
+  const tokens: TokenNode = loadTokens(opts.tokens || 'tokens/tokens.example.json');
+  // For now just accept a flat overrides JSON file if provided
+  let overrides: Record<string, any> | undefined;
+  if (opts.overrides) {
+    const fs = await import('node:fs');
+    if (fs.existsSync(opts.overrides)) {
+      overrides = JSON.parse(fs.readFileSync(opts.overrides, 'utf8'));
+    } else if (opts.overrides.startsWith('{')) {
+      overrides = JSON.parse(opts.overrides);
+    } else {
+      throw new Error(`Overrides not found: ${opts.overrides}`);
+    }
+  }
+  const patchDoc = buildPatch({ tokens, overrides, baseFile: opts.tokens });
+  outputResult(patchDoc, opts.format || 'json', opts.output);
+}

package/cli/commands/set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["set.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiB,UAAU,EAAe,MAAM,aAAa,CAAC;AAkE1E,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyJnE"}
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["set.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAiB,UAAU,EAAe,MAAM,aAAa,CAAC;AAmE1E,wBAAsB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAsKnE"}

package/cli/commands/set.js

@@ -1,9 +1,10 @@
 import { join } from 'node:path';
 import { readFileSync, existsSync } from 'node:fs';
 import { loadConfig } from '../config.js';
-import { createEngine } from '../engine-helpers.js';
+import { Engine } from '../../core/engine.js';
 import { flattenTokens } from '../../core/flatten.js';
 import { loadTokens, outputResult } from './utils.js';
+import { setupConstraints } from '../constraint-registry.js';
 // Lightweight suggestion helpers (kept local – why command uses core formatter instead)
 function levenshtein(a, b) {
     const al = a.length, bl = b.length;
@@ -81,9 +82,16 @@ export async function setCommand(options) {
     }
     const config = cfgRes.value;
     const tokens = loadTokens(tokensPath);
-    const engine = createEngine(tokens, config);
-    const { flat: flatAll } = flattenTokens(tokens);
-    const knownIds = new Set(Object.keys(flatAll));
+    // Create engine with flattened tokens
+    const { flat, edges } = flattenTokens(tokens);
+    const init = {};
+    for (const t of Object.values(flat)) {
+        init[t.id] = t.value;
+    }
+    const engine = new Engine(init, edges);
+    const knownIds = new Set(Object.keys(init));
+    // Discover and attach all constraints via centralized registry
+    setupConstraints(engine, { config, constraintsDir: 'themes' }, { knownIds });
     function ensureKnownOrSuggest(id) {
         if (!knownIds.has(id)) {
             const suggestions = suggestIds(id, Array.from(knownIds));