apify-test-tools 0.10.2-beta.4 → 0.10.2-beta.6

package/bin/affected-actors.ts

@@ -1,27 +1,31 @@
 import { type ChangedActors, getChangedActors } from './diff-changes.js';
 import {
-    getBranchOnlyChangedFiles,
+    findCommitSha,
     getChangedFilesBetween,
     getChangelogAdditions,
-    getCommits,
     getCommitsBetween,
-    hasMergeFromTarget,
+    getMergeBase,
     resolveCommitSha,
     resolveReleaseBaseCommit,
 } from './git.js';
 import { logger } from './logger.js';
-import type { ActorConfig, Commit } from './types.js';
+import type { ActorConfig, Commit, GitRange } from './types.js';
 import { readConfigFile } from './utils/config/load-config.js';
 
 // The range always ends at the checked-out commit: check out what you want to inspect
 const HEAD = 'HEAD';
 
 interface AffectedActorsOptions {
-    /** Only the commits on HEAD that are not on base count, i.e. the branch's own changes. */
+    /**
+     * Base usually points to the master branch
+     * Only what HEAD changes compared to base counts, like `git diff base...HEAD` or GitHub's "Files changed" tab:
+     * the branch's own changes, not what it merged in from base.
+     */
     base?: string;
     /**
-     * Only changes after this commit count. With `base` it's the last validated commit of the branch and is
-     * ignored when it isn't on the branch. Without `base` it must be an ancestor of HEAD (e.g. the last release).
+     * With `base` it's the last validated commit of the branch: Actors that didn't change after it are left out.
+     * It's ignored when it is HEAD (a rerun) or isn't in the local history. Without `base` everything after it
+     * counts, and it must be an ancestor of HEAD (e.g. the last release).
      */
     since?: string;
     /** Glob relative to the repo root. Matching files count as changes even when .dockerignore lists them. */
@@ -30,77 +34,113 @@ interface AffectedActorsOptions {
     ignore: string[];
 }
 
+/** The JSON document `get-affected-actors` prints. Versioned, since other commands and workflows consume it. */
 interface AffectedActors {
-    headSha: string;
+    version: 1;
+    head: string;
+    /** The commits, changed files and changelog describe the whole range, `--since` with `--base` only narrows the Actors. */
     commits: Commit[];
     changedFiles: string[];
     changelog: string | null;
-    /** Actors with at least one functional change. They need a new build and tests. */
-    functionallyChangedActors: ActorConfig[];
+    /**
+     * Actors with at least one functional change. They need a new build and tests. Only the names: the config file
+     * stays the source of truth for the rest.
+     */
+    functionallyChangedActors: { actorFullName: string }[];
     /** Actors whose changes are all cosmetic (README, CHANGELOG, cosmetic .actor JSON). They only need a release build. */
-    cosmeticallyChangedActors: ActorConfig[];
-}
-
-interface CommitRange {
-    commits: Commit[];
-    fromRef: string;
-    toRef: string;
+    cosmeticallyChangedActors: { actorFullName: string }[];
 }
 
-/** The branch's own commits, after `since` when it is on the branch (see getCommits). */
-const getBranchRange = async (base: string, since: string | undefined): Promise<CommitRange> => {
-    const commits = await getCommits({ sourceBranch: HEAD, targetBranch: base, baseCommit: since });
-    return { commits, fromRef: `${commits[0].sha}~`, toRef: commits[commits.length - 1].sha };
-};
+const names = (configs: ActorConfig[]) => configs.map(({ actorFullName }) => ({ actorFullName }));
 
-/** Everything after `since` up to HEAD. Unlike on a branch, `since` must be an ancestor of HEAD. */
-const getRangeSince = async (headSha: string, since: string): Promise<CommitRange> => {
-    const sinceSha = await resolveReleaseBaseCommit(since);
-    const commits = sinceSha === headSha ? [] : await getCommitsBetween(sinceSha, headSha);
-    return { commits, fromRef: sinceSha, toRef: headSha };
+/** The branch's last validated commit, unless it can't narrow anything down. */
+const findValidatedSha = async (since: string, headSha: string): Promise<string | undefined> => {
+    const sinceSha = await findCommitSha(since);
+    if (!sinceSha) {
+        logger.info(
+            `Last validated commit ${since} is not in the local history (force-push?), checking the whole branch`,
+        );
+        return undefined;
+    }
+    if (sinceSha === headSha) {
+        logger.info('Last validated commit is HEAD, so this is a rerun: checking the whole branch from scratch');
+        return undefined;
+    }
+    return sinceSha;
 };
 
 /**
- * This is an optimization for the common case where a branch only has cosmetic changes but had to merge in
- * functional changes from base (being up-to-date is a CI requirement). Base is already validated, and
- * since the branch has no functional changes of its own, there is nothing new to validate.
- * Exception: if the branch has any functional changes alongside the merge, we must re-test — even
- * individually validated changes can have novel interactions when combined.
- * Returns the Actors the branch's own commits changed, or undefined when it didn't merge base in.
+ * This is Juan's magical algorithm where we need just 2 git diffs to determine functional changes on Actors.
+ *
+ * Naively, we could just check branch HEAD changes vs base or parent of first commit and be done but
+ * we do this jiu-jitsu code to apply 2 optimizations:
+ * 1. On our PR branch, we track last validated commit (since) that was tested and so we only need to test new commits.
+ * 2. We also merge changes from the base branch (usually master) and we can consider those already validated as well.
+ *
+ * But there is annoying problem: even if both our branch and base are validated, they could have novel interactions and
+ * we need to retest those.
+ *
+ * So we look at:
+ * 1. The changes introduced by our branch since the last validated commit (`since..HEAD`).
+ * 2. The changes introduced by the branch compared to the base branch (`base...HEAD`). The important part is that this
+ * diff does check the whole branch, discarding the last validated commit (since) so it checks those novel interactions problem.
+ *
+ * The magic is that both need to contain changes for an Actor to be retested:
+ * 1. If we have changes only in since..HEAD (and not in base...HEAD), it means those changes came from merging the base alone
+ * which is already validated and there were actually no real changes introduced by our branch alone.
+ * 2. If we have changes only in base...HEAD (and not in since..HEAD), it means there are no new changes on our branch
+ * since it was last validated. base...HEAD has changes that we already validated.
+ *
+ * This enables to simply do those 2 diffs for each Actor's context separately and only Actors that have changes
+ * in both diffs need to be retested.
  *
- * TODO: Apply this per Actor instead of to the whole branch. Changes merged in from base only interact with the
- * branch's own changes in Actors whose context both touch, so an Actor that only base changed is already validated
- * and can be skipped even when the branch changes other Actors functionally. Today any functional change of the
- * branch's own keeps every Actor, and the log messages below describe the whole branch.
+ * THIS ASSUMES BRANCH IS UP TO DATE WITH BASE WHEN IT MERGES, which we currently require. Only then is HEAD what lands on
+ * base, and base's commits validated. Otherwise what lands is HEAD combined with base's newer commits, which nobody
+ * tested, however the Actors are picked.
+ *
+ * In each example the branch's functional change to Actor A was validated at `since`, then one more push follows:
+ *
+ * Example scenarios:
+ * - Our own branch only: a commit changes A's README and B's code.
+ *   `since..HEAD`: A cosmetic, B functional. `base...HEAD`: A and B functional.
+ *   → A cosmetic, B functional: only B is tested, A's code is still the validated one.
+ * - Cosmetic merge: the branch merges base, which only changed READMEs and the CHANGELOG.
+ *   `since..HEAD`: every Actor cosmetic (CHANGELOG counts for all). `base...HEAD`: A functional, since the merged
+ *   files now match base and drop out of it.
+ *   → A cosmetic, the other Actors left out: nothing is tested.
+ * - Functional merge: the branch merges base, which changed code of A and of C.
+ *   `since..HEAD`: A and C functional. `base...HEAD`: A functional.
+ *   → A functional, C left out: A is tested, since base's change can interact with the branch's, while C only has
+ *   base's change, which base already validated.
  */
-const getOwnChangesIfMergedFromBase = async (
-    base: string,
-    actorConfigs: ActorConfig[],
-    testFilesGlob: string | undefined,
-): Promise<ChangedActors | undefined> => {
-    if (!(await hasMergeFromTarget(HEAD, base))) return undefined;
+const intersectChangedInBranchVsSince = (branch: ChangedActors, sinceValidated: ChangedActors): ChangedActors => {
+    const narrowed: ChangedActors = { functional: [], cosmetic: [] };
+    // All checks are done for each Actor separately, that's cleanest and most accurate
+    for (const actor of [...branch.functional, ...branch.cosmetic]) {
+        // base...HEAD
+        const changedFunctionallyOnBranch = branch.functional.includes(actor);
+        // since..HEAD
+        const changedFunctionallySince = sinceValidated.functional.includes(actor);
+
+        // changedSince is used for release. Release cares also about cosmetic.
+        const changedSince = changedFunctionallySince || sinceValidated.cosmetic.includes(actor);
+
+        // Nothing changed since the last validation, so the branch's change to this Actor is already validated
+        if (!changedSince) continue;
 
-    logger.info(
-        '[MERGE-FROM-TARGET-OPTIMIZATION]: There is merge from target branch, checking if there are no functional changes in our own branch. If so, we can skip tests',
-    );
-    const own = await getChangedActors({
-        filepathsChanged: await getBranchOnlyChangedFiles(HEAD, base),
-        actorConfigs,
-        // Omit since to get full branch history. Validated functional commits can still interact with merged ones
-        commits: await getCommits({ sourceBranch: HEAD, targetBranch: base }),
-        testFilesGlob,
-    });
-    logger.info(
-        own.functional.length > 0
-            ? `[MERGE-FROM-TARGET-OPTIMIZATION]: Branch has ${own.functional.length} functional changes, cannot optimize, we continue with full check`
-            : '[MERGE-FROM-TARGET-OPTIMIZATION]: Branch itself has no functional changes, skipping tests',
-    );
-    return own;
+        // As we said, only intersection counts as functional, otherwise it's cosmetic
+        if (changedFunctionallyOnBranch && changedFunctionallySince) {
+            narrowed.functional.push(actor);
+        } else {
+            narrowed.cosmetic.push(actor);
+        }
+    }
+    return narrowed;
 };
 
 /**
- * Finds the Actors whose context changed in the given range. `base` selects the branch's own commits
- * (a PR), `since` the commits after a known one (a release, or the last validated commit of a PR).
+ * Finds the Actors whose context changed in the given range. `base` selects the branch's own changes
+ * (a PR), `since` the changes after a known commit (a release, or the last validated commit of a PR).
  */
 export const getAffectedActors = async ({
     base,
@@ -115,43 +155,44 @@ export const getAffectedActors = async ({
         throw new Error('Pass --base, --since, or both to select the commits to inspect.');
     }
 
-    const headSha = await resolveCommitSha(HEAD);
-    const { commits, fromRef, toRef } = base ? await getBranchRange(base, since) : await getRangeSince(headSha, since!);
     const actorConfigs = await readConfigFile({ actors, ignore });
+    const getChangedInRange = async (range: GitRange) => {
+        const changedFiles = await getChangedFilesBetween(range.fromRef, range.toRef);
+        return {
+            changedFiles,
+            changedActors: await getChangedActors({
+                filepathsChanged: changedFiles,
+                actorConfigs,
+                range,
+                testFilesGlob,
+            }),
+        };
+    };
 
-    // What the branch only merged in from base is already validated. Without functional changes of its own
-    // the branch has nothing to test, and without any changes of its own nothing to release either.
-    const own = base ? await getOwnChangesIfMergedFromBase(base, actorConfigs, testFilesGlob) : undefined;
-    const changedFiles = await getChangedFilesBetween(fromRef, toRef);
-    const changed = await getChangedActors({ filepathsChanged: changedFiles, actorConfigs, commits, testFilesGlob });
-
-    return {
-        headSha,
-        commits,
-        changedFiles,
-        changelog: await getChangelogAdditions(fromRef, toRef, changedFiles),
-        functionallyChangedActors: own && own.functional.length === 0 ? [] : changed.functional,
-        cosmeticallyChangedActors: own && own.functional.length + own.cosmetic.length === 0 ? [] : changed.cosmetic,
+    const headSha = await resolveCommitSha(HEAD);
+    const rangeVsBase: GitRange = {
+        // merge base = PR, release base = push to master (release)
+        fromRef: base ? await getMergeBase(base, HEAD) : await resolveReleaseBaseCommit(since!),
+        toRef: headSha,
     };
-};
 
-/** The JSON document `get-affected-actors` prints. Versioned, since other commands and workflows consume it. */
-export const toAffectedActorsDocument = ({
-    headSha,
-    commits,
-    changedFiles,
-    changelog,
-    functionallyChangedActors,
-    cosmeticallyChangedActors,
-}: AffectedActors) => {
-    const names = (configs: ActorConfig[]) => configs.map(({ actorFullName }) => ({ actorFullName }));
+    // Falls back to rangeVsBase.fromRef when there's no (usable) last validated commit — same as
+    // intersecting the branch's changes with themselves, which is a no-op (see this function's docs).
+    const validatedSha = base && since ? await findValidatedSha(since, headSha) : undefined;
+    const sinceFromRef = validatedSha ?? rangeVsBase.fromRef;
+
+    const { changedFiles, changedActors: changedVsBase } = await getChangedInRange(rangeVsBase);
+    const { changedActors: changedSinceActors } = await getChangedInRange({ fromRef: sinceFromRef, toRef: headSha });
+    // See this function's docs to understand the algorithm: only intersection counts as functional, otherwise it's cosmetic.
+    const changedActors = intersectChangedInBranchVsSince(changedVsBase, changedSinceActors);
+
     return {
         version: 1,
         head: headSha,
-        commits,
+        commits: await getCommitsBetween(rangeVsBase.fromRef, rangeVsBase.toRef),
         changedFiles,
-        changelog,
-        functionallyChangedActors: names(functionallyChangedActors),
-        cosmeticallyChangedActors: names(cosmeticallyChangedActors),
+        changelog: await getChangelogAdditions(rangeVsBase.fromRef, rangeVsBase.toRef, changedFiles),
+        functionallyChangedActors: names(changedActors.functional),
+        cosmeticallyChangedActors: names(changedActors.cosmetic),
     };
 };

package/bin/build.ts

@@ -14,8 +14,6 @@ type BuildPrActorOptions = {
 
 // Fixed version number used to build from local source files, since there is no real version to track.
 export const LOCAL_SOURCE_VERSION_NUMBER = '0.98';
-// Version that build-for-test builds, so tests never touch the version users run
-export const TEST_VERSION_NUMBER = '0.99';
 // Stands for each Actor's default version: the one its default build tag points to
 export const DEFAULT_VERSION_KEYWORD = 'default';
 

package/bin/diff-changes.ts

@@ -3,13 +3,14 @@ import picomatch from 'picomatch';
 import { isCosmeticOnlyJsonSchemaChange } from './diff-json-schema.js';
 import { type DockerIgnoreMatcher, loadDockerIgnore } from './dockerignore.js';
 import { logger } from './logger.js';
-import type { ActorConfig, Commit } from './types.js';
+import type { ActorConfig, GitRange } from './types.js';
 import { type RelativeDir, RelativeFile } from './utils/path/repo-relative.js';
 
 interface ShouldBuildAndTestOptions {
     filepathsChanged: string[];
     actorConfigs: ActorConfig[];
-    commits: Commit[];
+    /** The range the files changed in, to compare `.actor` JSON files across. */
+    range: GitRange;
     // Glob relative to the repo root. Matching files count as changes even when .dockerignore lists them.
     testFilesGlob?: string;
 }
@@ -52,7 +53,7 @@ type FileChangeForActor =
 const classifyFileChange = async (
     changedFile: RelativeFile,
     actorConfig: ActorConfig,
-    commits: Commit[],
+    range: GitRange,
     dockerIgnoreMatcher: DockerIgnoreMatcher,
     isTestFile: (filePath: string) => boolean,
 ): Promise<FileChangeForActor> => {
@@ -91,7 +92,7 @@ const classifyFileChange = async (
     }
 
     if (lowercaseFilePath.endsWith('.json') && isUnderActorDotDir) {
-        const isCosmetic = await isCosmeticOnlyJsonSchemaChange(commits, changedFile.path);
+        const isCosmetic = await isCosmeticOnlyJsonSchemaChange(range, changedFile.path);
         if (isCosmetic) return { impact: 'cosmetic', semanticallyVerified: true };
     }
 
@@ -175,7 +176,7 @@ export interface ChangedActors {
 export const getChangedActors = async ({
     filepathsChanged,
     actorConfigs,
-    commits,
+    range,
     testFilesGlob,
 }: ShouldBuildAndTestOptions): Promise<ChangedActors> => {
     const actorsChangedMap = new Map<string, ActorChangeEntry>();
@@ -192,7 +193,7 @@ export const getChangedActors = async ({
                 continue;
             }
 
-            const change = await classifyFileChange(filePath, actorConfig, commits, dockerIgnoreMatcher, isTestFile);
+            const change = await classifyFileChange(filePath, actorConfig, range, dockerIgnoreMatcher, isTestFile);
             if (change.impact !== 'outside-context' && isTestFile(originalFilePath)) {
                 testFilesInContext.add(originalFilePath);
             }

package/bin/diff-json-schema.ts

@@ -1,5 +1,5 @@
 import { logger } from './logger.js';
-import type { Commit } from './types.js';
+import type { GitRange } from './types.js';
 import { runGitCommand } from './utils.js';
 
 const COSMETIC_JSON_FIELD_NAMES = new Set([
@@ -29,11 +29,10 @@ const isCosmeticObjectChange = (oldVal: unknown, newVal: unknown, currentKey?: s
  * Returns true if the two JSON strings differ only in cosmetic fields
  * (title, description, example, enumTitles, sectionCaption, sectionDescription).
  */
-export const isCosmeticOnlyJsonSchemaChange = async (commits: Commit[], changedFilepath: string): Promise<boolean> => {
-    // TODO: validate this is the right commit range
-    const oldRef = `${commits[0].sha}~`;
-    const newRef = commits[commits.length - 1].sha;
-
+export const isCosmeticOnlyJsonSchemaChange = async (
+    { fromRef: oldRef, toRef: newRef }: GitRange,
+    changedFilepath: string,
+): Promise<boolean> => {
     const [oldJson, newJson] = await Promise.all([
         runGitCommand(['show', `${oldRef}:${changedFilepath}`])
             .then(JSON.parse)

package/bin/git.ts

@@ -9,8 +9,8 @@ const GIT_LOG_FORMAT = ['%H', '%aN<%aE>', '%aD', '%s'].join(GIT_FORMAT_SEPARATOR
  * Gets the list of changed files between the given commits (inclusive), so it diffs from the parent of the oldest.
  */
 export const getChangedFiles = async (commits: Commit[]) => {
-    // getCommits never returns an empty list (the rerun check returns all commits when the base commit
-    // is the branch HEAD, and an empty git range throws when parsing), so this signals a programmer error
+    // getCommits never returns an empty list (it throws on an empty range, and the rerun check returns all
+    // commits when the base commit is the branch HEAD), so this signals a programmer error
     if (commits.length === 0) {
         throw new Error('Cannot get changed files: the commit list is empty. This should never happen.');
     }
@@ -35,59 +35,22 @@ export const getChangedFilesBetween = async (fromRef: string, toRef: string) =>
 };
 
 /**
- * Returns true if the branch contains a merge commit whose parent is reachable from targetBranch
- * (i.e. a genuine "merge from target" commit, not a merge of some unrelated branch).
- * Uses the full targetBranch..sourceBranch range, ignoring baseCommit.
+ * The commit `git diff base...head` compares against: where `head` forked from `base`, or the last commit of `base`
+ * that `head` merged in. The diff from it holds only what `head` itself changed, like GitHub's "Files changed" tab.
+ * With criss-cross merges there are several such commits and git picks one.
  */
-export const hasMergeFromTarget = async (sourceBranch: string, targetBranch: string): Promise<boolean> => {
-    const mergeShas = (
-        await runGitCommand(['log', '--merges', '--pretty=format:%H', `${targetBranch}..${sourceBranch}`], {
-            operation: 'find merge commits on the source branch that are absent from the target branch',
-        })
-    )
-        .split('\n')
-        .filter(Boolean);
+export const getMergeBase = async (base: string, head: string): Promise<string> =>
+    runGitCommand(['merge-base', base, head], { operation: `find where ${head} forked from ${base}` });
 
-    for (const sha of mergeShas) {
-        const parents = (
-            await runGitCommand(['log', '-1', '--pretty=format:%P', sha], {
-                operation: 'get parents of a merge commit',
-            })
-        ).split(' ');
-        for (const parent of parents) {
-            // git merge-base A B outputs the common ancestor.
-            // If that equals A, then A is an ancestor of B (i.e. parent is reachable from targetBranch).
-            let mergeBase: string;
-            try {
-                mergeBase = await runGitCommand(['merge-base', parent, targetBranch], {
-                    operation: 'check whether a merge parent is reachable from the target branch',
-                });
-            } catch (error) {
-                // Exit code 1 on merge-base means the histories have no common ancestor.
-                if (error instanceof GitCommandError && error.exitCode === 1) {
-                    continue;
-                }
-                throw error;
-            }
-            if (mergeBase === parent) {
-                return true;
-            }
-        }
-    }
-    return false;
-};
-
-/**
- * Returns all files touched by non-merge commits on the branch (full history, ignoring baseCommit).
- * Used to check whether the branch itself has any functional changes, independent of what master merged in.
- */
-export const getBranchOnlyChangedFiles = async (sourceBranch: string, targetBranch: string): Promise<string[]> => {
-    const output = await runGitCommand(
-        ['log', '--no-merges', '--name-only', '--pretty=format:', `${targetBranch}..${sourceBranch}`],
-        { operation: 'list files changed by non-merge commits on the source branch' },
-    );
-    return output.split('\n').filter(Boolean);
-};
+/** Resolves a ref to a commit, or undefined when it isn't in the local history (e.g. it was force-pushed away). */
+export const findCommitSha = async (ref: string): Promise<string | undefined> =>
+    runGitCommand(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {
+        operation: `look up ${ref} in local Git history`,
+    }).catch((error: unknown) => {
+        // --quiet suppresses Git's error text for a missing commit, but Git still exits with code 1
+        if (error instanceof GitCommandError && error.exitCode === 1) return undefined;
+        throw error;
+    });
 
 const SHA_REGEX = /^[0-9a-f]{40}$/i;
 
@@ -120,8 +83,8 @@ export const getCommitsBetween = async (fromRef: string, toRef: string): Promise
     const output = await runGitCommand(['log', `--pretty=format:${GIT_LOG_FORMAT}`, `${fromRef}..${toRef}`], {
         operation: 'list commits reachable from the source ref but absent from the target ref',
     });
-    const commitsStrings = output.split('\n');
-    const commits = commitsStrings.map((commitString) => parseCommit(commitString));
+    // An empty range (e.g. `x..x`) prints nothing
+    const commits = output.split('\n').filter(Boolean).map(parseCommit);
     commits.reverse();
     return commits;
 };
@@ -137,6 +100,9 @@ export const getCommits = async ({
 }: Pick<Config, 'sourceBranch' | 'targetBranch' | 'baseCommit'>): Promise<Commit[]> => {
     const baseCommitSha = parseBaseCommit(baseCommit);
     const commits = await getCommitsBetween(targetBranch, sourceBranch);
+    if (commits.length === 0) {
+        throw new Error(`${sourceBranch} has no commits that are not on ${targetBranch}.`);
+    }
 
     // The last validated (base) commit being the branch HEAD means nothing new was pushed since the last
     // validation — the dev reran the workflow (or force-pushed to the same state) to trigger a clean test

package/bin/main.ts

@@ -6,13 +6,13 @@ import yargs, { type Options } from 'yargs';
 // eslint-disable-next-line import/extensions --- With .js, it cannot find types
 import { hideBin } from 'yargs/helpers';
 
-import { getAffectedActors, toAffectedActorsDocument } from './affected-actors.js';
-import { buildActors, DEFAULT_VERSION_KEYWORD, deleteOldBuilds, TEST_VERSION_NUMBER } from './build.js';
+import { getAffectedActors } from './affected-actors.js';
+import { buildActors, DEFAULT_VERSION_KEYWORD, deleteOldBuilds } from './build.js';
 import { runBuildsFromLocal } from './build-from-local.js';
-import { getChangedFiles, getCommits, getCurrentBranch } from './git.js';
+import { getChangedFiles, getCommits } from './git.js';
 import { logger, logLevels } from './logger.js';
 import { writeJson } from './output.js';
-import { announceRelease } from './slack.js';
+import { notifyToSlack } from './slack.js';
 import { parseBuildInput, parseReleaseChanges, readStdin } from './stdin-input.js';
 import { reportTestResults } from './test-report.js';
 import { readConfigFile } from './utils/config/load-config.js';
@@ -101,14 +101,7 @@ const buildOptions = {
     },
 } as const satisfies Record<string, Options>;
 
-/** Range of build-for-test: the checked-out branch's own commits, after its last validated one. */
-const buildForTestOptions = {
-    'target-branch': { type: 'string', demandOption: true },
-    'base-commit': { type: 'string' },
-    'test-files-glob': { type: 'string' },
-} as const satisfies Record<string, Options>;
-
-/** Where `release` and `notify-release` post the release. */
+/** Where `notify-release` posts the release. */
 const releaseSlackOptions = {
     'report-slack-channel': { type: 'string', describe: 'Channel for the full report: commits and changed files' },
     'release-slack-channel': { type: 'string', describe: 'Channel for the changelog additions only' },
@@ -172,7 +165,7 @@ await yargs()
         'Find the Actors whose context changed in a commit range ending at the checked-out HEAD',
         (y) => y.options(affectedRangeOptions).options(actorSelectionOptions),
         async (args) => {
-            writeJson(toAffectedActorsDocument(await getAffectedActors(args)));
+            writeJson(await getAffectedActors(args));
         },
     )
     .command(
@@ -207,96 +200,13 @@ await yargs()
             writeJson(builds);
         },
     )
-    .command(
-        'build-for-test',
-        'Build the Actors the checked-out branch changed functionally, for testing',
-        (y) =>
-            y
-                .options(buildForTestOptions)
-                .options(actorSelectionOptions)
-                .options(repoUrlOptions)
-                .options(dryRunOptions),
-        async (config) => {
-            logger.info(
-                '[BUILD-FOR-TEST]: Same as get-affected-actors --base <target-branch> [--since <base-commit>] ' +
-                    `| jq '{ actors: .functionallyChangedActors }' | build --version-number ${TEST_VERSION_NUMBER}`,
-            );
-            // Cosmetic-only changes don't need testing, so they don't need a build either
-            const { functionallyChangedActors } = await getAffectedActors({
-                base: config.targetBranch,
-                since: config.baseCommit,
-                testFilesGlob: config.testFilesGlob,
-                actors: config.actors,
-                ignore: config.ignore,
-            });
-            const builds = await buildActors({
-                actorConfigs: functionallyChangedActors,
-                versionNumber: TEST_VERSION_NUMBER,
-                repoUrl: config.repoUrl,
-                dryRun: config.dryRun,
-            });
-            writeJson(builds);
-        },
-    )
-    .command(
-        'release',
-        'Build the default version of the Actors changed since the last release and announce it on Slack',
-        (y) =>
-            y
-                .options(actorSelectionOptions)
-                .options(repoUrlOptions)
-                .options(dryRunOptions)
-                // The last commit that is already released, everything after it up to HEAD gets released.
-                // Required, see the README section "Releasing Actors" for how to set it for each merge strategy.
-                .option('base-commit', { type: 'string', demandOption: true })
-                .options(releaseSlackOptions),
-        async (args) => {
-            logger.info(
-                '[RELEASE]: Same as get-affected-actors --since <base-commit> > affected.json, then ' +
-                    "jq '{ actors: (.functionallyChangedActors + .cosmeticallyChangedActors) }' affected.json " +
-                    `| build --version-number ${DEFAULT_VERSION_KEYWORD}, then notify-release < affected.json`,
-            );
-            // Fail before anything else on a detached HEAD: there is no branch to release
-            await getCurrentBranch();
-            const { commits, changedFiles, changelog, functionallyChangedActors, cosmeticallyChangedActors } =
-                await getAffectedActors({
-                    since: args.baseCommit,
-                    actors: args.actors,
-                    ignore: args.ignore,
-                });
-            if (commits.length === 0) {
-                logger.info(`HEAD is the base commit ${args.baseCommit}, there is nothing new to release`);
-                return;
-            }
-
-            const { dryRun, reportSlackChannel, releaseSlackChannel } = args;
-            const builds = await buildActors({
-                // A release ships cosmetic changes (README, input schema descriptions, ...) too
-                actorConfigs: [...functionallyChangedActors, ...cosmeticallyChangedActors],
-                versionNumber: DEFAULT_VERSION_KEYWORD,
-                repoUrl: args.repoUrl,
-                dryRun,
-            });
-            logger.info(JSON.stringify(builds));
-
-            await announceRelease({
-                commits,
-                changedFiles,
-                changelog,
-                repoUrl: args.repoUrl,
-                dryRun,
-                reportSlackChannel,
-                releaseSlackChannel,
-            });
-        },
-    )
     .command(
         'notify-release',
         'Announce a release on Slack, from the get-affected-actors output on stdin',
         (y) => y.options(releaseSlackOptions).options(repoUrlOptions).options(dryRunOptions),
         async (args) => {
             const { commits, changedFiles, changelog } = parseReleaseChanges(await readStdin());
-            await announceRelease({
+            await notifyToSlack({
                 commits,
                 changedFiles,
                 changelog,