@deneb-ui/cli 2.0.22 → 2.0.24

package/src/arc/validator.cjs

@@ -0,0 +1,173 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseSource } = require('./ast.cjs');
+const { collectDesignSnapshot } = require('./semantic.cjs');
+const { getDeep } = require('./manifest.cjs');
+const { walkFiles, isJsxFile, rel } = require('./fs-utils.cjs');
+
+function validateAstFiles(files) {
+  const results = [];
+  for (const file of files) {
+    try {
+      parseSource(fs.readFileSync(file.abs, 'utf8'), file.rel);
+      results.push({ file: file.rel, passed: true });
+    } catch (err) {
+      results.push({ file: file.rel, passed: false, error: err.message });
+    }
+  }
+  return results;
+}
+
+function extractFieldPathsFromCode(code) {
+  return [
+    ...code.matchAll(/data-preview-field-path=["']([^"']+)["']/g),
+  ].map((m) => m[1]);
+}
+
+function validateContracts(projectDir, siteData, manifest) {
+  const files = walkFiles(projectDir, { include: (_p, name) => isJsxFile(name) });
+  const fieldPaths = [];
+  let actionCollisions = 0;
+  let staticAncestorCollisions = 0;
+  let duplicateMarkers = 0;
+  const seen = new Map();
+  const orphans = [];
+  const missingSchema = [];
+
+  for (const abs of files) {
+    const code = fs.readFileSync(abs, 'utf8');
+    const relative = rel(projectDir, abs);
+    const paths = extractFieldPathsFromCode(code);
+    for (const fieldPath of paths) {
+      fieldPaths.push(fieldPath);
+      const prev = seen.get(fieldPath) || 0;
+      seen.set(fieldPath, prev + 1);
+      if (siteData?.content && getDeep(siteData.content, fieldPath) === undefined) {
+        orphans.push({ fieldPath, file: relative });
+      }
+      if (manifest && !isFieldInEditorSchema(manifest, fieldPath)) {
+        missingSchema.push({ fieldPath, file: relative });
+      }
+    }
+
+    const collisions = code.matchAll(/<a\s+[^>]*data-preview-field-path="[^"]*(?:Url|Link|Action)"[^>]*>([^<>{}\n]+)<\/a>/gi);
+    for (const ac of collisions) {
+      if (String(ac[1] || '').trim().length > 1) actionCollisions++;
+    }
+
+    if (code.includes('data-preview-static') && code.includes('data-preview-field-path')) {
+      const blocks = code.matchAll(/<([a-zA-Z0-9_-]+)(\s+[^>]*data-preview-static[^>]*)>([\s\S]*?)<\/\1>/g);
+      for (const sb of blocks) {
+        if (sb[3].includes('data-preview-field-path')) staticAncestorCollisions++;
+      }
+    }
+  }
+
+  for (const [, count] of seen) {
+    if (count > 40) duplicateMarkers++;
+  }
+
+  return {
+    fieldPaths: [...new Set(fieldPaths)],
+    actionCollisions,
+    staticAncestorCollisions,
+    duplicateMarkers,
+    orphans,
+    missingSchema,
+    contractPassed: actionCollisions === 0 && staticAncestorCollisions === 0,
+  };
+}
+
+function isFieldInEditorSchema(manifest, fieldPath) {
+  const parts = String(fieldPath).split('.');
+  const sectionId = parts[0];
+  const fieldKey = parts.slice(1).join('.');
+  const section = (manifest.editorSchema?.sections || []).find((s) => s.id === sectionId || s.path === sectionId);
+  if (!section) return false;
+
+  function checkFields(fields, targetKey) {
+    if (!Array.isArray(fields)) return false;
+    for (const f of fields) {
+      if (f.key === targetKey) return true;
+      if (f.fields && targetKey.startsWith(f.key + '.')) {
+        const subKey = targetKey.substring(f.key.length + 1);
+        if (checkFields(f.fields, subKey)) return true;
+      }
+    }
+    return false;
+  }
+  return checkFields(section.fields, fieldKey);
+}
+
+function designPreservationScore(filePlans, afterFiles) {
+  let total = 0;
+  let matched = 0;
+  const details = [];
+  for (const plan of filePlans) {
+    if (!plan.designSnapshot || !afterFiles[plan.file]) continue;
+    let afterSnap;
+    try {
+      afterSnap = collectDesignSnapshot(afterFiles[plan.file]);
+    } catch {
+      continue;
+    }
+    const beforeC = plan.designSnapshot.classNames || [];
+    const afterC = afterSnap.classNames || [];
+    const beforeS = plan.designSnapshot.styles || [];
+    const afterS = afterSnap.styles || [];
+    total += beforeC.length + beforeS.length;
+    const classEqual = beforeC.length === afterC.length && beforeC.every((c, i) => c === afterC[i]);
+    const styleEqual = beforeS.length === afterS.length && beforeS.every((s, i) => s === afterS[i]);
+    matched += (classEqual ? beforeC.length : countOverlap(beforeC, afterC)) + (styleEqual ? beforeS.length : countOverlap(beforeS, afterS));
+    if (!classEqual || !styleEqual) {
+      details.push({ file: plan.file, classEqual, styleEqual });
+    }
+  }
+  if (total === 0) return { score: 100, details, total: 0 };
+  return { score: Math.round((matched / total) * 1000) / 10, details, total, matched };
+}
+
+function countOverlap(a, b) {
+  const bag = new Map();
+  for (const item of b) bag.set(item, (bag.get(item) || 0) + 1);
+  let n = 0;
+  for (const item of a) {
+    const left = bag.get(item) || 0;
+    if (left > 0) {
+      n++;
+      bag.set(item, left - 1);
+    }
+  }
+  return n;
+}
+
+function coverageMetrics({ analyses, plan, appliedCount, skippedDynamic, alreadyEditable }) {
+  const detected = analyses.reduce((n, a) => n + (a.candidates || []).filter((c) => c.kind !== 'decoration' && c.kind !== 'already-editable').length, 0);
+  const skippedLow = plan.skipped.filter((s) => s.reason === 'low-confidence' || (s.confidence || 0) < 0.6).length;
+  const transformed = appliedCount;
+  const coverage = detected === 0 ? 100 : Math.round((transformed / detected) * 1000) / 10;
+  return {
+    detectedEditableCandidates: detected,
+    safelyTransformed: transformed,
+    alreadyEditable,
+    skippedDynamic,
+    skippedLowConfidence: skippedLow,
+    editableCoverage: Math.min(100, coverage),
+  };
+}
+
+function idempotencyCheck(firstCode, secondCode) {
+  return firstCode === secondCode;
+}
+
+module.exports = {
+  validateAstFiles,
+  validateContracts,
+  designPreservationScore,
+  coverageMetrics,
+  isFieldInEditorSchema,
+  extractFieldPathsFromCode,
+  idempotencyCheck,
+};

