worktree-flow 0.0.1

package/dist/lib/status.js

@@ -0,0 +1,91 @@
+/**
+ * StatusService handles worktree status checking.
+ */
+export class StatusService {
+    git;
+    constructor(git) {
+        this.git = git;
+    }
+    async getWorktreeStatus(worktreePath, mainBranch) {
+        try {
+            // Always check for uncommitted changes first
+            const hasUncommitted = await this.git.hasUncommittedChanges(worktreePath);
+            if (hasUncommitted) {
+                return { type: 'uncommitted' };
+            }
+            // Check if origin branch exists
+            const hasOriginBranch = await this.git.originBranchExists(worktreePath);
+            if (hasOriginBranch) {
+                // Compare against origin branch
+                const isAhead = await this.git.isAheadOfOrigin(worktreePath);
+                const isBehind = await this.git.isBehindOrigin(worktreePath);
+                if (isAhead && isBehind) {
+                    return { type: 'diverged', comparedTo: 'origin' };
+                }
+                if (isAhead) {
+                    return { type: 'ahead', comparedTo: 'origin' };
+                }
+                if (isBehind) {
+                    return { type: 'behind', comparedTo: 'origin' };
+                }
+                return { type: 'clean', comparedTo: 'origin' };
+            }
+            // No origin branch, compare against main
+            const isAhead = await this.git.isAheadOfMain(worktreePath, mainBranch);
+            if (isAhead) {
+                return { type: 'ahead', comparedTo: 'main' };
+            }
+            return { type: 'clean', comparedTo: 'main' };
+        }
+        catch (err) {
+            return {
+                type: 'error',
+                error: err.stderr || err.message,
+            };
+        }
+    }
+    static getStatusMessage(status, mainBranch) {
+        switch (status.type) {
+            case 'clean':
+                return 'up to date';
+            case 'uncommitted':
+                return 'uncommitted changes';
+            case 'ahead':
+                return status.comparedTo === 'origin'
+                    ? 'ahead of origin'
+                    : `ahead of ${mainBranch}`;
+            case 'behind':
+                return 'behind origin';
+            case 'diverged':
+                return 'diverged from origin';
+            case 'error':
+                return `error: ${status.error}`;
+        }
+    }
+    static hasIssues(status) {
+        return (status.type === 'uncommitted' ||
+            status.type === 'ahead' ||
+            status.type === 'diverged' ||
+            status.type === 'error');
+    }
+    /**
+     * Check status of all worktrees in parallel
+     */
+    async checkAllWorktrees(worktreeDirs, mainBranch) {
+        const results = await Promise.all(worktreeDirs.map(async (worktreePath) => {
+            const repoName = worktreePath.split('/').pop() || worktreePath;
+            const status = await this.getWorktreeStatus(worktreePath, mainBranch);
+            return { repoName, status };
+        }));
+        return results;
+    }
+    /**
+     * Find repos with issues (for removal validation)
+     */
+    async findReposWithIssues(worktreeDirs, mainBranch) {
+        const results = await this.checkAllWorktrees(worktreeDirs, mainBranch);
+        return results
+            .filter(({ status }) => StatusService.hasIssues(status))
+            .map(({ repoName }) => repoName);
+    }
+}

package/dist/lib/tmux.js

@@ -0,0 +1,38 @@
+/**
+ * TmuxService handles tmux session operations.
+ */
+export class TmuxService {
+    shell;
+    constructor(shell) {
+        this.shell = shell;
+    }
+    async createSession(workspacePath, sessionName) {
+        try {
+            await this.shell.execFile('tmux', [
+                'new-session',
+                '-d',
+                '-s',
+                sessionName,
+                '-c',
+                workspacePath,
+            ]);
+        }
+        catch (error) {
+            // If session already exists, ignore the error
+            if (!error.message?.includes('duplicate session')) {
+                throw error;
+            }
+        }
+    }
+    async killSession(sessionName) {
+        try {
+            await this.shell.execFile('tmux', ['kill-session', '-t', sessionName]);
+        }
+        catch (error) {
+            // If session doesn't exist, ignore the error
+            if (!error.message?.includes('no such session')) {
+                throw error;
+            }
+        }
+    }
+}

