@astryxdesign/cli 0.1.0-canary.f94dd07 → 0.1.1-canary.a514b99

package/src/api/search.mjs

@@ -41,14 +41,184 @@ import {
 } from '../lib/component-discovery.mjs';
 import {discoverHooks, findHookDoc} from '../lib/hook-discovery.mjs';
 import {levenshteinDistance} from '../lib/string-utils.mjs';
-import {discoverTemplates} from './template.mjs';
+import {discoverTemplates, extractComponents} from './template.mjs';
 import {AstryxError} from './error.mjs';
 
 const DOCS_DIR = path.join(CLI_ROOT, 'docs');
 
+/**
+ * Synonym / intent map: product-language terms an agent is likely to type,
+ * expanded to the catalog's vocabulary so oblique queries still rank. Keys and
+ * values are matched bidirectionally (typing any value also pulls in the key
+ * and its siblings). Lowercase, single words or short phrases.
+ */
+const SYNONYMS = {
+  dashboard: ['overview', 'analytics', 'kpi', 'kpis', 'metrics', 'stats', 'reporting', 'insights', 'control'],
+  login: ['signin', 'auth', 'authentication', 'sso', 'credentials', 'account'],
+  signup: ['register', 'registration', 'onboarding'],
+  payment: ['checkout', 'billing', 'card', 'pay', 'purchase', 'order'],
+  pricing: ['plans', 'plan', 'tiers', 'tier', 'subscription', 'subscriptions'],
+  chat: ['messaging', 'message', 'messages', 'conversation', 'inbox', 'dm'],
+  settings: ['preferences', 'config', 'configuration', 'account'],
+  calendar: ['schedule', 'scheduling', 'events', 'event', 'month', 'agenda'],
+  table: ['list', 'rows', 'records', 'grid', 'spreadsheet', 'datatable'],
+  gallery: ['photos', 'photo', 'images', 'image', 'pictures'],
+  hero: ['banner', 'splash', 'headline', 'landing'],
+  form: ['fields', 'input', 'inputs', 'survey'],
+  profile: ['bio', 'avatar', 'user'],
+  documentation: ['docs', 'reference', 'guide', 'api'],
+  navigation: ['nav', 'menu', 'sidebar'],
+};
+
+// Flatten into a token -> Set(expansions) lookup (bidirectional).
+const SYNONYM_INDEX = (() => {
+  const idx = new Map();
+  const add = (a, b) => {
+    if (!idx.has(a)) idx.set(a, new Set());
+    idx.get(a).add(b);
+  };
+  for (const [key, vals] of Object.entries(SYNONYMS)) {
+    for (const v of vals) {
+      add(key, v);
+      add(v, key);
+      for (const v2 of vals) if (v2 !== v) add(v, v2);
+    }
+  }
+  return idx;
+})();
+
+/**
+ * Light stemmer: strips common English suffixes so "charts"/"charting" and
+ * "chart" share a root. Deliberately crude (no Porter) — good enough to bridge
+ * plural/gerund gaps without a dependency.
+ * @param {string} w
+ * @returns {string}
+ */
+export function stem(w) {
+  let s = w;
+  for (const suf of ['ing', 'ed', 'ies', 'es', 's']) {
+    if (s.length > suf.length + 2 && s.endsWith(suf)) {
+      s = suf === 'ies' ? s.slice(0, -3) + 'y' : s.slice(0, -suf.length);
+      break;
+    }
+  }
+  return s;
+}
+
+
 /** Valid domain filters for `--type`. */
 export const SEARCH_DOMAINS = ['component', 'hook', 'doc', 'template'];
 