package/src/arc/version.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const ARC_NAME = 'Deneb ARC';
+const ARC_FULL_NAME = 'Deneb Adaptive Refactoring Compiler';
+const ARC_VERSION = '1.1.0';
+const SCHEMA_VERSION = 2;
+const ENGINE_ID = 'deneb-arc';
+
+const CONFIDENCE = {
+  AUTO: 0.85,
+  VALIDATE: 0.6,
+  SKIP: 0.6,
+};
+
+module.exports = {
+  ARC_NAME,
+  ARC_FULL_NAME,
+  ARC_VERSION,
+  SCHEMA_VERSION,
+  ENGINE_ID,
+  CONFIDENCE,
+};

package/src/common/style-validation.ts

@@ -0,0 +1,30 @@
+import {
+  collectStyleTargetsFromHtml,
+  validateStyleTree,
+  type StyleValidationIssue,
+} from '@deneb-ui/core';
+
+import type { TemplateVisualEditingArtifact } from './template-visual-edit-contract';
+
+export function validateTemplateStyleContract(input: {
+  siteData: unknown;
+  artifacts: TemplateVisualEditingArtifact[];
+}): StyleValidationIssue[] {
+  const issues: StyleValidationIssue[] = [];
+  const htmlTargets = new Set<string>();
+
+  for (const artifact of input.artifacts) {
+    if (artifact.kind !== 'html') continue;
+    for (const target of collectStyleTargetsFromHtml(artifact.content)) {
+      htmlTargets.add(target);
+    }
+  }
+
+  const siteData =
+    input.siteData && typeof input.siteData === 'object' && !Array.isArray(input.siteData)
+      ? (input.siteData as Record<string, unknown>)
+      : null;
+  const styles = siteData?.styles;
+  issues.push(...validateStyleTree(styles, htmlTargets.size > 0 ? htmlTargets : undefined));
+  return issues;
+}

