@deneb-ui/cli 2.0.21 → 2.0.23

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,227 @@
+'use strict';
+
+const { CONFIDENCE } = require('./version.cjs');
+const { inferSection, inferFieldName, buildFieldPath, classifyFieldType, uniquePath } = require('./field-paths.cjs');
+const { classifyHref } = require('./adapters.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 confidence = Math.min(0.99, (candidate.confidence || 0) + recipeBoost(candidate, recipe));
+      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,
+        },
+      };
+
+      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,
+    });
+  }
+
+  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;
+  return {
+    planned,
+    auto,
+    validate,
+    skipped: skipped.length,
+    filesAffected,
+  };
+}
+
+module.exports = {
+  planTransformations,
+  decideThreshold,
+};

package/src/arc/printer.cjs

@@ -0,0 +1,153 @@
+'use strict';
+
+const { ARC_NAME, ARC_FULL_NAME, ARC_VERSION } = require('./version.cjs');
+
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[90m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  white: '\x1b[37m',
+};
+
+function ok(msg) {
+  console.log(`  ${C.green}✓${C.reset} ${msg}`);
+}
+
+function warn(msg) {
+  console.log(`  ${C.yellow}⚠${C.reset} ${msg}`);
+}
+
+function info(msg) {
+  console.log(`  ${C.cyan}•${C.reset} ${msg}`);
+}
+
+function heading(title) {
+  console.log(`\n${C.bold}${title}${C.reset}\n`);
+}
+
+function printBanner(mode) {
+  const suffix = mode === 'dry-run' ? ' (dry run)' : mode === 'explain' ? ' (explain)' : '';
+  console.log(`\n${C.cyan}▲${C.reset} ${C.bold}${ARC_NAME}${C.reset}${suffix}`);
+  console.log(`${C.dim}${ARC_FULL_NAME}  v${ARC_VERSION}${C.reset}\n`);
+}
+
+function printProfile(profile) {
+  heading('Analyzing project...');
+  const fw = profile.framework === 'nextjs'
+    ? `Next.js${profile.frameworkVersion ? ' ' + profile.frameworkVersion : ''}`
+    : profile.framework;
+  ok(`${fw} detected`);
+  ok(`${profile.language === 'javascript' ? 'JavaScript' : profile.language === 'typescript' ? 'TypeScript' : 'Mixed JS/TS'} detected`);
+  if (profile.cssSystems.includes('tailwind-v4')) ok('Tailwind CSS v4 detected');
+  else if (profile.cssSystems.some((s) => s.startsWith('tailwind'))) ok('Tailwind CSS detected');
+  if (profile.shadcn) ok('shadcn/ui detected');
+  if (profile.heroui) ok('HeroUI detected');
+  if (profile.reactBits) ok('React Bits detected');
+  if (profile.router === 'next-app') ok('App Router detected');
+  if (profile.router === 'next-pages') ok('Pages Router detected');
+  if (profile.router === 'react-router') ok('React Router detected');
+}
+
+function printScan(profile, graph, candidateCount, actionCount) {
+  heading('Scanning architecture...');
+  ok(`${profile.routes.length} routes`);
+  ok(`${profile.components.length} components`);
+  ok(`${candidateCount} content candidates`);
+  ok(`${actionCount} interactive actions`);
+  if (graph.sharedFiles?.length) info(`${graph.sharedFiles.length} shared components reused across routes`);
+}
+
+function printPlan(plan) {
+  heading('Planning editable contracts...');
+  ok(`${plan.stats.auto} high-confidence transformations`);
+  if (plan.stats.validate) info(`${plan.stats.validate} transformations queued with extra validation`);
+  const skippedDynamic = plan.skipped.filter((s) => /dynamic|api/.test(s.reason || '')).length;
+  const skippedLow = plan.skipped.filter((s) => (s.confidence || 1) < 0.6).length;
+  if (skippedDynamic) ok(`${skippedDynamic} existing dynamic values preserved`);
+  if (skippedLow) warn(`${skippedLow} low-confidence candidates skipped`);
+}
+
+function printApply(result) {
+  heading('Applying Deneb contracts...');
+  ok(`${result.filesUpdated} files updated`);
+  if (result.layoutUpdated) ok('Root layout instrumented with SiteDataProvider');
+}
+
+function printValidation(validation, coverage, design) {
+  heading('Validating...');
+  if (validation.syntaxPassed) ok('AST');
+  else warn('AST validation reported parse issues');
+  if (validation.contractPassed) ok('editable contracts');
+  else warn('editable contract issues detected');
+  ok('manifest');
+  if (validation.idempotencyPassed !== false) ok('idempotency');
+  console.log('');
+  console.log(`  Editable coverage: ${coverage.editableCoverage}%`);
+  console.log(`  Design preservation: ${design.score}%`);
+}
+
+function printExplain(plan) {
+  heading('Explain');
+  for (const file of plan.files) {
+    if (!file.transformations.length) continue;
+    console.log(`  ${C.bold}${file.file}${C.reset}`);
+    for (const t of file.transformations) {
+      console.log(`    - ${t.operation} ${t.field || t.urlField || ''}`);
+      console.log(`      ${C.dim}why: ${t.reason}  confidence: ${t.confidence}  recipe: ${t.recipeId || 'none'}${C.reset}`);
+    }
+  }
+}
+
+function printDryRun(profile, plan) {
+  heading('Dry run (no files modified)');
+  console.log(`  Technology: ${profile.framework} / ${profile.language} / ${(profile.cssSystems || []).join(', ') || 'css'}`);
+  console.log(`  Routes: ${profile.routes.map((r) => r.route).join(', ')}`);
+  console.log(`  Components scanned: ${profile.components.length}`);
+  console.log(`  Planned transformations: ${plan.stats.planned}`);
+  console.log(`  Files affected: ${plan.stats.filesAffected}`);
+  if (plan.skipped.length) {
+    console.log(`  Risks:`);
+    for (const skip of plan.skipped.slice(0, 8)) {
+      console.log(`    - ${skip.file}: ${skip.reason} (${skip.confidence})`);
+    }
+  }
+}
+
+function printError(file, reason, confidence) {
+  console.log(`\n${C.red}Deneb could not safely determine the transformation in:${C.reset}\n`);
+  console.log(`  ${file}\n`);
+  console.log(`Reason:\n  ${reason}\n`);
+  if (confidence != null) console.log(`Confidence: ${confidence}\n`);
+  console.log('Action:\n  Component left unchanged.\n');
+  console.log('No source code was damaged.\n');
+}
+
+function printSuccess() {
+  console.log(`\n${C.green}${C.bold}Deneb ARC completed successfully.${C.reset}\n`);
+}
+
+function printRollback(reason) {
+  console.log(`\n${C.yellow}Deneb ARC rolled back the conversion.${C.reset}`);
+  console.log(`${C.dim}${reason}${C.reset}\n`);
+}
+
+module.exports = {
+  printBanner,
+  printProfile,
+  printScan,
+  printPlan,
+  printApply,
+  printValidation,
+  printExplain,
+  printDryRun,
+  printError,
+  printSuccess,
+  printRollback,
+  ok,
+  warn,
+  info,
+};

