@deneb-ui/cli 2.0.91 → 2.0.93

package/src/arc/manifest.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+const fs = require('fs');
 const path = require('path');
 const { readJsonSafe, writeJson, deepMerge, isPlainObject } = require('./fs-utils.cjs');
 const { ARC_VERSION, SCHEMA_VERSION } = require('./version.cjs');
@@ -12,6 +13,7 @@ const {
   canonicalizeMarkerPath,
   wildcardPath,
 } = require('./fivora-contract.cjs');
+const { sanitizeEditorSections } = require('./fivora-schema-authority.cjs');
 
 function pruneUnboundLeaves(content, isBound) {
   function walk(node, path) {
@@ -322,14 +324,24 @@ function collectStylesFromPlan(plan, existingStyles) {
   return styles;
 }
 
-function baseContent(projectName, routes) {
+function baseContent(projectName, routes, projectDir) {
   const navLabels = {};
   for (const page of routes) navLabels[page.id] = page.label || page.id;
+  let logoUrl = '';
+  if (projectDir) {
+    const candidates = ['logo.svg', 'logo.png', 'logo-dark.svg', 'icon.svg', 'icon.png', 'fivora-logo.png'];
+    for (const cand of candidates) {
+      if (fs.existsSync(path.join(projectDir, 'public', cand))) {
+        logoUrl = `/${cand}`;
+        break;
+      }
+    }
+  }
   return {
     common: {
       websiteTitle: projectName,
       shortDescription: `A high-converting storefront built for the Fivora platform.`,
-      logoUrl: '/fivora-logo.png',
+      logoUrl,
       headerCtaLabel: 'Contact Us',
       copyright: `© ${new Date().getFullYear()} ${projectName}. All rights reserved.`,
       navLabels,
@@ -519,7 +531,7 @@ function buildSiteDataAndManifest({
       ...(r.required ? { required: true } : {}),
     }));
 
-  const content = baseContent(projectName, routes);
+  const content = baseContent(projectName, routes, projectDir);
 
   // Recipes may hint schema shape, but must not dump another storefront's content
   // into an unrelated project. Extracted values always win.
@@ -678,7 +690,7 @@ function buildSiteDataAndManifest({
     pages: routes,
     editorSchema: {
       version: 1,
-      sections: editorSections,
+      sections: sanitizeEditorSections(editorSections),
     },
   };
 

package/src/arc/planner.cjs

@@ -6,6 +6,7 @@ const { classifyHref } = require('./adapters.cjs');
 const { loadFingerprintBoost } = require('./learning.cjs');
 const { appendStyleBindTransforms } = require('./style-candidates.cjs');
 const { classifyDataCandidate, isEditableClassification } = require('./data-classification.cjs');
+const { recoverCandidateConfidence } = require('./confidence-recovery.cjs');
 
 function recipeBoost(candidate, recipe) {
   if (!recipe) return 0;
@@ -44,10 +45,21 @@ function planTransformations({ profile, analyses, recipe, ir }) {
         });
         continue;
       }
-      const confidence = Math.min(
+      let confidence = Math.min(
         0.99,
         (candidate.confidence || 0) + recipeBoost(candidate, recipe) + (fingerprintHint.boost || 0),
       );
+
+      // Multi-stage recovery pass for low-confidence candidates (< 0.60)
+      let recovered = false;
+      if (confidence < CONFIDENCE.VALIDATE && !candidate.skip) {
+        const rec = recoverCandidateConfidence(candidate);
+        if (rec.recovered) {
+          confidence = rec.confidence;
+          recovered = true;
+        }
+      }
+
       const dataClass = classifyDataCandidate(candidate, {
         file: candidate.file,
         componentName: candidate.componentName,

package/src/arc/transform-proof.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * TransformProof (P8, P9, P10)
+ * 
+ * Formal evidence record for every AST mutation executed by ARC.
+ * Captures source provenance, target schema paths, preconditions,
+ * and multi-stage verification proofs.
+ */
+
+class TransformProof {
+  constructor({
+    transformId,
+    type,
+    source = {},
+    target = {},
+    preconditions = [],
+    verification = {},
+  }) {
+    this.transformId = transformId || `tr_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    this.type = type; // 'TEXT_BIND' | 'ACTION_SPLIT' | 'COLLECTION_BIND' | 'IMAGE_BIND' | 'STYLE_BIND'
+    this.source = {
+      file: source.file || '',
+      loc: source.loc || '',
+      tag: source.tag || '',
+      originalText: source.originalText || '',
+    };
+    this.target = {
+      path: target.path || '',
+      type: target.type || 'text',
+      section: target.section || '',
+    };
+    this.preconditions = Array.isArray(preconditions) ? preconditions : [];
+    this.verification = {
+      astParsed: Boolean(verification.astParsed ?? true),
+      contractValid: Boolean(verification.contractValid ?? true),
+      runtimeTestable: Boolean(verification.runtimeTestable ?? true),
+      designPreserved: Boolean(verification.designPreserved ?? true),
+    };
+    this.timestamp = Date.now();
+  }
+
+  isVerified() {
+    return (
+      this.verification.astParsed &&
+      this.verification.contractValid &&
+      this.verification.designPreserved
+    );
+  }
+
+  toJSON() {
+    return {
+      transformId: this.transformId,
+      type: this.type,
+      source: this.source,
+      target: this.target,
+      preconditions: this.preconditions,
+      verification: this.verification,
+      timestamp: this.timestamp,
+    };
+  }
+}
+
+class ProofRegistry {
+  constructor() {
+    this.proofs = [];
+  }
+
+  record(proofData) {
+    const proof = new TransformProof(proofData);
+    this.proofs.push(proof);
+    return proof;
+  }
+
+  getAll() {
+    return [...this.proofs];
+  }
+
+  getVerified() {
+    return this.proofs.filter((p) => p.isVerified());
+  }
+
+  verifyPhaseInvariants({ plannedCount, boundCount, schemaPathCount }) {
+    const violations = [];
+
+    // Invariant 1: Every planned transformation must emit a proof
+    if (this.proofs.length < plannedCount) {
+      violations.push(`Phase Invariant Violation: Planned ${plannedCount} transforms, but only emitted ${this.proofs.length} proofs.`);
+    }
+
+    // Invariant 2: Every verified proof must have a non-empty target path
+    const emptyTargets = this.proofs.filter((p) => !p.target.path);
+    if (emptyTargets.length > 0) {
+      violations.push(`Phase Invariant Violation: Found ${emptyTargets.length} proofs with empty target paths.`);
+    }
+
+    return {
+      passed: violations.length === 0,
+      violations,
+    };
+  }
+
+  toJSON() {
+    return this.proofs.map((p) => (typeof p.toJSON === 'function' ? p.toJSON() : p));
+  }
+}
+
+module.exports = {
+  TransformProof,
+  ProofRegistry,
+};

package/src/arc/transforms/healing/sanitizer.cjs

@@ -12,6 +12,7 @@ const {
 } = require('../../ast.cjs');
 const { BROAD_CONTENT_CONTAINERS } = require('../../fivora-contract.cjs');
 const { injectSiteDataHook } = require('../runtime/provider.cjs');
+const { ensureClientDirective } = require('../../rsc-boundary.cjs');
 
 function sanitizeContradictoryMarkers(ast) {
   let cleaned = 0;
@@ -378,11 +379,37 @@ function healDecorativeOverlays(ast) {
 
 function healMissingSiteDataHooks(code, filePath = 'file.tsx') {
   if (!code.includes('siteData')) return code;
+
+  // Never touch files mounting SiteDataProvider
+  if (code.includes('SiteDataProvider')) return code;
+
+  // Never touch Server Component layouts or metadata files
+  const isLayout = /(?:^|[/\\])layout\.(?:tsx|jsx|js|ts)$/.test(filePath);
+  const isClient = /['"]use client['"]/.test(code);
+  if (isLayout && !isClient) return code;
+
+  // Never touch plain utilities or config files that contain zero JSX
+  const hasJsx = /<[a-zA-Z][\s\S]*?>/.test(code);
+  const isHookFile = /(?:^|[/\\])use[A-Z]/.test(filePath);
+  if (!hasJsx && !isHookFile) return code;
+
   try {
     const ast = parseSource(code, filePath);
-    const injected = injectSiteDataHook(ast);
+    const fileContext = {
+      filePath,
+      isServerComponent: !isClient,
+      isClientComponent: isClient,
+      mountsProvider: code.includes('SiteDataProvider'),
+    };
+    const injected = injectSiteDataHook(ast, filePath, fileContext);
     if (injected) {
-      ensureImport(ast, '@deneb-ui/ui', ['useSiteData']);
+      if (!isClient) {
+        ensureClientDirective(ast);
+      }
+      const importSpecifier = code.includes('@/lib/siteDataContext')
+        ? '@/lib/siteDataContext'
+        : '@deneb-ui/ui';
+      ensureImport(ast, importSpecifier, ['useSiteData']);
       return printSource(ast, code);
     }
   } catch {}

package/src/arc/transforms/primitives/text.cjs

@@ -7,9 +7,25 @@ const {
 } = require('../../ast.cjs');
 
 function replaceTextChildren(node, fieldPath, fallback, fieldType) {
+  const children = node.children || [];
+  const hasDynamicExpr = children.some(
+    (c) =>
+      c &&
+      c.type === 'JSXExpressionContainer' &&
+      c.expression &&
+      c.expression.type !== 'StringLiteral' &&
+      c.expression.type !== 'Literal'
+  );
+
+  // If there are dynamic runtime expressions, preserve them and wrap the static literal text
+  if (hasDynamicExpr) {
+    wrapLiteralTextChildren(node, fieldPath, fallback);
+    return;
+  }
+
   const nextChildren = [];
   let replaced = false;
-  for (const child of node.children || []) {
+  for (const child of children) {
     if (!child) continue;
     if (child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
       nextChildren.push(b.jsxExpressionContainer(siteDataBinding(fieldPath.split('.'), fallback, fieldType)));
@@ -35,7 +51,7 @@ function replaceTextChildren(node, fieldPath, fallback, fieldType) {
 
 /**
  * Replaces literal text children with an editable <span>, leaving the container
- * element and every one of its classes untouched.
+ * element, icons, and dynamic expressions untouched.
  */
 function wrapLiteralTextChildren(node, fieldPath, fallback) {
   const nextChildren = [];

package/src/arc/transforms/routing/page-key.cjs

@@ -27,11 +27,9 @@ function inferPageKey(relativeFile) {
  * rather than being guessed from the filename — Pages Router uses
  * `pages/contact.jsx`, App Router uses `app/contact/page.tsx`.
  *
- * `<main>` is preferred, but any project shape is supported by falling back to
- * the outermost element the page component returns.
+ * <main> is preferred, then any host element (div/section), then any root component element.
  */
 function instrumentPageKey(code, relativeFile, pageKey) {
-  if (code.includes('data-preview-page-key')) return { code, updated: false };
   const key = pageKey || inferPageKey(relativeFile);
 
   let ast;
@@ -41,40 +39,61 @@ function instrumentPageKey(code, relativeFile, pageKey) {
     return { code, updated: false };
   }
 
-  const attribute = () =>
-    b.jsxAttribute(b.jsxIdentifier('data-preview-page-key'), b.stringLiteral(key));
-
+  let existingAttr = null;
   let target = null;
+  let fallbackTarget = null;
+
   recast.types.visit(ast, {
     visitJSXOpeningElement(pathNode) {
+      const attrs = pathNode.node.attributes || [];
+      const pageKeyAttr = attrs.find(
+        (a) => a.type === 'JSXAttribute' && a.name && a.name.name === 'data-preview-page-key'
+      );
+      if (pageKeyAttr) {
+        existingAttr = pageKeyAttr;
+        return false;
+      }
+
       const name = pathNode.node.name && pathNode.node.name.name;
       if (!target && name === 'main') {
         target = pathNode.node;
-        return false;
+      } else if (!fallbackTarget && typeof name === 'string' && /^[a-z]/.test(name)) {
+        fallbackTarget = pathNode.node;
+      } else if (!fallbackTarget) {
+        // Root custom component (e.g. <PlatformProductDetail />)
+        fallbackTarget = pathNode.node;
       }
+
       this.traverse(pathNode);
     },
   });
 
-  if (!target) {
-    // No <main>: use the first host element of the returned tree so the marker
-    // still lands inside this route's exported HTML.
-    recast.types.visit(ast, {
-      visitJSXElement(pathNode) {
-        if (target) return false;
-        const name = getJsxName(pathNode.node);
-        if (typeof name === 'string' && /^[a-z]/.test(name)) {
-          target = pathNode.node.openingElement;
-          return false;
-        }
-        this.traverse(pathNode);
-      },
-    });
+  // If already has data-preview-page-key, ensure its value matches the expected page key
+  if (existingAttr) {
+    let currentValue = null;
+    if (existingAttr.value) {
+      if (existingAttr.value.type === 'StringLiteral') {
+        currentValue = existingAttr.value.value;
+      } else if (existingAttr.value.type === 'JSXExpressionContainer' && existingAttr.value.expression.type === 'StringLiteral') {
+        currentValue = existingAttr.value.expression.value;
+      }
+    }
+    if (currentValue === key) {
+      return { code, updated: false };
+    }
+    // Update to correct key
+    existingAttr.value = b.stringLiteral(key);
+    return { code: printSource(ast, code), updated: true };
   }
 
-  if (!target) return { code, updated: false };
-  target.attributes = target.attributes || [];
-  target.attributes.unshift(attribute());
+  const finalTarget = target || fallbackTarget;
+  if (!finalTarget) return { code, updated: false };
+
+  finalTarget.attributes = finalTarget.attributes || [];
+  finalTarget.attributes.unshift(
+    b.jsxAttribute(b.jsxIdentifier('data-preview-page-key'), b.stringLiteral(key))
+  );
+
   return { code: printSource(ast, code), updated: true };
 }
 

package/src/arc/transforms/runtime/provider.cjs

@@ -77,11 +77,24 @@ function functionReferencesSiteData(fn) {
   return found;
 }
 
-function injectSiteDataHook(ast) {
+const {
+  SCOPE_STATUS,
+  classifySiteDataRequirement,
+} = require('./site-data-scope.cjs');
+
+function injectSiteDataHook(ast, filePath = 'file.tsx', options = {}) {
   let injected = false;
   let anyFunctionReferencedSiteData = false;
   let alreadyHasUseSiteData = false;
 
+  const fileContext = {
+    filePath,
+    isServerComponent: options.isServerComponent ?? false,
+    isClientComponent: options.isClientComponent ?? false,
+    mountsProvider: options.mountsProvider ?? false,
+  };
+
+  // Inspect file-level AST properties
   recast.types.visit(ast, {
     visitCallExpression(pathNode) {
       if (pathNode.node.callee && pathNode.node.callee.name === 'useSiteData') {
@@ -90,13 +103,35 @@ function injectSiteDataHook(ast) {
       }
       this.traverse(pathNode);
     },
+    visitJSXElement(pathNode) {
+      const opening = pathNode.node.openingElement;
+      if (opening && opening.name) {
+        const name = opening.name.name;
+        if (name === 'SiteDataProvider' || name === 'BaseSiteDataProvider' || name === 'DenebDataProvider') {
+          fileContext.mountsProvider = true;
+        }
+      }
+      this.traverse(pathNode);
+    },
   });
 
-  function injectIntoFunction(fn) {
+  // If this file mounts SiteDataProvider, consumer hook injection is forbidden
+  if (fileContext.mountsProvider) {
+    return false;
+  }
+
+  function injectIntoFunction(fn, fnName) {
     if (!fn || !fn.body || fn.body.type !== 'BlockStatement') return false;
+
+    const requirement = classifySiteDataRequirement(fn, fnName, fileContext);
+    if (requirement !== SCOPE_STATUS.HOOK_SAFE) {
+      return false;
+    }
+
     const body = fn.body.body;
     const already = body.some((stmt) => recast.print(stmt).code.includes('useSiteData'));
     if (already) return false;
+
     const hook = b.variableDeclaration('const', [
       b.variableDeclarator(
         b.identifier('siteData'),
@@ -108,40 +143,45 @@ function injectSiteDataHook(ast) {
     return true;
   }
 
-  // Pass 1: Inject useSiteData() into EVERY component function that references siteData
+  // Pass 1: Inject useSiteData() into component functions that reference siteData
   recast.types.visit(ast, {
     visitFunctionDeclaration(pathNode) {
+      const name = pathNode.node.id ? pathNode.node.id.name : null;
       if (functionReferencesSiteData(pathNode.node)) {
         anyFunctionReferencedSiteData = true;
-        if (injectIntoFunction(pathNode.node)) injected = true;
+        if (injectIntoFunction(pathNode.node, name)) injected = true;
       }
       this.traverse(pathNode);
     },
     visitFunctionExpression(pathNode) {
+      const parent = pathNode.parent && pathNode.parent.node;
+      const name = parent && parent.type === 'VariableDeclarator' && parent.id ? parent.id.name : null;
       if (functionReferencesSiteData(pathNode.node)) {
         anyFunctionReferencedSiteData = true;
-        if (injectIntoFunction(pathNode.node)) injected = true;
+        if (injectIntoFunction(pathNode.node, name)) injected = true;
       }
       this.traverse(pathNode);
     },
     visitArrowFunctionExpression(pathNode) {
+      const parent = pathNode.parent && pathNode.parent.node;
+      const name = parent && parent.type === 'VariableDeclarator' && parent.id ? parent.id.name : null;
       if (functionReferencesSiteData(pathNode.node)) {
         anyFunctionReferencedSiteData = true;
-        if (injectIntoFunction(pathNode.node)) injected = true;
+        if (injectIntoFunction(pathNode.node, name)) injected = true;
       }
       this.traverse(pathNode);
     },
   });
 
-  // Pass 2: If no component references siteData yet (e.g. before subsequent AST edits),
-  // ensure the primary component receives useSiteData()
+  // Pass 2: If no component references siteData yet, ensure the primary component receives useSiteData()
   if (!injected && !anyFunctionReferencedSiteData && !alreadyHasUseSiteData) {
     recast.types.visit(ast, {
       visitExportDefaultDeclaration(pathNode) {
         if (injected) return false;
         const decl = pathNode.node.declaration;
         if (decl && (decl.type === 'FunctionDeclaration' || decl.type === 'ArrowFunctionExpression' || decl.type === 'FunctionExpression')) {
-          injected = injectIntoFunction(decl);
+          const name = decl.id ? decl.id.name : 'DefaultExport';
+          injected = injectIntoFunction(decl, name);
         }
         this.traverse(pathNode);
       },
@@ -149,7 +189,7 @@ function injectSiteDataHook(ast) {
         if (injected) return false;
         const name = pathNode.node.id && pathNode.node.id.name;
         if (name && /^[A-Z]/.test(name)) {
-          injected = injectIntoFunction(pathNode.node);
+          injected = injectIntoFunction(pathNode.node, name);
           return false;
         }
         this.traverse(pathNode);
@@ -159,7 +199,7 @@ function injectSiteDataHook(ast) {
         const id = pathNode.node.id;
         const init = pathNode.node.init;
         if (id && id.type === 'Identifier' && /^[A-Z]/.test(id.name) && init && (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression')) {
-          injected = injectIntoFunction(init);
+          injected = injectIntoFunction(init, id.name);
           return false;
         }
         this.traverse(pathNode);
@@ -167,16 +207,6 @@ function injectSiteDataHook(ast) {
     });
   }
 
-  if (!injected && !anyFunctionReferencedSiteData && !alreadyHasUseSiteData) {
-    recast.types.visit(ast, {
-      visitFunctionDeclaration(pathNode) {
-        if (injected) return false;
-        injected = injectIntoFunction(pathNode.node);
-        return false;
-      },
-    });
-  }
-
   return injected;
 }