@astryxdesign/cli 0.6.3 → 0.6.4-canary.10dd683

package/api/upgrade/upgrade.type.d.mts

@@ -2,7 +2,7 @@
 // DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
 
 /**
- * xds --json upgrade --list
+ * astryx --json upgrade --list
  */
 export type UpgradeListResponse = {
     type: "upgrade.list";
@@ -12,6 +12,10 @@ export type UpgradeListEntry = {
     name: string;
     title: string;
     version: string;
+    /**
+     * True when the codemod runs only if named with `--codemod`.
+     */
+    optional: boolean;
 };
 /**
  * State of the managed agent-docs block (`<!-- ASTRYX:START --> … END -->`)
@@ -121,14 +125,39 @@ export type RegistryCompositionSummary = {
     items: RegistryCompositionItemSummary[];
 };
 /**
- * xds --json upgrade --registry [--apply]
+ * astryx --json upgrade --registry [--apply]
  */
 export type UpgradeRegistryResponse = {
     type: "upgrade.registry";
     data: RegistryCompositionSummary;
 };
 /**
- * xds --json upgrade [--apply]
+ * A required codemod change blocked by effective working-tree protection.
+ */
+export type ProtectedCodemodFile = {
+    /**
+     * Project-relative path.
+     */
+    file: string;
+    /**
+     * Codemods that still require a change.
+     */
+    codemods: string[];
+    /**
+     * Protection categories (generated, vendored, ignored, and hard boundaries).
+     */
+    reasons: string[];
+    /**
+     * Effective declarations that protect the file.
+     */
+    declarations: string[];
+    /**
+     * Exact regeneration commands found in generated headers, when present.
+     */
+    commands: string[];
+};
+/**
+ * astryx --json upgrade [--apply]
  */
 export type UpgradeRunResponse = {
     type: "upgrade.run";
@@ -140,7 +169,16 @@ export type UpgradeRunResponse = {
         agentDocsRefreshed: boolean;
         agentDocs: AgentDocsSummary;
         registryCompositions?: RegistryCompositionSummary | undefined;
+        complete?: boolean | undefined;
+        errorCode?: "ERR_CODEMOD_PROTECTED" | undefined;
         filesChanged?: number | undefined;
+        modifiedFiles?: string[] | undefined;
+        protectedFiles?: ProtectedCodemodFile[] | undefined;
+        declinedCandidates?: {
+            file: string;
+            location?: string;
+            reason: string;
+        }[] | undefined;
         transformsApplied?: number | undefined;
         errors?: {
             file: string;
@@ -150,7 +188,7 @@ export type UpgradeRunResponse = {
     };
 };
 /**
- * xds --json upgrade — short-circuit status results.
+ * astryx --json upgrade — short-circuit status results.
  *
  * - `up_to_date`: `--from` is >= installed target and `--force` was not passed.
  * - `no_codemods`: no codemods (core or integration) apply to the range.
@@ -211,7 +249,7 @@ export type UpgradeOptions = {
      */
     skipCodemod?: string[] | undefined;
     /**
-     * Explicit integration package names / file paths.
+     * Explicit integration specifiers resolved beneath node_modules; absolute paths and `.` or `..` segments are rejected.
      */
     integration?: string[] | undefined;
     /**

package/api/upgrade/upgrade.type.mjs

@@ -4,17 +4,17 @@
  * @file Colocated types for the `upgrade` command — source of truth for the
  * upgrade command JSON responses. Re-exported by `types/upgrade.d.ts`.
  *
- * Invocation                                 -> type discriminator
+ * Invocation                                   -> type discriminator
  * ------------------------------------------------------------------
- * xds --json upgrade --list                 -> upgrade.list
- * xds --json upgrade [--apply]              -> upgrade.run
- * xds --json upgrade --registry [--apply]   -> upgrade.registry
- * xds --json upgrade (status short-circuit) -> upgrade.status
- * (version detection failure)               -> CLIError
+ * astryx --json upgrade --list                 -> upgrade.list
+ * astryx --json upgrade [--apply]              -> upgrade.run
+ * astryx --json upgrade --registry [--apply]   -> upgrade.registry
+ * astryx --json upgrade (status short-circuit) -> upgrade.status
+ * (version detection failure)                  -> CLIError
  */
 
 /**
- * xds --json upgrade --list
+ * astryx --json upgrade --list
  * @typedef {object} UpgradeListResponse
  * @property {'upgrade.list'} type
  * @property {UpgradeListEntry[]} data
@@ -25,6 +25,7 @@
  * @property {string} name
  * @property {string} title
  * @property {string} version
+ * @property {boolean} optional True when the codemod runs only if named with `--codemod`.
  */
 
 /**
@@ -88,14 +89,24 @@
  */
 
 /**
- * xds --json upgrade --registry [--apply]
+ * astryx --json upgrade --registry [--apply]
  * @typedef {object} UpgradeRegistryResponse
  * @property {'upgrade.registry'} type
  * @property {RegistryCompositionSummary} data
  */
 
 /**
- * xds --json upgrade [--apply]
+ * A required codemod change blocked by effective working-tree protection.
+ * @typedef {object} ProtectedCodemodFile
+ * @property {string} file Project-relative path.
+ * @property {string[]} codemods Codemods that still require a change.
+ * @property {string[]} reasons Protection categories (generated, vendored, ignored, and hard boundaries).
+ * @property {string[]} declarations Effective declarations that protect the file.
+ * @property {string[]} commands Exact regeneration commands found in generated headers, when present.
+ */
+
+/**
+ * astryx --json upgrade [--apply]
  * @typedef {object} UpgradeRunResponse
  * @property {'upgrade.run'} type
  * @property {object} data
@@ -106,13 +117,18 @@
  * @property {boolean} data.agentDocsRefreshed
  * @property {AgentDocsSummary} data.agentDocs
  * @property {RegistryCompositionSummary} [data.registryCompositions]
+ * @property {boolean} [data.complete] False when protected required changes remain.
+ * @property {'ERR_CODEMOD_PROTECTED'} [data.errorCode] Stable incomplete-result code when complete is false.
  * @property {number} [data.filesChanged] Total files changed across core + integration codemods (apply mode).
+ * @property {string[]} [data.modifiedFiles] Project-relative files changed or previewed.
+ * @property {ProtectedCodemodFile[]} [data.protectedFiles] Protected files that still require a codemod change after regeneration.
+ * @property {Array<{file: string, location?: string, reason: string}>} [data.declinedCandidates] Candidates left unchanged because proof was insufficient.
  * @property {number} [data.transformsApplied] Total transforms that reported a change.
  * @property {Array<{file: string, codemod: string, error: string}>} [data.errors] Per-codemod errors, when any codemod failed.
  */
 
 /**
- * xds --json upgrade — short-circuit status results.
+ * astryx --json upgrade — short-circuit status results.
  *
  * - `up_to_date`: `--from` is >= installed target and `--force` was not passed.
  * - `no_codemods`: no codemods (core or integration) apply to the range.
@@ -135,7 +151,7 @@
  * @property {boolean} [force] Run codemods even if `from` >= installed.
  * @property {string} [codemod] Run a single named transform.
  * @property {string[]} [skipCodemod] Exclude named codemods (re-run past a failure).
- * @property {string[]} [integration] Explicit integration package names / file paths.
+ * @property {string[]} [integration] Explicit integration specifiers resolved beneath node_modules; absolute paths and `.` or `..` segments are rejected.
  * @property {string} [path] Source directory to scan (default `./src`).
  * @property {boolean} [installDeps] Auto-install jscodeshift without prompting.
  * @property {boolean} [registry] Reconcile only ShadCN-copied compositions; `from` is not required.

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

@@ -28,6 +28,7 @@ describe('registry', () => {
         '0.4.0',
         '0.5.0',
         '0.6.0',
+        '0.6.4',
       ]);
     });
   });

package/assets/codemods/__tests__/runner.test.mjs

@@ -21,6 +21,40 @@ afterEach(() => {
   fs.rmSync(tmpDir, {recursive: true, force: true});
 });
 
+describe('runCodemods — ordered dry-run state', () => {
+  it('feeds each previewed code transform into the next transform', async () => {
+    const srcDir = path.join(tmpDir, 'src');
+    fs.mkdirSync(srcDir);
+    fs.writeFileSync(path.join(srcDir, 'a.ts'), 'const value = "a";\n');
+    const transforms = [
+      {
+        name: 'a-to-b',
+        meta: {title: 'a to b'},
+        transform: file => file.source.replace('"a"', '"b"'),
+      },
+      {
+        name: 'b-to-c',
+        meta: {title: 'b to c'},
+        transform: file => file.source.replace('"b"', '"c"'),
+      },
+    ];
+
+    const preview = await runCodemods([{version: '1.0.0', transforms}], {
+      apply: false,
+      path: srcDir,
+      root: tmpDir,
+      silent: true,
+    });
+
+    expect(preview.totalFilesChanged).toBe(2);
+    expect(preview.changedFiles).toEqual([
+      path.join(srcDir, 'a.ts'),
+      path.join(srcDir, 'a.ts'),
+    ]);
+    expect(fs.readFileSync(path.join(srcDir, 'a.ts'), 'utf8')).toContain('"a"');
+  });
+});
+
 describe('runCodemods — unified config codemod path', () => {
   it('routes a core config codemod through the (file, api) runner to edit astryx.config.*', async () => {
     fs.writeFileSync(
@@ -195,17 +229,219 @@ describe('runCodemods — unified config codemod path', () => {
   });
 });
 
-describe('findSourceFiles — scan boundaries (symlink + build dirs)', () => {
+describe('runCodemods — project plans honor existing-file protection', () => {
+  it('applies new and owned writes while blocking protected replacements and deletes', async () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.gitattributes'),
+      'generated/** linguist-generated=true\n',
+    );
+    fs.mkdirSync(path.join(tmpDir, 'generated'), {recursive: true});
+    fs.writeFileSync(path.join(tmpDir, 'generated', 'replace.ts'), 'old\n');
+    fs.writeFileSync(path.join(tmpDir, 'generated', 'remove.ts'), 'old\n');
+    fs.writeFileSync(path.join(tmpDir, 'owned.ts'), 'old\n');
+
+    const manifests = [
+      {
+        version: '1.0.0',
+        transforms: [
+          {
+            name: 'project-plan',
+            meta: {title: 'project plan', codemodType: 'project'},
+            transform: async root => ({
+              writes: [
+                {
+                  path: path.join(root, 'generated', 'replace.ts'),
+                  contents: 'new\n',
+                },
+                {path: path.join(root, 'owned.ts'), contents: 'new\n'},
+                {path: path.join(root, 'created.ts'), contents: 'new\n'},
+              ],
+              deletes: [path.join(root, 'generated', 'remove.ts')],
+              problems: [],
+            }),
+          },
+        ],
+      },
+    ];
+
+    const result = await runCodemods(manifests, {
+      apply: true,
+      path: './missing',
+      root: tmpDir,
+      silent: true,
+    });
+
+    expect(
+      fs.readFileSync(path.join(tmpDir, 'generated', 'replace.ts'), 'utf8'),
+    ).toBe('old\n');
+    expect(fs.existsSync(path.join(tmpDir, 'generated', 'remove.ts'))).toBe(
+      true,
+    );
+    expect(fs.readFileSync(path.join(tmpDir, 'owned.ts'), 'utf8')).toBe(
+      'new\n',
+    );
+    expect(fs.readFileSync(path.join(tmpDir, 'created.ts'), 'utf8')).toBe(
+      'new\n',
+    );
+    expect(result.totalFilesChanged).toBe(2);
+    expect(result.protectedFiles.map(item => item.file).sort()).toEqual([
+      'generated/remove.ts',
+      'generated/replace.ts',
+    ]);
+  });
+
+  it('blocks an existing file protected by a declaration in the same plan', async () => {
+    fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
+    fs.writeFileSync(path.join(tmpDir, 'src', 'out.ts'), 'old\n');
+    const manifests = [
+      {
+        version: '1.0.0',
+        transforms: [
+          {
+            name: 'declare-and-replace',
+            meta: {title: 'declare and replace', codemodType: 'project'},
+            transform: async root => ({
+              writes: [
+                {
+                  path: path.join(root, '.gitattributes'),
+                  contents: 'src/out.ts linguist-generated\n',
+                },
+                {path: path.join(root, 'src', 'out.ts'), contents: 'new\n'},
+              ],
+              deletes: [],
+              problems: [],
+            }),
+          },
+        ],
+      },
+    ];
+
+    const result = await runCodemods(manifests, {
+      apply: true,
+      path: './missing',
+      root: tmpDir,
+      silent: true,
+    });
+
+    expect(fs.readFileSync(path.join(tmpDir, 'src', 'out.ts'), 'utf8')).toBe(
+      'old\n',
+    );
+    expect(fs.readFileSync(path.join(tmpDir, '.gitattributes'), 'utf8')).toBe(
+      'src/out.ts linguist-generated\n',
+    );
+    expect(result.protectedFiles).toEqual([
+      expect.objectContaining({
+        file: 'src/out.ts',
+        declaration: 'linguist-generated in .gitattributes:1',
+      }),
+    ]);
+  });
+
+  it('does not apply rules from a blocked staged declaration', async () => {
+    fs.writeFileSync(
+      path.join(tmpDir, '.gitattributes'),
+      '.gitattributes linguist-generated\n',
+    );
+    fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
+    fs.writeFileSync(path.join(tmpDir, 'src', 'out.ts'), 'old\n');
+    const result = await runCodemods(
+      [
+        {
+          version: '1.0.0',
+          transforms: [
+            {
+              name: 'blocked-declaration',
+              meta: {title: 'blocked declaration', codemodType: 'project'},
+              transform: async root => ({
+                writes: [
+                  {
+                    path: path.join(root, '.gitattributes'),
+                    contents: 'src/out.ts linguist-generated\n',
+                  },
+                  {path: path.join(root, 'src', 'out.ts'), contents: 'new\n'},
+                ],
+                deletes: [],
+                problems: [],
+              }),
+            },
+          ],
+        },
+      ],
+      {apply: true, path: './missing', root: tmpDir, silent: true},
+    );
+
+    expect(fs.readFileSync(path.join(tmpDir, 'src', 'out.ts'), 'utf8')).toBe(
+      'new\n',
+    );
+    expect(result.protectedFiles).toEqual([
+      expect.objectContaining({file: '.gitattributes'}),
+    ]);
+  });
+
+  it('refreshes declarations written by an earlier project codemod before later writes', async () => {
+    fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
+    fs.writeFileSync(path.join(tmpDir, 'src', 'out.ts'), 'const foo = 1;\n');
+    const manifests = [
+      {
+        version: '1.0.0',
+        transforms: [
+          {
+            name: 'declare-generated',
+            meta: {title: 'declare generated', codemodType: 'project'},
+            transform: async root => ({
+              writes: [
+                {
+                  path: path.join(root, '.gitattributes'),
+                  contents: 'src/out.ts linguist-generated=true\n',
+                },
+              ],
+              deletes: [],
+              problems: [],
+            }),
+          },
+          {
+            name: 'rename-after-declaration',
+            meta: {title: 'rename after declaration'},
+            transform: file => file.source.replace('foo', 'bar'),
+          },
+        ],
+      },
+    ];
+
+    const result = await runCodemods(manifests, {
+      apply: true,
+      path: path.join(tmpDir, 'src'),
+      root: tmpDir,
+      silent: true,
+    });
+
+    expect(
+      fs.readFileSync(path.join(tmpDir, 'src', 'out.ts'), 'utf8'),
+    ).toContain('foo');
+    expect(result.protectedFiles).toEqual([
+      expect.objectContaining({
+        file: 'src/out.ts',
+        declaration: 'linguist-generated in .gitattributes:1',
+      }),
+    ]);
+  });
+});
+
+describe('findSourceFiles — scan boundaries (symlink + declared protection)', () => {
   const manifests = [
     {
       version: '0.1.3',
       transforms: [
-        {name: 'p', meta: {title: 'p'}, transform: f => f.source.replace(/foo/g, 'bar')},
+        {
+          name: 'p',
+          meta: {title: 'p'},
+          transform: f => f.source.replace(/foo/g, 'bar'),
+        },
       ],
     },
   ];
 
-  it('does not follow a symlinked file out of the scan tree', async () => {
+  it('reports a symlinked file without writing through it', async () => {
     const outside = path.join(tmpDir, 'outside');
     fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
     fs.mkdirSync(outside, {recursive: true});
@@ -214,13 +450,45 @@ describe('findSourceFiles — scan boundaries (symlink + build dirs)', () => {
     fs.writeFileSync(path.join(tmpDir, 'src', 'real.ts'), 'const foo = 2;\n');
     fs.symlinkSync(secret, path.join(tmpDir, 'src', 'link.ts'));
 
-    const r = await runCodemods(manifests, {apply: true, path: './src', silent: true});
+    const r = await runCodemods(manifests, {
+      apply: true,
+      path: './src',
+      silent: true,
+    });
     // the symlink target (outside the tree) must be untouched
     expect(fs.readFileSync(secret, 'utf-8')).toBe('const foo = 1;\n');
     expect(r.writtenFiles.map(f => path.basename(f))).toEqual(['real.ts']);
+    expect(r.protectedFiles).toEqual([
+      expect.objectContaining({file: 'src/link.ts', reason: 'symlink'}),
+    ]);
   });
 
-  it('does not scan generated-output dirs (dist/build/out)', async () => {
+  it('reports matching descendants of a symlinked directory without writing through it', async () => {
+    const targetDir = path.join(tmpDir, 'target');
+    const srcDir = path.join(tmpDir, 'src');
+    fs.mkdirSync(targetDir, {recursive: true});
+    fs.mkdirSync(srcDir, {recursive: true});
+    const target = path.join(targetDir, 'nested.ts');
+    fs.writeFileSync(target, 'const foo = 1;\n');
+    fs.symlinkSync(targetDir, path.join(srcDir, 'linked'));
+
+    const result = await runCodemods(manifests, {
+      apply: true,
+      path: srcDir,
+      root: tmpDir,
+      silent: true,
+    });
+
+    expect(fs.readFileSync(target, 'utf8')).toContain('foo');
+    expect(result.protectedFiles).toEqual([
+      expect.objectContaining({
+        file: 'src/linked/nested.ts',
+        reason: 'symlink',
+      }),
+    ]);
+  });
+
+  it('does not infer protection from generated-looking directory names', async () => {
     fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
     fs.mkdirSync(path.join(tmpDir, 'dist'), {recursive: true});
     fs.mkdirSync(path.join(tmpDir, 'build'), {recursive: true});
@@ -228,8 +496,62 @@ describe('findSourceFiles — scan boundaries (symlink + build dirs)', () => {
     fs.writeFileSync(path.join(tmpDir, 'dist', 'b.js'), 'const foo = 2;\n');
     fs.writeFileSync(path.join(tmpDir, 'build', 'c.js'), 'const foo = 3;\n');
 
-    const r = await runCodemods(manifests, {apply: true, path: '.', silent: true});
-    expect(r.writtenFiles.map(f => path.basename(f))).toEqual(['a.ts']);
-    expect(fs.readFileSync(path.join(tmpDir, 'dist', 'b.js'), 'utf-8')).toContain('foo');
+    const r = await runCodemods(manifests, {
+      apply: true,
+      path: '.',
+      silent: true,
+    });
+    expect(r.writtenFiles.map(f => path.basename(f)).sort()).toEqual([
+      'a.ts',
+      'b.js',
+      'c.js',
+    ]);
+  });
+
+  it('changes owned files but reports generated files without writing them', async () => {
+    fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
+    fs.mkdirSync(path.join(tmpDir, 'dist'), {recursive: true});
+    fs.writeFileSync(
+      path.join(tmpDir, '.gitattributes'),
+      'dist/** linguist-generated=true\n',
+    );
+    fs.writeFileSync(path.join(tmpDir, 'src', 'owned.ts'), 'const foo = 1;\n');
+    fs.writeFileSync(
+      path.join(tmpDir, 'dist', 'output.js'),
+      'const foo = 2;\n',
+    );
+
+    const r = await runCodemods(manifests, {
+      apply: true,
+      path: '.',
+      silent: true,
+    });
+
+    expect(
+      fs.readFileSync(path.join(tmpDir, 'src', 'owned.ts'), 'utf-8'),
+    ).toContain('bar');
+    expect(
+      fs.readFileSync(path.join(tmpDir, 'dist', 'output.js'), 'utf-8'),
+    ).toContain('foo');
+    expect(r.protectedFiles).toEqual([
+      expect.objectContaining({
+        file: 'dist/output.js',
+        reason: 'generated',
+        declaration: 'linguist-generated in .gitattributes:1',
+      }),
+    ]);
+  });
+
+  it('fails closed before an owned write when a declaration is malformed', async () => {
+    fs.mkdirSync(path.join(tmpDir, 'src'), {recursive: true});
+    fs.writeFileSync(path.join(tmpDir, 'src', 'owned.ts'), 'const foo = 1;\n');
+    fs.writeFileSync(path.join(tmpDir, '.hgignore'), 'syntax: regexp\n[bad\n');
+
+    await expect(
+      runCodemods(manifests, {apply: true, path: '.', silent: true}),
+    ).rejects.toThrow(/file-protection source \.hgignore/);
+    expect(
+      fs.readFileSync(path.join(tmpDir, 'src', 'owned.ts'), 'utf-8'),
+    ).toContain('foo');
   });
 });

package/assets/codemods/integration-discovery.mjs

@@ -32,6 +32,40 @@ import {semverCompare} from '../../foundation/env/semver.mjs';
 /** File extensions recognized as codemod modules. */
 const CODEMOD_EXTENSIONS = ['.ts', '.mjs', '.js'];
 
+/**
+ * Directories never walked for codemods: a test directory beside a transform is
+ * the natural place to put its test, and every file found here is loaded and
+ * validated as a codemod.
+ */
+const SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  '__tests__',
+  '__fixtures__',
+]);
+
+/**
+ * Whether a file name is a test or fixture rather than a codemod.
+ *
+ * The trap this closes: EVERY `.ts`/`.mjs`/`.js` under a version folder used to
+ * be loaded as a codemod, so a test file colocated with its transform failed
+ * validation and — because a definition error is a hard error — took every
+ * codemod in that package's version with it. `astryx upgrade` then applied no
+ * transforms and reported success, which is the worst shape a failure can take.
+ *
+ * Core's own codemods never hit this: they are enumerated in a registry, and
+ * their colocated tests are simply not in it. Only integrations are discovered
+ * by walking a directory, so only integrations carry the landmine — which is why
+ * this is a loader fix and not a documentation one. It protects the integrations
+ * that already exist, which no authoring tool can reach.
+ *
+ * @param {string} name a file's base name
+ * @returns {boolean}
+ */
+function isTestFile(name) {
+  return /\.(test|spec)\.[^.]+$/.test(name) || /\.fixture\.[^.]+$/.test(name);
+}
+
 /**
  * Recursively collect codemod module files under a version folder. Returns
  * entries of {id, file} where id is the extension-less relative path
@@ -49,14 +83,18 @@ function collectCodemodFiles(versionDir) {
     for (const entry of entries) {
       const full = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (entry.name === 'node_modules' || entry.name === '.git') continue;
+        if (SKIP_DIRS.has(entry.name)) continue;
         walk(full);
         continue;
       }
       const ext = path.extname(entry.name);
       if (!CODEMOD_EXTENSIONS.includes(ext)) continue;
+      if (isTestFile(entry.name)) continue;
       const rel = path.relative(versionDir, full);
-      const id = rel.slice(0, rel.length - ext.length).split(path.sep).join('/');
+      const id = rel
+        .slice(0, rel.length - ext.length)
+        .split(path.sep)
+        .join('/');
       out.push({id, file: full});
     }
   }
@@ -68,7 +106,7 @@ function collectCodemodFiles(versionDir) {
 /**
  * Discover file-based codemods contributed by configured integrations.
  *
- * @param {Array<{name?: string, codemods?: string, __spec?: string}>} loadedIntegrations
+ * @param {Array<{name?: string, codemods?: string, __spec?: string, __packageDir?: string}>} loadedIntegrations
  * @returns {Promise<Map<string, Array<{id: string, type: 'code'|'config', codemod: object, package: string}>>>}
  *   Map keyed by version string; each value is the list of discovered codemods
  *   for that version (across all integrations).
@@ -107,7 +145,13 @@ export async function discoverIntegrationCodemods(loadedIntegrations = []) {
       const seenInVersion = new Set();
 
       for (const {id, file} of files) {
-        const label = `Integration "${pkgLabel}" codemod ${version}/${id} (${file})`;
+        const shown = integration.__packageDir
+          ? path
+              .relative(integration.__packageDir, file)
+              .split(path.sep)
+              .join('/')
+          : file;
+        const label = `Integration "${pkgLabel}" codemod ${version}/${id} (${shown})`;
 
         if (seenInVersion.has(id)) {
           throw new Error(