screencraft 0.1.0

package/src/detectors/detectBrand.js

@@ -0,0 +1,1222 @@
+/**
+ * detectBrand.js
+ * --------------
+ * Reads the project codebase and extracts brand information
+ * without any user input. Returns a BrandProfile object.
+ *
+ * Detection priority:
+ *   1. screencraft.config.js overrides (always wins)
+ *   2. Framework-specific color files
+ *   3. Generic fallbacks (CSS variables, JSON tokens)
+ *   4. Built-in defaults
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ─────────────────────────────────────────────────────────────────
+// MAIN EXPORT
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * detectBrand(projectRoot, configOverrides)
+ * Returns a fully-resolved BrandProfile.
+ */
+async function detectBrand(projectRoot, configOverrides = {}) {
+  const framework = await detectFramework(projectRoot);
+  
+  console.log(`  ◆ Detected framework: ${framework.name}`);
+
+  const detected = await runDetector(framework, projectRoot);
+  const appInfo  = await detectAppInfo(framework, projectRoot);
+  const icon     = await detectAppIcon(framework, projectRoot);
+  const font     = await detectFont(framework, projectRoot);
+  const logo     = await detectLogo(framework, projectRoot);
+
+  // Config overrides win over auto-detection
+  const brand = {
+    ...detected,
+    ...stripNulls(configOverrides.brand || {}),
+    appName:  configOverrides.app?.name  || appInfo.name,
+    tagline:  configOverrides.app?.tagline || null,
+    cta:      configOverrides.app?.cta   || "Download Now",
+    icon:     configOverrides.brand?.icon || icon,
+    font:     configOverrides.brand?.font || font,
+    logo:     configOverrides.brand?.logo || logo,
+    framework: framework.name,
+  };
+
+  console.log(`  ◆ App name:    ${brand.appName}`);
+  console.log(`  ◆ Primary:     ${brand.primary}`);
+  console.log(`  ◆ Secondary:   ${brand.secondary}`);
+  console.log(`  ◆ Accent:      ${brand.accent}`);
+  console.log(`  ◆ Icon:        ${brand.icon ? 'found' : 'not found'}`);
+  console.log(`  ◆ Font:        ${brand.font?.family || 'not found'}${brand.font?.weight ? ` (${brand.font.weight})` : ''}`);
+  console.log(`  ◆ Logo:        ${brand.logo ? 'found' : 'not found'}`);
+
+  return brand;
+}
+
+module.exports = { detectBrand, detectFramework };
+
+
+// ─────────────────────────────────────────────────────────────────
+// FRAMEWORK DETECTION
+// ─────────────────────────────────────────────────────────────────
+
+async function detectFramework(root) {
+  const has = (f) => fs.existsSync(path.join(root, f));
+  const read = (f) => {
+    try { return fs.readFileSync(path.join(root, f), 'utf8'); }
+    catch { return ''; }
+  };
+
+  // Expo (check before React Native — Expo projects also have package.json)
+  if (has('app.json') || has('app.config.js') || has('app.config.ts')) {
+    const appJson = read('app.json');
+    if (appJson.includes('"expo"')) {
+      return { name: 'expo', platform: ['ios', 'android'], configFile: 'app.json' };
+    }
+  }
+
+  // React Native (bare)
+  if (has('package.json')) {
+    const pkg = read('package.json');
+    if (pkg.includes('"react-native"')) {
+      const hasIos     = has('ios');
+      const hasAndroid = has('android');
+      return {
+        name: 'react-native',
+        platform: [hasIos && 'ios', hasAndroid && 'android'].filter(Boolean),
+        configFile: 'package.json'
+      };
+    }
+  }
+
+  // Flutter
+  if (has('pubspec.yaml')) {
+    return { name: 'flutter', platform: ['ios', 'android'], configFile: 'pubspec.yaml' };
+  }
+
+  // Swift / SwiftUI — handle two cases:
+  // 1. Root is a cross-platform project with an ios/ subfolder
+  // 2. Root IS the iOS project (contains .xcodeproj directly)
+  if (!has('package.json') && !has('pubspec.yaml')) {
+    // Case 1: ios/ subfolder
+    if (has('ios')) {
+      const xcodeProjs = findFiles(path.join(root, 'ios'), '.xcodeproj', 1);
+      if (xcodeProjs.length > 0) {
+        return { name: 'swift', platform: ['ios'], configFile: xcodeProjs[0] };
+      }
+    }
+    // Case 2: .xcodeproj in root itself
+    const xcodeProjs = findFiles(root, '.xcodeproj', 1);
+    if (xcodeProjs.length > 0) {
+      return { name: 'swift', platform: ['ios'], configFile: xcodeProjs[0] };
+    }
+  }
+
+  // Kotlin / Android native
+  if (has('android') && has('android/app/src/main/AndroidManifest.xml')) {
+    return { name: 'android-native', platform: ['android'], configFile: 'android/app/src/main/AndroidManifest.xml' };
+  }
+
+  // Next.js / web app (PWA)
+  if (has('next.config.js') || has('next.config.ts')) {
+    return { name: 'nextjs', platform: ['web'], configFile: 'next.config.js' };
+  }
+
+  return { name: 'unknown', platform: [], configFile: null };
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// FRAMEWORK-SPECIFIC DETECTORS
+// ─────────────────────────────────────────────────────────────────
+
+async function runDetector(framework, root) {
+  switch (framework.name) {
+    case 'expo':          return detectExpo(root);
+    case 'react-native':  return detectReactNative(root);
+    case 'flutter':       return detectFlutter(root);
+    case 'swift':         return detectSwift(root);
+    case 'android-native':return detectAndroidNative(root);
+    case 'nextjs':        return detectNextjs(root);
+    default:              return detectGeneric(root);
+  }
+}
+
+// ── EXPO ──────────────────────────────────────────────────────────
+function detectExpo(root) {
+  // Try app.json first
+  const appJson = readJson(path.join(root, 'app.json'));
+  if (appJson?.expo?.splash?.backgroundColor) {
+    // Use splash background as primary if no theme file found
+  }
+
+  // Theme files — common patterns in Expo projects
+  const candidates = [
+    'constants/Colors.ts',
+    'constants/Colors.js',
+    'constants/colors.ts',
+    'constants/colors.js',
+    'src/constants/Colors.ts',
+    'src/constants/colors.ts',
+    'src/theme/colors.ts',
+    'src/theme/colors.js',
+    'theme/colors.ts',
+    'theme/colors.js',
+    'styles/colors.ts',
+    'styles/colors.js',
+  ];
+
+  for (const candidate of candidates) {
+    const result = parseJsColorFile(path.join(root, candidate));
+    if (result) {
+      console.log(`  ◆ Colors from: ${candidate}`);
+      return result;
+    }
+  }
+
+  // Fallback: read app.json tint color
+  const tint = appJson?.expo?.splash?.backgroundColor
+            || appJson?.expo?.primaryColor
+            || null;
+
+  return buildProfile({ primary: tint });
+}
+
+// ── REACT NATIVE (BARE) ───────────────────────────────────────────
+function detectReactNative(root) {
+  const candidates = [
+    'src/theme/colors.ts',
+    'src/theme/colors.js',
+    'src/constants/colors.ts',
+    'src/constants/colors.js',
+    'app/theme/colors.ts',
+    'app/constants/colors.ts',
+    'constants/Colors.ts',
+    'constants/colors.js',
+    'styles/colors.js',
+    'theme.js',
+    'theme.ts',
+  ];
+
+  for (const candidate of candidates) {
+    const result = parseJsColorFile(path.join(root, candidate));
+    if (result) {
+      console.log(`  ◆ Colors from: ${candidate}`);
+      return result;
+    }
+  }
+
+  // Try reading from iOS native color assets as fallback
+  const iosResult = detectSwiftColorAssets(root);
+  if (iosResult.primary) return iosResult;
+
+  return buildProfile({});
+}
+
+// ── FLUTTER ───────────────────────────────────────────────────────
+function detectFlutter(root) {
+  // Flutter color definitions live in .dart files
+  // Common patterns: lib/core/theme/app_colors.dart,
+  // lib/config/theme.dart, lib/utils/colors.dart
+
+  const dartCandidates = [
+    'lib/core/theme/app_colors.dart',
+    'lib/core/theme/colors.dart',
+    'lib/config/theme.dart',
+    'lib/theme/app_theme.dart',
+    'lib/utils/colors.dart',
+    'lib/constants/colors.dart',
+    'lib/app/theme.dart',
+  ];
+
+  for (const candidate of dartCandidates) {
+    const result = parseDartColorFile(path.join(root, candidate));
+    if (result) {
+      console.log(`  ◆ Colors from: ${candidate}`);
+      return result;
+    }
+  }
+
+  // Search recursively for any dart file with "Color(" definitions
+  const dartFiles = findFiles(path.join(root, 'lib'), '.dart', 4);
+  for (const file of dartFiles) {
+    if (file.includes('color') || file.includes('theme')) {
+      const result = parseDartColorFile(file);
+      if (result) {
+        console.log(`  ◆ Colors from: ${path.relative(root, file)}`);
+        return result;
+      }
+    }
+  }
+
+  return buildProfile({});
+}
+
+// ── SWIFT / SWIFTUI ───────────────────────────────────────────────
+function detectSwift(root) {
+  // Handle two cases:
+  //   A: cross-platform project root with ios/ subfolder
+  //   B: root IS the iOS project (contains .xcodeproj directly)
+  const iosRoot = fs.existsSync(path.join(root, 'ios')) ? path.join(root, 'ios') : root;
+
+  // Collect colors from multiple sources, merge at the end
+  const collected = {};
+
+  // 1. Color.xcassets (modern SwiftUI)
+  const xcassetsColors = detectSwiftColorAssetsRaw(iosRoot);
+  if (Object.keys(xcassetsColors).length > 0) {
+    console.log(`  ◆ Colors from: Color.xcassets`);
+    Object.assign(collected, xcassetsColors);
+  }
+
+  // 2. Swift files with color/theme/brand/style in filename
+  const swiftCandidates = findFiles(iosRoot, '.swift', 8)
+    .filter(f => {
+      const lc = f.toLowerCase();
+      return lc.includes('color') || lc.includes('theme') || lc.includes('style') || lc.includes('brand');
+    });
+
+  for (const file of swiftCandidates) {
+    const result = parseSwiftColorFile(file);
+    if (result) {
+      console.log(`  ◆ Colors from: ${path.relative(root, file)}`);
+      // Merge: Swift file fills gaps left by xcassets
+      if (!collected.primary   && result.primary   !== '#1A1A2E') collected.primary   = result.primary;
+      if (!collected.secondary && result.secondary !== '#F5F5F5') collected.secondary = result.secondary;
+      if (!collected.accent    && result.accent    !== '#E94560') collected.accent    = result.accent;
+      if (!collected.background && result.background !== '#FFFFFF') collected.background = result.background;
+      break;
+    }
+  }
+
+  // 3. Fallback: scan all Swift files if still missing primary
+  if (!collected.primary) {
+    for (const file of findFiles(iosRoot, '.swift', 8)) {
+      const result = parseSwiftColorFile(file);
+      if (result) {
+        console.log(`  ◆ Colors from: ${path.relative(root, file)}`);
+        if (!collected.primary   && result.primary   !== '#1A1A2E') collected.primary   = result.primary;
+        if (!collected.secondary && result.secondary !== '#F5F5F5') collected.secondary = result.secondary;
+        if (!collected.accent    && result.accent    !== '#E94560') collected.accent    = result.accent;
+        if (!collected.background && result.background !== '#FFFFFF') collected.background = result.background;
+        break;
+      }
+    }
+  }
+
+  return buildProfile(collected);
+}
+
+// ── ANDROID NATIVE ────────────────────────────────────────────────
+function detectAndroidNative(root) {
+  // Android colors live in res/values/colors.xml
+  const colorsXml = path.join(root, 'android/app/src/main/res/values/colors.xml');
+  const result = parseAndroidColorsXml(colorsXml);
+  if (result.primary) {
+    console.log(`  ◆ Colors from: res/values/colors.xml`);
+    return result;
+  }
+
+  // Also try themes.xml
+  const themesXml = path.join(root, 'android/app/src/main/res/values/themes.xml');
+  const themeResult = parseAndroidThemesXml(themesXml);
+  if (themeResult.primary) {
+    console.log(`  ◆ Colors from: res/values/themes.xml`);
+    return themeResult;
+  }
+
+  return buildProfile({});
+}
+
+// ── NEXT.JS ───────────────────────────────────────────────────────
+function detectNextjs(root) {
+  // 1. Tailwind config
+  const tailwindResult = parseTailwindConfig(root);
+  if (tailwindResult.primary) {
+    console.log(`  ◆ Colors from: tailwind.config.js`);
+    return tailwindResult;
+  }
+
+  // 2. CSS variables in globals.css
+  const cssResult = parseCssVariables(
+    path.join(root, 'styles/globals.css') ||
+    path.join(root, 'app/globals.css')
+  );
+  if (cssResult.primary) {
+    console.log(`  ◆ Colors from: globals.css`);
+    return cssResult;
+  }
+
+  // 3. Design tokens
+  return detectGeneric(root);
+}
+
+// ── GENERIC FALLBACK ──────────────────────────────────────────────
+function detectGeneric(root) {
+  // Design token files
+  const tokenCandidates = [
+    'tokens.json',
+    'design-tokens.json',
+    'src/tokens.json',
+    'src/design-tokens.json',
+    'styles/tokens.json',
+  ];
+
+  for (const candidate of tokenCandidates) {
+    const result = parseDesignTokens(path.join(root, candidate));
+    if (result.primary) return result;
+  }
+
+  return buildProfile({});
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// PARSERS
+// ─────────────────────────────────────────────────────────────────
+
+/**
+ * Parse JS/TS color files.
+ * Handles: export const primary = '#...'
+ *          Colors.primary = '#...'
+ *          light: { primary: '#...' }
+ */
+function parseJsColorFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  const colors = {};
+
+  // Match: primary: '#hex' or primary: "#hex"
+  const patterns = [
+    { key: 'primary',   regex: /primary['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+    { key: 'secondary', regex: /secondary['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+    { key: 'accent',    regex: /accent['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+    { key: 'tint',      regex: /tint['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+    { key: 'background',regex: /background['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+  ];
+
+  for (const { key, regex } of patterns) {
+    const match = content.match(regex);
+    if (match) colors[key] = match[1];
+  }
+
+  // Resolve tint → secondary if no explicit secondary
+  if (!colors.secondary && colors.tint) {
+    colors.secondary = colors.tint;
+  }
+
+  if (!colors.primary) return null;
+  return buildProfile(colors);
+}
+
+/**
+ * Parse Dart color files.
+ * Handles: static const Color primary = Color(0xFF1B3A6B);
+ *          Color get primary => const Color(0xFF1B3A6B);
+ */
+function parseDartColorFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  const colors = {};
+
+  // Match Color(0xFFRRGGBB) or Color(0xAARRGGBB)
+  const patterns = [
+    { key: 'primary',   regex: /primary[^=\n]*=?[^(]*Color\(0x[A-Fa-f0-9]{2}([A-Fa-f0-9]{6})\)/i },
+    { key: 'secondary', regex: /secondary[^=\n]*=?[^(]*Color\(0x[A-Fa-f0-9]{2}([A-Fa-f0-9]{6})\)/i },
+    { key: 'accent',    regex: /accent[^=\n]*=?[^(]*Color\(0x[A-Fa-f0-9]{2}([A-Fa-f0-9]{6})\)/i },
+  ];
+
+  for (const { key, regex } of patterns) {
+    const match = content.match(regex);
+    if (match) colors[key] = '#' + match[1];
+  }
+
+  if (!colors.primary) return null;
+  return buildProfile(colors);
+}
+
+/**
+ * Parse Swift color files.
+ * Handles:
+ *   static let primary = UIColor(hex: "#1B3A6B")
+ *   static let brandPurple = Color(hex: "7068B1")
+ *   Color("PrimaryColor")  → reads from xcassets
+ */
+function parseSwiftColorFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  const colors = {};
+
+  // Pass 1: exact name matches (primary, secondary, accent)
+  const exactPatterns = [
+    { key: 'primary',   regex: /primary[^=\n]*=.*?(?:UIColor|Color)\s*\(\s*(?:hex:\s*)?["']#?([0-9A-Fa-f]{6})/i },
+    { key: 'secondary', regex: /secondary[^=\n]*=.*?(?:UIColor|Color)\s*\(\s*(?:hex:\s*)?["']#?([0-9A-Fa-f]{6})/i },
+    { key: 'accent',    regex: /accent[^=\n]*=.*?(?:UIColor|Color)\s*\(\s*(?:hex:\s*)?["']#?([0-9A-Fa-f]{6})/i },
+  ];
+
+  for (const { key, regex } of exactPatterns) {
+    const match = content.match(regex);
+    if (match) colors[key] = '#' + match[1];
+  }
+
+  if (colors.primary) return buildProfile(colors);
+
+  // Pass 2: collect all Color(hex: "...") definitions with their variable names
+  // Handles: static let brandPurple = Color(hex: "7068B1")
+  const allColors = [];
+  const colorRegex = /(?:static\s+)?(?:let|var)\s+(\w+)\s*=\s*(?:UIColor|Color)\s*\(\s*(?:hex:\s*)?["']#?([0-9A-Fa-f]{6})/gi;
+  let m;
+  while ((m = colorRegex.exec(content)) !== null) {
+    allColors.push({ name: m[1].toLowerCase(), hex: '#' + m[2] });
+  }
+
+  if (allColors.length === 0) return null;
+
+  // Assign by name heuristics
+  for (const c of allColors) {
+    if (!colors.background && (c.name.includes('background') || c.name.includes('bg') || c.name.includes('deep'))) {
+      colors.background = c.hex;
+    } else if (!colors.primary && (c.name.includes('brand') || c.name.includes('primary') || c.name.includes('main'))) {
+      colors.primary = c.hex;
+    } else if (!colors.accent && (c.name.includes('accent') || c.name.includes('tint') || c.name.includes('highlight') || c.name.includes('mint'))) {
+      colors.accent = c.hex;
+    } else if (!colors.secondary && (c.name.includes('secondary') || c.name.includes('teal') || c.name.includes('blue'))) {
+      colors.secondary = c.hex;
+    }
+  }
+
+  // If still no primary, use the first non-background color
+  if (!colors.primary) {
+    const first = allColors.find(c => c.hex !== colors.background);
+    if (first) colors.primary = first.hex;
+  }
+
+  // If still no secondary, use next unused color
+  if (!colors.secondary) {
+    const used = new Set([colors.primary, colors.background, colors.accent]);
+    const next = allColors.find(c => !used.has(c.hex));
+    if (next) colors.secondary = next.hex;
+  }
+
+  if (!colors.primary) return null;
+  return buildProfile(colors);
+}
+
+/**
+ * Parse Color.xcassets — returns raw colors object (no defaults).
+ * Used by detectSwift for merging with Swift file colors.
+ */
+function detectSwiftColorAssetsRaw(root) {
+  const xcassetDirs = findFiles(root, '.xcassets', 3);
+  const colors = {};
+
+  for (const xcassetDir of xcassetDirs) {
+    const colorsets = findFiles(xcassetDir, '.colorset', 3);
+    for (const colorset of colorsets) {
+      const name = path.basename(colorset, '.colorset').toLowerCase();
+      const contentsPath = path.join(colorset, 'Contents.json');
+      if (!fs.existsSync(contentsPath)) continue;
+
+      try {
+        const json = JSON.parse(fs.readFileSync(contentsPath, 'utf8'));
+        const components = json?.colors?.[0]?.color?.components;
+        if (!components) continue;
+
+        const hex = componentsToHex(components);
+        if (!hex) continue;
+
+        if (name.includes('primary') && !colors.primary)   colors.primary   = hex;
+        if (name.includes('secondary') && !colors.secondary) colors.secondary = hex;
+        if (name.includes('accent') && !colors.accent)     colors.accent    = hex;
+        if (name.includes('tint') && !colors.secondary)    colors.secondary = hex;
+      } catch {}
+    }
+  }
+
+  return colors;
+}
+
+/**
+ * Parse Color.xcassets — returns full profile with defaults.
+ * Used by detectReactNative as fallback.
+ */
+function detectSwiftColorAssets(root) {
+  return buildProfile(detectSwiftColorAssetsRaw(root));
+}
+
+/**
+ * Parse Android res/values/colors.xml
+ */
+function parseAndroidColorsXml(filePath) {
+  if (!fs.existsSync(filePath)) return buildProfile({});
+  const content = fs.readFileSync(filePath, 'utf8');
+  const colors = {};
+
+  const matches = content.matchAll(/<color name="([^"]+)">#?([0-9A-Fa-f]{6,8})<\/color>/g);
+  for (const [, name, hex] of matches) {
+    const n = name.toLowerCase();
+    const h = '#' + hex.slice(-6); // Strip alpha if present
+    if (n.includes('primary') && !colors.primary)     colors.primary   = h;
+    if (n.includes('secondary') && !colors.secondary) colors.secondary = h;
+    if (n.includes('accent') && !colors.accent)       colors.accent    = h;
+  }
+
+  return buildProfile(colors);
+}
+
+/**
+ * Parse Android res/values/themes.xml
+ * Looks for colorPrimary, colorSecondary, colorAccent attributes.
+ */
+function parseAndroidThemesXml(filePath) {
+  if (!fs.existsSync(filePath)) return buildProfile({});
+  const content = fs.readFileSync(filePath, 'utf8');
+  const colors = {};
+
+  const patterns = [
+    { key: 'primary',   regex: /colorPrimary[^>]*>#?([0-9A-Fa-f]{6,8})/i },
+    { key: 'secondary', regex: /colorSecondary[^>]*>#?([0-9A-Fa-f]{6,8})/i },
+    { key: 'accent',    regex: /colorAccent[^>]*>#?([0-9A-Fa-f]{6,8})/i },
+  ];
+
+  for (const { key, regex } of patterns) {
+    const match = content.match(regex);
+    if (match) colors[key] = '#' + match[1].slice(-6);
+  }
+
+  return buildProfile(colors);
+}
+
+/**
+ * Parse Tailwind config for brand colors.
+ */
+function parseTailwindConfig(root) {
+  const candidates = ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs'];
+  for (const c of candidates) {
+    const filePath = path.join(root, c);
+    if (!fs.existsSync(filePath)) continue;
+    const content = fs.readFileSync(filePath, 'utf8');
+    const colors = {};
+
+    const patterns = [
+      { key: 'primary',   regex: /primary['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+      { key: 'secondary', regex: /secondary['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+      { key: 'accent',    regex: /accent['":\s]+['"]?(#[0-9A-Fa-f]{6})/i },
+    ];
+
+    for (const { key, regex } of patterns) {
+      const match = content.match(regex);
+      if (match) colors[key] = match[1];
+    }
+
+    if (colors.primary) return buildProfile(colors);
+  }
+  return buildProfile({});
+}
+
+/**
+ * Parse CSS custom properties (variables).
+ * Handles: --color-primary: #hex; --primary: #hex;
+ */
+function parseCssVariables(filePath) {
+  if (!fs.existsSync(filePath)) return buildProfile({});
+  const content = fs.readFileSync(filePath, 'utf8');
+  const colors = {};
+
+  const patterns = [
+    { key: 'primary',   regex: /--(?:color-)?primary\s*:\s*(#[0-9A-Fa-f]{6})/i },
+    { key: 'secondary', regex: /--(?:color-)?secondary\s*:\s*(#[0-9A-Fa-f]{6})/i },
+    { key: 'accent',    regex: /--(?:color-)?accent\s*:\s*(#[0-9A-Fa-f]{6})/i },
+  ];
+
+  for (const { key, regex } of patterns) {
+    const match = content.match(regex);
+    if (match) colors[key] = match[1];
+  }
+
+  return buildProfile(colors);
+}
+
+/**
+ * Parse design token JSON files.
+ * Handles W3C token format and Style Dictionary format.
+ */
+function parseDesignTokens(filePath) {
+  if (!fs.existsSync(filePath)) return buildProfile({});
+  try {
+    const json = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    const colors = {};
+
+    // W3C format: { "color": { "primary": { "$value": "#hex" } } }
+    const primary = json?.color?.primary?.$value || json?.colors?.primary?.$value;
+    const secondary = json?.color?.secondary?.$value || json?.colors?.secondary?.$value;
+    const accent = json?.color?.accent?.$value || json?.colors?.accent?.$value;
+
+    if (primary)   colors.primary   = primary;
+    if (secondary) colors.secondary = secondary;
+    if (accent)    colors.accent    = accent;
+
+    return buildProfile(colors);
+  } catch {
+    return buildProfile({});
+  }
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// APP INFO DETECTION
+// ─────────────────────────────────────────────────────────────────
+
+async function detectAppInfo(framework, root) {
+  switch (framework.name) {
+    case 'expo': {
+      const appJson = readJson(path.join(root, 'app.json'));
+      return {
+        name:     appJson?.expo?.name        || appJson?.name || null,
+        bundleId: appJson?.expo?.ios?.bundleIdentifier || null,
+        version:  appJson?.expo?.version     || null,
+      };
+    }
+    case 'react-native': {
+      // Read from ios/Info.plist
+      const plist = readPlist(path.join(root, 'ios'));
+      const pkg   = readJson(path.join(root, 'package.json'));
+      return {
+        name:    plist?.CFBundleDisplayName || plist?.CFBundleName || pkg?.name || null,
+        version: plist?.CFBundleShortVersionString || pkg?.version || null,
+      };
+    }
+    case 'flutter': {
+      const pubspec = readYaml(path.join(root, 'pubspec.yaml'));
+      return {
+        name:    pubspec?.name    || null,
+        version: pubspec?.version || null,
+      };
+    }
+    case 'swift': {
+      const plist = readPlist(path.join(root, 'ios'));
+      return {
+        name:    plist?.CFBundleDisplayName || plist?.CFBundleName || null,
+        version: plist?.CFBundleShortVersionString || null,
+      };
+    }
+    case 'android-native': {
+      const manifest = fs.readFileSync(
+        path.join(root, 'android/app/src/main/AndroidManifest.xml'), 'utf8'
+      );
+      const match = manifest.match(/android:label="@string\/([^"]+)"/);
+      return { name: match ? match[1] : null };
+    }
+    default:
+      return { name: readJson(path.join(root, 'package.json'))?.name || null };
+  }
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// APP ICON DETECTION
+// ─────────────────────────────────────────────────────────────────
+
+async function detectAppIcon(framework, root) {
+  // Quick-check common fixed paths first
+  const candidates = [
+    // Expo / React Native
+    'assets/icon.png',
+    'assets/images/icon.png',
+    'src/assets/icon.png',
+    // Android
+    'android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png',
+    'android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png',
+    // Generic
+    'icon.png',
+    'app-icon.png',
+  ];
+
+  for (const candidate of candidates) {
+    const full = path.join(root, candidate);
+    if (fs.existsSync(full)) return full;
+  }
+
+  // Deep search: find .appiconset directories and read Contents.json
+  // to locate the largest icon (works regardless of filename conventions)
+  const appiconsets = findFiles(root, '.appiconset', 8);
+  for (const dir of appiconsets) {
+    const icon = findLargestIconInSet(dir);
+    if (icon) return icon;
+  }
+
+  // Last resort: any large PNG named *icon* anywhere in the project
+  const allPngs = findFiles(root, '.png', 6);
+  const iconPng = allPngs.find(f => {
+    const name = path.basename(f).toLowerCase();
+    return name.includes('icon') && (name.includes('1024') || name.includes('large') || name.includes('appicon'));
+  });
+  if (iconPng) return iconPng;
+
+  return null;
+}
+
+/**
+ * Read Contents.json inside an .appiconset and return the path
+ * to the largest available icon image.
+ */
+function findLargestIconInSet(appiconsetDir) {
+  const contentsPath = path.join(appiconsetDir, 'Contents.json');
+  if (!fs.existsSync(contentsPath)) {
+    // No Contents.json — just grab the largest PNG by name
+    const pngs = findFiles(appiconsetDir, '.png', 1);
+    return pngs.length > 0 ? pngs[0] : null;
+  }
+
+  try {
+    const json = JSON.parse(fs.readFileSync(contentsPath, 'utf8'));
+    const images = json?.images || [];
+
+    // Find the largest icon by parsing the "size" field (e.g., "1024x1024")
+    let best = null;
+    let bestSize = 0;
+    for (const img of images) {
+      if (!img.filename) continue;
+      const sizeStr = img.size || '0x0';
+      const dim = parseInt(sizeStr.split('x')[0], 10) || 0;
+      const scale = parseFloat((img.scale || '1x').replace('x', '')) || 1;
+      const effective = dim * scale;
+      if (effective > bestSize) {
+        const full = path.join(appiconsetDir, img.filename);
+        if (fs.existsSync(full)) {
+          best = full;
+          bestSize = effective;
+        }
+      }
+    }
+    return best;
+  } catch {
+    return null;
+  }
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// FONT DETECTION
+// ─────────────────────────────────────────────────────────────────
+
+async function detectFont(framework, root) {
+  switch (framework.name) {
+    case 'swift':         return detectFontSwift(root);
+    case 'expo':          return detectFontExpoRN(root);
+    case 'react-native':  return detectFontExpoRN(root);
+    case 'flutter':       return detectFontFlutter(root);
+    case 'android-native':return detectFontAndroid(root);
+    case 'nextjs':        return detectFontWeb(root);
+    default:              return detectFontGeneric(root);
+  }
+}
+
+// ── Swift / iOS ──────────────────────────────────────────────────
+function detectFontSwift(root) {
+  const iosRoot = fs.existsSync(path.join(root, 'ios')) ? path.join(root, 'ios') : root;
+
+  // 1. Look for bundled font files
+  const fontFiles = [
+    ...findFiles(iosRoot, '.ttf', 6),
+    ...findFiles(iosRoot, '.otf', 6),
+  ];
+
+  if (fontFiles.length > 0) {
+    const picked = pickBestFontFile(fontFiles);
+    return { family: fontFamilyFromFile(picked), file: picked, weight: fontWeightFromFile(picked) };
+  }
+
+  // 2. Parse Swift files for .custom("FontName", ...) usage
+  const swiftFiles = findFiles(iosRoot, '.swift', 6);
+  for (const file of swiftFiles) {
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const match = content.match(/\.custom\(\s*["']([^"']+)["']/);
+      if (match) return { family: match[1], file: null, weight: null };
+    } catch {}
+  }
+
+  return { family: null, file: null, weight: null };
+}
+
+// ── Expo / React Native ──────────────────────────────────────────
+function detectFontExpoRN(root) {
+  // 1. Check common font directories
+  const fontDirs = [
+    'assets/fonts', 'src/assets/fonts', 'app/assets/fonts',
+    'assets', 'src/fonts', 'fonts',
+  ];
+
+  for (const dir of fontDirs) {
+    const full = path.join(root, dir);
+    if (!fs.existsSync(full)) continue;
+    const fonts = [
+      ...findFiles(full, '.ttf', 1),
+      ...findFiles(full, '.otf', 1),
+    ];
+    if (fonts.length > 0) {
+      const picked = pickBestFontFile(fonts);
+      return { family: fontFamilyFromFile(picked), file: picked, weight: fontWeightFromFile(picked) };
+    }
+  }
+
+  // 2. Check for @expo-google-fonts in package.json
+  const pkg = readJson(path.join(root, 'package.json'));
+  if (pkg?.dependencies) {
+    const googleFont = Object.keys(pkg.dependencies).find(d => d.startsWith('@expo-google-fonts/'));
+    if (googleFont) {
+      // e.g. "@expo-google-fonts/inter" → "Inter"
+      const name = googleFont.split('/')[1].split('-').map(w => w[0].toUpperCase() + w.slice(1)).join(' ');
+      return { family: name, file: null, weight: null };
+    }
+  }
+
+  return { family: null, file: null, weight: null };
+}
+
+// ── Flutter ──────────────────────────────────────────────────────
+function detectFontFlutter(root) {
+  // 1. Parse pubspec.yaml for fonts section
+  const pubspecPath = path.join(root, 'pubspec.yaml');
+  if (fs.existsSync(pubspecPath)) {
+    const content = fs.readFileSync(pubspecPath, 'utf8');
+    // Match: "  fonts:\n    - family: Inter"
+    const familyMatch = content.match(/fonts:\s*\n\s*-\s*family:\s*(.+)/);
+    if (familyMatch) {
+      const family = familyMatch[1].trim();
+      // Try to find the actual font file
+      const fontFiles = [
+        ...findFiles(root, '.ttf', 4),
+        ...findFiles(root, '.otf', 4),
+      ];
+      const matchingFile = fontFiles.find(f => path.basename(f).toLowerCase().includes(family.toLowerCase()));
+      const picked = matchingFile || (fontFiles.length > 0 ? pickBestFontFile(fontFiles) : null);
+      return { family, file: picked, weight: picked ? fontWeightFromFile(picked) : null };
+    }
+  }
+
+  // 2. Fallback: find font files in common Flutter font locations
+  const fontFiles = [
+    ...findFiles(path.join(root, 'assets', 'fonts'), '.ttf', 2),
+    ...findFiles(path.join(root, 'assets', 'fonts'), '.otf', 2),
+    ...findFiles(path.join(root, 'fonts'), '.ttf', 2),
+    ...findFiles(path.join(root, 'fonts'), '.otf', 2),
+  ];
+
+  if (fontFiles.length > 0) {
+    const picked = pickBestFontFile(fontFiles);
+    return { family: fontFamilyFromFile(picked), file: picked, weight: fontWeightFromFile(picked) };
+  }
+
+  return { family: null, file: null, weight: null };
+}
+
+// ── Android Native ───────────────────────────────────────────────
+function detectFontAndroid(root) {
+  const fontDir = path.join(root, 'android/app/src/main/res/font');
+  const fontFiles = [
+    ...findFiles(fontDir, '.ttf', 1),
+    ...findFiles(fontDir, '.otf', 1),
+  ];
+
+  if (fontFiles.length > 0) {
+    const picked = pickBestFontFile(fontFiles);
+    return { family: fontFamilyFromFile(picked), file: picked, weight: fontWeightFromFile(picked) };
+  }
+
+  // Also check assets/fonts
+  const assetsDir = path.join(root, 'android/app/src/main/assets/fonts');
+  const assetFonts = [
+    ...findFiles(assetsDir, '.ttf', 1),
+    ...findFiles(assetsDir, '.otf', 1),
+  ];
+
+  if (assetFonts.length > 0) {
+    const picked = pickBestFontFile(assetFonts);
+    return { family: fontFamilyFromFile(picked), file: picked, weight: fontWeightFromFile(picked) };
+  }
+
+  return { family: null, file: null, weight: null };
+}
+
+// ── Next.js / Web ────────────────────────────────────────────────
+function detectFontWeb(root) {
+  // 1. Check for next/font imports in layout/page files
+  const layoutCandidates = [
+    'app/layout.tsx', 'app/layout.jsx', 'app/layout.js',
+    'pages/_app.tsx', 'pages/_app.jsx', 'pages/_app.js',
+    'src/app/layout.tsx', 'src/app/layout.jsx',
+  ];
+
+  for (const candidate of layoutCandidates) {
+    const filePath = path.join(root, candidate);
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      // Match: import { Inter } from 'next/font/google'
+      const nextFontMatch = content.match(/import\s*\{?\s*(\w+)\s*\}?\s*from\s*['"]next\/font\/google['"]/);
+      if (nextFontMatch) {
+        const name = nextFontMatch[1].replace(/_/g, ' ');
+        return { family: name, file: null, weight: null };
+      }
+      // Match: import localFont from 'next/font/local' ... src: './fonts/MyFont.woff2'
+      const localFontMatch = content.match(/src:\s*['"]([^'"]+\.(?:ttf|otf|woff2?))['"]/);
+      if (localFontMatch) {
+        const fontFile = path.resolve(path.dirname(filePath), localFontMatch[1]);
+        if (fs.existsSync(fontFile)) {
+          return { family: fontFamilyFromFile(fontFile), file: fontFile, weight: fontWeightFromFile(fontFile) };
+        }
+      }
+    } catch {}
+  }
+
+  // 2. Tailwind fontFamily
+  const tailwindCandidates = ['tailwind.config.js', 'tailwind.config.ts', 'tailwind.config.cjs'];
+  for (const c of tailwindCandidates) {
+    const filePath = path.join(root, c);
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      // Match: sans: ['Inter', ...] or heading: ['Poppins', ...]
+      const fontMatch = content.match(/(?:sans|heading|body|display)\s*:\s*\[\s*['"]([^'"]+)['"]/);
+      if (fontMatch) return { family: fontMatch[1], file: null, weight: null };
+    } catch {}
+  }
+
+  // 3. CSS @font-face
+  const cssCandidates = [
+    'styles/globals.css', 'app/globals.css', 'src/styles/globals.css',
+    'styles/global.css', 'app/global.css',
+  ];
+  for (const candidate of cssCandidates) {
+    const filePath = path.join(root, candidate);
+    if (!fs.existsSync(filePath)) continue;
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const faceMatch = content.match(/@font-face\s*\{[^}]*font-family:\s*['"]?([^'";]+)/);
+      if (faceMatch) {
+        const srcMatch = content.match(/@font-face\s*\{[^}]*src:[^}]*url\(['"]?([^'")\s]+\.(?:ttf|otf|woff2?))/);
+        const fontFile = srcMatch ? path.resolve(path.dirname(filePath), srcMatch[1]) : null;
+        return {
+          family: faceMatch[1].trim(),
+          file: fontFile && fs.existsSync(fontFile) ? fontFile : null,
+          weight: null,
+        };
+      }
+    } catch {}
+  }
+
+  return detectFontGeneric(root);
+}
+
+// ── Generic Fallback ─────────────────────────────────────────────
+function detectFontGeneric(root) {
+  const fontDirs = ['fonts', 'assets/fonts', 'static/fonts', 'src/fonts', 'public/fonts'];
+
+  for (const dir of fontDirs) {
+    const full = path.join(root, dir);
+    if (!fs.existsSync(full)) continue;
+    const fonts = [
+      ...findFiles(full, '.ttf', 2),
+      ...findFiles(full, '.otf', 2),
+    ];
+    if (fonts.length > 0) {
+      const picked = pickBestFontFile(fonts);
+      return { family: fontFamilyFromFile(picked), file: picked, weight: fontWeightFromFile(picked) };
+    }
+  }
+
+  return { family: null, file: null, weight: null };
+}
+
+/**
+ * From a list of font files, pick the best one for headlines.
+ * Prefers: Bold > SemiBold > Medium > Regular. Prefers shorter family names.
+ */
+function pickBestFontFile(files) {
+  const weights = ['bold', 'semibold', 'semi-bold', 'medium', 'regular', 'book'];
+  for (const w of weights) {
+    const match = files.find(f => path.basename(f).toLowerCase().includes(w));
+    if (match) return match;
+  }
+  return files[0];
+}
+
+/**
+ * Extract font family name from filename.
+ * "Inter-Bold.ttf" → "Inter"
+ * "WorkSans-SemiBold.otf" → "Work Sans"
+ */
+function fontFamilyFromFile(filePath) {
+  let name = path.basename(filePath).replace(/\.(ttf|otf|woff2?)$/i, '');
+  // Strip weight/style suffixes
+  name = name.replace(/[-_]?(Thin|ExtraLight|Light|Regular|Medium|SemiBold|Semi-Bold|Bold|ExtraBold|Black|Heavy|Italic|Variable|VF)$/gi, '');
+  name = name.replace(/[-_]?(thin|extralight|light|regular|medium|semibold|bold|extrabold|black|heavy|italic|variable|vf)$/gi, '');
+  // Convert CamelCase to spaces: "WorkSans" → "Work Sans"
+  name = name.replace(/([a-z])([A-Z])/g, '$1 $2');
+  // Clean up separators
+  name = name.replace(/[-_]/g, ' ').trim();
+  return name || null;
+}
+
+/**
+ * Extract weight hint from filename.
+ * "Inter-Bold.ttf" → "Bold"
+ */
+function fontWeightFromFile(filePath) {
+  const basename = path.basename(filePath).toLowerCase();
+  const weights = [
+    'thin', 'extralight', 'light', 'regular', 'medium',
+    'semibold', 'semi-bold', 'bold', 'extrabold', 'black', 'heavy',
+  ];
+  for (const w of weights) {
+    if (basename.includes(w)) return w.charAt(0).toUpperCase() + w.slice(1);
+  }
+  return null;
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// LOGO DETECTION
+// ─────────────────────────────────────────────────────────────────
+
+async function detectLogo(framework, root) {
+  // 1. Check common logo filenames across typical directories
+  const dirs = ['', 'assets', 'src/assets', 'images', 'src/images', 'public', 'static', 'resources'];
+  const names = ['logo', 'logo-full', 'logo-dark', 'logo-light', 'wordmark', 'brand-logo', 'app-logo'];
+  // Prefer vector > raster
+  const exts = ['.svg', '.png', '.pdf', '.jpg'];
+
+  for (const dir of dirs) {
+    for (const name of names) {
+      for (const ext of exts) {
+        const full = path.join(root, dir, name + ext);
+        if (fs.existsSync(full)) return full;
+      }
+    }
+  }
+
+  // 2. Framework-specific splash/launch images
+  if (framework.name === 'expo') {
+    const appJson = readJson(path.join(root, 'app.json'));
+    const splashImage = appJson?.expo?.splash?.image;
+    if (splashImage) {
+      const full = path.join(root, splashImage);
+      if (fs.existsSync(full)) return full;
+    }
+  }
+
+  // 3. Search xcassets for .imageset directories with "logo" in the name
+  const imagesets = findFiles(root, '.imageset', 8);
+  for (const dir of imagesets) {
+    if (path.basename(dir).toLowerCase().includes('logo')) {
+      const pngs = findFiles(dir, '.png', 1);
+      if (pngs.length > 0) return pngs[0];
+      const svgs = findFiles(dir, '.svg', 1);
+      if (svgs.length > 0) return svgs[0];
+    }
+  }
+
+  // 4. Deep search for any file with "logo" in the name
+  const allFiles = [
+    ...findFiles(root, '.svg', 8),
+    ...findFiles(root, '.png', 8),
+  ];
+  const logoFile = allFiles.find(f => {
+    const name = path.basename(f).toLowerCase();
+    return name.includes('logo') && !f.includes('node_modules');
+  });
+  if (logoFile) return logoFile;
+
+  return null;
+}
+
+
+// ─────────────────────────────────────────────────────────────────
+// HELPERS
+// ─────────────────────────────────────────────────────────────────
+
+function buildProfile({ primary, secondary, accent, background } = {}) {
+  return {
+    primary:    primary    || '#1A1A2E',   // Deep navy default
+    secondary:  secondary  || '#F5F5F5',   // Light gray default
+    accent:     accent     || '#E94560',   // Red accent default
+    background: background || '#FFFFFF',
+  };
+}
+
+function stripNulls(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== null));
+}
+
+function readJson(filePath) {
+  try { return JSON.parse(fs.readFileSync(filePath, 'utf8')); }
+  catch { return null; }
+}
+
+function readYaml(filePath) {
+  // Minimal YAML reader for pubspec.yaml — just extracts top-level keys
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, 'utf8');
+  const result = {};
+  for (const line of content.split('\n')) {
+    const match = line.match(/^(\w+):\s*(.+)/);
+    if (match) result[match[1]] = match[2].trim();
+  }
+  return result;
+}
+
+function readPlist(iosDir) {
+  // Reads Info.plist as text — returns key/value map for simple string values
+  const plistFiles = findFiles(iosDir, 'Info.plist', 3);
+  if (!plistFiles.length) return null;
+
+  try {
+    const content = fs.readFileSync(plistFiles[0], 'utf8');
+    const result = {};
+    const keys = content.matchAll(/<key>([^<]+)<\/key>\s*<string>([^<]+)<\/string>/g);
+    for (const [, key, value] of keys) result[key] = value;
+    return result;
+  } catch { return null; }
+}
+
+function findFiles(dir, ext, maxDepth = 3, depth = 0) {
+  if (depth > maxDepth || !fs.existsSync(dir)) return [];
+  const results = [];
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        // Some extensions (.xcodeproj, .xcassets, .colorset, .appiconset) are directories
+        if (entry.name.endsWith(ext)) {
+          results.push(full);
+        } else if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+          results.push(...findFiles(full, ext, maxDepth, depth + 1));
+        }
+      } else if (entry.name.endsWith(ext)) {
+        results.push(full);
+      }
+    }
+  } catch {}
+  return results;
+}
+
+function componentsToHex(components) {
+  try {
+    // Components can be 0-1 floats or 0-255 integers
+    let r = parseFloat(components.red);
+    let g = parseFloat(components.green);
+    let b = parseFloat(components.blue);
+    if (r <= 1 && g <= 1 && b <= 1) { r *= 255; g *= 255; b *= 255; }
+    const toHex = n => Math.round(n).toString(16).padStart(2, '0');
+    return '#' + toHex(r) + toHex(g) + toHex(b);
+  } catch { return null; }
+}