@deneb-ui/cli 2.0.22 → 2.0.24

package/src/arc/next-config.cjs

@@ -0,0 +1,279 @@
+'use strict';
+
+/**
+ * Fivora hosts storefronts as static exports served from merchant sub-paths.
+ * A converted project therefore needs `output: 'export'`, unoptimized images
+ * and a NEXT_PUBLIC_SITE_BASE_PATH-driven basePath, or `deneb package` fails
+ * its sandbox build. ARC configures this via AST so an existing config keeps
+ * its plugins, comments and formatting.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const recast = require('recast');
+const { parseSource, printSource, b } = require('./ast.cjs');
+
+const CONFIG_FILENAMES = [
+  'next.config.ts',
+  'next.config.mjs',
+  'next.config.js',
+  'next.config.cjs',
+];
+
+const BASE_PATH_ENV = 'NEXT_PUBLIC_SITE_BASE_PATH';
+
+function findNextConfig(projectDir) {
+  for (const name of CONFIG_FILENAMES) {
+    const abs = path.join(projectDir, name);
+    if (fs.existsSync(abs)) return { abs, name };
+  }
+  return null;
+}
+
+function createNextConfig(projectDir, isTypeScript) {
+  const name = isTypeScript ? 'next.config.ts' : 'next.config.mjs';
+  const abs = path.join(projectDir, name);
+  const typed = isTypeScript
+    ? `import type { NextConfig } from 'next';\n\n`
+    : '';
+  const annotation = isTypeScript ? ': NextConfig' : '';
+
+  const code = `${typed}const basePath = process.env.${BASE_PATH_ENV} || '';
+
+const nextConfig${annotation} = {
+  output: 'export',
+  basePath: basePath || undefined,
+  assetPrefix: basePath ? \`\${basePath}/\` : undefined,
+  images: {
+    unoptimized: true,
+  },
+};
+
+export default nextConfig;
+`;
+
+  fs.writeFileSync(abs, code, 'utf8');
+  return { file: name, created: true, updated: true, warnings: [] };
+}
+
+/** Locates the object literal that describes the Next.js config. */
+function findConfigObject(ast) {
+  let found = null;
+
+  recast.types.visit(ast, {
+    visitExportDefaultDeclaration(pathNode) {
+      const declaration = pathNode.node.declaration;
+      if (declaration?.type === 'ObjectExpression') {
+        found = declaration;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+    visitAssignmentExpression(pathNode) {
+      const node = pathNode.node;
+      const left = recast.print(node.left).code;
+      if (!found && /^module\.exports$/.test(left) && node.right?.type === 'ObjectExpression') {
+        found = node.right;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  if (found) return found;
+
+  // `const nextConfig = {...}` possibly wrapped by a plugin on export.
+  recast.types.visit(ast, {
+    visitVariableDeclarator(pathNode) {
+      const node = pathNode.node;
+      if (
+        !found &&
+        node.id?.type === 'Identifier' &&
+        /config/i.test(node.id.name) &&
+        node.init?.type === 'ObjectExpression'
+      ) {
+        found = node.init;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  return found;
+}
+
+function hasProperty(objectExpression, key) {
+  return (objectExpression.properties || []).some(
+    (property) =>
+      (property.type === 'ObjectProperty' || property.type === 'Property') &&
+      (property.key?.name === key || property.key?.value === key)
+  );
+}
+
+function propertyValue(objectExpression, key) {
+  const property = (objectExpression.properties || []).find(
+    (candidate) =>
+      (candidate.type === 'ObjectProperty' || candidate.type === 'Property') &&
+      (candidate.key?.name === key || candidate.key?.value === key)
+  );
+  return property ? property.value : null;
+}
+
+function hasBasePathDeclaration(ast) {
+  let declared = false;
+  recast.types.visit(ast, {
+    visitVariableDeclarator(pathNode) {
+      if (pathNode.node.id?.type === 'Identifier' && pathNode.node.id.name === 'basePath') {
+        declared = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return declared;
+}
+
+function insertBasePathDeclaration(ast) {
+  const program = ast.program || ast;
+  const declaration = b.variableDeclaration('const', [
+    b.variableDeclarator(
+      b.identifier('basePath'),
+      b.logicalExpression(
+        '||',
+        b.memberExpression(
+          b.memberExpression(b.identifier('process'), b.identifier('env')),
+          b.identifier(BASE_PATH_ENV)
+        ),
+        b.stringLiteral('')
+      )
+    ),
+  ]);
+
+  const body = program.body || [];
+  let insertAt = 0;
+  for (let index = 0; index < body.length; index += 1) {
+    const node = body[index];
+    const isDirective =
+      node.type === 'ExpressionStatement' &&
+      (node.expression?.type === 'StringLiteral' || node.expression?.type === 'Literal');
+    if (node.type === 'ImportDeclaration' || isDirective) insertAt = index + 1;
+    else break;
+  }
+  body.splice(insertAt, 0, declaration);
+}
+
+/**
+ * Adds the static-export settings a converted project needs, leaving any
+ * setting the developer already chose untouched.
+ */
+function ensureStaticExportConfig(projectDir, profile) {
+  const existing = findNextConfig(projectDir);
+  if (!existing) {
+    return createNextConfig(projectDir, profile?.language !== 'javascript');
+  }
+
+  const original = fs.readFileSync(existing.abs, 'utf8');
+  let ast;
+  try {
+    ast = parseSource(original, existing.name);
+  } catch (err) {
+    return {
+      file: existing.name,
+      created: false,
+      updated: false,
+      warnings: [
+        `${existing.name} could not be parsed (${err.message}). Add output: 'export', images.unoptimized and a ${BASE_PATH_ENV} basePath manually.`,
+      ],
+    };
+  }
+
+  const configObject = findConfigObject(ast);
+  if (!configObject) {
+    return {
+      file: existing.name,
+      created: false,
+      updated: false,
+      warnings: [
+        `${existing.name} does not expose a plain config object, so ARC left it unchanged. Add output: 'export', images.unoptimized and a ${BASE_PATH_ENV} basePath manually.`,
+      ],
+    };
+  }
+
+  const warnings = [];
+  let updated = false;
+
+  if (!hasProperty(configObject, 'output')) {
+    configObject.properties.push(
+      b.objectProperty(b.identifier('output'), b.stringLiteral('export'))
+    );
+    updated = true;
+  } else {
+    const value = propertyValue(configObject, 'output');
+    if (value?.value !== 'export') {
+      warnings.push(
+        `${existing.name} sets output: '${value?.value}'. Fivora requires output: 'export'; ARC left your value in place.`
+      );
+    }
+  }
+
+  if (!hasProperty(configObject, 'images')) {
+    configObject.properties.push(
+      b.objectProperty(
+        b.identifier('images'),
+        b.objectExpression([
+          b.objectProperty(b.identifier('unoptimized'), b.booleanLiteral(true)),
+        ])
+      )
+    );
+    updated = true;
+  } else {
+    const images = propertyValue(configObject, 'images');
+    if (images?.type === 'ObjectExpression' && !hasProperty(images, 'unoptimized')) {
+      images.properties.push(
+        b.objectProperty(b.identifier('unoptimized'), b.booleanLiteral(true))
+      );
+      updated = true;
+    }
+  }
+
+  if (!hasProperty(configObject, 'basePath')) {
+    if (!hasBasePathDeclaration(ast)) insertBasePathDeclaration(ast);
+    configObject.properties.push(
+      b.objectProperty(
+        b.identifier('basePath'),
+        b.logicalExpression('||', b.identifier('basePath'), b.identifier('undefined'))
+      )
+    );
+    configObject.properties.push(
+      b.objectProperty(
+        b.identifier('assetPrefix'),
+        b.conditionalExpression(
+          b.identifier('basePath'),
+          b.templateLiteral(
+            [
+              b.templateElement({ raw: '', cooked: '' }, false),
+              b.templateElement({ raw: '/', cooked: '/' }, true),
+            ],
+            [b.identifier('basePath')]
+          ),
+          b.identifier('undefined')
+        )
+      )
+    );
+    updated = true;
+  }
+
+  if (!updated) {
+    return { file: existing.name, created: false, updated: false, warnings };
+  }
+
+  const code = printSource(ast, original);
+  fs.writeFileSync(existing.abs, code, 'utf8');
+  return { file: existing.name, created: false, updated: true, warnings };
+}
+
+module.exports = {
+  ensureStaticExportConfig,
+  findNextConfig,
+  BASE_PATH_ENV,
+};

package/src/arc/planner.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+const { CONFIDENCE } = require('./version.cjs');
+const { inferSection, inferFieldName, buildFieldPath, classifyFieldType, uniquePath } = require('./field-paths.cjs');
+const { classifyHref } = require('./adapters.cjs');
+const { loadFingerprintBoost } = require('./learning.cjs');
+const { appendStyleBindTransforms } = require('./style-candidates.cjs');
+
+function recipeBoost(candidate, recipe) {
+  if (!recipe) return 0;
+  let boost = 0;
+  if (recipe.actionRules?.splitActionAndLabel && candidate.operation === 'split-action-contract') boost += 0.03;
+  const keywords = recipe.signatures?.keywords || [];
+  const hay = `${candidate.tag} ${candidate.value || ''} ${candidate.label || ''} ${candidate.file || ''}`.toLowerCase();
+  if (keywords.some((kw) => hay.includes(String(kw).toLowerCase()))) boost += 0.02;
+  return Math.min(boost, 0.08);
+}
+
+function decideThreshold(confidence, candidate) {
+  if (candidate.skip) return 'skip';
+  if (confidence >= CONFIDENCE.AUTO) return 'auto';
+  if (confidence >= CONFIDENCE.VALIDATE) return 'validate';
+  return 'skip';
+}
+
+function planTransformations({ profile, analyses, recipe }) {
+  const usedPaths = new Set();
+  const filePlans = [];
+  const skipped = [];
+  const explanations = [];
+
+  for (const analysis of analyses) {
+    const transformations = [];
+    for (const candidate of analysis.candidates || []) {
+      const fingerprintHint = loadFingerprintBoost(candidate.fingerprint);
+      if (fingerprintHint.skip) {
+        skipped.push({
+          file: candidate.file,
+          loc: candidate.loc,
+          reason: 'fingerprint-deprecated',
+          confidence: candidate.confidence || 0,
+          kind: candidate.kind,
+        });
+        continue;
+      }
+      const confidence = Math.min(
+        0.99,
+        (candidate.confidence || 0) + recipeBoost(candidate, recipe) + (fingerprintHint.boost || 0),
+      );
+      const decision = decideThreshold(confidence, candidate);
+      const section = inferSection({
+        componentName: candidate.componentName,
+        fileName: candidate.file,
+        className: candidate.className,
+        parentName: candidate.parentName,
+        tag: candidate.tag,
+        role: candidate.role,
+      });
+
+      let scope = candidate.ownerScope || 'home';
+      if (candidate.extra && ['instagram', 'facebook', 'tiktok', 'twitter', 'youtube', 'linkedin', 'pinterest'].includes(candidate.extra.action || candidate.extra.platform)) {
+        scope = 'common';
+      }
+      if (section === 'header' || section === 'footer' || section === 'navigation' || section === 'announcement') {
+        scope = 'common';
+      }
+
+      const extra = { ...(candidate.extra || {}) };
+      if (candidate.operation === 'split-action-contract') {
+        extra.action = extra.action || classifyHref(candidate.value);
+        extra.paired = true;
+      }
+
+      let transform = {
+        loc: candidate.loc,
+        operation: candidate.operation || candidate.kind,
+        tag: candidate.tag,
+        file: candidate.file,
+        confidence,
+        decision,
+        reason: candidate.reason,
+        recipeId: recipe?.name || recipe?.id || null,
+        fingerprint: candidate.fingerprint,
+        fallback: candidate.value,
+        labelFallback: candidate.label,
+        fieldType: classifyFieldType(candidate.kind, candidate.value || candidate.label),
+        section,
+        scope,
+        explain: {
+          detected: `${candidate.tag} ${candidate.kind}`,
+          why: candidate.reason,
+          recipe: recipe?.name || null,
+          confidence,
+          fingerprintBoost: fingerprintHint.boost || 0,
+          fingerprintState: fingerprintHint.state || null,
+        },
+      };
+
+      if (decision === 'skip' || candidate.skip || candidate.kind === 'already-editable' || candidate.kind === 'decoration') {
+        skipped.push({
+          file: candidate.file,
+          loc: candidate.loc,
+          reason: candidate.reason || 'low-confidence',
+          confidence,
+          kind: candidate.kind,
+        });
+        continue;
+      }
+
+      if (candidate.operation === 'split-action-contract') {
+        const urlName = inferFieldName('url', candidate.tag, candidate.label, extra);
+        const labelName = inferFieldName('label', candidate.tag, candidate.label, { ...extra, paired: true });
+        const actionSection = sectionForAction(scope, section, extra);
+        transform.urlField = buildFieldPath({ scope, section: actionSection, field: urlName, used: usedPaths });
+        const sibling = transform.urlField.split('.');
+        sibling[sibling.length - 1] = labelName;
+        transform.labelField = uniquePath(usedPaths, sibling.join('.'));
+        transform.fieldType = 'url';
+        transform.labelFieldType = 'text';
+      } else if (candidate.operation === 'extract-url') {
+        transform.field = buildFieldPath({
+          scope,
+          section: sectionForAction(scope, section, extra),
+          field: inferFieldName('url', candidate.tag, candidate.value, extra),
+          used: usedPaths,
+        });
+        transform.fieldType = 'url';
+      } else if (candidate.operation === 'extract-image') {
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: inferFieldName('image', candidate.tag, extra.alt, extra),
+          used: usedPaths,
+        });
+        transform.fieldType = 'image';
+      } else if (candidate.operation === 'extract-alt') {
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: inferFieldName('alt', candidate.tag, candidate.value, extra),
+          used: usedPaths,
+        });
+        transform.fieldType = 'text';
+      } else if (candidate.operation === 'wrap-text-span') {
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: inferFieldName('text', candidate.tag, candidate.value, extra),
+          used: usedPaths,
+        });
+        transform.fieldType = 'text';
+      } else if (candidate.operation === 'extract-placeholder') {
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: inferFieldName('placeholder', candidate.tag, candidate.value, extra),
+          used: usedPaths,
+        });
+      } else if (candidate.operation === 'collection-conversion') {
+        // A collection is named after the developer's own array variable so the
+        // merchant sees "products", not "items2".
+        transform.listField = uniquePath(usedPaths, `${scope}.${extra.binding || 'items'}`);
+        transform.field = undefined;
+        transform.fieldType = 'list';
+        transform.itemFields = (extra.itemFields || []).map((field) => ({
+          key: field.key,
+          type: field.role === 'image' ? 'image' : field.role === 'url' ? 'url' : 'text',
+        }));
+        transform.items = candidate.value.map((item) => item.value);
+        transform.itemParam = extra.itemParam;
+        transform.indexParam = extra.indexParam;
+        if (!transform.itemFields.length || !extra.objectItems) transform.decision = 'skip';
+      } else {
+        transform.field = buildFieldPath({
+          scope,
+          section,
+          field: inferFieldName(candidate.kind, extra.tag || candidate.tag, candidate.value, extra),
+          used: usedPaths,
+        });
+      }
+
+      if (transform.decision === 'skip') {
+        skipped.push({
+          file: candidate.file,
+          loc: candidate.loc,
+          reason: 'collection-not-safe',
+          confidence,
+          kind: candidate.kind,
+        });
+        continue;
+      }
+
+      transformations.push(transform);
+      explanations.push(transform.explain);
+    }
+
+    filePlans.push({
+      file: analysis.relativeFile,
+      alreadyEditable: analysis.alreadyEditable,
+      parseError: analysis.reason === 'parse-error' ? analysis.error : null,
+      skippedFile: analysis.skipped,
+      skipReason: analysis.skipped ? analysis.reason : null,
+      transformations,
+      originalCode: analysis.code,
+      designSnapshot: analysis.designSnapshot,
+    });
+  }
+
+  appendStyleBindTransforms(filePlans);
+
+  return {
+    files: filePlans,
+    skipped,
+    explanations,
+    usedPaths: [...usedPaths],
+    stats: summarizePlan(filePlans, skipped),
+  };
+}
+
+function sectionForAction(scope, section, extra) {
+  if (scope === 'common' && (extra.social || ['instagram', 'facebook', 'twitter', 'tiktok', 'youtube', 'linkedin'].includes(extra.action))) {
+    return 'footer';
+  }
+  if (extra.action === 'whatsapp' || extra.action === 'phone' || extra.action === 'email') {
+    return section || 'contact';
+  }
+  return section;
+}
+
+function summarizePlan(filePlans, skipped) {
+  const planned = filePlans.reduce((n, f) => n + f.transformations.length, 0);
+  const auto = filePlans.reduce((n, f) => n + f.transformations.filter((t) => t.decision === 'auto').length, 0);
+  const validate = filePlans.reduce((n, f) => n + f.transformations.filter((t) => t.decision === 'validate').length, 0);
+  const filesAffected = filePlans.filter((f) => f.transformations.length > 0).length;
+  const styleBinds = filePlans.reduce(
+    (n, f) => n + f.transformations.filter((t) => t.operation === 'style-bind').length,
+    0,
+  );
+  return {
+    planned,
+    auto,
+    validate,
+    skipped: skipped.length,
+    filesAffected,
+    styleBinds,
+  };
+}
+
+module.exports = {
+  planTransformations,
+  decideThreshold,
+};