@astryxdesign/cli 0.7.2-canary.fe2c655 → 0.7.2

package/api/upgrade/run/cli-behind-core.test.mjs

@@ -0,0 +1,438 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Core codemods ship inside the CLI, so a CLI older than the installed
+ * Core has none for the releases after its own version. Every result past the
+ * up-to-date exit says so in `cliBehindCore`, with the same upgrade pinned to
+ * the CLI release that matches the Core; a CLI that covers the range returns
+ * what it always did. The pinned command changes to the folder the run used
+ * and names the directory it scanned as an absolute path, both with symbolic
+ * links resolved, so a POSIX shell runs it there, with every argument
+ * unchanged, wherever it is pasted, even when upgrade() reached the project
+ * through a link.
+ */
+
+import {describe, it, expect, beforeEach, afterEach, vi} from 'vitest';
+import {execFileSync, spawnSync} from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {upgrade} from '../upgrade.mjs';
+import {logCliBehindCore} from '../status/status.mjs';
+import {logger} from '../../logger.mjs';
+import {CLI_ROOT} from '../../../foundation/fs/paths.mjs';
+import {
+  commandInFolder,
+  getDlxPrefix,
+  quoteCommandArgument,
+} from '../../../foundation/env/package-manager.mjs';
+
+const SLOW = 30_000;
+
+const CLI_VERSION = JSON.parse(
+  fs.readFileSync(path.join(CLI_ROOT, 'package.json'), 'utf8'),
+).version;
+const [MAJOR, MINOR] = CLI_VERSION.split('.').map(Number);
+/** A Core release after this CLI: it has no codemods for it. */
+const NEWER_CORE = `${MAJOR}.${MINOR + 1}.0`;
+
+/** A source file a 0.7.0 codemod rewrites (`emptySearchResultsText`). */
+const TYPEAHEAD_SOURCE =
+  "import {Typeahead} from '@astryxdesign/core';\n" +
+  'export const x = <Typeahead emptySearchResultsText="None" />;\n';
+
+let dir;
+
+/** @param {string} version @param {string} [packageName] */
+function installCore(version, packageName = '@astryxdesign/core') {
+  const core = path.join(dir, 'node_modules', ...packageName.split('/'));
+  fs.mkdirSync(core, {recursive: true});
+  fs.writeFileSync(
+    path.join(core, 'package.json'),
+    JSON.stringify({name: packageName, version}),
+  );
+}
+
+/** @param {string} rel @param {string} body */
+function write(rel, body) {
+  const file = path.join(dir, rel);
+  fs.mkdirSync(path.dirname(file), {recursive: true});
+  fs.writeFileSync(file, body);
+}
+
+/**
+ * A path in the project as a process running there sees it: every symbolic
+ * link resolved.
+ * @param {string} rel
+ */
+function inProject(rel) {
+  return path.join(fs.realpathSync(dir), rel);
+}
+
+/**
+ * The pinned command for this project, as the CLI prints it.
+ * @param {...string} args the arguments after `upgrade`
+ */
+function pinned(...args) {
+  return commandInFolder(
+    fs.realpathSync(dir),
+    [
+      getDlxPrefix(dir),
+      `@astryxdesign/cli@${NEWER_CORE}`,
+      'upgrade',
+      ...args.map(arg => quoteCommandArgument(arg)),
+    ].join(' '),
+  );
+}
+
+/**
+ * Stand-ins for the package runners: each prints the folder it runs in and the
+ * arguments the shell passed.
+ */
+const RUNNERS = ['npx', 'pnpm', 'yarn', 'bunx']
+  .map(
+    name =>
+      `${name}() { "$0" -e 'process.stdout.write(JSON.stringify({cwd: process.cwd(), argv: process.argv.slice(1)}))' -- "$@"; }`,
+  )
+  .join('; ');
+
+/**
+ * What a POSIX shell runs for `command` pasted in `cwd`: the folder the
+ * package runner ran in, and its arguments from the pinned CLI package on.
+ * @param {string} command
+ * @param {string} cwd the folder the command is pasted in
+ * @returns {{cwd: string, args: string[]}}
+ */
+function runInShell(command, cwd) {
+  const ran = JSON.parse(
+    execFileSync(
+      '/bin/sh',
+      ['-c', `${RUNNERS}; ${command}`, process.execPath],
+      {
+        cwd,
+        encoding: 'utf8',
+      },
+    ),
+  );
+  return {
+    cwd: ran.cwd,
+    args: ran.argv.slice(ran.argv.indexOf(`@astryxdesign/cli@${NEWER_CORE}`)),
+  };
+}
+
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'upg-cli-behind-'));
+  write('package.json', JSON.stringify({name: 'consumer', version: '1.0.0'}));
+  write('src/index.tsx', TYPEAHEAD_SOURCE);
+});
+
+afterEach(() => fs.rmSync(dir, {recursive: true, force: true}));
+
+describe('a CLI older than the installed Core', {timeout: SLOW}, () => {
+  // The defect: the range past this CLI has no codemods here, so the run
+  // reported `no_codemods` (and "already up to date") and exited 0, while the
+  // project still needed the newer releases' migrations.
+  it('marks a range this CLI has no codemods for, and names the CLI that does', async () => {
+    installCore(NEWER_CORE);
+
+    const res = await upgrade({from: CLI_VERSION, apply: true}, {cwd: dir});
+
+    expect(res.type).toBe('upgrade.status');
+    expect(res.data.status).toBe('no_codemods');
+    expect(res.data.cliBehindCore).toEqual({
+      cliVersion: CLI_VERSION,
+      command: pinned(
+        '--from',
+        CLI_VERSION,
+        '--path',
+        inProject('src'),
+        '--apply',
+      ),
+    });
+  });
+
+  it('runs the codemods it has for a range it covers only in part, and marks the rest', async () => {
+    installCore(NEWER_CORE);
+
+    const res = await upgrade({from: '0.6.8', apply: true}, {cwd: dir});
+
+    expect(res.type).toBe('upgrade.run');
+    expect(res.data.codemods).toBeGreaterThan(0);
+    expect(fs.readFileSync(path.join(dir, 'src/index.tsx'), 'utf8')).toContain(
+      'emptySearchText="None"',
+    );
+    expect(res.data.cliBehindCore).toEqual({
+      cliVersion: CLI_VERSION,
+      command: pinned('--from', '0.6.8', '--path', inProject('src'), '--apply'),
+    });
+  });
+
+  it('repeats the invocation in the pinned command', async () => {
+    installCore(NEWER_CORE);
+    write('my src/index.tsx', TYPEAHEAD_SOURCE);
+    // An installed integration the run names, so --integration is repeated.
+    write(
+      'node_modules/@acme/widgets/package.json',
+      JSON.stringify({name: '@acme/widgets', version: '1.0.0'}),
+    );
+    write(
+      'node_modules/@acme/widgets/astryx.integration.mjs',
+      'export default {};\n',
+    );
+
+    const res = await upgrade(
+      {
+        from: CLI_VERSION,
+        path: 'my src',
+        codemod: 'only-this',
+        skipCodemod: ['first', 'second'],
+        integration: ['@acme/widgets'],
+        force: true,
+        installDeps: true,
+      },
+      {cwd: dir},
+    );
+
+    expect(res.data.cliBehindCore?.command).toBe(
+      pinned(
+        '--from',
+        CLI_VERSION,
+        '--path',
+        inProject('my src'),
+        '--codemod',
+        'only-this',
+        '--skip-codemod',
+        'first',
+        '--skip-codemod',
+        'second',
+        '--integration',
+        '@acme/widgets',
+        '--force',
+        '--install-deps',
+      ),
+    );
+  });
+
+  // Where an upgrade runs decides what it finds: the installed Core is read
+  // from that folder, and --path must stay inside it. The command printed
+  // without a folder failed when pasted anywhere else: ERR_PATH_TRAVERSAL from
+  // a subfolder, ERR_VERSION_DETECT from a parent. A package runner can also
+  // move the run: Yarn 1 runs `yarn astryx` at the project root.
+  it('changes to the folder the run used and names the directory it scanned as an absolute path', async () => {
+    installCore(NEWER_CORE);
+    write('app/index.tsx', TYPEAHEAD_SOURCE);
+    const project = fs.realpathSync(dir);
+
+    for (const [given, scanned] of [
+      [undefined, inProject('src')],
+      ['.', project],
+      ['app', inProject('app')],
+      ['./app/', inProject('app')],
+    ]) {
+      const res = await upgrade(
+        {from: CLI_VERSION, ...(given ? {path: given} : {})},
+        {cwd: dir},
+      );
+      const command = /** @type {string} */ (res.data.cliBehindCore?.command);
+
+      expect(command).toBe(pinned('--from', CLI_VERSION, '--path', scanned));
+      if (process.platform !== 'win32') {
+        for (const pastedIn of [
+          path.join(dir, 'app'),
+          path.dirname(dir),
+          path.parse(dir).root,
+        ]) {
+          const ran = runInShell(command, pastedIn);
+          expect(ran.cwd).toBe(project);
+          expect(ran.args[ran.args.indexOf('--path') + 1]).toBe(scanned);
+        }
+      }
+    }
+  });
+
+  it.skipIf(process.platform === 'win32')(
+    'quotes the command so a POSIX shell enters the folder and passes every argument unchanged',
+    async () => {
+      fs.rmSync(dir, {recursive: true, force: true});
+      dir = fs.mkdtempSync(
+        path.join(os.tmpdir(), 'upg cost $5 `date` \'one\' "two" !x -'),
+      );
+      write(
+        'package.json',
+        JSON.stringify({name: 'consumer', version: '1.0.0'}),
+      );
+      write('src/index.tsx', TYPEAHEAD_SOURCE);
+      installCore(NEWER_CORE);
+
+      const res = await upgrade(
+        {
+          from: CLI_VERSION,
+          skipCodemod: ["it's", 'a$b c'],
+          apply: true,
+        },
+        {cwd: dir},
+      );
+
+      const ran = runInShell(
+        /** @type {string} */ (res.data.cliBehindCore?.command),
+        path.dirname(dir),
+      );
+
+      expect(ran.cwd).toBe(fs.realpathSync(dir));
+      expect(ran.args).toEqual([
+        `@astryxdesign/cli@${NEWER_CORE}`,
+        'upgrade',
+        '--from',
+        CLI_VERSION,
+        '--path',
+        inProject('src'),
+        '--skip-codemod',
+        "it's",
+        '--skip-codemod',
+        'a$b c',
+        '--apply',
+      ]);
+    },
+  );
+});
+
+/** The CLI's own bin, which the stand-in runners below run. */
+const BIN = path.join(CLI_ROOT, 'clients', 'cli', 'bin', 'astryx.mjs');
+
+/**
+ * Stand-ins for the package runners: each drops its own words and the pinned
+ * package, then runs this CLI with the rest of the command.
+ */
+const RUNS_THIS_CLI = /** @type {Array<[string, number]>} */ ([
+  ['npx', 1],
+  ['bunx', 1],
+  ['pnpm', 2],
+  ['yarn', 2],
+])
+  .map(
+    ([name, words]) =>
+      `${name}() { shift ${words}; "$0" ${quoteCommandArgument(BIN)} "$@"; }`,
+  )
+  .join('; ');
+
+// A shell's `cd` follows a symbolic link, but the CLI it starts reads its
+// folder with every link resolved and checks --path against that. A command
+// that kept the link upgrade() was given exited 1 with ERR_PATH_TRAVERSAL.
+describe.skipIf(process.platform === 'win32')(
+  'a project upgrade() reaches through a symbolic link',
+  {timeout: SLOW},
+  () => {
+    /** @type {string} */
+    let base;
+
+    beforeEach(() => {
+      fs.rmSync(dir, {recursive: true, force: true});
+      base = fs.mkdtempSync(path.join(os.tmpdir(), 'upg-link-'));
+      dir = path.join(base, 'real', 'my app');
+      write(
+        'package.json',
+        JSON.stringify({name: 'consumer', version: '1.0.0'}),
+      );
+      write('src/index.tsx', TYPEAHEAD_SOURCE);
+      installCore(NEWER_CORE);
+    });
+
+    afterEach(() => fs.rmSync(base, {recursive: true, force: true}));
+
+    /**
+     * Run upgrade() from `cwd`, then the command it prints, in /bin/sh, from
+     * `cwd` and from the folder above the project.
+     * @param {string} cwd
+     */
+    async function expectPrintedCommandToRun(cwd) {
+      const res = await upgrade({from: CLI_VERSION}, {cwd});
+      const command = /** @type {string} */ (res.data.cliBehindCore?.command);
+
+      for (const pastedIn of [cwd, base]) {
+        const ran = spawnSync(
+          '/bin/sh',
+          ['-c', `${RUNS_THIS_CLI}; ${command}`, process.execPath],
+          {cwd: pastedIn, encoding: 'utf8'},
+        );
+
+        expect(ran.status, ran.stderr).toBe(0);
+        expect(ran.stdout).toContain(`Installed target: ${NEWER_CORE}`);
+        expect(ran.stdout).toContain(`Scanning ${inProject('src')} `);
+      }
+      expect(command).toBe(
+        pinned('--from', CLI_VERSION, '--path', inProject('src')),
+      );
+    }
+
+    it('prints a command that runs, from a folder reached through a link above the project', async () => {
+      fs.symlinkSync(path.join(base, 'real'), path.join(base, 'link'), 'dir');
+
+      await expectPrintedCommandToRun(path.join(base, 'link', 'my app'));
+    });
+
+    it('prints a command that runs, through a project root that is a link', async () => {
+      fs.symlinkSync(dir, path.join(base, 'app'), 'dir');
+
+      await expectPrintedCommandToRun(path.join(base, 'app'));
+    });
+  },
+);
+
+describe('a CLI that covers the range', {timeout: SLOW}, () => {
+  it('adds nothing when the installed Core is this CLI release', async () => {
+    installCore(CLI_VERSION);
+
+    const res = await upgrade({from: '0.6.8'}, {cwd: dir});
+
+    expect(res.type).toBe('upgrade.run');
+    expect('cliBehindCore' in res.data).toBe(false);
+  });
+
+  it('adds nothing when --from is already the installed Core', async () => {
+    installCore(NEWER_CORE);
+
+    const res = await upgrade({from: NEWER_CORE}, {cwd: dir});
+
+    expect(res.data.status).toBe('up_to_date');
+    expect('cliBehindCore' in res.data).toBe(false);
+
+    const forced = await upgrade({from: NEWER_CORE, force: true}, {cwd: dir});
+
+    expect(forced.data.status).toBe('no_codemods');
+    expect('cliBehindCore' in forced.data).toBe(false);
+  });
+
+  it('adds nothing for legacy @xds/core, which shares no version with a CLI release', async () => {
+    installCore(NEWER_CORE, '@xds/core');
+
+    const res = await upgrade({from: CLI_VERSION}, {cwd: dir});
+
+    expect(res.data.status).toBe('no_codemods');
+    expect('cliBehindCore' in res.data).toBe(false);
+  });
+});
+
+describe('logCliBehindCore: the warning names the shell its command is written for', () => {
+  it.each([
+    ['win32', 'Run it in PowerShell with the CLI that matches your Core:'],
+    ['linux', 'Run it with the CLI that matches your Core:'],
+    ['darwin', 'Run it with the CLI that matches your Core:'],
+  ])('on %s', (platform, ending) => {
+    const warn = vi.spyOn(logger, 'warn').mockImplementation(() => {});
+    try {
+      logCliBehindCore(
+        {cliVersion: '0.7.0', command: 'cd x; npx y'},
+        '0.8.0',
+        platform,
+      );
+      expect(warn.mock.calls.map(([line]) => String(line))).toEqual([
+        expect.stringMatching(
+          new RegExp(`${ending.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&')}$`, 'u'),
+        ),
+        '  cd x; npx y',
+      ]);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});

package/api/upgrade/run/run.mjs

@@ -15,12 +15,18 @@
  * ShadCN-copied compositions → post-codemod hooks → render + refresh agent docs
  * from final post-upgrade state. Integration DISCOVERY errors skip that
  * integration; execution errors abort before the agent-doc write.
+ *
+ * Core codemods ship inside the CLI, so a CLI older than the installed Core
+ * has none for the releases after its own version. Every result past the
+ * up-to-date exit then carries `cliBehindCore`, and no human line says the
+ * upgrade finished; the warning names the same upgrade on the matching CLI.
  */
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import {
   detectInstalledTargetVersion,
+  detectCliBehindCore,
   prepareAgentDocsRefresh,
   applyAgentDocsRefresh,
   inspectAgentDocs,
@@ -42,9 +48,11 @@ import {
   statusUpToDate,
   statusNoCodemods,
   statusConfigFixable,
+  logCliBehindCore,
 } from '../status/status.mjs';
 import {semverGte} from '../../../foundation/env/semver.mjs';
 import {getCliInvocation} from '../../../foundation/env/package-manager.mjs';
+import {isOutsideProject} from '../../../foundation/env/project-scope.mjs';
 import {ERROR_CODES} from '../../../foundation/response/error-codes.mjs';
 import {AstryxError} from '../../error.mjs';
 import {logger} from '../../logger.mjs';
@@ -146,7 +154,10 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
   const currentVersion = /** @type {string} */ (options.from);
   const installed = detectInstalledTargetVersion(cwd);
   if (!installed) {
-    const msg = `Could not find installed @astryxdesign/core (or legacy @xds/core). Install the target version first, then rerun \`${getCliInvocation()} upgrade --from <old-version>\`.`;
+    // Outside a project there is no version to install (spec AST-081 FR3).
+    const msg = isOutsideProject(cwd)
+      ? 'Could not find installed @astryxdesign/core (or legacy @xds/core). This folder is outside a project; upgrade migrates the code of an app project that installs @astryxdesign/core.'
+      : `Could not find installed @astryxdesign/core (or legacy @xds/core). Install the target version first, then rerun \`${getCliInvocation()} upgrade --from <old-version>\`.`;
     logger.error(msg);
     logger.log('Aborted\n');
     throw new AstryxError(msg, undefined, ERROR_CODES.ERR_VERSION_DETECT);
@@ -195,6 +206,17 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
     });
   }
 
+  // Past the up-to-date exit, codemods are needed through targetVersion. A
+  // CLI older than that has none for the releases after its own version.
+  const cliBehindCore = detectCliBehindCore({
+    from: currentVersion,
+    to: targetVersion,
+    packageName: installed.packageName,
+    options,
+    cwd,
+    sourcePath: path_,
+  });
+
   const versionManifests = await getCoreVersionManifests(
     currentVersion,
     targetVersion,
@@ -243,6 +265,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
     skipCodemods,
     root: cwd,
     protection,
+    coversTarget: !cliBehindCore,
   });
   const coreResult =
     codemodResult && 'totalFilesChanged' in codemodResult
@@ -271,6 +294,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
       for (const item of protectedFiles) {
         logger.error(`  ${item.file} — ${item.declarations.join('; ')}`);
       }
+      if (cliBehindCore) logCliBehindCore(cliBehindCore, targetVersion);
       logger.log('Upgrade incomplete: protected changes remain\n');
       return {
         type: 'upgrade.run',
@@ -299,6 +323,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
           complete: false,
           errorCode: 'ERR_CODEMOD_PROTECTED',
           errors: coreResult?.errors ?? [],
+          ...(cliBehindCore ? {cliBehindCore} : {}),
         },
       };
     }
