@clerk/upgrade 2.0.0-snapshot.v20251204175016 → 2.0.0-snapshot.v20251211120550

package/dist/codemods/transform-remove-deprecated-appearance-props.cjs

@@ -0,0 +1,109 @@
+const VARIABLE_RENAMES = {
+  colorText: 'colorForeground',
+  colorTextSecondary: 'colorMutedForeground',
+  colorInputText: 'colorInputForeground',
+  colorInputBackground: 'colorInput',
+  colorTextOnPrimaryBackground: 'colorPrimaryForeground',
+  spacingUnit: 'spacing'
+};
+const isStringLiteral = node => node && node.type === 'Literal' && typeof node.value === 'string' || node && node.type === 'StringLiteral' && typeof node.value === 'string';
+const getKeyName = key => {
+  if (!key) {
+    return null;
+  }
+  if (key.type === 'Identifier') {
+    return key.name;
+  }
+  if (isStringLiteral(key)) {
+    return key.value;
+  }
+  return null;
+};
+module.exports = function transformRemoveDeprecatedAppearanceProps({
+  source
+}, {
+  jscodeshift: j
+}) {
+  const root = j(source);
+  let dirty = false;
+  const renamePropertyKey = (prop, newName) => {
+    if (j.Identifier.check(prop.key)) {
+      prop.key.name = newName;
+    } else if (isStringLiteral(prop.key)) {
+      prop.key.value = newName;
+    } else {
+      prop.key = j.identifier(newName);
+      prop.computed = false;
+    }
+    dirty = true;
+  };
+  const maybeRenameBaseTheme = prop => {
+    if (!prop || prop.computed) {
+      return;
+    }
+    if (getKeyName(prop.key) === 'baseTheme') {
+      renamePropertyKey(prop, 'theme');
+    }
+  };
+  const maybeRenameVariableKey = prop => {
+    if (!prop || prop.computed) {
+      return;
+    }
+    const keyName = getKeyName(prop.key);
+    const newName = VARIABLE_RENAMES[keyName];
+    if (newName) {
+      renamePropertyKey(prop, newName);
+    }
+  };
+  const transformAppearanceObject = objExpr => {
+    const props = objExpr.properties || [];
+    props.forEach(prop => {
+      if (!prop || !prop.key) {
+        return;
+      }
+      maybeRenameBaseTheme(prop);
+      if (getKeyName(prop.key) === 'variables' && j.ObjectExpression.check(prop.value)) {
+        (prop.value.properties || []).forEach(maybeRenameVariableKey);
+      }
+    });
+  };
+  const findObjectForIdentifier = identifier => {
+    if (!identifier || !j.Identifier.check(identifier)) {
+      return null;
+    }
+    const name = identifier.name;
+    const decl = root.find(j.VariableDeclarator, {
+      id: {
+        type: 'Identifier',
+        name
+      }
+    }).filter(p => j.ObjectExpression.check(p.node.init)).at(0);
+    if (decl.size() === 0) {
+      return null;
+    }
+    return decl.get().node.init;
+  };
+  root.find(j.JSXAttribute, {
+    name: {
+      name: 'appearance'
+    }
+  }).forEach(path => {
+    const {
+      value
+    } = path.node;
+    if (!value || !j.JSXExpressionContainer.check(value)) {
+      return;
+    }
+    const expr = value.expression;
+    if (j.ObjectExpression.check(expr)) {
+      transformAppearanceObject(expr);
+    } else if (j.Identifier.check(expr)) {
+      const obj = findObjectForIdentifier(expr);
+      if (obj) {
+        transformAppearanceObject(obj);
+      }
+    }
+  });
+  return dirty ? root.toSource() : undefined;
+};
+module.exports.parser = 'tsx';

package/dist/codemods/transform-remove-deprecated-props.cjs

