@kamaalio/codemod-kit 0.0.30 → 0.0.32

package/dist/codemods/index.d.ts

@@ -1,2 +1,2 @@
-export { runCodemods, runCodemod, commitEditModifications, findAndReplace, findAndReplaceEdits, findAndReplaceConfig, findAndReplaceConfigModifications, traverseUp, } from './utils.js';
-export type { Codemod, Modifications, FindAndReplaceConfig, RunCodemodOkResult, RunCodemodResult } from './types.js';
+export { runCodemods, runCodemod, commitEditModifications, findAndReplace, findAndReplaceEdits, findAndReplaceConfig, findAndReplaceConfigModifications, traverseUp, runCodemodsOnProjects, } from './utils.js';
+export type { Codemod, Modifications, FindAndReplaceConfig, RunCodemodOkResult, RunCodemodResult, CodemodRunnerCodemod, RepositoryToClone, } from './types.js';

package/dist/codemods/types.d.ts

@@ -19,6 +19,14 @@ export type Codemod = {
         results: Array<RunCodemodOkResult>;
     }) => Promise<void>;
 };
+export type CodemodRunnerCodemod<Tag = string, C extends Codemod = Codemod> = C & {
+    tags: Set<Tag> | Array<Tag>;
+    commitMessage: string;
+};
+export type RepositoryToClone<Tag = string> = {
+    address: string;
+    tags: Set<Tag>;
+};
 export type ModificationsReport = {
     changesApplied: number;
 };

package/dist/codemods/utils.d.ts

@@ -2,20 +2,24 @@ import { type Edit, type SgRoot, type SgNode } from '@ast-grep/napi';
 import type { Kinds, TypesMap } from '@ast-grep/napi/types/staticTypes.js';
 import type { NapiLang } from '@ast-grep/napi/types/lang.js';
 import { type types } from '@kamaalio/kamaal';