package/dist/lib/workspaceDirectory.js

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { WorkspaceAlreadyExistsError } from './errors.js';
+/**
+ * WorkspaceDirectoryService handles workspace directory operations.
+ * Pure directory management, no orchestration.
+ */
+export class WorkspaceDirectoryService {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    createWorkspaceDir(destPath, branch) {
+        const workspacePath = path.join(destPath, branch);
+        if (this.fs.existsSync(workspacePath)) {
+            throw new WorkspaceAlreadyExistsError(workspacePath);
+        }
+        this.fs.mkdirSync(workspacePath, { recursive: true });
+        return workspacePath;
+    }
+    copyAgentsMd(sourcePath, workspacePath) {
+        const agentsPath = path.join(sourcePath, 'AGENTS.md');
+        if (this.fs.existsSync(agentsPath)) {
+            this.fs.copyFileSync(agentsPath, path.join(workspacePath, 'AGENTS.md'));
+        }
+    }
+    detectWorkspace(cwd, destPath) {
+        const normalizedCwd = path.resolve(cwd);
+        const normalizedDest = path.resolve(destPath);
+        if (!normalizedCwd.startsWith(normalizedDest + path.sep) &&
+            normalizedCwd !== normalizedDest) {
+            return null;
+        }
+        const relative = path.relative(normalizedDest, normalizedCwd);
+        const segments = relative.split(path.sep);
+        if (segments.length === 0 || segments[0] === '') {
+            return null;
+        }
+        const workspacePath = path.join(normalizedDest, segments[0]);
+        if (!this.fs.existsSync(workspacePath)) {
+            return null;
+        }
+        return workspacePath;
+    }
+    getWorktreeDirs(workspacePath) {
+        const entries = this.fs.readdirSync(workspacePath, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(workspacePath, entry.name));
+    }
+    listWorkspaces(destPath) {
+        if (!this.fs.existsSync(destPath)) {
+            return [];
+        }
+        const entries = this.fs.readdirSync(destPath, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => {
+            const workspacePath = path.join(destPath, entry.name);
+            try {
+                const worktrees = this.getWorktreeDirs(workspacePath);
+                return {
+                    name: entry.name,
+                    path: workspacePath,
+                    repoCount: worktrees.length,
+                };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((ws) => ws !== null && ws.repoCount > 0);
+    }
+    removeWorkspaceDir(workspacePath) {
+        this.fs.rmSync(workspacePath, { recursive: true, force: true });
+    }
+    findWorkspace(destPath, branchName) {
+        const workspaces = this.listWorkspaces(destPath);
+        return workspaces.find(ws => ws.name === branchName) || null;
+    }
+}

package/dist/lib/workspaceResolver.js

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { NotInWorkspaceError, WorkspaceNotFoundError } from './errors.js';
+/**
+ * Resolves a workspace path from either an explicit branch name or by auto-detecting
+ * from the current working directory.
+ *
+ * @param branchName - Optional branch name. If provided, looks for workspace with this name.
+ *                     If undefined, auto-detects from current directory.
+ * @param workspaceDir - WorkspaceDirectoryService instance
+ * @param config - ConfigService instance
+ * @param process - IProcess instance for getting cwd
+ * @returns WorkspaceResolution containing the workspace path and display name
+ * @throws NotInWorkspaceError if auto-detecting and cwd is outside dest-path
+ * @throws WorkspaceNotFoundError if explicit branch provided but workspace doesn't exist
+ */
+export function resolveWorkspace(branchName, workspaceDir, config, process) {
+    const { destPath } = config.getRequired();
+    if (branchName) {
+        // Explicit branch provided
+        const workspacePath = path.join(destPath, branchName);
+        const workspace = workspaceDir.findWorkspace(destPath, branchName);
+        if (!workspace) {
+            throw new WorkspaceNotFoundError(workspacePath);
+        }
+        return {
+            workspacePath,
+            displayName: branchName,
+        };
+    }
+    else {
+        // Auto-detect from current directory
+        const detectedPath = workspaceDir.detectWorkspace(process.cwd(), destPath);
+        if (!detectedPath) {
+            throw new NotInWorkspaceError(destPath);
+        }
+        return {
+            workspacePath: detectedPath,
+            displayName: path.basename(detectedPath),
+        };
+    }
+}

package/dist/lib/worktree.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+/**
+ * WorktreeService handles worktree creation and file copying.
+ * No orchestration - just individual worktree operations.
+ */
+export class WorktreeService {
+    fs;
+    git;
+    constructor(fs, git) {
+        this.fs = fs;
+        this.git = git;
+    }
+    copyConfigFilesToWorktree(sourceRepoPath, worktreePath, copyFiles) {
+        // Default to no files if not specified
+        const files = (copyFiles || '')
+            .split(',')
+            .map(f => f.trim())
+            .filter(f => f.length > 0);
+        // Copy each config file from source repo to worktree
+        for (const file of files) {
+            const sourceFilePath = path.join(sourceRepoPath, file);
+            const destFilePath = path.join(worktreePath, file);
+            // Skip if file doesn't exist in source repo
+            if (!this.fs.existsSync(sourceFilePath)) {
+                continue;
+            }
+            // Copy file to worktree
+            try {
+                this.fs.copyFileSync(sourceFilePath, destFilePath);
+            }
+            catch {
+                // Silently ignore copy errors
+            }
+        }
+    }
+    async createWorktreeWithBranch(repoPath, worktreePath, branchName, sourceBranch) {
+        await this.git.addWorktreeNewBranch(repoPath, worktreePath, branchName, sourceBranch);
+    }
+    async createWorktreeCheckout(repoPath, worktreePath, branchName) {
+        await this.git.addWorktree(repoPath, worktreePath, branchName);
+    }
+    async removeWorktree(repoPath, worktreePath) {
+        await this.git.removeWorktree(repoPath, worktreePath);
+    }
+}

package/dist/usecases/checkWorkspaceStatus.js

@@ -0,0 +1,19 @@
+/**
+ * Use case for checking status of all worktrees in a workspace.
+ */
+export class CheckWorkspaceStatusUseCase {
+    workspaceDir;
+    fetch;
+    status;
+    constructor(workspaceDir, fetch, status) {
+        this.workspaceDir = workspaceDir;
+        this.fetch = fetch;
+        this.status = status;
+    }
+    async execute(params) {
+        const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
+        await this.fetch.fetchRepos(worktreeDirs);
+        const statuses = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+        return { statuses };
+    }
+}

package/dist/usecases/checkoutWorkspace.js

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { RepoService } from '../lib/repos.js';
+import { NoReposFoundError } from '../lib/errors.js';
+/**
+ * Use case for checking out an existing branch across multiple repos.
+ * Orchestrates repo discovery, branch checking, and workspace creation.
+ */
+export class CheckoutWorkspaceUseCase {
+    workspaceDir;
+    worktree;
+    repos;
+    fetch;
+    parallel;
+    tmux;
+    postCheckout;
+    constructor(workspaceDir, worktree, repos, fetch, parallel, tmux, postCheckout) {
+        this.workspaceDir = workspaceDir;
+        this.worktree = worktree;
+        this.repos = repos;
+        this.fetch = fetch;
+        this.parallel = parallel;
+        this.tmux = tmux;
+        this.postCheckout = postCheckout;
+    }
+    async execute(params) {
+        // 1. Discover all repos
+        const allRepos = this.repos.discoverRepos(params.sourcePath);
+        if (allRepos.length === 0) {
+            throw new NoReposFoundError(params.sourcePath);
+        }
+        // 2. Fetch all repos
+        await this.fetch.fetchRepos(allRepos);
+        // 3. Find repos that have this branch
+        const { matching, results } = await this.repos.findReposWithBranch(allRepos, params.branchName);
+        if (matching.length === 0) {
+            throw new Error(`Branch "${params.branchName}" not found in any repo.`);
+        }
+        // 4. Create workspace directory
+        const workspacePath = this.workspaceDir.createWorkspaceDir(params.destPath, params.branchName);
+        // 5. Create worktrees in parallel
+        const successCount = await this.parallel.processInParallel(matching, (repoPath) => RepoService.getRepoName(repoPath), async (repoPath) => {
+            const name = RepoService.getRepoName(repoPath);
+            const worktreeDest = path.join(workspacePath, name);
+            await this.worktree.createWorktreeCheckout(repoPath, worktreeDest, params.branchName);
+            this.worktree.copyConfigFilesToWorktree(repoPath, worktreeDest, params.copyFiles);
+            return 'created';
+        });
+        // 6. Copy AGENTS.md
+        this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
+        // 7. Create tmux session if enabled
+        let tmuxCreated = false;
+        if (params.tmux) {
+            try {
+                await this.tmux.createSession(workspacePath, params.branchName);
+                tmuxCreated = true;
+            }
+            catch (error) {
+                // Don't fail
+            }
+        }
+        // 8. Run post-checkout if configured
+        let postCheckoutResult;
+        if (params.postCheckout) {
+            const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);
+            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout);
+        }
+        return {
+            workspacePath,
+            matchingRepos: matching.length,
+            successCount,
+            totalCount: matching.length,
+            tmuxCreated,
+            postCheckoutSuccess: postCheckoutResult?.successCount,
+            postCheckoutTotal: postCheckoutResult?.totalCount,
+            branchCheckResults: results,
+        };
+    }
+}

package/dist/usecases/createBranchWorkspace.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import { RepoService } from '../lib/repos.js';
+/**
+ * Use case for creating a workspace with new branches across multiple repos.
+ * Orchestrates the entire workflow from fetching to post-checkout commands.
+ */
+export class CreateBranchWorkspaceUseCase {
+    workspaceDir;
+    worktree;
+    repos;
+    fetch;
+    parallel;
+    tmux;
+    postCheckout;
+    constructor(workspaceDir, worktree, repos, fetch, parallel, tmux, postCheckout) {
+        this.workspaceDir = workspaceDir;
+        this.worktree = worktree;
+        this.repos = repos;
+        this.fetch = fetch;
+        this.parallel = parallel;
+        this.tmux = tmux;
+        this.postCheckout = postCheckout;
+    }
+    async execute(params) {
+        // 1. Fetch all repos
+        await this.fetch.fetchRepos(params.repos);
+        // 2. Create workspace directory
+        const workspacePath = this.workspaceDir.createWorkspaceDir(params.destPath, params.branchName);
+        // 3. Create worktrees in parallel
+        const successCount = await this.parallel.processInParallel(params.repos, (repoPath) => RepoService.getRepoName(repoPath), async (repoPath) => {
+            const name = RepoService.getRepoName(repoPath);
+            const worktreeDest = path.join(workspacePath, name);
+            await this.worktree.createWorktreeWithBranch(repoPath, worktreeDest, params.branchName, params.sourceBranch);
+            this.worktree.copyConfigFilesToWorktree(repoPath, worktreeDest, params.copyFiles);
+            return 'created';
+        });
+        // 4. Copy AGENTS.md if exists
+        this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
+        // 5. Create tmux session if enabled
+        let tmuxCreated = false;
+        if (params.tmux) {
+            try {
+                await this.tmux.createSession(workspacePath, params.branchName);
+                tmuxCreated = true;
+            }
+            catch (error) {
+                // Don't fail, just return false
+            }
+        }
+        // 6. Run post-checkout command if configured
+        let postCheckoutResult;
+        if (params.postCheckout) {
+            const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);
+            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout);
+        }
+        return {
+            workspacePath,
+            successCount,
+            totalCount: params.repos.length,
+            tmuxCreated,
+            postCheckoutSuccess: postCheckoutResult?.successCount,
+            postCheckoutTotal: postCheckoutResult?.totalCount,
+        };
+    }
+}