@@ -20,14 +20,13 @@ const COMPONENT_REDIRECT_ATTR = new Map([['ClerkProvider', {
 const COMPONENTS_WITH_USER_BUTTON_REMOVALS = new Map([['UserButton', ['afterSignOutUrl', 'afterMultiSessionSingleSignOutUrl']]]);
 const ORGANIZATION_SWITCHER_RENAMES = new Map([['afterSwitchOrganizationUrl', 'afterSelectOrganizationUrl']]);
 module.exports = function transformDeprecatedProps({
-  source,
-  path: filePath
+  source
 }, {
-  jscodeshift: j
-}, options = {}) {
+  jscodeshift: j,
+  stats
+}) {
   const root = j(source);
   let dirty = false;
-  const stats = options.clerkUpgradeStats;
   const {
     namedImports,
     namespaceImports
@@ -41,29 +40,15 @@ module.exports = function transformDeprecatedProps({
     if (COMPONENTS_WITH_HIDE_SLUG.has(canonicalName)) {
       if (removeJsxAttribute(j, jsxNode, 'hideSlug')) {
         dirty = true;
-        if (stats) {
-          stats.hideSlugRemoved = (stats.hideSlugRemoved || 0) + 1;
-          stats.hideSlugFiles = stats.hideSlugFiles || [];
-          if (!stats.hideSlugFiles.includes(filePath)) {
-            stats.hideSlugFiles.push(filePath);
-          }
-        }
+        stats('hideSlugRemoved');
       }
     }
     if (COMPONENTS_WITH_USER_BUTTON_REMOVALS.has(canonicalName)) {
       const propsToRemove = COMPONENTS_WITH_USER_BUTTON_REMOVALS.get(canonicalName);
-      let removedCount = 0;
       for (const attrName of propsToRemove) {
         if (removeJsxAttribute(j, jsxNode, attrName)) {
           dirty = true;
-          removedCount += 1;
-        }
-      }
-      if (removedCount > 0 && stats) {
-        stats.userbuttonAfterSignOutPropsRemoved = (stats.userbuttonAfterSignOutPropsRemoved || 0) + removedCount;
-        stats.userbuttonFilesAffected = stats.userbuttonFilesAffected || [];
-        if (!stats.userbuttonFilesAffected.includes(filePath)) {
-          stats.userbuttonFilesAffected.push(filePath);
+          stats('userbuttonAfterSignOutPropsRemoved');
         }
       }
     }
@@ -115,7 +100,7 @@ module.exports = function transformDeprecatedProps({
   if (renameObjectProperties(root, j, 'activeSessions', 'signedInSessions')) {
     dirty = true;
   }
-  if (transformSetActiveBeforeEmit(root, j, stats, filePath)) {
+  if (transformSetActiveBeforeEmit(root, j, stats)) {
     dirty = true;
   }
   if (renameTypeReferences(root, j, 'ClerkMiddlewareAuthObject', 'ClerkMiddlewareSessionAuthObject')) {
@@ -338,7 +323,7 @@ function renameTSPropertySignatures(root, j, oldName, newName) {
   });
   return changed;
 }
-function transformSetActiveBeforeEmit(root, j, stats, filePath) {
+function transformSetActiveBeforeEmit(root, j, stats) {
   let changed = false;
   root.find(j.CallExpression).filter(path => isSetActiveCall(path.node.callee)).forEach(path => {
     const [args0] = path.node.arguments;
@@ -362,13 +347,7 @@ function transformSetActiveBeforeEmit(root, j, stats, filePath) {
     const navigateProp = j.objectProperty(j.identifier('navigate'), buildNavigateArrowFunction(j, originalValue));
     args0.properties.splice(beforeEmitIndex, 1, navigateProp);
     changed = true;
-    if (stats) {
-      stats.beforeEmitTransformed = (stats.beforeEmitTransformed || 0) + 1;
-      stats.beforeEmitFiles = stats.beforeEmitFiles || [];
-      if (!stats.beforeEmitFiles.includes(filePath)) {
-        stats.beforeEmitFiles.push(filePath);
-      }
-    }
+    stats('beforeEmitTransformed');
   });
   return changed;
 }
@@ -399,8 +378,8 @@ function getPropertyValueExpression(valueNode) {
 }
 function buildNavigateArrowFunction(j, originalExpression) {
   const paramIdentifier = j.identifier('params');
-  const calleeExpression = clone(originalExpression);
-  const callExpression = j.callExpression(calleeExpression, [j.memberExpression(paramIdentifier, j.identifier('session'))]);
+  // No need to clone - we're moving the expression from beforeEmit to navigate
+  const callExpression = j.callExpression(originalExpression, [j.memberExpression(paramIdentifier, j.identifier('session'))]);
   return j.arrowFunctionExpression([paramIdentifier], callExpression);
 }
 function renameTypeReferences(root, j, oldName, newName) {

package/dist/codemods/transform-themes-to-ui-themes.cjs

@@ -0,0 +1,65 @@
+const LEGACY_PACKAGE = '@clerk/themes';
+const TARGET_PACKAGE = '@clerk/ui/themes';
+const isStringLiteral = (j, node) => j.Literal.check(node) && typeof node.value === 'string' || j.StringLiteral && j.StringLiteral.check(node);
+const getReplacement = value => {
+  if (typeof value !== 'string' || !value.startsWith(LEGACY_PACKAGE)) {
+    return null;
+  }
+  return `${TARGET_PACKAGE}${value.slice(LEGACY_PACKAGE.length)}`;
+};
+module.exports = function transformThemesToUiThemes({
+  source
+}, {
+  jscodeshift: j
+}) {
+  const root = j(source);
+  let dirty = false;
+  const replaceSourceLiteral = literal => {
+    if (!isStringLiteral(j, literal)) {
+      return;
+    }
+    const nextValue = getReplacement(literal.value);
+    if (nextValue && nextValue !== literal.value) {
+      literal.value = nextValue;
+      dirty = true;
+    }
+  };
+  root.find(j.ImportDeclaration).forEach(path => {
+    replaceSourceLiteral(path.node.source);
+  });
+  root.find(j.ExportNamedDeclaration).forEach(path => {
+    if (path.node.source) {
+      replaceSourceLiteral(path.node.source);
+    }
+  });
+  root.find(j.ExportAllDeclaration).forEach(path => {
+    replaceSourceLiteral(path.node.source);
+  });
+  root.find(j.CallExpression, {
+    callee: {
+      name: 'require'
+    }
+  }).forEach(path => {
+    const [arg] = path.node.arguments || [];
+    if (arg) {
+      replaceSourceLiteral(arg);
+    }
+  });
+  if (j.ImportExpression) {
+    root.find(j.ImportExpression).forEach(path => {
+      replaceSourceLiteral(path.node.source);
+    });
+  }
+  root.find(j.CallExpression, {
+    callee: {
+      type: 'Import'
+    }
+  }).forEach(path => {
+    const [arg] = path.node.arguments || [];
+    if (arg) {
+      replaceSourceLiteral(arg);
+    }
+  });
+  return dirty ? root.toSource() : undefined;
+};
+module.exports.parser = 'tsx';

package/dist/config.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import matter from 'gray-matter';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const VERSIONS_DIR = path.join(__dirname, 'versions');
+export async function loadConfig(sdk, currentVersion, release) {
+  const versionDirs = fs.readdirSync(VERSIONS_DIR, {
+    withFileTypes: true
+  }).filter(d => d.isDirectory()).map(d => d.name);
+
+  // If a specific release is requested, load it directly
+  if (release) {
+    if (!versionDirs.includes(release)) {
+      return null;
+    }
+    const configPath = path.join(VERSIONS_DIR, release, 'index.js');
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const moduleUrl = pathToFileURL(configPath).href;
+    const mod = await import(moduleUrl);
+    const config = mod.default ?? mod;
+    const changes = loadChanges(release, sdk);
+    const versionStatus = getVersionStatus(config, sdk, currentVersion);
+    return {
+      ...config,
+      changes,
+      versionStatus,
+      needsUpgrade: versionStatus === 'needs-upgrade',
+      alreadyUpgraded: versionStatus === 'already-upgraded'
+    };
+  }
+  let applicableConfig = null;
+  for (const versionDir of versionDirs) {
+    const configPath = path.join(VERSIONS_DIR, versionDir, 'index.js');
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+    const moduleUrl = pathToFileURL(configPath).href;
+    const mod = await import(moduleUrl);
+    const config = mod.default ?? mod;
+    if (!config.sdkVersions) {
+      continue;
+    }
+    const versionStatus = getVersionStatus(config, sdk, currentVersion);
+    if (versionStatus === 'unsupported' || versionStatus === 'unknown') {
+      continue;
+    }
+    if (versionStatus === 'needs-upgrade') {
+      const changes = loadChanges(versionDir, sdk);
+      return {
+        ...config,
+        changes,
+        versionStatus,
+        needsUpgrade: true,
+        alreadyUpgraded: false
+      };
+    }
+    if (versionStatus === 'already-upgraded' && !applicableConfig) {
+      applicableConfig = {
+        config,
+        versionDir
+      };
+    }
+  }
+  if (applicableConfig) {
+    const changes = loadChanges(applicableConfig.versionDir, sdk);
+    return {
+      ...applicableConfig.config,
+      changes,
+      versionStatus: 'already-upgraded',
+      needsUpgrade: false,
+      alreadyUpgraded: true
+    };
+  }
+  return null;
+}
+function getVersionStatus(config, sdk, currentVersion) {
+  if (!config?.sdkVersions) {
+    return 'unknown';
+  }
+  const range = config.sdkVersions[sdk];
+  if (!range) {
+    return 'unknown';
+  }
+  if (typeof currentVersion !== 'number') {
+    return 'unknown';
+  }
+  if (typeof range.from === 'number' && currentVersion < range.from) {
+    return 'unsupported';
+  }
+  if (typeof range.to === 'number' && currentVersion >= range.to) {
+    return 'already-upgraded';
+  }
+  return 'needs-upgrade';
+}
+export function getTargetPackageName(sdk) {
+  if (sdk === 'clerk-react' || sdk === 'react') {
+    return '@clerk/react';
+  }
+  if (sdk === 'clerk-expo' || sdk === 'expo') {
+    return '@clerk/expo';
+  }
+  return `@clerk/${sdk}`;
+}
+export function getOldPackageName(sdk) {
+  if (sdk === 'clerk-react' || sdk === 'react') {
+    return '@clerk/clerk-react';
+  }
+  if (sdk === 'clerk-expo' || sdk === 'expo') {
+    return '@clerk/clerk-expo';
+  }
+  return null;
+}
+function loadChanges(versionDir, sdk) {
+  const changesDir = path.join(VERSIONS_DIR, versionDir, 'changes');
+  if (!fs.existsSync(changesDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(changesDir).filter(f => f.endsWith('.md'));
+  const changes = [];
+  for (const file of files) {
+    const filePath = path.join(changesDir, file);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = matter(content);
+    const fm = parsed.data;
+    const packages = fm.packages || ['*'];
+    const appliesToSdk = packages.includes('*') || packages.includes(sdk);
+    if (!appliesToSdk) {
+      continue;
+    }
+    const matcher = fm.matcher ? Array.isArray(fm.matcher) ? fm.matcher.map(m => new RegExp(m, `g${fm.matcherFlags || ''}`)) : new RegExp(fm.matcher, `g${fm.matcherFlags || ''}`) : null;
+    changes.push({
+      title: fm.title,
+      matcher,
+      packages,
+      category: fm.category || 'breaking',
+      warning: fm.warning || fm.category === 'warning',
+      docsAnchor: fm.docsAnchor || file.replace('.md', ''),
+      content: parsed.content
+    });
+  }
+  return changes;
+}

package/dist/render.js

@@ -0,0 +1,170 @@
+import * as readline from 'node:readline';
+import chalk from 'chalk';
+export function renderHeader() {
+  console.log('');
+  console.log(chalk.magenta.bold('>> Clerk Upgrade CLI <<'));
+  console.log('');
+}
+export function renderText(message, color) {
+  const colorFn = chalk[color] || (s => s);
+  console.log(colorFn(message));
+}
+export function renderSuccess(message) {
+  console.log(chalk.green(`✅ ${message}`));
+}
+export function renderError(message) {
+  console.error(chalk.red(`⛔ ${message}`));
+}
+export function renderWarning(message) {
+  console.log(chalk.yellow(`⚠️ ${message}`));
+}
+export function renderNewline() {
+  console.log('');
+}
+export function renderConfig({
+  sdk,
+  currentVersion,
+  fromVersion,
+  toVersion,
+  versionName,
+  dir,
+  packageManager
+}) {
+  console.log(`🔧 ${chalk.bold('Upgrade config')}`);
+  const versionSuffix = currentVersion ? ` ${chalk.gray(`(v${currentVersion})`)}` : '';
+  console.log(`Clerk SDK: ${chalk.green(`@clerk/${sdk}`)}${versionSuffix}`);
+  if (fromVersion && toVersion) {
+    const versionLabel = versionName ? ` ${chalk.gray(`(${versionName})`)}` : '';
+    console.log(`Upgrade: ${chalk.green(`v${fromVersion}`)} → ${chalk.green(`v${toVersion}`)}${versionLabel}`);
+  }
+  console.log(`Directory: ${chalk.green(dir)}`);
+  if (packageManager) {
+    console.log(`Package manager: ${chalk.green(packageManager)}`);
+  }
+  console.log('');
+}
+export async function promptConfirm(message, defaultYes = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    const prompt = defaultYes ? `${message} (Y/n): ` : `${message} (y/N): `;
+    rl.question(prompt, answer => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (!normalized) {
+        resolve(defaultYes);
+        return;
+      }
+      resolve(normalized === 'y' || normalized === 'yes');
+    });
+  });
+}
+export async function promptSelect(message, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log(message);
+  options.forEach((opt, i) => {
+    console.log(`  ${i + 1}) ${opt.label}`);
+  });
+  return new Promise(resolve => {
+    rl.question('Enter number: ', answer => {
+      rl.close();
+      const index = parseInt(answer, 10) - 1;
+      if (index >= 0 && index < options.length) {
+        resolve(options[index].value);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+export async function promptText(message, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const prompt = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
+  return new Promise(resolve => {
+    rl.question(prompt, answer => {
+      rl.close();
+      resolve(answer || defaultValue);
+    });
+  });
+}
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function createSpinner(label) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentLabel = label;
+  const start = () => {
+    interval = setInterval(() => {
+      process.stdout.write(`\r${spinnerFrames[frameIndex]} ${currentLabel}`);
+      frameIndex = (frameIndex + 1) % spinnerFrames.length;
+    }, 80);
+  };
+  start();
+  return {
+    update(newLabel) {
+      currentLabel = newLabel;
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+        process.stdout.write('\r\x1b[K');
+      }
+    },
+    success(message) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write(`\r\x1b[K${chalk.green('✓')} ${message}\n`);
+    },
+    error(message) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write(`\r\x1b[K${chalk.red('✗')} ${message}\n`);
+    }
+  };
+}
+export function renderCodemodResults(transform, result) {
+  console.log(`  ${result.ok ?? 0} file(s) modified, ${chalk.red(`  ${result.error ?? 0} errors`)}`);
+  console.log('');
+}
+export function renderScanResults(results, docsUrl) {
+  if (results.length === 0) {
+    console.log(chalk.green('✓ No breaking changes detected!'));
+    console.log('');
+    return;
+  }
+  console.log(chalk.yellow.bold(`Found ${results.length} potential issue(s) to review:`));
+  console.log('');
+  for (const item of results) {
+    console.log(chalk.bold(item.title));
+    if (item.warning) {
+      console.log(chalk.yellow('(warning - may not require action)'));
+    }
+    console.log(chalk.gray(`Found ${item.instances.length} instance(s):`));
+    for (const inst of item.instances) {
+      console.log(chalk.gray(`  ${inst.file}:${inst.position.line}:${inst.position.column}`));
+    }
+    const link = docsUrl && item.docsAnchor ? `${docsUrl}#${item.docsAnchor}` : null;
+    if (link) {
+      console.log(chalk.blue(`→ View in migration guide: ${link}`));
+    }
+    console.log('');
+  }
+}
+export function renderComplete(sdk, docsUrl) {
+  console.log(chalk.green.bold(`✅ Upgrade complete for @clerk/${sdk}`));
+  console.log('');
+  console.log(`Review the changes above and test your application before deployment.`);
+  console.log(chalk.gray(`For more information, see the migration guide: ${docsUrl}`));
+}

package/dist/runner.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import { convertPathToPattern, globby } from 'globby';
+import indexToPosition from 'index-to-position';
+import { getCodemodConfig, runCodemod } from './codemods/index.js';
+import { createSpinner, renderCodemodResults } from './render.js';
+const GLOBBY_IGNORE = ['node_modules/**', '**/node_modules/**', '.git/**', 'dist/**', '**/dist/**', 'build/**', '**/build/**', '.next/**', '**/.next/**', 'package.json', '**/package.json', 'package-lock.json', '**/package-lock.json', 'yarn.lock', '**/yarn.lock', 'pnpm-lock.yaml', '**/pnpm-lock.yaml', '**/*.{png,webp,svg,gif,jpg,jpeg}', '**/*.{mp4,mkv,wmv,m4v,mov,avi,flv,webm,flac,mka,m4a,aac,ogg}'];
+export async function runCodemods(config, sdk, options) {
+  const codemods = config.codemods || [];
+  if (codemods.length === 0) {
+    return;
+  }
+  const glob = typeof options.glob === 'string' ? options.glob.split(/[ ,]/).filter(Boolean) : options.glob;
+  for (const transform of codemods) {
+    const spinner = createSpinner(`Running codemod: ${transform}`);
+    try {
+      const result = await runCodemod(transform, glob, options);
+      spinner.success(`Codemod applied: ${chalk.dim(transform)}`);
+      renderCodemodResults(transform, result);
+      const codemodConfig = getCodemodConfig(transform);
+      if (codemodConfig?.renderSummary && result.stats) {
+        codemodConfig.renderSummary(result.stats);
+      }
+    } catch (error) {
+      spinner.error(`Codemod failed: ${transform}`);
+      throw error;
+    }
+  }
+}
+export async function runScans(config, sdk, options) {
+  const matchers = loadMatchers(config, sdk);
+  if (matchers.length === 0) {
+    return [];
+  }
+  const spinner = createSpinner('Scanning files for breaking changes...');
+  try {
+    const pattern = convertPathToPattern(path.resolve(options.dir));
+    const files = await globby(pattern, {
+      ignore: [...GLOBBY_IGNORE, ...(options.ignore || [])]
+    });
+    const results = {};
+    for (let idx = 0; idx < files.length; idx++) {
+      const file = files[idx];
+      spinner.update(`Scanning ${path.basename(file)} (${idx + 1}/${files.length})`);
+      const content = await fs.readFile(file, 'utf8');
+      for (const matcher of matchers) {
+        const matches = findMatches(content, matcher.matcher);
+        if (matches.length === 0) {
+          continue;
+        }
+        if (!results[matcher.title]) {
+          results[matcher.title] = {
+            instances: [],
+            ...matcher
+          };
+        }
+        for (const match of matches) {
+          const position = indexToPosition(content, match.index, {
+            oneBased: true
+          });
+          const fileRelative = path.relative(process.cwd(), file);
+          const isDuplicate = results[matcher.title].instances.some(i => i.position.line === position.line && i.position.column === position.column && i.file === fileRelative);
+          if (!isDuplicate) {
+            results[matcher.title].instances.push({
+              sdk,
+              position,
+              file: fileRelative
+            });
+          }
+        }
+      }
+    }
+    spinner.success(`Scanned ${files.length} files`);
+    return Object.values(results);
+  } catch (error) {
+    spinner.error('Scan failed');
+    throw error;
+  }
+}
+function loadMatchers(config, sdk) {
+  if (!config.changes) {
+    return [];
+  }
+  return config.changes.filter(change => {
+    if (!change.matcher) {
+      return false;
+    }
+    const packages = change.packages || ['*'];
+    return packages.includes('*') || packages.includes(sdk);
+  });
+}
+function findMatches(content, matcher) {
+  if (Array.isArray(matcher)) {
+    return matcher.flatMap(m => Array.from(content.matchAll(m)));
+  }
+  return Array.from(content.matchAll(matcher));
+}