-import type { Codemod, FindAndReplaceConfig, Modifications, RunCodemodResult } from './types.js';
-type RunCodemodHooks<C extends Codemod> = {
+import type { Codemod, CodemodRunnerCodemod, FindAndReplaceConfig, Modifications, RepositoryToClone, RunCodemodResult } from './types.js';
+type RunCodemodHooks<C extends Codemod = Codemod> = {
     targetFiltering?: (filepath: string, codemod: C) => boolean;
     preCodemodRun?: (codemod: C) => Promise<void>;
     postTransform?: (transformedContent: string, codemod: C) => Promise<string>;
 };
-type RunCodemodOptions<C extends Codemod> = {
+type RunCodemodOptions<C extends Codemod = Codemod> = {
     hooks?: RunCodemodHooks<C>;
     log?: boolean;
     dry?: boolean;
     rootPaths?: Array<string>;
 };
-export declare function runCodemods<C extends Codemod>(codemods: Array<C>, transformationPath: string, options?: RunCodemodOptions<C>): Promise<Record<string, Array<RunCodemodResult>>>;
-export declare function runCodemod<C extends Codemod>(codemod: C, transformationPath: string, options?: RunCodemodOptions<C>): Promise<Array<RunCodemodResult>>;
+export declare function runCodemodsOnProjects<Tag = string, C extends Codemod = Codemod>(repositoriesToClone: Array<RepositoryToClone<Tag>>, codemods: Array<CodemodRunnerCodemod<Tag, C>>, options: {
+    workingDirectory: string;
+    pushChanges: boolean;
+}): Promise<void>;
+export declare function runCodemods<C extends Codemod = Codemod>(codemods: Array<C>, transformationPath: string, options?: RunCodemodOptions<C>): Promise<Record<string, Array<RunCodemodResult>>>;
+export declare function runCodemod<C extends Codemod = Codemod>(codemod: C, transformationPath: string, options?: RunCodemodOptions<C>): Promise<Array<RunCodemodResult>>;
 export declare function traverseUp(node: SgNode<TypesMap, Kinds<TypesMap>>, until: (node: SgNode<TypesMap, Kinds<TypesMap>>) => boolean): types.Optional<SgNode<TypesMap, Kinds<TypesMap>>>;
 export declare function findAndReplaceConfigModifications(modifications: Modifications, config: Array<FindAndReplaceConfig>): Promise<Modifications>;
 export declare function findAndReplaceConfig(content: SgRoot<TypesMap>, lang: NapiLang, config: Array<FindAndReplaceConfig>): Promise<string>;

package/dist/git/branch.d.ts

@@ -0,0 +1,10 @@
+interface IBranch {
+    isSelected: boolean;
+    name: string;
+}
+declare class Branch implements IBranch {
+    readonly isSelected: boolean;
+    readonly name: string;
+    constructor(params: IBranch);
+}
+export default Branch;

package/dist/git/errors.d.ts

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

package/dist/git/index.d.ts

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

package/dist/git/repository.d.ts

@@ -0,0 +1,41 @@
+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 {
+    name: string;
+    address: string;
+    path: string;
+}
+declare class Repository implements IRepository {
+    readonly name: string;
+    readonly address: string;
+    readonly path: string;
+    private currentBranch;
+    private constructor();
+    clone: () => Promise<Result<void, GitError>>;
+    commit: (message: string) => Promise<void>;
+    push: () => Promise<Result<void, GitError>>;
+    resetBranch: (workingBranchName: string) => Promise<Result<void, GitError>>;
+    updateBranchToLatestMain: (workingBranchName: string) => Promise<Result<void, GitError>>;
+    deleteBranch: (branchName: string) => ResultAsync<unknown, unknown>;
+    prepareForUpdate: (workingBranchName: string) => Promise<Result<Repository, GitError>>;
+    getMainBranch: () => Promise<Result<Branch, GitError>>;
+    getRemoteName: () => Promise<types.Optional<string>>;
+    checkoutBranch: (branchName: string, options?: {
+        forceCreateNew: boolean;
+    }) => Promise<Result<Branch, GitError>>;
+    getSelectedBranch: () => Promise<types.Optional<Branch>>;
+    getRemoteBranches: () => Promise<Array<Branch>>;
+    getBranches: () => Promise<Array<Branch>>;
+    private get exec();
+    private getCurrentBranch;
+    private setCurrentBranch;
+    private getMainBranchName;
+    static fromAddressAndCwd: ({ address, cwd }: {
+        address: string;
+        cwd: string;
+    }) => types.Optional<Repository>;
+    private static getRepoNameFromRepoAddress;
+}
+export default Repository;

package/dist/git/schemas.d.ts

@@ -0,0 +1,18 @@
+import z from 'zod';
+export declare const DefaultBranchRefSchema: z.ZodObject<{
+    defaultBranchRef: z.ZodObject<{
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    defaultBranchRef: {
+        name: string;
+    };
+}, {
+    defaultBranchRef: {
+        name: string;
+    };
+}>;

package/dist/git/utils.d.ts

@@ -0,0 +1,4 @@
+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>>;

package/dist/github/index.d.ts

@@ -0,0 +1 @@
+export { makePullRequestsForCodemodResults, makePullRequestsForCodemodResult } from './utils.js';

package/dist/github/utils.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from 'neverthrow';
+import type { Repository } from '../git/index.js';
+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>;
+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>;

package/dist/index.cjs

@@ -33,6 +33,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    traverseUp: ()=>traverseUp,
     findAndReplace: ()=>findAndReplace,
     findAndReplaceConfig: ()=>findAndReplaceConfig,
     commitEditModifications: ()=>commitEditModifications,
@@ -40,7 +41,7 @@ __webpack_require__.d(__webpack_exports__, {
     findAndReplaceConfigModifications: ()=>findAndReplaceConfigModifications,
     findAndReplaceEdits: ()=>findAndReplaceEdits,
     runCodemods: ()=>runCodemods,
-    traverseUp: ()=>traverseUp
+    runCodemodsOnProjects: ()=>runCodemodsOnProjects
 });
 const external_node_path_namespaceObject = require("node:path");
 var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
@@ -96,6 +97,419 @@ function groupBy(array, key) {
         return acc;
     }, {});
 }
+const external_execa_namespaceObject = require("execa");
+class GitError extends Error {
+    cause;
+    repository;
+    constructor(message, repository, options){
+        super(message);
+        this.repository = repository;
+        this.cause = options?.cause;
+    }
+}
+class CloneError extends GitError {
+    constructor(repository){
+        super(`Git clone failed for ${repository.address}`, repository);
+    }
+}
+class CheckoutError extends GitError {
+    constructor(repository, branchName){
+        super(`Git checkout failed for ${repository.address}, couldn't checkout to ${branchName}`, repository);
+    }
+}
+class GetMainBranchError extends GitError {
+    constructor(repository, options){
+        super(`Failed to get main branch for ${repository.address}`, repository, options);
+    }
+}
+class PushError extends GitError {
+    constructor(repository, message, options){
+        super(`Git push failed for ${repository.address}; message: ${message}`, repository, options);
+    }
+}
+class RebaseError extends GitError {
+    constructor(repository, options){
+        super(`Git rebase failed for ${repository.address}`, repository, options);
+    }
+}
+class Branch {
+    isSelected;
+    name;
+    constructor(params){
+        this.name = params.name;
+        this.isSelected = params.isSelected;
+    }
+}
+const git_branch = Branch;
+const external_zod_namespaceObject = require("zod");
+var external_zod_default = /*#__PURE__*/ __webpack_require__.n(external_zod_namespaceObject);
+const DefaultBranchRefSchema = external_zod_default().object({
+    defaultBranchRef: external_zod_default().object({
+        name: external_zod_default().string().nonempty()
+    })
+});
+function tryCatch(callback) {
+    try {
+        return (0, external_neverthrow_namespaceObject.ok)(callback());
+    } catch (error) {
+        return (0, external_neverthrow_namespaceObject.err)(error);
+    }
+}
+function tryCatchAsync(callback) {
+    return external_neverthrow_namespaceObject.ResultAsync.fromPromise(callback(), (e)=>e);
+}
+function groupResults(results) {
+    return results.reduce((acc, result)=>{
+        if (result.isErr()) return {
+            ...acc,
+            failure: [
+                ...acc.failure,
+                result.error
+            ]
+        };
+        return {
+            ...acc,
+            success: [
+                ...acc.success,
+                result.value
+            ]
+        };
+    }, {
+        success: [],
+        failure: []
+    });
+}
+class Repository {
+    name;
+    address;
+    path;
+    currentBranch;
+    constructor(params){
+        this.name = params.name;
+        this.address = params.address;
+        this.path = params.path;
+    }
+    clone = async ()=>{
+        const cwd = this.path.split('/').slice(0, -1).join('/');
+        const exec = (0, external_execa_namespaceObject.$)({
+            cwd
+        });
+        const cloneResult = await exec`git clone ${this.address}`;
+        if (null != cloneResult.code && '0' !== cloneResult.code) return (0, external_neverthrow_namespaceObject.err)(new CloneError(this));
+        return (0, external_neverthrow_namespaceObject.ok)();
+    };
+    commit = async (message)=>{
+        await this.exec`git add .`;
+        await tryCatchAsync(()=>this.exec`git commit -m ${message} --no-verify`);
+    };
+    push = async ()=>{
+        const [remoteName, currentBranch, mainBranchNameResult] = await Promise.all([
+            this.getRemoteName(),
+            this.getCurrentBranch(),
+            this.getMainBranchName()
+        ]);
+        if (null == remoteName || null == currentBranch) return (0, external_neverthrow_namespaceObject.err)(new PushError(this, 'Failed to find remote name'));
+        if (mainBranchNameResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(mainBranchNameResult.error);
+        if (mainBranchNameResult.value === currentBranch.name) return (0, external_neverthrow_namespaceObject.err)(new PushError(this, "Can't push to main branch"));
+        await this.exec`git add .`;
+        await this.exec`git push --force --no-verify --set-upstream ${remoteName} ${currentBranch.name}`;
+        return (0, external_neverthrow_namespaceObject.ok)();
+    };
+    resetBranch = async (workingBranchName)=>{
+        await this.exec`git add .`;
+        await this.exec`git reset --hard`;
+        await this.exec`git fetch`;
+        return this.updateBranchToLatestMain(workingBranchName);
+    };
+    updateBranchToLatestMain = async (workingBranchName)=>{
+        const [remoteName, mainBranchNameResult] = await Promise.all([
+            this.getRemoteName(),
+            this.getMainBranchName()
+        ]);
+        if (mainBranchNameResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(new RebaseError(this, {
+            cause: mainBranchNameResult.error
+        }));
+        if (null == remoteName) return (0, external_neverthrow_namespaceObject.err)(new RebaseError(this));
+        const remoteBranches = await this.getRemoteBranches();
+        const existsInRemote = remoteBranches.some((branch)=>branch.name === workingBranchName);
+        const checkoutWorkingBranchResult = await this.checkoutBranch(workingBranchName);
+        if (checkoutWorkingBranchResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(checkoutWorkingBranchResult.error);
+        const rebaseResult = await tryCatchAsync(()=>this.exec`git rebase ${remoteName}/${mainBranchNameResult.value}`);
+        if (rebaseResult.isErr() || !existsInRemote) {
+            if (workingBranchName === mainBranchNameResult.value) return (0, external_neverthrow_namespaceObject.err)(new GitError('Checked out branch is main branch', this));
+            const checkoutResult = await this.checkoutBranch(mainBranchNameResult.value);
+            if (checkoutResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(checkoutResult.error);
+            await this.deleteBranch(workingBranchName);
+            const checkoutWorkingBranchResult = await this.checkoutBranch(workingBranchName, {
+                forceCreateNew: true
+            });
+            if (checkoutWorkingBranchResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(checkoutWorkingBranchResult.error);
+            const currentBranch = await this.getCurrentBranch();
+            if (null == currentBranch) return (0, external_neverthrow_namespaceObject.err)(new GitError('Failed to find current branch', this));
+            if (currentBranch.name === mainBranchNameResult.value) return (0, external_neverthrow_namespaceObject.err)(new GitError('Checked out branch is main branch', this));
+        }
+        return (0, external_neverthrow_namespaceObject.ok)();
+    };
+    deleteBranch = (branchName)=>tryCatchAsync(()=>this.exec`git branch -D ${branchName}`);
+    prepareForUpdate = async (workingBranchName)=>{
+        const checkoutBranchResult = await this.checkoutBranch(workingBranchName);
+        if (checkoutBranchResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(checkoutBranchResult.error);
+        const resetBranchResult = await this.resetBranch(workingBranchName);
+        if (resetBranchResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(resetBranchResult.error);
+        return (0, external_neverthrow_namespaceObject.ok)(this);
+    };
+    getMainBranch = async ()=>{
+        const [branches, mainBranchNameResult] = await Promise.all([
+            this.getBranches(),
+            this.getMainBranchName()
+        ]);
+        if (mainBranchNameResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(mainBranchNameResult.error);
+        const mainBranch = branches.find((branch)=>branch.name === mainBranchNameResult.value);
+        if (null == mainBranch) return (0, external_neverthrow_namespaceObject.err)(new GetMainBranchError(this));
+        return (0, external_neverthrow_namespaceObject.ok)(mainBranch);
+    };
+    getRemoteName = async ()=>{
+        const remoteResult = await this.exec`git remote`;
+        return remoteResult.stdout.split('\n')[0];
+    };
+    checkoutBranch = async (branchName, options)=>{
+        const currentBranch = await this.getCurrentBranch();
+        const forceCreateNew = options?.forceCreateNew ?? false;
+        if (null != currentBranch && currentBranch.name === branchName && !forceCreateNew) return (0, external_neverthrow_namespaceObject.ok)(currentBranch);
+        const branches = await this.getBranches();
+        const existingBranch = branches.find((branch)=>branch.name === branchName);
+        if (null != existingBranch && !forceCreateNew) {
+            const checkoutResult = await this.exec`git checkout ${branchName}`;
+            if (null != checkoutResult.code && '0' !== checkoutResult.code) return (0, external_neverthrow_namespaceObject.err)(new CheckoutError(this, branchName));
+            return (0, external_neverthrow_namespaceObject.ok)(existingBranch);
+        }
+        const checkoutResult = await this.exec`git checkout -b ${branchName}`;
+        if (null != checkoutResult.code && '0' !== checkoutResult.code) return (0, external_neverthrow_namespaceObject.err)(new CheckoutError(this, branchName));
+        const branch = new git_branch({
+            name: branchName,
+            isSelected: true
+        });
+        this.setCurrentBranch(branch);
+        return (0, external_neverthrow_namespaceObject.ok)(branch);
+    };
+    getSelectedBranch = async ()=>{
+        const currentBranch = await this.getCurrentBranch();
+        if (null != currentBranch) return currentBranch;
+        const branches = await this.getBranches();
+        const branch = branches.find((branch)=>branch.isSelected);
+        if (null == branch) return null;
+        this.setCurrentBranch(branch);
+        return branch;
+    };
+    getRemoteBranches = async ()=>{
+        const remoteHeadsResult = await this.exec`git ls-remote --heads`;
+        return kamaal_namespaceObject.arrays.compactMap(remoteHeadsResult.stdout.split('\n'), (line)=>{
+            const isValid = line.includes('refs/heads/');
+            if (!isValid) return null;
+            const name = line.trim().split('refs/heads/')[1];
+            if (!name) return null;
+            return new git_branch({
+                name,
+                isSelected: false
+            });
+        });
+    };
+    getBranches = async ()=>{
+        const branchResult = await this.exec`git branch`;
+        return branchResult.stdout.split('\n').map((branch)=>{
+            const name = branch.split('*').join('').trim();
+            const isSelected = branch.startsWith('*');
+            return new git_branch({
+                name,
+                isSelected
+            });
+        });
+    };
+    get exec() {
+        return (0, external_execa_namespaceObject.$)({
+            cwd: this.path
+        });
+    }
+    getCurrentBranch = async ()=>{
+        if (null != this.currentBranch) return this.currentBranch;
+        const branches = await this.getBranches();
+        return branches.find((branch)=>branch.isSelected);
+    };
+    setCurrentBranch = (branch)=>{
+        this.currentBranch = branch;
+    };
+    getMainBranchName = async ()=>{
+        const rawDefaultBranchRefResult = await this.exec`gh repo view --json defaultBranchRef`;
+        if (null != rawDefaultBranchRefResult.code && '0' !== rawDefaultBranchRefResult.code) return (0, external_neverthrow_namespaceObject.err)(new GetMainBranchError(this));
+        const parsedStdoutResult = tryCatch(()=>JSON.parse(rawDefaultBranchRefResult.stdout)).mapErr((e)=>new GetMainBranchError(this, {
+                cause: e
+            }));
+        if (parsedStdoutResult.isErr()) return (0, external_neverthrow_namespaceObject.err)(parsedStdoutResult.error);
+        const defaultBranchRef = await DefaultBranchRefSchema.safeParseAsync(parsedStdoutResult.value);
+        if (defaultBranchRef.error) return (0, external_neverthrow_namespaceObject.err)(new GetMainBranchError(this, {
+            cause: defaultBranchRef.error
+        }));
+        return (0, external_neverthrow_namespaceObject.ok)(defaultBranchRef.data.defaultBranchRef.name);
+    };
+    static fromAddressAndCwd = ({ address, cwd })=>{
+        const name = Repository.getRepoNameFromRepoAddress(address);
+        if (null == name) return null;
+        return new Repository({
+            name,
+            address,
+            path: external_node_path_default().resolve(cwd, name)
+        });
+    };
+    static getRepoNameFromRepoAddress = (repoAddress)=>{
+        const repoAddressComponents = repoAddress.split('/');
+        return repoAddressComponents[repoAddressComponents.length - 1]?.split('.').slice(0, -1).join('.');
+    };
+}
+const git_repository = Repository;
+async function cloneRepositories(repoAddresses, 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 results = await Promise.all(dedupedRepos.map(cloneRepositoryInternal(existingRepositories)));
+    return kamaal_namespaceObject.arrays.compactMap(results, (result, index)=>{
+        const repo = dedupedRepos[index];
+        if (result.isErr()) {
+            console.error(result.error.message);
+            return null;
+        }
+        return repo;
+    });
+}
+async function getExistingRepositories(exec, repoAddresses) {
+    const lsResult = await exec`ls`;
+    const existingNames = new Set(lsResult.stdout.split('\n'));
+    return kamaal_namespaceObject.arrays.compactMap(repoAddresses, (address)=>{
+        const repository = git_repository.fromAddressAndCwd({
+            address,
+            cwd: lsResult.cwd
+        });
+        if (null == repository) return null;
+        if (!existingNames.has(repository.name)) return null;
+        return repository;
+    });
+}
+function cloneRepositoryInternal(existingRepositories) {
+    const existingRepositoryAddresses = new Set(existingRepositories.map((repo)=>repo.address));
+    return async (repository)=>{
+        if (existingRepositoryAddresses.has(repository.address)) return (0, external_neverthrow_namespaceObject.ok)();
+        return repository.clone();
+    };
+}
+function dedupeRepositoriesToClone(repoAddresses, cwd) {
+    const initialDedupeResult = {
+        result: [],
+        names: []
+    };
+    const dedupedRepos = repoAddresses.reduce((acc, repoAddress)=>{
+        const repository = git_repository.fromAddressAndCwd({
+            address: repoAddress,
+            cwd
+        });
+        if (null == repository) return acc;
+        if (acc.names.includes(repository.name)) return acc;
+        return {
+            result: [
+                ...acc.result,
+                repository
+            ],
+            names: [
+                ...acc.names,
+                repository.name
+            ]
+        };
+    }, initialDedupeResult).result;
+    return dedupedRepos;
+}
+async function makePullRequestsForCodemodResults(codemods, codemodResults, repositories) {
+    for (const [codemodName, codemodResult] of Object.entries(codemodResults)){
+        const codemod = codemods.find((c)=>c.name === codemodName);
+        if (null == codemod) throw new Error('Invariant found codemod should be present');
+        await makePullRequestsForCodemodResult(codemod, codemodResult, repositories);
+    }
+}
+async function makePullRequestsForCodemodResult(codemod, codemodResult, repositories) {
+    const { success } = groupResults(codemodResult);
+    const hasChanges = success.some((result)=>result.hasChanges);
+    if (!hasChanges) return void console.log(`\u{1F438} nothing transformed for '${codemod.name}'`);
+    await Promise.all(repositories.map(async (repository)=>{
+        await repository.commit(codemod.commitMessage);
+        const pushResult = await repository.push();
+        if (pushResult.isErr()) return void console.error(`\u{274C} Failed to push changes`, pushResult.error.message);
+        const pullRequestResult = await makePullRequest({
+            workingDirectory: repository.path,
+            title: codemod.commitMessage
+        });
+        if (pullRequestResult.isErr()) return void console.error(`\u{2705} already pushed transformation for`, repository.address);
+        console.log(`\u{2705} pull request created`, pullRequestResult.value.stdout);
+    }));
+}
+async function makePullRequest(params) {
+    return tryCatchAsync(()=>(0, external_execa_namespaceObject.$)({
+            cwd: params.workingDirectory
+        })`gh pr create --title ${params.title} --fill`);
+}
+async function runCodemodsOnProjects(repositoriesToClone, codemods, options) {
+    const clonedRepositories = await cloneRepositories(repositoriesToClone.map((repo)=>repo.address), 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);
+    if (options.pushChanges) await makePullRequestsForCodemodResults(codemods, codemodResults, clonedRepositories);
+}
+function codemodTargetFiltering(mappingsByName, 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 failedRepositoryAddressesSet = failedRepositoryAddressesMappedByCodemodNames[codemod.name];
+        if (null == failedRepositoryAddressesSet || collectionIsEmpty(failedRepositoryAddressesSet)) return true;
+        return !failedRepositoryAddressesSet.has(mapping.repository.address) && (collectionIsEmpty(codemod.tags) || collectionIsEmpty(mapping.tags) || [
+            ...codemod.tags
+        ].some((tag)=>mapping.tags.has(tag)));
+    };
+}
+async function codemodPreCodemodRun(repositories, codemod) {
+    const preparationResults = await Promise.all(repositories.map((repo)=>repo.prepareForUpdate(codemod.name)));
+    const { failure: preparationFailures } = groupResults(preparationResults);
+    const failedRepositoryAddresses = preparationFailures.map((failure)=>failure.repository.address);
+    if (preparationFailures.length > 0) console.error(`\u{274C} failed to prepare [${failedRepositoryAddresses.join(', ')}] for '${codemod.name}'`);
+    return new Set(failedRepositoryAddresses);
+}
+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: codemodTargetFiltering(mappingsByName, failedRepositoryAddressesMappedByCodemodNames),
+            postTransform: codemodPostTransform
+        }
+    });
+}
 async function runCodemods(codemods, transformationPath, options) {
     const results = {};
     for (const codemod of codemods)results[codemod.name] = await runCodemod(codemod, transformationPath, options);
@@ -139,7 +553,7 @@ async function runCodemod(codemod, transformationPath, options) {
                 hasChanges,
                 content: modifiedContent,
                 fullPath,
-                root: filepath.split('/')[0]
+                root: external_node_path_default().resolve(transformationPath, filepath.split('/')[0])
             });
         } catch (error) {
             if (enableLogging) console.error(`\u{274C} '${codemod.name}' failed to parse file`, filepath, error);
@@ -309,6 +723,7 @@ exports.findAndReplaceConfigModifications = __webpack_exports__.findAndReplaceCo
 exports.findAndReplaceEdits = __webpack_exports__.findAndReplaceEdits;
 exports.runCodemod = __webpack_exports__.runCodemod;
 exports.runCodemods = __webpack_exports__.runCodemods;
+exports.runCodemodsOnProjects = __webpack_exports__.runCodemodsOnProjects;
 exports.traverseUp = __webpack_exports__.traverseUp;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "commitEditModifications",
@@ -318,6 +733,7 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "findAndReplaceEdits",
     "runCodemod",
     "runCodemods",
+    "runCodemodsOnProjects",
     "traverseUp"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {

package/dist/index.d.ts

@@ -1 +1 @@
-export { runCodemods, runCodemod, commitEditModifications, findAndReplace, findAndReplaceEdits, findAndReplaceConfig, findAndReplaceConfigModifications, traverseUp, type Codemod, type Modifications, type FindAndReplaceConfig, type RunCodemodOkResult, type RunCodemodResult, } from './codemods/index.js';
+export { runCodemods, runCodemod, commitEditModifications, findAndReplace, findAndReplaceEdits, findAndReplaceConfig, findAndReplaceConfigModifications, traverseUp, runCodemodsOnProjects, type Codemod, type Modifications, type FindAndReplaceConfig, type RunCodemodOkResult, type RunCodemodResult, type CodemodRunnerCodemod, type RepositoryToClone, } from './codemods/index.js';

package/dist/index.js

@@ -1,9 +1,11 @@
 import node_path from "node:path";
 import promises from "node:fs/promises";
 import fast_glob from "fast-glob";
-import { err, ok } from "neverthrow";
+import { ResultAsync, err, ok } from "neverthrow";
 import { Lang, parseAsync } from "@ast-grep/napi";
-import { arrays } from "@kamaalio/kamaal";
+import { arrays, asserts } from "@kamaalio/kamaal";
+import { $ } from "execa";
+import zod from "zod";
 const JAVASCRIPT_EXTENSIONS = [
     '.js',
     '.cjs',
@@ -49,6 +51,416 @@ function groupBy(array, key) {
         return acc;
     }, {});
 }
+class GitError extends Error {
+    cause;
+    repository;
+    constructor(message, repository, options){
+        super(message);
+        this.repository = repository;
+        this.cause = options?.cause;
+    }
+}
+class CloneError extends GitError {
+    constructor(repository){
+        super(`Git clone failed for ${repository.address}`, repository);
+    }
+}
+class CheckoutError extends GitError {
+    constructor(repository, branchName){
+        super(`Git checkout failed for ${repository.address}, couldn't checkout to ${branchName}`, repository);
+    }
+}
+class GetMainBranchError extends GitError {
+    constructor(repository, options){
+        super(`Failed to get main branch for ${repository.address}`, repository, options);
+    }
+}
+class PushError extends GitError {
+    constructor(repository, message, options){
+        super(`Git push failed for ${repository.address}; message: ${message}`, repository, options);
+    }
+}
+class RebaseError extends GitError {
+    constructor(repository, options){
+        super(`Git rebase failed for ${repository.address}`, repository, options);
+    }
+}
+class Branch {
+    isSelected;
+    name;
+    constructor(params){
+        this.name = params.name;
+        this.isSelected = params.isSelected;
+    }
+}
+const git_branch = Branch;
+const DefaultBranchRefSchema = zod.object({
+    defaultBranchRef: zod.object({
+        name: zod.string().nonempty()
+    })
+});
+function tryCatch(callback) {
+    try {
+        return ok(callback());
+    } catch (error) {
+        return err(error);
+    }
+}
+function tryCatchAsync(callback) {
+    return ResultAsync.fromPromise(callback(), (e)=>e);
+}
+function groupResults(results) {
+    return results.reduce((acc, result)=>{
+        if (result.isErr()) return {
+            ...acc,
+            failure: [
+                ...acc.failure,
+                result.error
+            ]
+        };
+        return {
+            ...acc,
+            success: [
+                ...acc.success,
+                result.value
+            ]
+        };
+    }, {
+        success: [],
+        failure: []
+    });
+}
+class Repository {
+    name;
+    address;
+    path;
+    currentBranch;
+    constructor(params){
+        this.name = params.name;
+        this.address = params.address;
+        this.path = params.path;
+    }
+    clone = async ()=>{
+        const cwd = this.path.split('/').slice(0, -1).join('/');
+        const exec = $({
+            cwd
+        });
+        const cloneResult = await exec`git clone ${this.address}`;
+        if (null != cloneResult.code && '0' !== cloneResult.code) return err(new CloneError(this));
+        return ok();
+    };
+    commit = async (message)=>{
+        await this.exec`git add .`;
+        await tryCatchAsync(()=>this.exec`git commit -m ${message} --no-verify`);
+    };
+    push = async ()=>{
+        const [remoteName, currentBranch, mainBranchNameResult] = await Promise.all([
+            this.getRemoteName(),
+            this.getCurrentBranch(),
+            this.getMainBranchName()
+        ]);
+        if (null == remoteName || null == currentBranch) return err(new PushError(this, 'Failed to find remote name'));
+        if (mainBranchNameResult.isErr()) return err(mainBranchNameResult.error);
+        if (mainBranchNameResult.value === currentBranch.name) return err(new PushError(this, "Can't push to main branch"));
+        await this.exec`git add .`;
+        await this.exec`git push --force --no-verify --set-upstream ${remoteName} ${currentBranch.name}`;
+        return ok();
+    };
+    resetBranch = async (workingBranchName)=>{
+        await this.exec`git add .`;
+        await this.exec`git reset --hard`;
+        await this.exec`git fetch`;
+        return this.updateBranchToLatestMain(workingBranchName);
+    };
+    updateBranchToLatestMain = async (workingBranchName)=>{
+        const [remoteName, mainBranchNameResult] = await Promise.all([
+            this.getRemoteName(),
+            this.getMainBranchName()
+        ]);
+        if (mainBranchNameResult.isErr()) return err(new RebaseError(this, {
+            cause: mainBranchNameResult.error
+        }));
+        if (null == remoteName) return err(new RebaseError(this));
+        const remoteBranches = await this.getRemoteBranches();
+        const existsInRemote = remoteBranches.some((branch)=>branch.name === workingBranchName);
+        const checkoutWorkingBranchResult = await this.checkoutBranch(workingBranchName);
+        if (checkoutWorkingBranchResult.isErr()) return err(checkoutWorkingBranchResult.error);
+        const rebaseResult = await tryCatchAsync(()=>this.exec`git rebase ${remoteName}/${mainBranchNameResult.value}`);
+        if (rebaseResult.isErr() || !existsInRemote) {
+            if (workingBranchName === mainBranchNameResult.value) return err(new GitError('Checked out branch is main branch', this));
+            const checkoutResult = await this.checkoutBranch(mainBranchNameResult.value);
+            if (checkoutResult.isErr()) return err(checkoutResult.error);
+            await this.deleteBranch(workingBranchName);
+            const checkoutWorkingBranchResult = await this.checkoutBranch(workingBranchName, {
+                forceCreateNew: true
+            });
+            if (checkoutWorkingBranchResult.isErr()) return err(checkoutWorkingBranchResult.error);
+            const currentBranch = await this.getCurrentBranch();
+            if (null == currentBranch) return err(new GitError('Failed to find current branch', this));
+            if (currentBranch.name === mainBranchNameResult.value) return err(new GitError('Checked out branch is main branch', this));
+        }
+        return ok();
+    };
+    deleteBranch = (branchName)=>tryCatchAsync(()=>this.exec`git branch -D ${branchName}`);
+    prepareForUpdate = async (workingBranchName)=>{
+        const checkoutBranchResult = await this.checkoutBranch(workingBranchName);
+        if (checkoutBranchResult.isErr()) return err(checkoutBranchResult.error);
+        const resetBranchResult = await this.resetBranch(workingBranchName);
+        if (resetBranchResult.isErr()) return err(resetBranchResult.error);
+        return ok(this);
+    };
+    getMainBranch = async ()=>{
+        const [branches, mainBranchNameResult] = await Promise.all([
+            this.getBranches(),
+            this.getMainBranchName()
+        ]);
+        if (mainBranchNameResult.isErr()) return err(mainBranchNameResult.error);
+        const mainBranch = branches.find((branch)=>branch.name === mainBranchNameResult.value);
+        if (null == mainBranch) return err(new GetMainBranchError(this));
+        return ok(mainBranch);
+    };
+    getRemoteName = async ()=>{
+        const remoteResult = await this.exec`git remote`;
+        return remoteResult.stdout.split('\n')[0];
+    };
+    checkoutBranch = async (branchName, options)=>{
+        const currentBranch = await this.getCurrentBranch();
+        const forceCreateNew = options?.forceCreateNew ?? false;
+        if (null != currentBranch && currentBranch.name === branchName && !forceCreateNew) return ok(currentBranch);
+        const branches = await this.getBranches();
+        const existingBranch = branches.find((branch)=>branch.name === branchName);
+        if (null != existingBranch && !forceCreateNew) {
+            const checkoutResult = await this.exec`git checkout ${branchName}`;
+            if (null != checkoutResult.code && '0' !== checkoutResult.code) return err(new CheckoutError(this, branchName));
+            return ok(existingBranch);
+        }
+        const checkoutResult = await this.exec`git checkout -b ${branchName}`;
+        if (null != checkoutResult.code && '0' !== checkoutResult.code) return err(new CheckoutError(this, branchName));
+        const branch = new git_branch({
+            name: branchName,
+            isSelected: true
+        });
+        this.setCurrentBranch(branch);
+        return ok(branch);
+    };
+    getSelectedBranch = async ()=>{
+        const currentBranch = await this.getCurrentBranch();
+        if (null != currentBranch) return currentBranch;
+        const branches = await this.getBranches();
+        const branch = branches.find((branch)=>branch.isSelected);
+        if (null == branch) return null;
+        this.setCurrentBranch(branch);
+        return branch;
+    };
+    getRemoteBranches = async ()=>{
+        const remoteHeadsResult = await this.exec`git ls-remote --heads`;
+        return arrays.compactMap(remoteHeadsResult.stdout.split('\n'), (line)=>{
+            const isValid = line.includes('refs/heads/');
+            if (!isValid) return null;
+            const name = line.trim().split('refs/heads/')[1];
+            if (!name) return null;
+            return new git_branch({
+                name,
+                isSelected: false
+            });
+        });
+    };
+    getBranches = async ()=>{
+        const branchResult = await this.exec`git branch`;
+        return branchResult.stdout.split('\n').map((branch)=>{
+            const name = branch.split('*').join('').trim();
+            const isSelected = branch.startsWith('*');
+            return new git_branch({
+                name,
+                isSelected
+            });
+        });
+    };
+    get exec() {
+        return $({
+            cwd: this.path
+        });
+    }
+    getCurrentBranch = async ()=>{
+        if (null != this.currentBranch) return this.currentBranch;
+        const branches = await this.getBranches();
+        return branches.find((branch)=>branch.isSelected);
+    };
+    setCurrentBranch = (branch)=>{
+        this.currentBranch = branch;
+    };
+    getMainBranchName = async ()=>{
+        const rawDefaultBranchRefResult = await this.exec`gh repo view --json defaultBranchRef`;
+        if (null != rawDefaultBranchRefResult.code && '0' !== rawDefaultBranchRefResult.code) return err(new GetMainBranchError(this));
+        const parsedStdoutResult = tryCatch(()=>JSON.parse(rawDefaultBranchRefResult.stdout)).mapErr((e)=>new GetMainBranchError(this, {
+                cause: e
+            }));
+        if (parsedStdoutResult.isErr()) return err(parsedStdoutResult.error);
+        const defaultBranchRef = await DefaultBranchRefSchema.safeParseAsync(parsedStdoutResult.value);
+        if (defaultBranchRef.error) return err(new GetMainBranchError(this, {
+            cause: defaultBranchRef.error
+        }));
+        return ok(defaultBranchRef.data.defaultBranchRef.name);
+    };
+    static fromAddressAndCwd = ({ address, cwd })=>{
+        const name = Repository.getRepoNameFromRepoAddress(address);
+        if (null == name) return null;
+        return new Repository({
+            name,
+            address,
+            path: node_path.resolve(cwd, name)
+        });
+    };
+    static getRepoNameFromRepoAddress = (repoAddress)=>{
+        const repoAddressComponents = repoAddress.split('/');
+        return repoAddressComponents[repoAddressComponents.length - 1]?.split('.').slice(0, -1).join('.');
+    };
+}
+const git_repository = Repository;
+async function cloneRepositories(repoAddresses, location) {
+    await $`mkdir -p ${location}`;
+    const exec = $({
+        cwd: location
+    });
+    const dedupedRepos = dedupeRepositoriesToClone(repoAddresses, location);
+    const existingRepositories = await getExistingRepositories(exec, repoAddresses);
+    const results = await Promise.all(dedupedRepos.map(cloneRepositoryInternal(existingRepositories)));
+    return arrays.compactMap(results, (result, index)=>{
+        const repo = dedupedRepos[index];
+        if (result.isErr()) {
+            console.error(result.error.message);
+            return null;
+        }
+        return repo;
+    });
+}
+async function getExistingRepositories(exec, repoAddresses) {
+    const lsResult = await exec`ls`;
+    const existingNames = new Set(lsResult.stdout.split('\n'));
+    return arrays.compactMap(repoAddresses, (address)=>{
+        const repository = git_repository.fromAddressAndCwd({
+            address,
+            cwd: lsResult.cwd
+        });
+        if (null == repository) return null;
+        if (!existingNames.has(repository.name)) return null;
+        return repository;
+    });
+}
+function cloneRepositoryInternal(existingRepositories) {
+    const existingRepositoryAddresses = new Set(existingRepositories.map((repo)=>repo.address));
+    return async (repository)=>{
+        if (existingRepositoryAddresses.has(repository.address)) return ok();
+        return repository.clone();
+    };
+}
+function dedupeRepositoriesToClone(repoAddresses, cwd) {
+    const initialDedupeResult = {
+        result: [],
+        names: []
+    };
+    const dedupedRepos = repoAddresses.reduce((acc, repoAddress)=>{
+        const repository = git_repository.fromAddressAndCwd({
+            address: repoAddress,
+            cwd
+        });
+        if (null == repository) return acc;
+        if (acc.names.includes(repository.name)) return acc;
+        return {
+            result: [
+                ...acc.result,
+                repository
+            ],
+            names: [
+                ...acc.names,
+                repository.name
+            ]
+        };
+    }, initialDedupeResult).result;
+    return dedupedRepos;
+}
+async function makePullRequestsForCodemodResults(codemods, codemodResults, repositories) {
+    for (const [codemodName, codemodResult] of Object.entries(codemodResults)){
+        const codemod = codemods.find((c)=>c.name === codemodName);
+        if (null == codemod) throw new Error('Invariant found codemod should be present');
+        await makePullRequestsForCodemodResult(codemod, codemodResult, repositories);
+    }
+}
+async function makePullRequestsForCodemodResult(codemod, codemodResult, repositories) {
+    const { success } = groupResults(codemodResult);
+    const hasChanges = success.some((result)=>result.hasChanges);
+    if (!hasChanges) return void console.log(`\u{1F438} nothing transformed for '${codemod.name}'`);
+    await Promise.all(repositories.map(async (repository)=>{
+        await repository.commit(codemod.commitMessage);
+        const pushResult = await repository.push();
+        if (pushResult.isErr()) return void console.error(`\u{274C} Failed to push changes`, pushResult.error.message);
+        const pullRequestResult = await makePullRequest({
+            workingDirectory: repository.path,
+            title: codemod.commitMessage
+        });
+        if (pullRequestResult.isErr()) return void console.error(`\u{2705} already pushed transformation for`, repository.address);
+        console.log(`\u{2705} pull request created`, pullRequestResult.value.stdout);
+    }));
+}
+async function makePullRequest(params) {
+    return tryCatchAsync(()=>$({
+            cwd: params.workingDirectory
+        })`gh pr create --title ${params.title} --fill`);
+}
+async function runCodemodsOnProjects(repositoriesToClone, codemods, options) {
+    const clonedRepositories = await cloneRepositories(repositoriesToClone.map((repo)=>repo.address), 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);
+    if (options.pushChanges) await makePullRequestsForCodemodResults(codemods, codemodResults, clonedRepositories);
+}
+function codemodTargetFiltering(mappingsByName, 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 failedRepositoryAddressesSet = failedRepositoryAddressesMappedByCodemodNames[codemod.name];
+        if (null == failedRepositoryAddressesSet || collectionIsEmpty(failedRepositoryAddressesSet)) return true;
+        return !failedRepositoryAddressesSet.has(mapping.repository.address) && (collectionIsEmpty(codemod.tags) || collectionIsEmpty(mapping.tags) || [
+            ...codemod.tags
+        ].some((tag)=>mapping.tags.has(tag)));
+    };
+}
+async function codemodPreCodemodRun(repositories, codemod) {
+    const preparationResults = await Promise.all(repositories.map((repo)=>repo.prepareForUpdate(codemod.name)));
+    const { failure: preparationFailures } = groupResults(preparationResults);
+    const failedRepositoryAddresses = preparationFailures.map((failure)=>failure.repository.address);
+    if (preparationFailures.length > 0) console.error(`\u{274C} failed to prepare [${failedRepositoryAddresses.join(', ')}] for '${codemod.name}'`);
+    return new Set(failedRepositoryAddresses);
+}
+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: codemodTargetFiltering(mappingsByName, failedRepositoryAddressesMappedByCodemodNames),
+            postTransform: codemodPostTransform
+        }
+    });
+}
 async function runCodemods(codemods, transformationPath, options) {
     const results = {};
     for (const codemod of codemods)results[codemod.name] = await runCodemod(codemod, transformationPath, options);
@@ -92,7 +504,7 @@ async function runCodemod(codemod, transformationPath, options) {
                 hasChanges,
                 content: modifiedContent,
                 fullPath,
-                root: filepath.split('/')[0]
+                root: node_path.resolve(transformationPath, filepath.split('/')[0])
             });
         } catch (error) {
             if (enableLogging) console.error(`\u{274C} '${codemod.name}' failed to parse file`, filepath, error);
@@ -255,4 +667,4 @@ function defaultedHooks(hooks) {
         preCodemodRun
     };
 }