package/dist/usecases/discoverPrunableWorkspaces.js

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { StatusService as StatusServiceClass } from '../lib/status.js';
+/**
+ * Use case for analyzing workspaces to find candidates for pruning.
+ * Returns workspaces where all worktrees have no issues and commits are older than specified days.
+ */
+export class DiscoverPrunableWorkspacesUseCase {
+    workspaceDir;
+    fetch;
+    status;
+    git;
+    constructor(workspaceDir, fetch, status, git) {
+        this.workspaceDir = workspaceDir;
+        this.fetch = fetch;
+        this.status = status;
+        this.git = git;
+    }
+    async execute(params) {
+        const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        const prunable = [];
+        const cutoffDate = new Date(Date.now() - params.daysOld * 24 * 60 * 60 * 1000);
+        // Collect all worktree directories and unique source repos across all workspaces
+        const uniqueSourceRepos = new Set();
+        const workspaceWorktrees = new Map();
+        for (const workspace of workspaces) {
+            const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
+            if (worktreeDirs.length > 0) {
+                workspaceWorktrees.set(workspace.path, worktreeDirs);
+                // Extract repo names and build source repo paths
+                worktreeDirs.forEach((worktreePath) => {
+                    const repoName = path.basename(worktreePath);
+                    const sourceRepoPath = path.join(params.sourcePath, repoName);
+                    uniqueSourceRepos.add(sourceRepoPath);
+                });
+            }
+        }
+        // Fetch all unique source repos once
+        // Since worktrees share the same git repository, fetching in one worktree
+        // updates the remote refs for all worktrees of that repository
+        if (uniqueSourceRepos.size > 0) {
+            await this.fetch.fetchRepos(Array.from(uniqueSourceRepos));
+        }
+        // Now analyze each workspace
+        for (const workspace of workspaces) {
+            const worktreeDirs = workspaceWorktrees.get(workspace.path);
+            // Skip workspaces with no worktrees
+            if (!worktreeDirs || worktreeDirs.length === 0) {
+                continue;
+            }
+            // Check status for all worktrees
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+            // Skip if any worktree has issues
+            const hasAnyIssues = statuses.some(({ status }) => StatusServiceClass.hasIssues(status));
+            if (hasAnyIssues) {
+                continue;
+            }
+            // Get last commit dates for all worktrees
+            const commitDates = await Promise.all(worktreeDirs.map((worktreePath) => this.git.getLastCommitDate(worktreePath)));
+            // Find the most recent commit
+            const oldestCommitDate = commitDates.reduce((oldest, current) => current > oldest ? current : oldest);
+            // Skip if any commit is too recent
+            if (oldestCommitDate > cutoffDate) {
+                continue;
+            }
+            // This workspace is prunable
+            prunable.push({
+                name: workspace.name,
+                path: workspace.path,
+                repoCount: workspace.repoCount,
+                oldestCommitDate,
+                statuses,
+            });
+        }
+        return { prunable };
+    }
+}

