apify-test-tools 0.6.0 → 0.6.2-beta.0

package/bin/build.ts

@@ -1,25 +1,36 @@
+import type { Build } from 'apify-client';
+import { ApifyClient } from 'apify-client';
+
 import { ACTOR_SOURCE_TYPES } from '@apify/consts';
-import { ApifyClient, Build } from 'apify-client';
+
 import type { ActorConfig, BuildData } from './types.js';
 import { getEnvVar } from './utils.js';
 
 type BuildPrActorOptions = {
-    buildTag?: string
-    versionNumber: string
-    gitRepoUrl: string
-    actorName: string
-}
+    buildTag?: string;
+    versionNumber: string;
+    gitRepoUrl: string;
+    actorName: string;
+};
 class ApifyBuilder {
-    // eslint-disable-next-line no-empty-function
-    private constructor(private readonly apifyClient: ApifyClient, private readonly actorName: string) { }
+    private constructor(
+        private readonly apifyClient: ApifyClient,
+        private readonly actorName: string,
+    ) {}
 
     // Usually 'latest' but not necessarily (can be e.g. 'version-0')
-    getDefaultVersionAndTag = async (): Promise<{ defaultBuildNumber: string, defaultVersionNumber: string, defaultBuildTag: string }> => {
+    getDefaultVersionAndTag = async (): Promise<{
+        defaultBuildNumber: string;
+        defaultVersionNumber: string;
+        defaultBuildTag: string;
+    }> => {
         const actorClient = this.apifyClient.actor(this.actorName);
         const actorInfo = await actorClient.get();
 
         if (!actorInfo) {
-            throw new Error(`[${this.actorName}] not found. It is not published or we are missing token to access it privately or its name is misspelled`);
+            throw new Error(
+                `[${this.actorName}] not found. It is not published or we are missing token to access it privately or its name is misspelled`,
+            );
         }
 
         const defaultBuildTag = actorInfo.defaultRunOptions.build;
@@ -27,8 +38,10 @@ class ApifyBuilder {
 
         // We could technically allow this but in most cases this is accidentally set wrongly and there is a workaround
         if (defaultBuildTag.match(/\d+\.\d+\.\d+/)) {
-            throw new Error(`[${this.actorName}] Default build is a build number, not a tag. While this could work, `
-                + `we want to have a default as tag so this is often an accidental misconfiguration from the dev`);
+            throw new Error(
+                `[${this.actorName}] Default build is a build number, not a tag. While this could work, ` +
+                    `we want to have a default as tag so this is often an accidental misconfiguration from the dev`,
+            );
         }
         // I reported that buildNumber should probably not be optional
         const defaultBuildNumber = actorInfo.taggedBuilds![defaultBuildTag].buildNumber!;
@@ -38,17 +51,15 @@ class ApifyBuilder {
         return { defaultBuildNumber, defaultVersionNumber, defaultBuildTag };
     };
 
-    startActorBuild = async ({
-        buildTag,
-        versionNumber,
-        gitRepoUrl,
-    }: BuildPrActorOptions): Promise<BuildData> => {
+    startActorBuild = async ({ buildTag, versionNumber, gitRepoUrl }: BuildPrActorOptions): Promise<BuildData> => {
         const actorClient = this.apifyClient.actor(this.actorName);
         const actorInfo = await actorClient.get();
         if (!actorInfo) {
-            throw new Error(`No actor named '${this.actorName}' was found on the platform. If this`
-                + ' is unexpected, make sure the actor you are targeting is spelled the'
-                + ' same as the folder in the repository.');
+            throw new Error(
+                `No actor named '${this.actorName}' was found on the platform. If this` +
+                    ' is unexpected, make sure the actor you are targeting is spelled the' +
+                    ' same as the folder in the repository.',
+            );
         }
 
         // NOTE: I couldn't find this type, so I had to extract it :(
@@ -83,8 +94,9 @@ class ApifyBuilder {
         const build = await this.apifyClient.build(buildId).waitForFinish();
         const versionNumber = build.buildNumber;
         if (build.status === 'FAILED' || build.status === 'TIMED-OUT') {
-            const message = `[BUILD][${actorName}]: Build ${buildId} (${versionNumber}) failed. `
-                + `Not continuing with other builds and tests.`;
+            const message =
+                `[BUILD][${actorName}]: Build ${buildId} (${versionNumber}) failed. ` +
+                `Not continuing with other builds and tests.`;
             console.error(`[${this.actorName}]: ${versionNumber}`);
             throw new Error(message);
         }
@@ -93,8 +105,8 @@ class ApifyBuilder {
     };
 
     /**
-    * Create ApifyBuilder with actor owner's token
-    */
+     * Create ApifyBuilder with actor owner's token
+     */
     static fromActorName = (actorName: string): ApifyBuilder => {
         const username = actorName.split('/')[0];
         // GitHib secrets only allow word characters (alphanum + underscore)
@@ -102,8 +114,10 @@ class ApifyBuilder {
         const usernameEnvVar = `APIFY_TOKEN_${usernameInGitHubSecretsFormat}`;
         const token = process.env[usernameEnvVar];
         if (!token) {
-            throw new Error(`Cannot find Apify API token for username: ${username}. `
-                + `Have you set secret env var to this GitHub repo with key: ${usernameEnvVar}?`);
+            throw new Error(
+                `Cannot find Apify API token for username: ${username}. ` +
+                    `Have you set secret env var to this GitHub repo with key: ${usernameEnvVar}?`,
+            );
         }
         const apifyClient = new ApifyClient({ token });
         const builder = new ApifyBuilder(apifyClient, actorName);
@@ -118,7 +132,21 @@ class ApifyBuilder {
         // Even though we don't version our current Actors, if we ever such Actors to GitHub CI, we would accidentally delete old supported versions
         // This hardcoded solution is not ideal, but it should prevent most imaginable cases
         // All currently popular versioned Actors use `version-${number}` format
-        const PROTECTED_TAGS_PREFIX = ['latest', 'v-', 'version', 'v0', 'v1', 'v2', 'v3', 'v4', 'v5', 'v6', 'v7', 'v8', 'v9'];
+        const PROTECTED_TAGS_PREFIX = [
+            'latest',
+            'v-',
+            'version',
+            'v0',
+            'v1',
+            'v2',
+            'v3',
+            'v4',
+            'v5',
+            'v6',
+            'v7',
+            'v8',
+            'v9',
+        ];
 
         // We don't want to be too short because we might to debug something
         // but also not too long because it increases the risk of users using outdated versions
@@ -132,43 +160,58 @@ class ApifyBuilder {
 
         const allTags = Object.keys(actorInfo.taggedBuilds ?? {});
         const protectedTags = allTags.filter((tag) => PROTECTED_TAGS_PREFIX.some((prefix) => tag.startsWith(prefix)));
-        const protectedBuildNumbers = protectedTags.map((tag) => ({ buildNumber: actorInfo.taggedBuilds![tag]!.buildNumber, tag }));
+        const protectedBuildNumbers = protectedTags.map((tag) => ({
+            buildNumber: actorInfo.taggedBuilds![tag]!.buildNumber,
+            tag,
+        }));
 
-        const { items } = (await this.apifyClient.actor(this.actorName).builds().list());
+        const { items } = await this.apifyClient.actor(this.actorName).builds().list();
 
         // Deleting default build throws an error, so we skip it
-        const { defaultBuildNumber, defaultBuildTag } = await ApifyBuilder.fromActorName(this.actorName).getDefaultVersionAndTag();
+        const { defaultBuildNumber, defaultBuildTag } = await ApifyBuilder.fromActorName(
+            this.actorName,
+        ).getDefaultVersionAndTag();
 
         const daysAgoUnixProd = Date.now() - DEFAULT_DAYS_BACK_PROD_VERSIONS * 24 * 60 * 60 * 1000;
         const daysAgoUnixDevel = Date.now() - DEFAULT_DAYS_BACK_DEVEL * 24 * 60 * 60 * 1000;
 
         // Fixing API client missing buildNumber field
-        type CorrectBuildColletionItem = typeof items[0] & { buildNumber: string };
+        type CorrectBuildColletionItem = (typeof items)[0] & { buildNumber: string };
         const buildsToDelete = (items as CorrectBuildColletionItem[]).filter((build) => {
             if (build.buildNumber === defaultBuildNumber) {
-                console.error(`[DELETE OLD BUILDS][${this.actorName}]: Skipping default build ${defaultBuildNumber} (${defaultBuildTag}). `
-                    + `We never delete default builds`);
+                console.error(
+                    `[DELETE OLD BUILDS][${this.actorName}]: Skipping default build ${defaultBuildNumber} (${defaultBuildTag}). ` +
+                        `We never delete default builds`,
+                );
                 return false;
             }
 
-            const protectedTagFound = protectedBuildNumbers.find((protectedBuildNumber) => protectedBuildNumber.buildNumber === build.buildNumber);
+            const protectedTagFound = protectedBuildNumbers.find(
+                (protectedBuildNumber) => protectedBuildNumber.buildNumber === build.buildNumber,
+            );
             if (protectedTagFound) {
-                console.error(`[DELETE OLD BUILDS][${this.actorName}]: Skipping protected build ${protectedTagFound.buildNumber} (${protectedTagFound.tag}).`);
+                console.error(
+                    `[DELETE OLD BUILDS][${this.actorName}]: Skipping protected build ${protectedTagFound.buildNumber} (${protectedTagFound.tag}).`,
+                );
                 return false;
             }
 
             if (taggedDevelBuildNumber && build.buildNumber === taggedDevelBuildNumber) {
                 const shouldDeleteDevelBuild = build.startedAt.getTime() < daysAgoUnixDevel;
                 if (shouldDeleteDevelBuild) {
-                    console.error(`[DELETE OLD BUILDS][${this.actorName}]: Removing olf devel build ${taggedDevelBuildNumber}.`);
+                    console.error(
+                        `[DELETE OLD BUILDS][${this.actorName}]: Removing olf devel build ${taggedDevelBuildNumber}.`,
+                    );
                 }
                 return shouldDeleteDevelBuild;
             }
             return build.startedAt.getTime() < daysAgoUnixProd;
         });
 
-        console.error(`[DELETE OLD BUILDS][${this.actorName}]: Deleting ${buildsToDelete.length} old builds that are non-default and `
-            + `older than 30 days from total ${items.length}`);
+        console.error(
+            `[DELETE OLD BUILDS][${this.actorName}]: Deleting ${buildsToDelete.length} old builds that are non-default and ` +
+                `older than 30 days from total ${items.length}`,
+        );
         for (const build of buildsToDelete) {
             await this.apifyClient.build(build.id).delete();
         }
@@ -176,20 +219,14 @@ class ApifyBuilder {
 }
 
 type RunBuildsOptions = {
-    actorConfigs: ActorConfig[]
-    isLatest?: boolean
-    repoUrl: string
-    branch: string
-    dryRun: boolean
-}
+    actorConfigs: ActorConfig[];
+    isLatest?: boolean;
+    repoUrl: string;
+    branch: string;
+    dryRun: boolean;
+};
 
-export const runBuilds = async ({
-    repoUrl,
-    branch,
-    actorConfigs,
-    isLatest = false,
-    dryRun,
-}: RunBuildsOptions) => {
+export const runBuilds = async ({ repoUrl, branch, actorConfigs, isLatest = false, dryRun }: RunBuildsOptions) => {
     const buildConfigs: BuildPrActorOptions[] = [];
 
     const circleActors = isLatest ? await findCircleApifyManaged(actorConfigs) : [];
@@ -199,7 +236,8 @@ export const runBuilds = async ({
         let buildTag: string | undefined;
 
         if (isLatest) {
-            const { defaultVersionNumber, defaultBuildTag } = await ApifyBuilder.fromActorName(actorName).getDefaultVersionAndTag();
+            const { defaultVersionNumber, defaultBuildTag } =
+                await ApifyBuilder.fromActorName(actorName).getDefaultVersionAndTag();
             versionNumber = defaultVersionNumber;
             buildTag = defaultBuildTag;
         } else {
@@ -217,25 +255,29 @@ export const runBuilds = async ({
     if (dryRun) {
         return buildConfigs;
     }
-    console.error("=========================================");
-    console.error("STARTED BUILDS:");
-    const startedBuilds = await Promise.all(buildConfigs.map(async (buildConfig) => {
-        const builder = ApifyBuilder.fromActorName(buildConfig.actorName);
-        const buildData = await builder.startActorBuild(buildConfig);
-        return buildData;
-    }));
-    console.error("=========================================");
-    console.error("FINISHED BUILDS:");
-    await Promise.all(startedBuilds.map(async (buildData) => {
-        const builder = ApifyBuilder.fromActorName(buildData.actorName);
-        await builder.waitForBuildToFinish(buildData.buildId, buildData.actorName);
-    }));
-    console.error("=========================================");
-    console.error("SUMMARY:");
+    console.error('=========================================');
+    console.error('STARTED BUILDS:');
+    const startedBuilds = await Promise.all(
+        buildConfigs.map(async (buildConfig) => {
+            const builder = ApifyBuilder.fromActorName(buildConfig.actorName);
+            const buildData = await builder.startActorBuild(buildConfig);
+            return buildData;
+        }),
+    );
+    console.error('=========================================');
+    console.error('FINISHED BUILDS:');
+    await Promise.all(
+        startedBuilds.map(async (buildData) => {
+            const builder = ApifyBuilder.fromActorName(buildData.actorName);
+            await builder.waitForBuildToFinish(buildData.buildId, buildData.actorName);
+        }),
+    );
+    console.error('=========================================');
+    console.error('SUMMARY:');
     for (const buildData of startedBuilds.sort((a, b) => a.actorName.localeCompare(b.actorName))) {
         console.error(`[${buildData.actorName}]: ${buildData.buildNumber} `);
     }
-    console.error("=========================================");
+    console.error('=========================================');
 
     return startedBuilds;
 };
@@ -259,27 +301,36 @@ const findCircleApifyManaged = async (actorConfigs: ActorConfig[]): Promise<Acto
 
     const { items: circleActors } = await client.actors().list();
 
-    const actorsToBuild = circleActors.map<ActorConfig | undefined>((circleActor) => {
-        // They prefix all with apify-managed---, I communicated with Jacques to keep doing that
-        let actorConfigFound = actorConfigs.find((actorConfig) => circleActor.name.replace('apify-managed---', '') === actorConfig.actorName.split('/')[1]);
-
-        // Hack for bad naming of circ_le/apify-managed-google-search, we don't want to rename now to break customers
-        if (!actorConfigFound && circleActor.name === 'apify-managed-google-search') {
-            actorConfigFound = actorConfigs.find((actorConfig) => actorConfig.actorName.split('/')[1] === 'google-search-scraper');
-        }
+    const actorsToBuild = circleActors
+        .map<ActorConfig | undefined>((circleActor) => {
+            // They prefix all with apify-managed---, I communicated with Jacques to keep doing that
+            let actorConfigFound = actorConfigs.find(
+                (actorConfig) =>
+                    circleActor.name.replace('apify-managed---', '') === actorConfig.actorName.split('/')[1],
+            );
+
+            // Hack for bad naming of circ_le/apify-managed-google-search, we don't want to rename now to break customers
+            if (!actorConfigFound && circleActor.name === 'apify-managed-google-search') {
+                actorConfigFound = actorConfigs.find(
+                    (actorConfig) => actorConfig.actorName.split('/')[1] === 'google-search-scraper',
+                );
+            }
 
-        if (actorConfigFound) {
-            return {
-                // We point the circle Actor to the repo folder
-                actorName: `${circleActor.username}/${circleActor.name}`,
-                folder: actorConfigFound.folder,
-                isStandalone: actorConfigFound.isStandalone,
-            };
-        }
-        return undefined;
-    }).filter((config) => config !== undefined);
+            if (actorConfigFound) {
+                return {
+                    // We point the circle Actor to the repo folder
+                    actorName: `${circleActor.username}/${circleActor.name}`,
+                    folder: actorConfigFound.folder,
+                    isStandalone: actorConfigFound.isStandalone,
+                };
+            }
+            return undefined;
+        })
+        .filter((config) => config !== undefined);
 
-    console.error(`Found ${actorsToBuild.length} circ_le actors that match Actors we built out of total ${circleActors.length} circ_le actors`);
+    console.error(
+        `Found ${actorsToBuild.length} circ_le actors that match Actors we built out of total ${circleActors.length} circ_le actors`,
+    );
     console.error(`All circ_le actors: ${circleActors.map((actor) => actor.name).join(', ')}`);
     console.error(`circ_le Actors to build: ${actorsToBuild.map((actor) => actor.actorName).join(', ')}`);
 

package/bin/diff-changes.ts

@@ -0,0 +1,156 @@
+import { isCosmeticOnlyJsonSchemaChange } from './diff-json-schema.js';
+import type { ActorConfig, Commit } from './types.js';
+
+interface ShouldBuildAndTestOptions {
+    filepathsChanged: string[];
+    actorConfigs: ActorConfig[];
+    isLatest?: boolean;
+    commits: Commit[];
+}
+
+export const maybeParseActorFolder = (
+    lowercaseFilePath: string,
+): { isActorFolder: true; actorName: string } | { isActorFolder: false } => {
+    const match = lowercaseFilePath.match(/^(?:standalone-)?actors\/([^/]+)\/.+/);
+    if (match) {
+        // Some usernames weirdly use underscores, e.g. google_maps_email_extractor_standby-contact-details-scraper so we only need replace the last one
+        return { isActorFolder: true, actorName: match[1].replace(/_(?=[^_]*$)/, '/') };
+    }
+    return { isActorFolder: false };
+};
+
+/**
+ * Also works for folders
+ */
+const isIgnoredTopLevelFile = (lowercaseFilePath: string) => {
+    // On top level, we should only have dev-only readme and .actor/ is just for apify push CLI (real Actor configs are in /actors)
+    const IGNORED_TOP_LEVEL_FILES = [
+        '.vscode/',
+        '.gitignore',
+        'readme.md',
+        '.husky/',
+        '.eslintrc',
+        'eslint.config.mjs',
+        '.prettierrc',
+        '.editorconfig',
+        '.actor/',
+    ];
+    // Strip out deprecated /code and /shared folders, treat them as top-level code
+    const sanitizedLowercaseFilePath = lowercaseFilePath.replace(/^code\//, '').replace(/^shared\//, '');
+
+    return IGNORED_TOP_LEVEL_FILES.some((ignoredFile) => sanitizedLowercaseFilePath.startsWith(ignoredFile));
+};
+
+type FileChange =
+    | { impact: 'ignored' }
+    // Only things that influence how the Actor looks - e.g. README and CHANGELOG files, schema titles, descriptions, reordering, etc. We only need to rebuild on release
+    | { impact: 'cosmetic'; includes: 'all-actors' | ActorConfig }
+    // Influences how the Actor works - we need to run tests
+    | {
+          impact: 'functional';
+          includes: 'all-actors' | ActorConfig;
+      };
+
+const classifyFileChange = (lowercaseFilePath: string, actorConfigs: ActorConfig[], commits: Commit[]): FileChange => {
+    if (isIgnoredTopLevelFile(lowercaseFilePath)) {
+        return { impact: 'ignored' };
+    }
+
+    if (lowercaseFilePath.endsWith('changelog.md')) {
+        return { impact: 'cosmetic', includes: 'all-actors' };
+    }
+
+    const actorFolderInfo = maybeParseActorFolder(lowercaseFilePath);
+    if (actorFolderInfo.isActorFolder) {
+        const actorConfigChanged = actorConfigs.find(
+            ({ actorName }) => actorName.toLowerCase() === actorFolderInfo.actorName,
+        );
+        // This is some super weird case that happened once in the past but I don't remember the context anymore
+        if (actorConfigChanged === undefined) {
+            console.error(
+                'SHOULD NEVER HAPPEN: changes was found in an actor folder which no longer exists in the current commit, skipping this file',
+                {
+                    actorName: actorFolderInfo.actorName,
+                    lowercaseFilePath,
+                },
+            );
+            return { impact: 'ignored' };
+        }
+        if (lowercaseFilePath.endsWith('readme.md')) {
+            return { impact: 'cosmetic', includes: actorConfigChanged };
+        }
+        if (lowercaseFilePath.endsWith('.json') && isCosmeticOnlyJsonSchemaChange(commits, lowercaseFilePath)) {
+            return { impact: 'cosmetic', includes: actorConfigChanged };
+        }
+
+        return { impact: 'functional', includes: actorConfigChanged };
+    }
+
+    // For any other files, we assume they can interact with the code
+    return { impact: 'functional', includes: 'all-actors' };
+};
+
+export const getChangedActors = ({
+    filepathsChanged,
+    actorConfigs,
+    isLatest = false,
+    commits,
+}: ShouldBuildAndTestOptions): ActorConfig[] => {
+    // folder -> ActorConfig
+    const actorsChangedMap = new Map<string, ActorConfig>();
+
+    const actorConfigsWithoutStandalone = actorConfigs.filter(({ isStandalone }) => !isStandalone);
+
+    const lowercaseFiles = filepathsChanged.map((file) => file.toLowerCase());
+
+    for (const lowercaseFilePath of lowercaseFiles) {
+        const fileChange = classifyFileChange(lowercaseFilePath, actorConfigs, commits);
+        if (fileChange.impact === 'ignored') {
+            continue;
+        }
+
+        if (fileChange.impact === 'cosmetic' && !isLatest) {
+            continue;
+        }
+
+        if (fileChange.includes !== 'all-actors') {
+            actorsChangedMap.set(fileChange.includes.folder, fileChange.includes);
+        } else if (fileChange.includes === 'all-actors') {
+            // Standalone Actors are handled always via specific actors change, not all-actors
+            for (const actorConfig of actorConfigsWithoutStandalone) {
+                actorsChangedMap.set(actorConfig.folder, actorConfig);
+            }
+        }
+    }
+
+    const actorsChanged = Array.from(actorsChangedMap.values());
+
+    // All below here is just for logging
+    const ignoredFilesChanged = lowercaseFiles.filter(
+        (file) => classifyFileChange(file, actorConfigs, commits).impact === 'ignored',
+    );
+    console.error(`[DIFF]: Ignored files (don't trigger test or build): ${ignoredFilesChanged.join(', ')}`);
+
+    const cosmeticFilesChanged = lowercaseFiles.filter(
+        (file) => classifyFileChange(file, actorConfigs, commits).impact === 'cosmetic',
+    );
+    console.error(`[DIFF]: Cosmetic files (should only trigger release build): ${cosmeticFilesChanged.join(', ')}`);
+
+    const functionalFilesChanged = lowercaseFiles.filter(
+        (file) => classifyFileChange(file, actorConfigs, commits).impact === 'functional',
+    );
+    console.error(`[DIFF]: Functional files (trigger test & release build): ${functionalFilesChanged.join(', ')}`);
+
+    if (actorsChanged.length > 0) {
+        const miniactors = actorsChanged.filter((config) => !config.isStandalone).map((config) => config.actorName);
+        const standaloneActors = actorsChanged
+            .filter((config) => config.isStandalone)
+            .map((config) => config.actorName);
+        console.error(`[DIFF]: MiniActors to be built and tested: ${miniactors.join(', ')}`);
+        console.error(`[DIFF]: Standalone Actors to be built and tested: ${standaloneActors.join(', ')}`);
+    } else {
+        console.error(`[DIFF]: No relevant files changed, skipping builds and tests`);
+    }
+
+    return actorsChanged;
+};

package/bin/diff-json-schema.ts

@@ -0,0 +1,50 @@
+import type { Commit } from './types.js';
+import { spawnCommandInGhWorkspace } from './utils.js';
+
+const COSMETIC_JSON_FIELD_NAMES = new Set([
+    'title',
+    'description',
+    'example',
+    'enumTitles',
+    'sectionCaption',
+    'sectionDescription',
+]);
+
+const isPlainObject = (val: unknown): val is Record<string, unknown> =>
+    typeof val === 'object' && val !== null && !Array.isArray(val);
+
+const isCosmeticObjectChange = (oldVal: unknown, newVal: unknown, currentKey?: string): boolean => {
+    // If the key itself is cosmetic, any change under it is fine
+    if (currentKey && COSMETIC_JSON_FIELD_NAMES.has(currentKey)) return true;
+    if (JSON.stringify(oldVal) === JSON.stringify(newVal)) return true;
+    if (isPlainObject(oldVal) && isPlainObject(newVal)) {
+        const allKeys = new Set([...Object.keys(oldVal), ...Object.keys(newVal)]);
+        return [...allKeys].every((key) => isCosmeticObjectChange(oldVal[key], newVal[key], key));
+    }
+    return false;
+};
+
+/**
+ * Returns true if the two JSON strings differ only in cosmetic fields
+ * (title, description, example, enumTitles, sectionCaption, sectionDescription).
+ */
+export const isCosmeticOnlyJsonSchemaChange = (commits: Commit[], changedFilepath: string): boolean => {
+    // TODO: validate this is the right commit range
+    const oldRef = `${commits[0].sha}~`;
+    const newRef = commits[commits.length - 1].sha;
+    let oldJson: unknown;
+    let newJson: unknown;
+    try {
+        const oldContent = spawnCommandInGhWorkspace(`git show ${oldRef}:${changedFilepath}`);
+        const newContent = spawnCommandInGhWorkspace(`git show ${newRef}:${changedFilepath}`);
+
+        oldJson = JSON.parse(oldContent);
+        newJson = JSON.parse(newContent);
+    } catch {
+        console.error(
+            `Failed to get or parse JSON content for ${changedFilepath} at refs ${oldRef} and ${newRef}, maybe it is new file or deleted? Treating it as a non-cosmetic change.`,
+        );
+        return false;
+    }
+    return isCosmeticObjectChange(oldJson, newJson);
+};

package/bin/git.ts

@@ -1,4 +1,4 @@
-import { Commit, Config } from './types.js';
+import type { Commit, Config } from './types.js';
 import { spawnCommandInGhWorkspace } from './utils.js';
 
 export const GIT_FORMAT_SEPARATOR = '»¦«';
@@ -8,18 +8,44 @@ const GIT_LOG_FORMAT = ['%H', '%aN<%aE>', '%aD', '%s'].join(GIT_FORMAT_SEPARATOR
  * Gets the list of changed files between the given commits (inclusive).
  */
 export const getChangedFiles = (commits: Commit[]) => {
-    const changedFiles = spawnCommandInGhWorkspace(
+    const changedFilesString = spawnCommandInGhWorkspace(
         `git diff --name-only ${commits[0].sha}~..${commits[commits.length - 1].sha}`,
     );
 
-    return changedFiles.split('\n');
+    const changedFiles = changedFilesString.split('\n');
+    console.error(`Changed files (up to 50): ${changedFiles.slice(0, 50).join(', ')}`);
+    return changedFiles;
+};
+
+const SHA_REGEX = /^[0-9a-f]{40}$/i;
+
+/**
+ *
+ * @param shaOrCommit Supports both a SHA string or a Commit object in JSON format. Can be empty.
+ * @returns The SHA string if valid, otherwise throws an error.
+ */
+export const parseBaseCommit = (shaOrCommit: string | undefined): string | undefined => {
+    if (!shaOrCommit) return undefined;
+    let sha: string;
+    if (shaOrCommit.startsWith('{')) {
+        sha = (JSON.parse(shaOrCommit) as Commit).sha;
+    } else {
+        sha = shaOrCommit;
+    }
+    if (!SHA_REGEX.test(sha)) {
+        throw new Error(
+            `Invalid base commit SHA: "${sha}". It should be a 40-character hexadecimal string, instead got input: "${shaOrCommit}".`,
+        );
+    }
+    return sha;
 };
 
 /**
  * Gets the commits between sourceBranch and targetBranch (exclusive).
  * - If baseCommit is provided, only returns commits after the baseCommit.
  */
-export const getCommits = ({ sourceBranch, targetBranch, baseCommit: baseCommitSha }: Config): Commit[] => {
+export const getCommits = ({ sourceBranch, targetBranch, baseCommit }: Config): Commit[] => {
+    const baseCommitSha = parseBaseCommit(baseCommit);
     const commitsStrings = spawnCommandInGhWorkspace(
         `git log --pretty=format:'${GIT_LOG_FORMAT}' ${targetBranch}..${sourceBranch}`,
     ).split('\n');
@@ -29,17 +55,22 @@ export const getCommits = ({ sourceBranch, targetBranch, baseCommit: baseCommitS
     const baseCommitIndex = commits.findIndex((commit) => commit.sha === baseCommitSha);
 
     const hasBaseCommit = baseCommitIndex !== -1;
-    if (hasBaseCommit) return commits.slice(baseCommitIndex + 1);
+    if (hasBaseCommit) {
+        const commitsUpToBaseCommit = commits.slice(baseCommitIndex + 1);
+        console.error(
+            `Found base commit ${baseCommitSha} at index ${baseCommitIndex}, returning ${commitsUpToBaseCommit.length} commits after it`,
+        );
+        console.error(`Commits being returned: ${commitsUpToBaseCommit.map((c) => c.sha).join(', ')}`);
+        return commitsUpToBaseCommit;
+    }
 
+    console.error(
+        `Base commit ${baseCommitSha} not found in the commit range, returning all ${commits.length} commits`,
+    );
+    console.error(`Commits being returned: ${commits.map((c) => c.sha).join(', ')}`);
     return commits;
 };
 
-export const getCommitInfo = (commitSha: string): Commit => {
-    const commitString = spawnCommandInGhWorkspace(`git log -1 --pretty=format:'${GIT_LOG_FORMAT}' ${commitSha}`);
-    const commit = parseCommit(commitString);
-    return commit;
-};
-
 export const parseCommit = (commitString: string): Commit => {
     const splits = commitString.split(GIT_FORMAT_SEPARATOR);
     if (splits.length !== 4) {