@astryxdesign/cli 0.1.0 → 0.1.1-canary.080d887

package/src/commands/upgrade.test.mjs

@@ -6,7 +6,6 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import {Command} from 'commander';
 import {registerUpgrade} from './upgrade.mjs';
-import {latestVersion} from '../codemods/registry.mjs';
 
 let tmpDir;
 let originalCwd;
@@ -15,7 +14,7 @@ let stdoutCalls;
 let exitCode;
 
 beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'xds-upgrade-test-'));
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-upgrade-test-'));
   originalCwd = process.cwd();
   process.chdir(tmpDir);
   logCalls = [];
@@ -53,13 +52,28 @@ function createProgram() {
   return program;
 }
 
-function writePkg(deps) {
+function writePkg(deps = {}) {
   fs.writeFileSync(
     path.join(tmpDir, 'package.json'),
     JSON.stringify({name: 'fixture', dependencies: deps}, null, 2),
   );
 }
 
+function writeInstalledCore(version, packageName = '@astryxdesign/core') {
+  const parts = packageName.split('/');
+  const dir = path.join(tmpDir, 'node_modules', ...parts);
+  fs.mkdirSync(dir, {recursive: true});
+  fs.writeFileSync(
+    path.join(dir, 'package.json'),
+    JSON.stringify({name: packageName, version}, null, 2),
+  );
+}
+
+function writeSourceFile() {
+  fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
+  fs.writeFileSync(path.join(tmpDir, 'src', 'index.ts'), 'const x = 1;\n');
+}
+
 /** Run a command and capture the parsed JSON response (last printed JSON line). */
 async function runJson(args) {
   const program = createProgram();
@@ -83,53 +97,53 @@ async function runJson(args) {
 }
 
 describe('upgrade gate (semver comparison)', () => {
-  it('does NOT block an upgrade from 0.0.9 to 0.0.10 (regression)', async () => {
+  it('does NOT block an upgrade from 0.0.9 to installed 0.0.10 (regression)', async () => {
     // The original bug: string compare said '0.0.9' >= '0.0.10', so the
     // gate told users "Already up to date" without --force.
-    writePkg({'@astryxdesign/core': '^0.0.9'});
+    writePkg();
+    writeInstalledCore('0.0.10');
+    writeSourceFile();
 
-    const result = await runJson(['--json', 'upgrade', '--to', '0.0.10', '--codemod-only']);
-    // Either a real run or "no codemods available" — but never the
-    // up-to-date short-circuit (which has no `type` field).
+    const result = await runJson(['--json', 'upgrade', '--from', '0.0.9', '--path', 'src']);
     expect(result).not.toBeNull();
-    // The receipt or "no codemods" path should not look like the
-    // up-to-date short-circuit (which would return without printing JSON).
     expect(result.type === 'upgrade.run' || result.error || logCalls.some(l => l.includes('No codemods'))).toBeTruthy();
   });
 
-  it('blocks when current >= target by semver (e.g. 0.0.10 → 0.0.9)', async () => {
-    writePkg({'@astryxdesign/core': '^0.0.10'});
+  it('blocks when --from >= installed target by semver (e.g. 0.0.10 → 0.0.9)', async () => {
+    writePkg();
+    writeInstalledCore('0.0.9');
     const program = createProgram();
-    await program.parseAsync(['node', 'astryx', 'upgrade', '--to', '0.0.9']);
+    await program.parseAsync(['node', 'astryx', 'upgrade', '--from', '0.0.10']);
     const output = stdoutCalls.join('') + logCalls.join('\n');
     expect(output).toMatch(/up to date|Already/i);
   });
 });
 
-describe('upgrade --to validation', () => {
-  it('rejects bogus --to values with a structured error', async () => {
-    writePkg({'@astryxdesign/core': '^0.0.5'});
-    const result = await runJson(['--json', 'upgrade', '--to', 'bogus']);
+describe('upgrade argument validation', () => {
+  it('requires --from for upgrade runs', async () => {
+    writePkg();
+    writeInstalledCore('0.0.15');
+    const result = await runJson(['--json', 'upgrade']);
     expect(result).not.toBeNull();
-    expect(result.error).toMatch(/Invalid --to/);
+    expect(result.error).toMatch(/Missing required --from/);
     expect(exitCode).toBe(1);
   });
 
   it('rejects bogus --from values', async () => {
-    writePkg({'@astryxdesign/core': '^0.0.5'});
-    const result = await runJson(['--json', 'upgrade', '--from', 'not-a-version', '--to', '0.0.5']);
+    writePkg();
+    writeInstalledCore('0.0.15');
+    const result = await runJson(['--json', 'upgrade', '--from', 'not-a-version']);
     expect(result).not.toBeNull();
     expect(result.error).toMatch(/Invalid --from/);
     expect(exitCode).toBe(1);
   });
 
-  it('accepts a valid semver --to', async () => {
-    writePkg({'@astryxdesign/core': '^0.0.5'});
-    // Don't actually run codemods — codemod-only + a target with no
-    // matching transforms is enough to confirm validation passed.
-    const result = await runJson(['--json', 'upgrade', '--to', latestVersion, '--codemod-only']);
-    // No "Invalid --to" error means validation passed.
-    expect(result?.error || '').not.toMatch(/Invalid --to/);
+  it('detects the installed target version from @astryxdesign/core', async () => {
+    writePkg();
+    writeInstalledCore('0.0.15');
+    writeSourceFile();
+    const result = await runJson(['--json', 'upgrade', '--from', '0.0.14', '--path', 'src']);
+    expect(result?.error || '').not.toMatch(/Could not find installed/);
   });
 });
 

package/src/config.mjs

@@ -0,0 +1,31 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {validateConfig, validateIntegration} from './lib/config-schema.mjs';
+
+/**
+ * Type-preserving helpers for Astryx config and integration manifests.
+ *
+ * These are intentionally tiny runtime identity functions. Their value is the
+ * exported TypeScript surface from `@astryxdesign/cli/config`, so config files
+ * can get editor/type feedback without coupling to CLI internals.
+ */
+
+/**
+ * @template {import('./types/config').AstryxConfig} T
+ * @param {T} config
+ * @returns {T}
+ */
+export function createConfig(config) {
+  validateConfig(config);
+  return config;
+}
+
+/**
+ * @template {import('./types/config').AstryxIntegration} T
+ * @param {T} integration
+ * @returns {T}
+ */
+export function createIntegration(integration) {
+  validateIntegration(integration);
+  return integration;
+}

package/src/config.test.mjs

@@ -0,0 +1,24 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, expect, it} from 'vitest';
+import {createConfig, createIntegration} from './config.mjs';
+
+describe('config helpers', () => {
+  it('return config and integration objects unchanged', () => {
+    const config = {integrations: ['@acme/widgets']};
+    const integration = {name: '@acme/widgets', docs: './docs'};
+    expect(createConfig(config)).toBe(config);
+    expect(createIntegration(integration)).toBe(integration);
+  });
+
+  it('validates config and integration shapes', () => {
+    expect(() => createConfig({integrations: [42]})).toThrow(/integrations/);
+    expect(() => createIntegration({docs: './docs'})).toThrow(/name/);
+    expect(() =>
+      createIntegration({
+        name: '@acme/widgets',
+        postCodemod: [{name: 'empty'}],
+      }),
+    ).toThrow(/postCodemod/);
+  });
+});

package/src/index.mjs

@@ -63,6 +63,9 @@ export const JSON_SUPPORTED = new Set([
   'upgrade',
   'manifest',
   'doctor',
+  'layout expand',
+  'layout check',
+  'layout grammar',
 ]);
 
 program
@@ -243,12 +246,14 @@ const commands = [
   {name: 'swizzle', path: './commands/swizzle.mjs', register: 'registerSwizzle'},
   // agent-docs folded into init — functions still importable from agent-docs.mjs
   {name: 'template', path: './commands/template.mjs', register: 'registerTemplate'},
+  {name: 'layout', path: './commands/layout.mjs', register: 'registerLayout'},
   {name: 'gap-report', path: './commands/gap-report.mjs', register: 'registerGapReport'},
   {name: 'upgrade', path: './commands/upgrade.mjs', register: 'registerUpgrade'},
   {name: 'theme', path: './commands/build-theme.mjs', register: 'registerTheme'},
   {name: 'hook', path: './commands/hook/index.mjs', register: 'registerHook'},
   {name: 'discover', path: './commands/discover.mjs', register: 'registerDiscover'},
   {name: 'search', path: './commands/search.mjs', register: 'registerSearch'},
+  {name: 'build', path: './commands/build.mjs', register: 'registerBuild'},
   {name: 'doctor', path: './commands/doctor.mjs', register: 'registerDoctor'},
 ];
 

package/src/lib/config-schema.mjs

@@ -0,0 +1,119 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/** Runtime schemas for Astryx config and integration manifests. */
+
+import {z} from 'zod';
+
+const Fn = z.custom(value => typeof value === 'function', {
+  message: 'Expected function',
+});
+
+const StringOrStringArray = z.union([z.string(), z.array(z.string())]);
+const GapReportSchema = z.union([
+  z.literal(false),
+  z.object({command: z.string()}).passthrough(),
+]);
+
+export const AstryxConfigSchema = z
+  .object({
+    packages: StringOrStringArray.optional(),
+    integrations: StringOrStringArray.optional(),
+    gapReport: GapReportSchema.optional(),
+    template: z
+      .object({
+        get: Fn.optional(),
+      })
+      .passthrough()
+      .optional(),
+  })
+  .passthrough();
+
+export const AstryxIntegrationCodemodSchema = z
+  .object({
+    name: z.string(),
+    from: z.string().optional(),
+    to: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    pr: z.string().optional(),
+    optional: z.boolean().optional(),
+    fileExtensions: z.array(z.string()).optional(),
+    transform: z.union([z.string(), Fn]),
+  })
+  .passthrough();
+
+export const AstryxPostCodemodHookSchema = z
+  .object({
+    name: z.string().optional(),
+    run: Fn.optional(),
+    command: Fn.optional(),
+  })
+  .passthrough()
+  .refine(value => value.run || value.command, {
+    message: 'postCodemod hook must define run() or command()',
+  });
+
+export const AstryxIntegrationSchema = z
+  .object({
+    name: z.string(),
+    version: z.string().optional(),
+    displayName: z.string().optional(),
+    description: z.string().optional(),
+    docs: z.string().optional(),
+    category: z.string().optional(),
+    blocks: z.string().optional(),
+    gapReport: GapReportSchema.optional(),
+    template: z
+      .object({
+        get: z.union([z.string(), Fn]).optional(),
+      })
+      .passthrough()
+      .optional(),
+    codemods: z.array(AstryxIntegrationCodemodSchema).optional(),
+    postCodemod: z.array(AstryxPostCodemodHookSchema).optional(),
+  })
+  .passthrough();
+
+/**
+ * @param {string} label
+ * @param {import('zod').ZodError} error
+ */
+function formatZodError(label, error) {
+  const issues = error.issues
+    .map(issue => {
+      const path = issue.path.length ? issue.path.join('.') : '(root)';
+      return `${path}: ${issue.message}`;
+    })
+    .join('; ');
+  return `${label} is invalid: ${issues}`;
+}
+
+/**
+ * @param {unknown} config
+ * @returns {import('../types/config').AstryxConfig}
+ */
+export function validateConfig(config) {
+  const result = AstryxConfigSchema.safeParse(config);
+  if (!result.success) {
+    throw new Error(
+      formatZodError('astryx.config.mjs default export', result.error),
+    );
+  }
+  return result.data;
+}
+
+/**
+ * @param {unknown} integration
+ * @param {string} [label]
+ * @returns {import('../types/config').AstryxIntegration}
+ */
+export function validateIntegration(
+  integration,
+  label = 'integration manifest',
+) {
+  const result = AstryxIntegrationSchema.safeParse(integration);
+  if (!result.success) {
+    throw new Error(formatZodError(label, result.error));
+  }
+  return result.data;
+}

package/src/lib/config.mjs

@@ -10,9 +10,12 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import {pathToFileURL} from 'node:url';
+import {loadIntegrations} from './integrations.mjs';
+import {validateConfig} from './config-schema.mjs';
 
 const DEFAULTS = {
   packages: [],
+  integrations: [],
 };
 
 /**
@@ -39,17 +42,30 @@ export async function loadConfig(startDir = process.cwd()) {
   const configPath = findConfigPath(startDir);
   if (!configPath) return {...DEFAULTS};
 
+  let rawConfig;
   try {
     const mod = await import(pathToFileURL(configPath).href);
-    const config = mod.default || {};
-    return {
-      ...DEFAULTS,
-      ...config,
-      packages: normalizePackages(config.packages, path.dirname(configPath)),
-    };
+    rawConfig = mod.default || {};
   } catch {
     return {...DEFAULTS};
   }
+
+  const config = validateConfig(rawConfig);
+  const configDir = path.dirname(configPath);
+  const integrationSpecs = normalizeIntegrations(config.integrations);
+  const loadedIntegrations = await loadIntegrations(integrationSpecs, {
+    cwd: configDir,
+  });
+  return {
+    ...DEFAULTS,
+    ...config,
+    packages: normalizePackages(config.packages, configDir),
+    integrations: integrationSpecs,
+    loadedIntegrations,
+    gapReport:
+      config.gapReport ?? firstDefined(loadedIntegrations, 'gapReport'),
+    template: mergeTemplateConfig(config.template, loadedIntegrations),
+  };
 }
 
 /**
@@ -72,3 +88,26 @@ function normalizePackages(packages, configDir) {
   }
   return result;
 }
+
+/**
+ * Normalize integration specs to a string array. Integrations are package names
+ * or manifest paths consumed by `astryx upgrade --integration`.
+ */
+function normalizeIntegrations(integrations) {
+  if (!integrations) return [];
+  const arr = Array.isArray(integrations) ? integrations : [integrations];
+  return arr.filter(value => typeof value === 'string' && value !== '');
+}
+
+function firstDefined(integrations, key) {
+  for (const integration of integrations) {
+    if (integration[key] !== undefined) return integration[key];
+  }
+  return undefined;
+}
+
+function mergeTemplateConfig(template, integrations) {
+  if (template?.get) return template;
+  const integrationTemplate = firstDefined(integrations, 'template');
+  return integrationTemplate ?? template;
+}

package/src/lib/config.test.mjs

@@ -0,0 +1,91 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {afterEach, beforeEach, describe, expect, it} from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {loadConfig} from './config.mjs';
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-config-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+function installIntegrationPackage(dir, name = '@nest/xds-meta') {
+  const packageDir = path.join(dir, 'node_modules', ...name.split('/'));
+  fs.mkdirSync(packageDir, {recursive: true});
+  fs.writeFileSync(
+    path.join(packageDir, 'package.json'),
+    JSON.stringify({name, astryx: {integration: './astryx.integration.mjs'}}),
+  );
+  fs.writeFileSync(
+    path.join(packageDir, 'astryx.integration.mjs'),
+    `export default { name: '${name}' };
+`,
+  );
+}
+
+describe('loadConfig', () => {
+  it('normalizes integrations from astryx.config.mjs', async () => {
+    const dir = path.join(tmpDir, 'one');
+    fs.mkdirSync(dir);
+    installIntegrationPackage(dir);
+    fs.writeFileSync(
+      path.join(dir, 'astryx.config.mjs'),
+      `export default { integrations: '@nest/xds-meta' };\n`,
+    );
+    await expect(loadConfig(dir)).resolves.toMatchObject({
+      integrations: ['@nest/xds-meta'],
+    });
+  });
+
+  it('rejects invalid integration package manifests', async () => {
+    const dir = path.join(tmpDir, 'bad');
+    fs.mkdirSync(dir);
+    const packageDir = path.join(dir, 'node_modules', '@bad', 'widgets');
+    fs.mkdirSync(packageDir, {recursive: true});
+    fs.writeFileSync(
+      path.join(dir, 'astryx.config.mjs'),
+      `export default { integrations: '@bad/widgets' };\n`,
+    );
+    fs.writeFileSync(
+      path.join(packageDir, 'package.json'),
+      JSON.stringify({
+        name: '@bad/widgets',
+        astryx: {integration: './astryx.integration.mjs'},
+      }),
+    );
+    fs.writeFileSync(
+      path.join(packageDir, 'astryx.integration.mjs'),
+      `export default { docs: './docs' };\n`,
+    );
+    await expect(loadConfig(dir)).rejects.toThrow(/name/);
+  });
+
+  it('normalizes integration arrays', async () => {
+    const dir = path.join(tmpDir, 'two');
+    fs.mkdirSync(dir);
+    installIntegrationPackage(dir);
+    fs.writeFileSync(
+      path.join(dir, 'astryx.config.mjs'),
+      `export default { integrations: ['@nest/xds-meta', ''] };\n`,
+    );
+    await expect(loadConfig(dir)).resolves.toMatchObject({
+      integrations: ['@nest/xds-meta'],
+    });
+  });
+
+  it('rejects invalid config shapes', async () => {
+    const dir = path.join(tmpDir, 'invalid');
+    fs.mkdirSync(dir);
+    fs.writeFileSync(
+      path.join(dir, 'astryx.config.mjs'),
+      `export default { integrations: [42] };\n`,
+    );
+    await expect(loadConfig(dir)).rejects.toThrow(/integrations/);
+  });
+});

package/src/lib/error-codes.mjs

@@ -56,6 +56,7 @@
  *   | 'ERR_UNKNOWN_AGENT'
  *   | 'ERR_UNKNOWN_FEATURE'
  *   | 'ERR_UNKNOWN_CODEMOD'
+   | 'ERR_CODEMOD_FAILED'
  *   | 'ERR_NOT_FOUND'
  *   | 'ERR_NO_DOC'
  *   | 'ERR_NO_SHOWCASE'
@@ -74,6 +75,8 @@
  *   | 'ERR_DEP_MISSING'
  *   | 'ERR_GH_CLI'
  *   | 'ERR_GAP_REPORT_FAILED'
+ *   | 'ERR_LAYOUT_PARSE'
+ *   | 'ERR_LAYOUT_INVALID'
  * )} ErrorCode
  */
 
@@ -129,6 +132,8 @@ export const ERROR_CODES = Object.freeze({
   ERR_UNKNOWN_FEATURE: 'ERR_UNKNOWN_FEATURE',
   /** A `--codemod` value did not match any registered codemod (upgrade). */
   ERR_UNKNOWN_CODEMOD: 'ERR_UNKNOWN_CODEMOD',
+  /** One or more codemods failed during an upgrade run. */
+  ERR_CODEMOD_FAILED: 'ERR_CODEMOD_FAILED',
   /** A generic discover/lookup query matched nothing in any package. */
   ERR_NOT_FOUND: 'ERR_NOT_FOUND',
 
@@ -177,6 +182,12 @@ export const ERROR_CODES = Object.freeze({
   ERR_GH_CLI: 'ERR_GH_CLI',
   /** Filing a gap report failed at the command/integration boundary. */
   ERR_GAP_REPORT_FAILED: 'ERR_GAP_REPORT_FAILED',
+
+  // ── Layout expressions (XLE/XLO) ─────────────────────────────────
+  /** A layout expression failed to parse (syntax error, with line/col). */
+  ERR_LAYOUT_PARSE: 'ERR_LAYOUT_PARSE',
+  /** A layout expression parsed but failed validation (unknown component/prop/enum/block). */
+  ERR_LAYOUT_INVALID: 'ERR_LAYOUT_INVALID',
 });
 
 /**

package/src/lib/integrations.mjs

@@ -0,0 +1,155 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Integration manifest loading for Astryx config.
+ *
+ * Integrations are package names or direct manifest paths listed in
+ * astryx.config.mjs. A manifest can contribute docs/discovery metadata,
+ * gap-report/template hooks, upgrade codemods, and post-codemod hooks.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {pathToFileURL} from 'node:url';
+import {validateIntegration} from './config-schema.mjs';
+
+export function isPathSpec(spec) {
+  return (
+    spec.startsWith('.') ||
+    spec.startsWith('/') ||
+    spec.endsWith('.mjs') ||
+    spec.endsWith('.js')
+  );
+}
+
+export function resolvePackageDir(packageName, cwd = process.cwd()) {
+  return path.resolve(cwd, 'node_modules', ...packageName.split('/'));
+}
+
+export function resolveIntegrationFile(spec, cwd = process.cwd()) {
+  if (isPathSpec(spec)) {
+    return path.resolve(cwd, spec);
+  }
+
+  const packageDir = resolvePackageDir(spec, cwd);
+  const pkgPath = path.join(packageDir, 'package.json');
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  } catch {
+    throw new Error(
+      `Could not find installed integration package "${spec}" at ${pkgPath}. Install it first or pass a direct integration file path.`,
+    );
+  }
+
+  const manifestPath = pkg.astryx?.integration ?? pkg.xds?.integration;
+  if (!manifestPath) {
+    throw new Error(
+      `Package "${spec}" does not declare astryx.integration (or legacy xds.integration) in package.json.`,
+    );
+  }
+  return path.resolve(packageDir, manifestPath);
+}
+
+function normalizePackageContribution(integration) {
+  const docs = integration.docs;
+  if (!docs) return null;
+  const packageDir = integration.__packageDir ?? integration.__dir;
+  const docsDir = path.resolve(packageDir, docs);
+  return {
+    name: integration.name ?? integration.__spec,
+    version: integration.version,
+    description: integration.description,
+    displayName: integration.displayName,
+    dir: packageDir,
+    astryx: {
+      docs,
+      category: integration.category,
+      blocks: integration.blocks,
+    },
+    category: integration.category ?? integration.name ?? integration.__spec,
+    docsDir,
+  };
+}
+
+function resolveHookFunction(hook, integration) {
+  if (typeof hook === 'function') return hook;
+  if (typeof hook !== 'string') return hook;
+  const [moduleSpec, exportName = 'default'] = hook.split('#');
+  return async (...args) => {
+    const mod = isPathSpec(moduleSpec)
+      ? await import(
+          pathToFileURL(path.resolve(integration.__dir, moduleSpec)).href
+        )
+      : await import(moduleSpec);
+    const fn = exportName === 'default' ? mod.default : mod[exportName];
+    if (typeof fn !== 'function') {
+      throw new Error(
+        `Integration hook ${hook} did not resolve to a function.`,
+      );
+    }
+    return fn(...args);
+  };
+}
+
+export async function loadIntegrations(specs = [], {cwd = process.cwd()} = {}) {
+  const integrations = [];
+  const seen = new Set();
+
+  for (const spec of specs) {
+    if (!spec || seen.has(spec)) continue;
+    seen.add(spec);
+
+    const file = resolveIntegrationFile(spec, cwd);
+    const mod = await import(pathToFileURL(file).href);
+    const exported = mod.default ?? mod.integration ?? mod;
+    if (!exported || typeof exported !== 'object') {
+      throw new Error(`Integration ${spec} did not export an object.`);
+    }
+    const integration = validateIntegration(exported, `Integration ${spec}`);
+
+    const integrationDir = path.dirname(file);
+    const packageDir = isPathSpec(spec)
+      ? integrationDir
+      : resolvePackageDir(spec, cwd);
+    const normalized = {
+      ...integration,
+      __file: file,
+      __dir: integrationDir,
+      __packageDir: packageDir,
+      __spec: spec,
+    };
+
+    if (Array.isArray(normalized.codemods)) {
+      for (const codemod of normalized.codemods) {
+        if (typeof codemod.transform === 'string') {
+          const transformPath = path.resolve(integrationDir, codemod.transform);
+          const transformMod = await import(pathToFileURL(transformPath).href);
+          codemod.transform =
+            transformMod.default ?? transformMod.transform ?? transformMod;
+        }
+      }
+    }
+
+    normalized.package = normalizePackageContribution(normalized);
+    if (
+      normalized.gapReport?.command &&
+      isPathSpec(normalized.gapReport.command)
+    ) {
+      normalized.gapReport = {
+        ...normalized.gapReport,
+        command: path.resolve(packageDir, normalized.gapReport.command),
+      };
+    }
+    if (normalized.template?.get) {
+      normalized.template = {
+        ...normalized.template,
+        get: resolveHookFunction(normalized.template.get, normalized),
+      };
+    }
+
+    integrations.push(normalized);
+  }
+
+  return integrations;
+}