package/dist/usecases/pullWorkspace.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+/**
+ * Use case for pulling all worktrees in a workspace.
+ */
+export class PullWorkspaceUseCase {
+    workspaceDir;
+    git;
+    parallel;
+    constructor(workspaceDir, git, parallel) {
+        this.workspaceDir = workspaceDir;
+        this.git = git;
+        this.parallel = parallel;
+    }
+    async execute(params) {
+        const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
+        const successCount = await this.parallel.processInParallel(worktreeDirs, (worktreePath) => path.basename(worktreePath), async (worktreePath) => {
+            await this.git.pull(worktreePath);
+            return 'pulled';
+        });
+        return {
+            successCount,
+            totalCount: worktreeDirs.length,
+        };
+    }
+}

package/dist/usecases/pushWorkspace.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+/**
+ * Use case for pushing all worktrees in a workspace.
+ */
+export class PushWorkspaceUseCase {
+    workspaceDir;
+    git;
+    parallel;
+    constructor(workspaceDir, git, parallel) {
+        this.workspaceDir = workspaceDir;
+        this.git = git;
+        this.parallel = parallel;
+    }
+    async execute(params) {
+        const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
+        const successCount = await this.parallel.processInParallel(worktreeDirs, (worktreePath) => path.basename(worktreePath), async (worktreePath) => {
+            return await this.git.pushWithRetry(worktreePath);
+        });
+        return {
+            successCount,
+            totalCount: worktreeDirs.length,
+        };
+    }
+}