-export { commitEditModifications, findAndReplace, findAndReplaceConfig, findAndReplaceConfigModifications, findAndReplaceEdits, runCodemod, runCodemods, traverseUp };
+export { commitEditModifications, findAndReplace, findAndReplaceConfig, findAndReplaceConfigModifications, findAndReplaceEdits, runCodemod, runCodemods, runCodemodsOnProjects, traverseUp };

package/dist/utils/results.d.ts

@@ -0,0 +1,7 @@
+import { ResultAsync, type Result } from 'neverthrow';
+export declare function tryCatch<T>(callback: () => T): Result<T, unknown>;
+export declare function tryCatchAsync<T>(callback: () => Promise<T>): ResultAsync<T, unknown>;
+export declare function groupResults<S, E>(results: Array<Result<S, E>>): {
+    success: Array<S>;
+    failure: Array<E>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kamaalio/codemod-kit",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "module",
   "author": "Kamaal Farah",
   "license": "MIT",
@@ -21,8 +21,10 @@
   "dependencies": {
     "@ast-grep/napi": "^0.38.5",
     "@kamaalio/kamaal": "^0.7.8",
+    "execa": "^9.6.0",
     "fast-glob": "^3.3.3",
-    "neverthrow": "^8.2.0"
+    "neverthrow": "^8.2.0",
+    "zod": "^3.25.67"
   },
   "devDependencies": {
     "@eslint/js": "^9.29.0",