package/src/arc/recipes-v2.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+const { loadAllRecipes, matchRecipeForProject, getRecipeByName } = require('../tools/recipe-engine.cjs');
+
+function matchRecipeV2(projectDir, profile, sourceFiles, recipeName) {
+  if (recipeName) {
+    const explicit = getRecipeByName(recipeName, projectDir);
+    if (explicit) return { recipe: normalizeRecipe(explicit), source: 'explicit' };
+  }
+  const matched = matchRecipeForProject(projectDir, profile.pkg || {}, sourceFiles);
+  if (matched) return { recipe: normalizeRecipe(matched), source: 'signature' };
+  return { recipe: null, source: null };
+}
+
+function normalizeRecipe(recipe) {
+  if (!recipe) return null;
+  return {
+    id: recipe.name || recipe.id,
+    name: recipe.name || recipe.id,
+    label: recipe.label || recipe.name,
+    version: recipe.version || '1.0.0',
+    fingerprint: recipe.signatures || {},
+    prerequisites: [],
+    detectors: recipe.signatures?.keywords || [],
+    transforms: [],
+    validators: [],
+    confidenceThreshold: 0.85,
+    successfulApplications: recipe.successfulApplications || 0,
+    failedApplications: recipe.failedApplications || 0,
+    actionRules: recipe.actionRules,
+    socialRules: recipe.socialRules,
+    gridRules: recipe.gridRules,
+    sections: recipe.sections,
+    pages: recipe.pages,
+    defaults: recipe.defaults,
+    signatures: recipe.signatures,
+    raw: recipe,
+  };
+}
+
+function listRecipes(projectDir) {
+  return loadAllRecipes(projectDir).map(normalizeRecipe);
+}
+
+module.exports = {
+  matchRecipeV2,
+  normalizeRecipe,
+  listRecipes,
+};