@@ -316,6 +341,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
         to: targetVersion,
         configError: configErr.message,
         configCodemods: coreConfigCodemodNames,
+        cliBehindCore,
         agentDocs:
           /** @type {import('../upgrade.type.mjs').AgentDocsSummary} */ ({
             status: inspection.status,
@@ -381,6 +407,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
       to: targetVersion,
       agentDocs,
       ...(registryResult ? {registryCompositions: registryResult.summary} : {}),
+      cliBehindCore,
     });
   }
 
@@ -620,6 +647,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
   }
   receipt.errors = finalErrors;
   if (registryResult) receipt.registryCompositions = registryResult.summary;
+  if (cliBehindCore) receipt.cliBehindCore = cliBehindCore;
 
   if (protectedFiles.length > 0) {
     logger.error(
@@ -655,7 +683,12 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
   }
 
   const registryOk = receipt.registryCompositions?.ok ?? true;
-  const done = apply ? 'Upgrade complete' : 'Dry run complete';
+  if (cliBehindCore) logCliBehindCore(cliBehindCore, targetVersion);
+  const done = cliBehindCore
+    ? 'Upgrade incomplete'
+    : apply
+      ? 'Upgrade complete'
+      : 'Dry run complete';
   logger.log(
     protectedFiles.length > 0
       ? 'Upgrade incomplete: protected changes remain\n'

package/api/upgrade/status/status.d.mts

@@ -13,27 +13,43 @@ export function statusUpToDate({ from, to, agentDocs, registryCompositions }: {
     registryCompositions?: import("../upgrade.type.mjs").RegistryCompositionSummary;
 }): import("../upgrade.type.mjs").UpgradeStatusResponse;
 /**
- * No core or integration codemods apply to the requested version range.
- * @param {{from: string, to: string, agentDocs: import('../upgrade.type.mjs').AgentDocsSummary, registryCompositions?: import('../upgrade.type.mjs').RegistryCompositionSummary}} data
+ * The one warning for a CLI older than the installed Core: it has no codemods
+ * for the releases after its own version, and the pinned command does. The
+ * command gets a line of its own, so it copies exactly, whatever quotes or
+ * backticks its arguments carry. On Windows it is written for PowerShell, and
+ * the warning says so.
+ * @param {import('../upgrade.type.mjs').CliBehindCore} cliBehindCore
+ * @param {string} to the installed Core version
+ * @param {string} [platform] the `process.platform` the command was printed
+ *   for, as `quoteCommandArgument` and `commandInFolder` take it
+ */
+export function logCliBehindCore({ cliVersion, command }: import("../upgrade.type.mjs").CliBehindCore, to: string, platform?: string): void;
+/**
+ * No core or integration codemods apply to the requested version range. When
+ * the CLI is older than the installed Core, that only means this CLI has none:
+ * the result carries `cliBehindCore` and the human lines say so.
+ * @param {{from: string, to: string, agentDocs: import('../upgrade.type.mjs').AgentDocsSummary, registryCompositions?: import('../upgrade.type.mjs').RegistryCompositionSummary, cliBehindCore?: import('../upgrade.type.mjs').CliBehindCore | null}} data
  * @returns {import('../upgrade.type.mjs').UpgradeStatusResponse}
  */
-export function statusNoCodemods({ from, to, agentDocs, registryCompositions }: {
+export function statusNoCodemods({ from, to, agentDocs, registryCompositions, cliBehindCore }: {
     from: string;
     to: string;
     agentDocs: import("../upgrade.type.mjs").AgentDocsSummary;
     registryCompositions?: import("../upgrade.type.mjs").RegistryCompositionSummary;
+    cliBehindCore?: import("../upgrade.type.mjs").CliBehindCore | null;
 }): import("../upgrade.type.mjs").UpgradeStatusResponse;
 /**
  * DRY-RUN only: the consumer's astryx.config fails strict validation, but a
  * pending core CONFIG codemod previewed a change that would repair it. Preview
  * the fix + report the exact `--apply` command; integrations are skipped here.
- * @param {{from: string, to: string, configError: string, configCodemods: string[], agentDocs: import('../upgrade.type.mjs').AgentDocsSummary}} data
+ * @param {{from: string, to: string, configError: string, configCodemods: string[], agentDocs: import('../upgrade.type.mjs').AgentDocsSummary, cliBehindCore?: import('../upgrade.type.mjs').CliBehindCore | null}} data
  * @returns {import('../upgrade.type.mjs').UpgradeStatusResponse}
  */
-export function statusConfigFixable({ from, to, configError, configCodemods, agentDocs }: {
+export function statusConfigFixable({ from, to, configError, configCodemods, agentDocs, cliBehindCore }: {
     from: string;
     to: string;
     configError: string;
     configCodemods: string[];
     agentDocs: import("../upgrade.type.mjs").AgentDocsSummary;
+    cliBehindCore?: import("../upgrade.type.mjs").CliBehindCore | null;
 }): import("../upgrade.type.mjs").UpgradeStatusResponse;