@kamaalio/codemod-kit 0.0.33 → 0.0.34

package/dist/git/errors.d.ts

@@ -1,30 +1,30 @@
 import type { types } from '@kamaalio/kamaal';
 import type Repository from './repository.js';
-export declare class GitError extends Error {
+export declare class GitError<Tag = string> extends Error {
     readonly cause: types.Optional<unknown>;
-    readonly repository: Repository;
-    constructor(message: string, repository: Repository, options?: {
+    readonly repository: Repository<Tag>;
+    constructor(message: string, repository: Repository<Tag>, options?: {
         cause: unknown;
     });
 }
-export declare class CloneError extends GitError {
-    constructor(repository: Repository);
+export declare class CloneError<Tag = string> extends GitError<Tag> {
+    constructor(repository: Repository<Tag>);
 }
-export declare class CheckoutError extends GitError {
-    constructor(repository: Repository, branchName: string);
+export declare class CheckoutError<Tag = string> extends GitError<Tag> {
+    constructor(repository: Repository<Tag>, branchName: string);
 }
-export declare class GetMainBranchError extends GitError {
-    constructor(repository: Repository, options?: {
+export declare class GetMainBranchError<Tag = string> extends GitError<Tag> {
+    constructor(repository: Repository<Tag>, options?: {
         cause: unknown;
     });
 }
-export declare class PushError extends GitError {
-    constructor(repository: Repository, message: string, options?: {
+export declare class PushError<Tag = string> extends GitError<Tag> {
+    constructor(repository: Repository<Tag>, message: string, options?: {
         cause: unknown;
     });
 }
-export declare class RebaseError extends GitError {
-    constructor(repository: Repository, options?: {
+export declare class RebaseError<Tag = string> extends GitError<Tag> {
+    constructor(repository: Repository<Tag>, options?: {
         cause: unknown;
     });
 }

package/dist/git/index.d.ts

@@ -1,3 +1,3 @@
-export { cloneRepositories, cloneRepository } from './utils.js';
+export { cloneRepositories } from './utils.js';
 export { GitError } from './errors.js';
 export { default as Repository } from './repository.js';

package/dist/git/repository.d.ts

@@ -2,29 +2,32 @@ import { type ResultAsync, type Result } from 'neverthrow';
 import { type types } from '@kamaalio/kamaal';
 import { GitError } from './errors.js';
 import Branch from './branch.js';
-interface IRepository {
+interface IRepository<Tag> {
     name: string;
     address: string;
     path: string;
+    tags: Array<Tag> | Set<Tag>;
 }
-declare class Repository implements IRepository {
+declare class Repository<Tag = string> implements IRepository<Tag> {
     readonly name: string;
     readonly address: string;
     readonly path: string;
+    readonly tags: Array<Tag> | Set<Tag>;
     private currentBranch;
     private constructor();
-    clone: () => Promise<Result<void, GitError>>;
+    copy: (newPath: string) => Promise<Repository<Tag>>;
+    clone: () => Promise<Result<void, GitError<Tag>>>;
     commit: (message: string) => Promise<void>;
-    push: () => Promise<Result<void, GitError>>;
-    resetBranch: (workingBranchName: string) => Promise<Result<void, GitError>>;
-    updateBranchToLatestMain: (workingBranchName: string) => Promise<Result<void, GitError>>;
+    push: () => Promise<Result<void, GitError<Tag>>>;
+    resetBranch: (workingBranchName: string) => Promise<Result<void, GitError<Tag>>>;
+    updateBranchToLatestMain: (workingBranchName: string) => Promise<Result<void, GitError<Tag>>>;
     deleteBranch: (branchName: string) => ResultAsync<unknown, unknown>;
-    prepareForUpdate: (workingBranchName: string) => Promise<Result<Repository, GitError>>;
-    getMainBranch: () => Promise<Result<Branch, GitError>>;
+    prepareForUpdate: (workingBranchName: string) => Promise<Result<Repository<Tag>, GitError<Tag>>>;
+    getMainBranch: () => Promise<Result<Branch, GitError<Tag>>>;
     getRemoteName: () => Promise<types.Optional<string>>;
     checkoutBranch: (branchName: string, options?: {
         forceCreateNew: boolean;
-    }) => Promise<Result<Branch, GitError>>;
+    }) => Promise<Result<Branch, GitError<Tag>>>;
     getSelectedBranch: () => Promise<types.Optional<Branch>>;
     getRemoteBranches: () => Promise<Array<Branch>>;
     getBranches: () => Promise<Array<Branch>>;
@@ -32,10 +35,11 @@ declare class Repository implements IRepository {
     private getCurrentBranch;
     private setCurrentBranch;
     private getMainBranchName;
-    static fromAddressAndCwd: ({ address, cwd }: {
+    static fromAddressAndCwd: <Tag_1>({ address, cwd, tags, }: {
         address: string;
         cwd: string;
-    }) => types.Optional<Repository>;
+        tags: Array<Tag_1> | Set<Tag_1>;
+    }) => types.Optional<Repository<Tag_1>>;
     private static getRepoNameFromRepoAddress;
 }
 export default Repository;

package/dist/git/utils.d.ts

@@ -1,4 +1,5 @@
-import { type types } from '@kamaalio/kamaal';
 import Repository from './repository.js';
-export declare function cloneRepositories(repoAddresses: Array<string>, location: string): Promise<Array<Repository>>;
-export declare function cloneRepository(repoAddress: string, location: string): Promise<types.Optional<Repository>>;
+export declare function cloneRepositories<Tag = string>(repositories: Array<{
+    address: string;
+    tags: Array<Tag> | Set<Tag>;
+}>, location: string): Promise<Array<Repository<Tag>>>;

package/dist/github/utils.d.ts

@@ -4,8 +4,8 @@ import type { Codemod, CodemodRunnerCodemod } from '../codemods/index.js';
 export declare function makePullRequestsForCodemodResults<Tag = string, C extends Codemod = Codemod>(codemods: Array<CodemodRunnerCodemod<Tag, C>>, codemodResults: Record<string, Array<Result<{
     hasChanges: boolean;
     content: string;
-}, Error>>>, repositories: Array<Repository>): Promise<void>;
+}, Error>>>, repositories: Array<Repository<Tag>>): Promise<void>;
 export declare function makePullRequestsForCodemodResult<Tag = string, C extends Codemod = Codemod>(codemod: CodemodRunnerCodemod<Tag, C>, codemodResult: Array<Result<{
     hasChanges: boolean;
     content: string;
-}, Error>>, repositories: Array<Repository>): Promise<void>;
+}, Error>>, repositories: Array<Repository<Tag>>): Promise<void>;

package/dist/index.cjs

@@ -84,11 +84,17 @@ function getCollectionCount(collection) {
 function collectionIsEmpty(collection) {
     return 0 === getCollectionCount(collection);
 }
-function groupBy(array, key) {
-    const arrayCopy = [
+function collectionContains(collection, value) {
+    if (Array.isArray(collection)) return collection.includes(value);
+    return collection.has(value);
+}
+function shallowCopy(array) {
+    return [
         ...array
     ];
-    return arrayCopy.reduce((acc, current)=>{
+}
+function groupBy(array, key) {
+    return shallowCopy(array).reduce((acc, current)=>{
         const keyValue = String(current[key]);
         if (null == acc[keyValue]) acc[keyValue] = [
             current
@@ -97,6 +103,13 @@ function groupBy(array, key) {
         return acc;
     }, {});
 }
+function groupByFlat(array, key) {
+    return shallowCopy(array).reduce((acc, current)=>{
+        const keyValue = String(current[key]);
+        acc[keyValue] = current;
+        return acc;
+    }, {});
+}
 const external_execa_namespaceObject = require("execa");
 class GitError extends Error {
     cause;
@@ -183,12 +196,24 @@ class Repository {
     name;
     address;
     path;
+    tags;
     currentBranch;
     constructor(params){
         this.name = params.name;
         this.address = params.address;
         this.path = params.path;
+        this.tags = params.tags;
     }
+    copy = async (newPath)=>{
+        await (0, external_execa_namespaceObject.$)`rm -rf ${newPath}`;
+        await (0, external_execa_namespaceObject.$)`cp -R ${this.path} ${newPath}`;
+        return new Repository({
+            name: this.name,
+            address: this.address,
+            path: newPath,
+            tags: this.tags
+        });
+    };
     clone = async ()=>{
         const cwd = this.path.split('/').slice(0, -1).join('/');
         const exec = (0, external_execa_namespaceObject.$)({
@@ -351,13 +376,14 @@ class Repository {
         }));
         return (0, external_neverthrow_namespaceObject.ok)(defaultBranchRef.data.defaultBranchRef.name);
     };
-    static fromAddressAndCwd = ({ address, cwd })=>{
+    static fromAddressAndCwd = ({ address, cwd, tags })=>{
         const name = Repository.getRepoNameFromRepoAddress(address);
         if (null == name) return null;
         return new Repository({
             name,
             address,
-            path: external_node_path_default().resolve(cwd, name)
+            path: external_node_path_default().resolve(cwd, name),
+            tags
         });
     };
     static getRepoNameFromRepoAddress = (repoAddress)=>{
@@ -366,13 +392,13 @@ class Repository {
     };
 }
 const git_repository = Repository;
-async function cloneRepositories(repoAddresses, location) {
+async function cloneRepositories(repositories, location) {
     await (0, external_execa_namespaceObject.$)`mkdir -p ${location}`;
     const exec = (0, external_execa_namespaceObject.$)({
         cwd: location
     });
-    const dedupedRepos = dedupeRepositoriesToClone(repoAddresses, location);
-    const existingRepositories = await getExistingRepositories(exec, repoAddresses);
+    const dedupedRepos = dedupeRepositoriesToClone(repositories, location);
+    const existingRepositories = await getExistingRepositories(exec, repositories);
     const results = await Promise.all(dedupedRepos.map(cloneRepositoryInternal(existingRepositories)));
     return kamaal_namespaceObject.arrays.compactMap(results, (result, index)=>{
         const repo = dedupedRepos[index];
@@ -383,13 +409,14 @@ async function cloneRepositories(repoAddresses, location) {
         return repo;
     });
 }
-async function getExistingRepositories(exec, repoAddresses) {
+async function getExistingRepositories(exec, repositories) {
     const lsResult = await exec`ls`;
     const existingNames = new Set(lsResult.stdout.split('\n'));
-    return kamaal_namespaceObject.arrays.compactMap(repoAddresses, (address)=>{
+    return kamaal_namespaceObject.arrays.compactMap(repositories, (repo)=>{
         const repository = git_repository.fromAddressAndCwd({
-            address,
-            cwd: lsResult.cwd
+            address: repo.address,
+            cwd: lsResult.cwd,
+            tags: repo.tags
         });
         if (null == repository) return null;
         if (!existingNames.has(repository.name)) return null;
@@ -403,15 +430,16 @@ function cloneRepositoryInternal(existingRepositories) {
         return repository.clone();
     };
 }
-function dedupeRepositoriesToClone(repoAddresses, cwd) {
+function dedupeRepositoriesToClone(repositories, cwd) {
     const initialDedupeResult = {
         result: [],
         names: []
     };
-    const dedupedRepos = repoAddresses.reduce((acc, repoAddress)=>{
+    const dedupedRepos = repositories.reduce((acc, repo)=>{
         const repository = git_repository.fromAddressAndCwd({
-            address: repoAddress,
-            cwd
+            address: repo.address,
+            cwd,
+            tags: repo.tags
         });
         if (null == repository) return acc;
         if (acc.names.includes(repository.name)) return acc;
@@ -457,33 +485,22 @@ async function makePullRequest(params) {
         })`gh pr create --title ${params.title} --fill`);
 }
 async function runCodemodsOnProjects(repositoriesToClone, codemods, options) {
-    const clonedRepositories = await cloneRepositories(repositoriesToClone.map((repo)=>repo.address), options.workingDirectory);
+    const clonedRepositories = await cloneRepositories(repositoriesToClone, options.workingDirectory);
     console.log(`\u{1F5A8}\u{FE0F} cloned ${clonedRepositories.length} ${1 === clonedRepositories.length ? 'repository' : 'repositories'}`);
-    const mappingsByName = clonedRepositories.reduce((acc, repository)=>{
-        const tags = repositoriesToClone.find(({ address })=>address === repository.address)?.tags;
-        kamaal_namespaceObject.asserts.invariant(null != tags, 'Tags should be present');
-        return {
-            ...acc,
-            [repository.name]: {
-                repository,
-                tags
-            }
-        };
-    }, {});
-    const codemodResults = await runCodemodRunner(codemods, clonedRepositories, mappingsByName, options.workingDirectory);
+    const codemodResults = await runCodemodRunner(codemods, clonedRepositories, options.workingDirectory);
     if (options.pushChanges) await makePullRequestsForCodemodResults(codemods, codemodResults, clonedRepositories);
 }
-function utils_codemodTargetFiltering(mappingsByName, failedRepositoryAddressesMappedByCodemodNames) {
+function utils_codemodTargetFiltering(repositories, failedRepositoryAddressesMappedByCodemodNames) {
     return (filepath, codemod)=>{
         const projectName = filepath.split('/')[0];
         kamaal_namespaceObject.asserts.invariant(null != projectName, 'project name should be present');
-        const mapping = mappingsByName[projectName];
-        if (null == mapping) return false;
+        const repository = repositories[projectName];
+        if (null == repository) return false;
         const failedRepositoryAddressesSet = failedRepositoryAddressesMappedByCodemodNames[codemod.name];
         if (null == failedRepositoryAddressesSet || collectionIsEmpty(failedRepositoryAddressesSet)) return true;
-        return !failedRepositoryAddressesSet.has(mapping.repository.address) && (collectionIsEmpty(codemod.tags) || collectionIsEmpty(mapping.tags) || [
+        return !failedRepositoryAddressesSet.has(repository.address) && (collectionIsEmpty(codemod.tags) || collectionIsEmpty(repository.tags) || [
             ...codemod.tags
-        ].some((tag)=>mapping.tags.has(tag)));
+        ].some((tag)=>collectionContains(repository.tags, tag)));
     };
 }
 async function codemodPreCodemodRun(repositories, codemod) {
@@ -496,19 +513,50 @@ async function codemodPreCodemodRun(repositories, codemod) {
 async function codemodPostTransform(transformedContent) {
     return transformedContent;
 }
-async function runCodemodRunner(codemods, repositories, mappingsByName, workingDirectory) {
-    const rootPaths = repositories.map((repository)=>repository.path);
-    const failedRepositoryAddressesMappedByCodemodNames = {};
-    return runCodemods(codemods, workingDirectory, {
-        rootPaths,
-        hooks: {
-            preCodemodRun: async (codemod)=>{
-                failedRepositoryAddressesMappedByCodemodNames[codemod.name] = await codemodPreCodemodRun(repositories, codemod);
-            },
-            targetFiltering: utils_codemodTargetFiltering(mappingsByName, failedRepositoryAddressesMappedByCodemodNames),
-            postTransform: codemodPostTransform
-        }
-    });
+async function runCodemodRunner(codemods, repositories, workingDirectory) {
+    const codemodRepositoriesMappedByCodemodName = await prepareRepositoriesForCodemods(repositories, codemods, workingDirectory);
+    const results = Object.fromEntries(await Promise.all(codemods.map(async (codemod)=>{
+        const codemodRepositories = codemodRepositoriesMappedByCodemodName[codemod.name];
+        kamaal_namespaceObject.asserts.invariant(null != codemodRepositories, 'Codemod repositories should be present');
+        const failedRepositoryAddressesMappedByCodemodNames = {};
+        const result = await runCodemod(codemod, workingDirectory, {
+            rootPaths: codemodRepositories.map((repository)=>repository.path),
+            hooks: {
+                preCodemodRun: async (codemod)=>{
+                    failedRepositoryAddressesMappedByCodemodNames[codemod.name] = await codemodPreCodemodRun(repositories, codemod);
+                },
+                targetFiltering: utils_codemodTargetFiltering(groupByFlat(codemodRepositories, 'name'), failedRepositoryAddressesMappedByCodemodNames),
+                postTransform: codemodPostTransform
+            }
+        });
+        return [
+            codemod.name,
+            result
+        ];
+    })));
+    return results;
+}
+async function prepareRepositoriesForCodemods(repositories, codemods, workingDirectory) {
+    const reposMappedByMainBranchName = Object.fromEntries(await Promise.all(repositories.map(async (repo)=>{
+        const mainBranchResult = await repo.getMainBranch();
+        if (mainBranchResult.isErr()) throw mainBranchResult.error;
+        return [
+            mainBranchResult.value.name,
+            repo
+        ];
+    })));
+    const updatedRepositories = await Promise.all(kamaal_namespaceObject.objects.toEntries(reposMappedByMainBranchName).map(async ([mainBranchName, repo])=>{
+        const prepareResult = await repo.prepareForUpdate(mainBranchName);
+        if (prepareResult.isErr()) throw prepareResult.error;
+        return prepareResult.value;
+    }));
+    return Object.fromEntries(await Promise.all(codemods.map(async (codemod)=>{
+        const codeRepositories = await Promise.all(updatedRepositories.map((repo)=>repo.copy(external_node_path_default().resolve(workingDirectory, codemod.name, repo.name))));
+        return [
+            codemod.name,
+            codeRepositories
+        ];
+    })));
 }
 async function runCodemods(codemods, transformationPath, options) {
     const results = {};

package/dist/index.js

@@ -3,7 +3,7 @@ import promises from "node:fs/promises";
 import fast_glob from "fast-glob";
 import { ResultAsync, err, ok } from "neverthrow";
 import { Lang, parseAsync } from "@ast-grep/napi";
-import { arrays, asserts } from "@kamaalio/kamaal";
+import { arrays, asserts, objects } from "@kamaalio/kamaal";
 import { $ } from "execa";
 import zod from "zod";
 const JAVASCRIPT_EXTENSIONS = [
@@ -38,11 +38,17 @@ function getCollectionCount(collection) {
 function collectionIsEmpty(collection) {
     return 0 === getCollectionCount(collection);
 }
-function groupBy(array, key) {
-    const arrayCopy = [
+function collectionContains(collection, value) {
+    if (Array.isArray(collection)) return collection.includes(value);
+    return collection.has(value);
+}
+function shallowCopy(array) {
+    return [
         ...array
     ];
-    return arrayCopy.reduce((acc, current)=>{
+}
+function groupBy(array, key) {
+    return shallowCopy(array).reduce((acc, current)=>{
         const keyValue = String(current[key]);
         if (null == acc[keyValue]) acc[keyValue] = [
             current
@@ -51,6 +57,13 @@ function groupBy(array, key) {
         return acc;
     }, {});
 }
+function groupByFlat(array, key) {
+    return shallowCopy(array).reduce((acc, current)=>{
+        const keyValue = String(current[key]);
+        acc[keyValue] = current;
+        return acc;
+    }, {});
+}
 class GitError extends Error {
     cause;
     repository;
@@ -134,12 +147,24 @@ class Repository {
     name;
     address;
     path;
+    tags;
     currentBranch;
     constructor(params){
         this.name = params.name;
         this.address = params.address;
         this.path = params.path;
+        this.tags = params.tags;
     }
+    copy = async (newPath)=>{
+        await $`rm -rf ${newPath}`;
+        await $`cp -R ${this.path} ${newPath}`;
+        return new Repository({
+            name: this.name,
+            address: this.address,
+            path: newPath,
+            tags: this.tags
+        });
+    };
     clone = async ()=>{
         const cwd = this.path.split('/').slice(0, -1).join('/');
         const exec = $({
@@ -302,13 +327,14 @@ class Repository {
         }));
         return ok(defaultBranchRef.data.defaultBranchRef.name);
     };
-    static fromAddressAndCwd = ({ address, cwd })=>{
+    static fromAddressAndCwd = ({ address, cwd, tags })=>{
         const name = Repository.getRepoNameFromRepoAddress(address);
         if (null == name) return null;
         return new Repository({
             name,
             address,
-            path: node_path.resolve(cwd, name)
+            path: node_path.resolve(cwd, name),
+            tags
         });
     };
     static getRepoNameFromRepoAddress = (repoAddress)=>{
@@ -317,13 +343,13 @@ class Repository {
     };
 }
 const git_repository = Repository;
-async function cloneRepositories(repoAddresses, location) {
+async function cloneRepositories(repositories, location) {
     await $`mkdir -p ${location}`;
     const exec = $({
         cwd: location
     });
-    const dedupedRepos = dedupeRepositoriesToClone(repoAddresses, location);
-    const existingRepositories = await getExistingRepositories(exec, repoAddresses);
+    const dedupedRepos = dedupeRepositoriesToClone(repositories, location);
+    const existingRepositories = await getExistingRepositories(exec, repositories);
     const results = await Promise.all(dedupedRepos.map(cloneRepositoryInternal(existingRepositories)));
     return arrays.compactMap(results, (result, index)=>{
         const repo = dedupedRepos[index];
@@ -334,13 +360,14 @@ async function cloneRepositories(repoAddresses, location) {
         return repo;
     });
 }
-async function getExistingRepositories(exec, repoAddresses) {
+async function getExistingRepositories(exec, repositories) {
     const lsResult = await exec`ls`;
     const existingNames = new Set(lsResult.stdout.split('\n'));
-    return arrays.compactMap(repoAddresses, (address)=>{
+    return arrays.compactMap(repositories, (repo)=>{
         const repository = git_repository.fromAddressAndCwd({
-            address,
-            cwd: lsResult.cwd
+            address: repo.address,
+            cwd: lsResult.cwd,
+            tags: repo.tags
         });
         if (null == repository) return null;
         if (!existingNames.has(repository.name)) return null;
@@ -354,15 +381,16 @@ function cloneRepositoryInternal(existingRepositories) {
         return repository.clone();
     };
 }
-function dedupeRepositoriesToClone(repoAddresses, cwd) {
+function dedupeRepositoriesToClone(repositories, cwd) {
     const initialDedupeResult = {
         result: [],
         names: []
     };
-    const dedupedRepos = repoAddresses.reduce((acc, repoAddress)=>{
+    const dedupedRepos = repositories.reduce((acc, repo)=>{
         const repository = git_repository.fromAddressAndCwd({
-            address: repoAddress,
-            cwd
+            address: repo.address,
+            cwd,
+            tags: repo.tags
         });
         if (null == repository) return acc;
         if (acc.names.includes(repository.name)) return acc;
@@ -408,33 +436,22 @@ async function makePullRequest(params) {
         })`gh pr create --title ${params.title} --fill`);
 }
 async function runCodemodsOnProjects(repositoriesToClone, codemods, options) {
-    const clonedRepositories = await cloneRepositories(repositoriesToClone.map((repo)=>repo.address), options.workingDirectory);
+    const clonedRepositories = await cloneRepositories(repositoriesToClone, options.workingDirectory);
     console.log(`\u{1F5A8}\u{FE0F} cloned ${clonedRepositories.length} ${1 === clonedRepositories.length ? 'repository' : 'repositories'}`);
-    const mappingsByName = clonedRepositories.reduce((acc, repository)=>{
-        const tags = repositoriesToClone.find(({ address })=>address === repository.address)?.tags;
-        asserts.invariant(null != tags, 'Tags should be present');
-        return {
-            ...acc,
-            [repository.name]: {
-                repository,
-                tags
-            }
-        };
-    }, {});
-    const codemodResults = await runCodemodRunner(codemods, clonedRepositories, mappingsByName, options.workingDirectory);
+    const codemodResults = await runCodemodRunner(codemods, clonedRepositories, options.workingDirectory);
     if (options.pushChanges) await makePullRequestsForCodemodResults(codemods, codemodResults, clonedRepositories);
 }
-function utils_codemodTargetFiltering(mappingsByName, failedRepositoryAddressesMappedByCodemodNames) {
+function utils_codemodTargetFiltering(repositories, failedRepositoryAddressesMappedByCodemodNames) {
     return (filepath, codemod)=>{
         const projectName = filepath.split('/')[0];
         asserts.invariant(null != projectName, 'project name should be present');
-        const mapping = mappingsByName[projectName];
-        if (null == mapping) return false;
+        const repository = repositories[projectName];
+        if (null == repository) return false;
         const failedRepositoryAddressesSet = failedRepositoryAddressesMappedByCodemodNames[codemod.name];
         if (null == failedRepositoryAddressesSet || collectionIsEmpty(failedRepositoryAddressesSet)) return true;
-        return !failedRepositoryAddressesSet.has(mapping.repository.address) && (collectionIsEmpty(codemod.tags) || collectionIsEmpty(mapping.tags) || [
+        return !failedRepositoryAddressesSet.has(repository.address) && (collectionIsEmpty(codemod.tags) || collectionIsEmpty(repository.tags) || [
             ...codemod.tags
-        ].some((tag)=>mapping.tags.has(tag)));
+        ].some((tag)=>collectionContains(repository.tags, tag)));
     };
 }
 async function codemodPreCodemodRun(repositories, codemod) {
@@ -447,19 +464,50 @@ async function codemodPreCodemodRun(repositories, codemod) {
 async function codemodPostTransform(transformedContent) {
     return transformedContent;
 }
-async function runCodemodRunner(codemods, repositories, mappingsByName, workingDirectory) {
-    const rootPaths = repositories.map((repository)=>repository.path);
-    const failedRepositoryAddressesMappedByCodemodNames = {};
-    return runCodemods(codemods, workingDirectory, {
-        rootPaths,
-        hooks: {
-            preCodemodRun: async (codemod)=>{
-                failedRepositoryAddressesMappedByCodemodNames[codemod.name] = await codemodPreCodemodRun(repositories, codemod);
-            },
-            targetFiltering: utils_codemodTargetFiltering(mappingsByName, failedRepositoryAddressesMappedByCodemodNames),
-            postTransform: codemodPostTransform
-        }
-    });
+async function runCodemodRunner(codemods, repositories, workingDirectory) {
+    const codemodRepositoriesMappedByCodemodName = await prepareRepositoriesForCodemods(repositories, codemods, workingDirectory);
+    const results = Object.fromEntries(await Promise.all(codemods.map(async (codemod)=>{
+        const codemodRepositories = codemodRepositoriesMappedByCodemodName[codemod.name];
+        asserts.invariant(null != codemodRepositories, 'Codemod repositories should be present');
+        const failedRepositoryAddressesMappedByCodemodNames = {};
+        const result = await runCodemod(codemod, workingDirectory, {
+            rootPaths: codemodRepositories.map((repository)=>repository.path),
+            hooks: {
+                preCodemodRun: async (codemod)=>{
+                    failedRepositoryAddressesMappedByCodemodNames[codemod.name] = await codemodPreCodemodRun(repositories, codemod);
+                },
+                targetFiltering: utils_codemodTargetFiltering(groupByFlat(codemodRepositories, 'name'), failedRepositoryAddressesMappedByCodemodNames),
+                postTransform: codemodPostTransform
+            }
+        });
+        return [
+            codemod.name,
+            result
+        ];
+    })));
+    return results;
+}
+async function prepareRepositoriesForCodemods(repositories, codemods, workingDirectory) {
+    const reposMappedByMainBranchName = Object.fromEntries(await Promise.all(repositories.map(async (repo)=>{
+        const mainBranchResult = await repo.getMainBranch();
+        if (mainBranchResult.isErr()) throw mainBranchResult.error;
+        return [
+            mainBranchResult.value.name,
+            repo
+        ];
+    })));
+    const updatedRepositories = await Promise.all(objects.toEntries(reposMappedByMainBranchName).map(async ([mainBranchName, repo])=>{
+        const prepareResult = await repo.prepareForUpdate(mainBranchName);
+        if (prepareResult.isErr()) throw prepareResult.error;
+        return prepareResult.value;
+    }));
+    return Object.fromEntries(await Promise.all(codemods.map(async (codemod)=>{
+        const codeRepositories = await Promise.all(updatedRepositories.map((repo)=>repo.copy(node_path.resolve(workingDirectory, codemod.name, repo.name))));
+        return [
+            codemod.name,
+            codeRepositories
+        ];
+    })));
 }
 async function runCodemods(codemods, transformationPath, options) {
     const results = {};

package/dist/utils/arrays.d.ts

@@ -1 +1,2 @@
 export declare function groupBy<T, K extends keyof T>(array: Array<T>, key: K): Record<string, Array<T>>;
+export declare function groupByFlat<T, K extends keyof T>(array: Array<T>, key: K): Record<string, T>;

package/dist/utils/collections.d.ts

@@ -1,3 +1,4 @@
-type AnyCollection = Array<unknown> | Set<unknown>;
+type AnyCollection<Value = unknown> = Array<Value> | Set<Value>;
 export declare function collectionIsEmpty<T extends AnyCollection>(collection: T): boolean;
+export declare function collectionContains<Value, T extends AnyCollection<Value>>(collection: T, value: Value): boolean;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamaalio/codemod-kit",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "type": "module",
   "author": "Kamaal Farah",
   "license": "MIT",