package/src/tools/deneb-fonts.cjs

@@ -0,0 +1,114 @@
+'use strict';
+
+const {
+  DENEB_FONT_REGISTRY,
+  DENEB_GOOGLE_FONT_COUNT,
+  listFontsByCategory,
+  normalizeFontId,
+  installProjectFonts,
+} = (() => {
+  try {
+    return {
+      ...require('@deneb-ui/core'),
+      ...require('@deneb-ui/core/install-fonts'),
+    };
+  } catch {
+    return {
+      ...require('../../../../packages/deneb-core/dist/index.js'),
+      ...require('../../../../packages/deneb-core/dist/fonts/installProject.js'),
+    };
+  }
+})();
+
+function runFontsList(options = {}) {
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        { count: DENEB_FONT_REGISTRY.length, google: DENEB_GOOGLE_FONT_COUNT, grouped: listFontsByCategory() },
+        null,
+        2,
+      ),
+    );
+    return 0;
+  }
+
+  console.log(
+    `\n\x1b[1mDENEB Font Catalog\x1b[0m — ${DENEB_FONT_REGISTRY.length} presets (${DENEB_GOOGLE_FONT_COUNT} on Google Fonts)\n`,
+  );
+  const grouped = listFontsByCategory();
+  for (const [category, fonts] of Object.entries(grouped)) {
+    console.log(`\x1b[36m${category}\x1b[0m`);
+    for (const font of fonts) {
+      const badge = font.googleFonts ? 'google' : font.substituteId ? `→ ${font.substituteId}` : 'system';
+      console.log(`  ${font.id.padEnd(22)} ${font.label.padEnd(24)} \x1b[90m${badge}\x1b[0m`);
+    }
+    console.log('');
+  }
+  return 0;
+}
+
+function parseInstallArgs(argv) {
+  const fontIds = [];
+  let all = false;
+  let target = '.';
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--all') all = true;
+    else if (arg === '--font' || arg === '-f') fontIds.push(normalizeFontId(argv[++i] || ''));
+    else if (arg.startsWith('--font=')) fontIds.push(normalizeFontId(arg.split('=')[1]));
+    else if (arg === '--json') continue;
+    else if (!arg.startsWith('-')) target = arg;
+  }
+  return { target, fontIds: fontIds.filter(Boolean), all };
+}
+
+function runFontsInstall(projectDirInput, args = []) {
+  const parsed = Array.isArray(args)
+    ? { target: projectDirInput, fontIds: parseInstallArgs(args).fontIds, all: parseInstallArgs(args).all }
+    : parseInstallArgs([projectDirInput, ...(args || [])]);
+
+  const result = installProjectFonts({
+    projectDir: parsed.target || projectDirInput || '.',
+    fontIds: parsed.fontIds,
+    all: parsed.all,
+  });
+  return result.ok ? 0 : 1;
+}
+
+function runFontsCommand(argv = []) {
+  const sub = argv[0];
+  const rest = argv.slice(1);
+  let json = rest.includes('--json');
+
+  if (sub === 'list') return runFontsList({ json });
+  if (sub === 'install') {
+    const parsed = parseInstallArgs(rest);
+    const result = installProjectFonts({
+      projectDir: parsed.target,
+      fontIds: parsed.fontIds,
+      all: parsed.all,
+    });
+    return result.ok ? 0 : 1;
+  }
+
+  console.log(`Usage: deneb fonts <command> [directory] [options]
+
+Commands:
+  list                 Show all ${DENEB_FONT_REGISTRY.length} curated DENEB font presets
+  install [dir]        Download @fontsource packages, write CSS, patch layout
+
+Options:
+  --font <id>          Install a specific font (repeatable)
+  --all                Install all Google Fonts presets (~${DENEB_GOOGLE_FONT_COUNT} packages)
+  --json               JSON output for list
+
+Examples:
+  deneb fonts list
+  deneb fonts install .
+  deneb fonts install . --font inter --font playfair-display
+  deneb fonts install . --all
+`);
+  return 1;
+}
+
+module.exports = { runFontsCommand, runFontsInstall, runFontsList };