+/**
+ * Filler words stripped from multi-word queries so natural-language phrasing
+ * ("a page where you can see business stats") ranks on its content words.
+ */
+const STOPWORDS = new Set([
+  'a', 'an', 'the', 'of', 'for', 'to', 'with', 'and', 'or', 'in', 'on', 'at',
+  'by', 'that', 'this', 'my', 'your', 'our', 'their', 'is', 'are', 'be', 'it',
+  'its', 'as', 'from', 'page', 'screen', 'app', 'application', 'view', 'where',
+  'you', 'can', 'some', 'like', 'just', 'basically', 'kinda', 'want', 'wants',
+  'need', 'needs', 'something', 'thing', 'things', 'build', 'make', 'create',
+  'i', 'me', 'we', 'us', 'so', 'up', 'out', 'over', 'side', 'one', 'big',
+]);
+
+/**
+ * Split a query into meaningful content tokens (lowercased, stopwords + very
+ * short words removed). Empty for single-word queries (callers fall back to
+ * whole-phrase scoring).
+ * @param {string} term - Already-lowercased query.
+ * @returns {string[]}
+ */
+export function tokenizeQuery(term) {
+  return term
+    .split(/\s+/)
+    // Strip only leading/trailing punctuation; keep joined identifiers intact
+    // (e.g. "foo_bar" stays one token) so gibberish stays gibberish.
+    .map(t => t.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, ''))
+    .filter(t => t.length >= 2 && !STOPWORDS.has(t));
+}
+
+/**
+ * Score a candidate against a query, handling multi-word natural language.
+ * Tries the whole phrase (so exact/near matches still win) AND a per-token
+ * pass (so "data table with filters" matches `table-page` via table+filter),
+ * and returns whichever is stronger.
+ *
+ * @param {string} term - Lowercased full query.
+ * @param {string[]} tokens - Content tokens from tokenizeQuery(term).
+ * @param {object} candidate
+ * @returns {{score: number, reason: string} | null}
+ */
+/**
+ * Minimum per-token score (in the multi-word pass) to count as a real match.
+ * 50 = a genuine name/keyword/description hit; below that is loose Levenshtein
+ * fuzz that would otherwise turn gibberish queries into noise.
+ */
+const MIN_TOKEN_SCORE = 50;
+
+/**
+ * Best score for a token against a candidate, fanning out through synonyms
+ * (synonym hits are discounted so a direct hit always wins).
+ * @returns {{score: number, reason: string} | null}
+ */
+function bestForToken(tok, candidate) {
+  let best = scoreCandidate(tok, candidate);
+  const syns = SYNONYM_INDEX.get(tok);
+  if (syns) {
+    for (const s of syns) {
+      const h = scoreCandidate(s, candidate);
+      if (h) {
+        const score = Math.round(h.score * 0.85);
+        if (!best || score > best.score) best = {score, reason: `${h.reason} (~${tok})`};
+      }
+    }
+  }
+  return best;
+}
+
+export function scoreQuery(term, tokens, candidate) {
+  const full = scoreCandidate(term, candidate);
+
+  // 0–1 content tokens: keep whole-phrase fuzzy matching (typo tolerance for
+  // single words), but if stopwords left exactly one DIFFERENT token (e.g.
+  // "pricing page" → "pricing"), score that token too and take the stronger.
+  if (tokens.length <= 1) {
+    const single = tokens.length === 1 ? bestForToken(tokens[0], candidate) : null;
+    if (full && (!single || full.score >= single.score)) return full;
+    return single;
+  }
+
+  // Multi-word natural language: score each content token, counting only
+  // strong hits, then reward coverage so candidates matching more terms win.
+  let sum = 0;
+  let matched = 0;
+  const hitTerms = [];
+  for (const tok of tokens) {
+    const h = bestForToken(tok, candidate);
+    if (h && h.score >= MIN_TOKEN_SCORE) {
+      sum += h.score;
+      matched++;
+      hitTerms.push(tok);
+    }
+  }
+  if (matched === 0) return full;
+
+  // Reward the AVERAGE strength of the concepts that matched (not divided by
+  // total query length — that penalizes verbose / low-fidelity prompts), plus
+  // a bonus per additional matched concept and a coverage term. A candidate
+  // that matches several of the query's concepts beats one matching a single
+  // incidental word.
+  const avgMatched = sum / matched;
+  const coverage = matched / tokens.length;
+  const tokenScore = Math.round(avgMatched + Math.min(matched - 1, 3) * 12 + coverage * 15);
+
+  if (full && full.score >= tokenScore) return full;
+  return {
+    score: tokenScore,
+    reason: `matches ${matched}/${tokens.length} terms: ${hitTerms.join(', ')}`,
+  };
+}
+
 /**
  * Score a single candidate against the search term across name, keywords,
  * and prose signals. Returns the best (highest) score plus a human reason,
@@ -107,10 +277,13 @@ export function scoreCandidate(term, {name, keywords = [], description = '', pro
     else if (dist === 2) consider(30, `keyword "${kw}" (distance ${dist})`);
   }
 
-  // ── Prose / description signals (whole-word boundary) ───────────
+  // ── Prose / description signals (stem-tolerant whole word) ──────
+  // Match the term's stem as a whole word, tolerating plural/gerund suffixes
+  // so "chart" matches "charts" and "filter" matches "filtering".
   if (term.length >= 3) {
-    const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const re = new RegExp(`\\b${escaped}\\b`);
+    const root = stem(term);
+    const escaped = root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`\\b${escaped}(s|es|ing|ed|ies)?\\b`);
     if (description && re.test(description.toLowerCase())) {
       consider(50, `description mentions "${term}"`);
     } else {
@@ -240,14 +413,30 @@ async function gatherTemplates(cwd) {
   } catch {
     return [];
   }
-  return templates.map(t => ({
-    domain: 'template',
-    name: t.dirName,
-    keywords: Array.isArray(t.componentsUsed) ? t.componentsUsed : [],
-    description: t.description || '',
-    _displayName: t.name,
-    _kind: t.type, // 'page' | 'block'
-  }));
+  return templates.map(t => {
+    // Blocks ship componentsUsed; page templates don't, so derive them from the
+    // source. Category words (e.g. "Dashboard - Analytics") are strong intent
+    // signal for pages, which otherwise only index on name + description.
+    let keywords = Array.isArray(t.componentsUsed) ? [...t.componentsUsed] : [];
+    if (t.type === 'page') {
+      if (t.filePath) {
+        try {
+          keywords = keywords.concat(extractComponents(t.filePath));
+        } catch {
+          // Best-effort: skip keyword enrichment if the source can't be read.
+        }
+      }
+      if (t.category) keywords = keywords.concat(t.category.split(/[^A-Za-z0-9]+/).filter(Boolean));
+    }
+    return {
+      domain: 'template',
+      name: t.dirName,
+      keywords,
+      description: t.description || '',
+      _displayName: t.name,
+      _kind: t.type, // 'page' | 'block'
+    };
+  });
 }
 
 /**
@@ -325,6 +514,7 @@ export async function search(query, options = {}) {
   }
 
   const term = String(query).trim().toLowerCase();
+  const tokens = tokenizeQuery(term);
 
   const coreDir = findCoreDir(cwd);
   if (!coreDir) {
@@ -342,9 +532,13 @@ export async function search(query, options = {}) {
 
   const all = [...components, ...hooks, ...docTopics, ...templates];
 
+  // Score every candidate on its own merits. The consumer groups results by
+  // role (page / block / component) and takes the top of each, so there's no
+  // cross-role competition to engineer — a target page only needs to be the
+  // strongest PAGE, not outrank every component.
   const scored = [];
   for (const candidate of all) {
-    const hit = scoreCandidate(term, candidate);
+    const hit = scoreQuery(term, tokens, candidate);
     if (hit) scored.push(toResult(candidate, hit.score, hit.reason));
   }
 

package/src/api/template.mjs

@@ -95,6 +95,7 @@ async function discoverPages() {
       dirName: dir.name,
       name: doc?.name || dir.name,
       description: doc?.description || '',
+      category: doc?.category || '',
       isReady: doc?.isReady ?? true,
       scaffold: doc?.scaffold ?? false,
       filePath: path.join(dirPath, 'page.tsx'),
@@ -245,7 +246,7 @@ const UBIQUITOUS = new Set([
   'StackItem', 'Icon',
 ]);
 
-function extractComponents(pagePath) {
+export function extractComponents(pagePath) {
   const src = fs.readFileSync(pagePath, 'utf-8');
   // Match JSX opening tags, e.g. `<Section` or the legacy `<XDSSection`.
   // Templates author bare component names post un-prefix migration

package/src/codemods/__tests__/registry.test.mjs

@@ -16,6 +16,7 @@ describe('registry', () => {
         '0.0.13',
         '0.0.14',
         '0.0.15',
+        '0.1.0',
       ]);
     });
   });

package/src/codemods/registry.mjs

@@ -17,6 +17,7 @@ const registry = new Map([
   ['0.0.13', () => import('./transforms/v0.0.13/index.mjs')],
   ['0.0.14', () => import('./transforms/v0.0.14/index.mjs')],
   ['0.0.15', () => import('./transforms/v0.0.15/index.mjs')],
+  ['0.1.0', () => import('./transforms/v0.1.0/index.mjs')],
 ]);
 
 // Re-export from the shared utility so registry callers and other consumers

package/src/codemods/runner.mjs

@@ -11,7 +11,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as p from '@clack/prompts';
-import {getRunPrefix} from '../utils/package-manager.mjs';
 import {humanLog} from '../lib/json.mjs';
 
 // Known corruption patterns that indicate a broken transform.
@@ -87,39 +86,6 @@ function findSourceFiles(dir) {
   return results.sort();
 }
 
-/**
- * Detect the project's formatter and run it on changed files.
- * Tries prettier, then biome. Silently skips if none found.
- *
- * @param {string[]} files - Absolute paths to files that were modified
- * @param {boolean} [silent] - Suppress human-facing output
- */
-async function formatChangedFiles(files, silent = false) {
-  if (files.length === 0) return;
-
-  const {execSync} = await import('node:child_process');
-  const fileArgs = files.map(f => `"${f}"`).join(' ');
-  const prefix = getRunPrefix();
-
-  const formatters = [
-    {name: 'prettier', cmd: `${prefix} prettier --write ${fileArgs}`},
-    {name: 'biome', cmd: `${prefix} biome format --write ${fileArgs}`},
-  ];
-
-  for (const {name, cmd} of formatters) {
-    try {
-      execSync(cmd, {stdio: 'pipe', timeout: 30000});
-      if (!silent)
-        p.log.info(
-          `Formatted ${files.length} file${files.length === 1 ? '' : 's'} with ${name}`,
-        );
-      return;
-    } catch {
-      // Formatter not available or failed — try next
-    }
-  }
-}
-
 /**
  * Validate transform output before writing to disk.
  *
@@ -162,6 +128,86 @@ export function validateOutput(result, source, j, {parse = true} = {}) {
   return {valid: true};
 }
 
+function isConfigCodemod(transformEntry) {
+  return transformEntry.meta?.codemodType === 'config';
+}
+
+const CONFIG_CODEMOD_PATHS = new Set([
+  'package.json',
+  'astryx.config.mjs',
+  'xds.config.mjs',
+]);
+
+function resolveConfigPath(relativePath) {
+  if (!CONFIG_CODEMOD_PATHS.has(relativePath)) {
+    throw new Error(`unsupported config codemod path: ${relativePath}`);
+  }
+  return path.resolve(process.cwd(), relativePath);
+}
+
+function readOptionalConfigFile(relativePath) {
+  const fullPath = resolveConfigPath(relativePath);
+  if (!fs.existsSync(fullPath)) return null;
+  return {path: relativePath, source: fs.readFileSync(fullPath, 'utf-8')};
+}
+
+function getConfigCodemodContext() {
+  return {
+    packageJson: readOptionalConfigFile('package.json'),
+    astryxConfig: readOptionalConfigFile('astryx.config.mjs'),
+    xdsConfig: readOptionalConfigFile('xds.config.mjs'),
+  };
+}
+
+async function runConfigCodemod(transformEntry, {apply, log}) {
+  const {transform} = transformEntry;
+  const api = {config: getConfigCodemodContext()};
+  const result = await transform({path: process.cwd(), source: ''}, api);
+  const errors = result?.errors ?? [];
+  if (errors.length > 0) {
+    for (const error of errors) {
+      log.error(`    ✗ ${error.file ?? 'config'} — ${error.error}`);
+    }
+    return {filesChanged: 0, errors};
+  }
+
+  const changes = result?.changes ?? [];
+  if (changes.length === 0) return {filesChanged: 0, errors: []};
+
+  for (const change of changes) {
+    const fullPath = resolveConfigPath(change.path);
+    if (change.delete) {
+      if (apply) fs.rmSync(fullPath, {force: true});
+      log[apply ? 'success' : 'warn'](
+        `    ${apply ? '✓' : '~'} ${change.path} (delete${apply ? '' : ', dry run'})`,
+      );
+      continue;
+    }
+
+    if (apply) {
+      fs.writeFileSync(fullPath, change.source, 'utf-8');
+    }
+    log[apply ? 'success' : 'warn'](
+      `    ${apply ? '✓' : '~'} ${change.path}${apply ? '' : ' (would change)'}`,
+    );
+  }
+
+  if (changes.length > 0) {
+    const verb = apply ? 'Updated' : 'Would update';
+    log.info(
+      `  ${verb} ${changes.length} config file${changes.length === 1 ? '' : 's'}`,
+    );
+  }
+
+  return {
+    filesChanged: changes.length,
+    writtenFiles: changes
+      .filter(change => !change.delete && path.extname(change.path) !== '.json')
+      .map(change => resolveConfigPath(change.path)),
+    errors: [],
+  };
+}
+
 /**
  * Run codemods against source files.
  *
@@ -197,18 +243,12 @@ export async function runCodemods(
 
   if (files.length === 0) {
     log.warn('No source files found.');
-    return {
-      ok: true,
-      totalFilesChanged: 0,
-      totalTransformsApplied: 0,
-      errors: [],
-      writtenFiles: [],
-      skippedOptional: [],
-    };
+  } else {
+    log.info(
+      `Found ${files.length} source file${files.length === 1 ? '' : 's'}`,
+    );
   }
 
-  log.info(`Found ${files.length} source file${files.length === 1 ? '' : 's'}`);
-
   // Dynamically import jscodeshift
   const jscodeshift = (await import('jscodeshift')).default;
 
@@ -239,6 +279,24 @@ export async function runCodemods(
 
       log.info(`  ${meta.title}`);
 
+      if (isConfigCodemod(transformEntry)) {
+        const result = await runConfigCodemod(transformEntry, {apply, log});
+        if (result.errors.length > 0) {
+          for (const error of result.errors) {
+            errors.push({
+              file: error.file ?? 'config',
+              codemod: name,
+              error: error.error,
+            });
+          }
+        } else if (result.filesChanged > 0) {
+          totalFilesChanged += result.filesChanged;
+          totalTransformsApplied += result.filesChanged;
+          writtenFiles.push(...(result.writtenFiles ?? []));
+        }
+        continue;
+      }
+
       let filesChanged = 0;
 
       for (const filePath of files) {
@@ -323,12 +381,6 @@ export async function runCodemods(
     }
   }
 
-  // Post-codemod formatting: run the project's formatter on changed files
-  // so codemods don't introduce style drift (jscodeshift may change quotes, etc.)
-  if (apply && writtenFiles.length > 0) {
-    await formatChangedFiles(writtenFiles, silent);
-  }
-
   if (totalValidationBlocked > 0) {
     log.warn(
       `${totalValidationBlocked} file${totalValidationBlocked === 1 ? ' was' : 's were'} blocked by validation — no changes written to ${totalValidationBlocked === 1 ? 'that file' : 'those files'}.`,
@@ -366,7 +418,9 @@ export async function runCodemods(
       if (meta.description) {
         log.info(`    ${meta.description}`);
       }
-      log.info(`    Run: astryx upgrade --codemod ${name} --path <dir> --apply`);
+      log.info(
+        `    Run: astryx upgrade --codemod ${name} --path <dir> --apply`,
+      );
     }
   }
 

package/src/codemods/transforms/v0.1.0/__tests__/migrate-xds-config-surfaces.test.mjs

@@ -0,0 +1,116 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect} from 'vitest';
+
+async function applyConfigCodemod(files) {
+  const {default: transform} =
+    await import('../migrate-xds-config-surfaces.mjs');
+  const config = {
+    packageJson: files['package.json']
+      ? {path: 'package.json', source: files['package.json']}
+      : null,
+    astryxConfig: files['astryx.config.mjs']
+      ? {path: 'astryx.config.mjs', source: files['astryx.config.mjs']}
+      : null,
+    xdsConfig: files['xds.config.mjs']
+      ? {path: 'xds.config.mjs', source: files['xds.config.mjs']}
+      : null,
+  };
+  return transform({path: process.cwd(), source: ''}, {config});
+}
+
+describe('migrate-xds-config-surfaces', () => {
+  it('extracts package.json xds config into astryx.config.mjs and removes the package key in place', async () => {
+    const input = `{
+    "dependencies": {"@xds/core":"^0.0.15"},
+    "xds"  : {"theme":"neutral","docs":"./src"}
+}
+`;
+
+    const result = await applyConfigCodemod({'package.json': input});
+    expect(result.errors ?? []).toEqual([]);
+    expect(result.changes).toEqual([
+      {
+        path: 'package.json',
+        source: `{
+    "dependencies": {"@xds/core":"^0.0.15"}
+}
+`,
+      },
+      {
+        path: 'astryx.config.mjs',
+        source: `export default {
+  "theme": "neutral",
+  "docs": "./src"
+};
+`,
+      },
+    ]);
+  });
+
+  it('extracts package.json astryx config into astryx.config.mjs too', async () => {
+    const result = await applyConfigCodemod({
+      'package.json': `{"astryx":{"theme":"neutral"}}\n`,
+    });
+    expect(result.changes).toEqual([
+      {path: 'package.json', source: `{}\n`},
+      {
+        path: 'astryx.config.mjs',
+        source: `export default {
+  "theme": "neutral"
+};
+`,
+      },
+    ]);
+  });
+
+  it('bails when package.json contains both xds and astryx config keys', async () => {
+    const result = await applyConfigCodemod({
+      'package.json': `{"xds":{"theme":"default"},"astryx":{"theme":"neutral"}}\n`,
+    });
+    expect(result.errors?.[0]?.error).toMatch(/both xds and astryx/);
+  });
+
+  it('does not rewrite dependency keys in package.json', async () => {
+    const input = `{"dependencies":{"@xds/core":"^0.0.15"}}\n`;
+    const result = await applyConfigCodemod({'package.json': input});
+    expect(result.changes).toEqual([]);
+  });
+
+  it('bails when package config and astryx.config.mjs both exist', async () => {
+    const result = await applyConfigCodemod({
+      'package.json': `{"xds":{"theme":"neutral"}}\n`,
+      'astryx.config.mjs': `export default {};\n`,
+    });
+    expect(result.errors?.[0]?.error).toMatch(/migrate the config manually/);
+  });
+
+  it('bails when package config and xds.config.mjs both exist', async () => {
+    const result = await applyConfigCodemod({
+      'package.json': `{"xds":{"theme":"neutral"}}\n`,
+      'xds.config.mjs': `export default {};\n`,
+    });
+    expect(result.errors?.[0]?.error).toMatch(/migrate the config manually/);
+  });
+
+  it('renames xds.config.mjs to astryx.config.mjs when no package config exists', async () => {
+    const result = await applyConfigCodemod({
+      'xds.config.mjs': "export default { theme: 'neutral' };\n",
+    });
+    expect(result.changes).toEqual([
+      {
+        path: 'astryx.config.mjs',
+        source: "export default { theme: 'neutral' };\n",
+      },
+      {path: 'xds.config.mjs', delete: true},
+    ]);
+  });
+
+  it('bails when xds.config.mjs and astryx.config.mjs both exist', async () => {
+    const result = await applyConfigCodemod({
+      'xds.config.mjs': `export default {};\n`,
+      'astryx.config.mjs': `export default {};\n`,
+    });
+    expect(result.errors?.[0]?.error).toMatch(/migrate the config manually/);
+  });
+});

package/src/codemods/transforms/v0.1.0/__tests__/migrate-xds-module-specifiers.test.mjs

@@ -0,0 +1,51 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect} from 'vitest';
+
+async function applyTransform(source, filePath = 'test.tsx') {
+  const {default: transform} =
+    await import('../migrate-xds-module-specifiers.mjs');
+  const jscodeshift = (await import('jscodeshift')).default;
+  const j = jscodeshift.withParser('tsx');
+  const api = {jscodeshift: j, stats: () => {}, report: () => {}};
+  const file = {source, path: filePath};
+  const result = transform(file, api);
+  return result ?? source;
+}
+
+describe('migrate-xds-module-specifiers', () => {
+  it('renames import and export source paths including subpaths', async () => {
+    const input = [
+      "import {Button} from '@xds/core/Button';",
+      "import '@xds/theme-default/theme.css';",
+      "export {LabThing} from '@xds/lab/Thing';",
+      "export * from '@xds/core/theme';",
+    ].join('\n');
+
+    const output = await applyTransform(input);
+    expect(output).toContain('@astryxdesign/core/Button');
+    expect(output).toContain('@astryxdesign/theme-neutral/theme.css');
+    expect(output).toContain('@astryxdesign/lab/Thing');
+    expect(output).toContain('@astryxdesign/core/theme');
+    expect(output).not.toContain('@xds/');
+  });
+
+  it('renames dynamic import and require string literals', async () => {
+    const output = await applyTransform(
+      [
+        "const mod = await import('@xds/core/theme');",
+        "const core = require('@xds/core');",
+      ].join('\n'),
+      'test.ts',
+    );
+    expect(output).toContain('@astryxdesign/core/theme');
+    expect(output).toContain('@astryxdesign/core');
+    expect(output).not.toContain('@xds/');
+  });
+
+  it('does not rewrite ordinary string literals', async () => {
+    const input = "const packageName = '@xds/core';";
+    const output = await applyTransform(input, 'test.ts');
+    expect(output).toBe(input);
+  });
+});