package/dist/usecases/removeWorkspace.js

@@ -0,0 +1,90 @@
+import path from 'node:path';
+import { WorkspaceHasIssuesError } from '../lib/errors.js';
+import { StatusService as StatusServiceClass } from '../lib/status.js';
+/**
+ * Use case for removing a workspace with validation.
+ * Checks for uncommitted changes before removal.
+ */
+export class RemoveWorkspaceUseCase {
+    workspaceDir;
+    worktree;
+    repos;
+    fetch;
+    status;
+    tmux;
+    constructor(workspaceDir, worktree, repos, fetch, status, tmux) {
+        this.workspaceDir = workspaceDir;
+        this.worktree = worktree;
+        this.repos = repos;
+        this.fetch = fetch;
+        this.status = status;
+        this.tmux = tmux;
+    }
+    async execute(params) {
+        const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
+        const issuesFound = [];
+        // 1. Fetch and check status if worktrees exist
+        if (worktreeDirs.length > 0) {
+            await this.fetch.fetchRepos(worktreeDirs);
+            const results = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+            for (const { repoName, status } of results) {
+                if (StatusServiceClass.hasIssues(status)) {
+                    issuesFound.push({
+                        repoName,
+                        issue: StatusServiceClass.getStatusMessage(status, params.mainBranch),
+                    });
+                }
+            }
+            if (issuesFound.length > 0) {
+                throw new WorkspaceHasIssuesError(`${issuesFound.length} repo(s) have uncommitted or unmerged changes.`);
+            }
+        }
+        // 2. Remove all worktrees
+        const removalErrors = [];
+        let worktreesRemoved = 0;
+        for (const worktreePath of worktreeDirs) {
+            const repoName = path.basename(worktreePath);
+            const sourceRepoPath = path.join(params.sourcePath, repoName);
+            try {
+                const allRepos = this.repos.discoverRepos(params.sourcePath);
+                if (!allRepos.includes(sourceRepoPath)) {
+                    removalErrors.push({ repo: repoName, error: 'source repo not found' });
+                    continue;
+                }
+                await this.worktree.removeWorktree(sourceRepoPath, worktreePath);
+                worktreesRemoved++;
+            }
+            catch (err) {
+                removalErrors.push({ repo: repoName, error: err.stderr || err.message });
+            }
+        }
+        // 3. Remove workspace directory
+        let workspaceDirRemoved = false;
+        try {
+            this.workspaceDir.removeWorkspaceDir(params.workspacePath);
+            workspaceDirRemoved = true;
+        }
+        catch (err) {
+            throw err; // Re-throw directory removal errors
+        }
+        // 4. Kill tmux session if enabled
+        let tmuxKilled = false;
+        if (params.tmux) {
+            try {
+                await this.tmux.killSession(params.branchName);
+                tmuxKilled = true;
+            }
+            catch (error) {
+                // Don't fail
+            }
+        }
+        return {
+            worktreesRemoved,
+            worktreesTotal: worktreeDirs.length,
+            workspaceDirRemoved,
+            tmuxKilled,
+            issuesFound,
+            removalErrors,
+        };
+    }
+}