worktree-flow 0.0.3 → 0.0.6

package/README.md

@@ -68,15 +68,20 @@ Push all repos in the current workspace. Automatically sets upstream on first pu
 
 Check the status of all repos in a workspace. Shows uncommitted changes, commits ahead of main, and up-to-date repos.
 
-### `flow list`
+### `flow list` (alias: `ls`)
 
-List all workspaces and their repo counts.
+List all workspaces with status indicators. Shows:
+- Active workspace (marked with `*`) based on current directory
+- Overall status: `clean`, `uncommitted`, `ahead`, `behind`, `diverged`, or `mixed`
+- Repo count for each workspace
+
+Fetches all repos before checking status to ensure accurate information.
 
 ### `flow remove <name>`
 
 Remove a workspace and all its worktrees. Fetches latest, checks for uncommitted changes and unpushed commits, and prompts for confirmation before removing.
 
-### `flow prune`
+### `flow prune` (alias: `clean`)
 
 Remove stale workspaces in bulk. Finds workspaces where all worktrees are clean, fully merged, and haven't been committed to in over 7 days.
 
@@ -96,6 +101,23 @@ Settings are stored in `~/.config/flow/config.json`.
 | `tmux` | Create tmux sessions with split panes (root + each worktree) | `false` |
 | `copy-files` | Files to copy from source repos to worktrees | `.env` |
 | `post-checkout` | Command to run after checkout (e.g. `npm ci`) | *none* |
+| `per-repo-post-checkout` | Per-repo commands (see below) | `{}` |
+
+### Per-repo post-checkout commands
+
+Configure different commands for specific repos by editing `~/.config/flow/config.json`:
+
+```json
+{
+  "post-checkout": "npm ci",
+  "per-repo-post-checkout": {
+    "api-service": "npm ci && npm run build",
+    "frontend": "yarn install"
+  }
+}
+```
+
+Repos with per-repo commands use those; others fall back to the global `post-checkout` command.
 
 ## AGENTS.md
 

package/dist/commands/branch.js

@@ -34,6 +34,10 @@ export async function runBranch(branchName, useCases, services, deps) {
         });
     }
     services.console.log('\nCreating workspace...');
+    // Fetch all selected repos
+    await services.fetch.fetchRepos(selected, {
+        ttlSeconds: config.fetchCacheTtlSeconds,
+    });
     // Execute use case
     const result = await useCases.createBranchWorkspace.execute({
         repos: selected,
@@ -44,6 +48,7 @@ export async function runBranch(branchName, useCases, services, deps) {
         copyFiles: config.copyFiles,
         tmux: config.tmux,
         postCheckout: shouldRunPostCheckout ? config.postCheckout : undefined,
+        perRepoPostCheckout: shouldRunPostCheckout ? config.perRepoPostCheckout : {},
     });
     // Display results
     services.console.log(`\nCreated workspace at ${chalk.cyan(result.workspacePath)} with ${result.successCount}/${result.totalCount} repos.`);

package/dist/commands/checkout.js

@@ -14,6 +14,11 @@ export async function runCheckout(branchName, useCases, services, deps) {
     }
     services.console.log('\nChecking for branch...');
     try {
+        // Fetch all repos from source-path
+        await useCases.fetchAllRepos.execute({
+            sourcePath,
+            fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+        });
         // Execute use case
         const result = await useCases.checkoutWorkspace.execute({
             branchName,
@@ -22,6 +27,7 @@ export async function runCheckout(branchName, useCases, services, deps) {
             copyFiles: config.copyFiles,
             tmux: config.tmux,
             postCheckout: shouldRunPostCheckout ? config.postCheckout : undefined,
+            perRepoPostCheckout: shouldRunPostCheckout ? config.perRepoPostCheckout : {},
         });
         // Display branch check results
         for (const checkResult of result.branchCheckResults) {

package/dist/commands/list.js

@@ -1,26 +1,94 @@
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
-export async function runList(services) {
-    const { destPath } = services.config.getRequired();
-    const workspaces = services.workspaceDir.listWorkspaces(destPath);
-    if (workspaces.length === 0) {
+import { createUseCases } from '../usecases/usecases.js';
+function getStatusIndicator(workspace) {
+    const hasUncommitted = workspace.statuses.some(s => s.status.type === 'uncommitted');
+    const hasAhead = workspace.statuses.some(s => s.status.type === 'ahead');
+    const hasBehind = workspace.statuses.some(s => s.status.type === 'behind');
+    const hasDiverged = workspace.statuses.some(s => s.status.type === 'diverged');
+    const hasError = workspace.statuses.some(s => s.status.type === 'error');
+    if (hasUncommitted) {
+        return chalk.yellow('uncommitted');
+    }
+    else if (hasDiverged) {
+        return chalk.red('diverged');
+    }
+    else if (hasAhead && hasBehind) {
+        return chalk.yellow('ahead');
+    }
+    else if (hasAhead) {
+        return chalk.yellow('ahead');
+    }
+    else if (hasBehind) {
+        return chalk.blue('behind');
+    }
+    else if (hasError) {
+        return chalk.red('error');
+    }
+    else {
+        return chalk.green('clean');
+    }
+}
+export async function runList(useCases, services) {
+    const { destPath, sourcePath } = services.config.getRequired();
+    const config = services.config.load();
+    const cwd = services.process.cwd();
+    // Get basic workspace list immediately
+    const basicWorkspaces = services.workspaceDir.listWorkspaces(destPath);
+    if (basicWorkspaces.length === 0) {
         services.console.log('No workspaces found.');
         return;
     }
+    // Phase 1: Show basic list immediately
     services.console.log(chalk.bold('\nWorkspaces:'));
-    for (const workspace of workspaces) {
-        services.console.log(`  ${chalk.cyan(workspace.name)} ${chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`)}`);
+    for (const workspace of basicWorkspaces) {
+        const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
+        services.console.log(`  ${chalk.cyan(workspace.name)} ${repoCount} ${chalk.dim('fetching...')}`);
     }
     services.console.log('');
+    // Phase 2: Fetch repos used across all workspaces
+    await useCases.fetchUsedRepos.execute({
+        destPath,
+        sourcePath,
+        fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+        silent: true,
+    });
+    // Phase 3: Check status for all workspaces
+    const result = await useCases.listWorkspacesWithStatus.execute({
+        destPath,
+        sourcePath,
+        mainBranch: config.mainBranch,
+        cwd,
+    });
+    // Phase 4: Clear previous output and re-print with status
+    // Lines to clear:
+    // - 2 lines from '\nWorkspaces:' (blank line + header)
+    // - N workspace lines
+    // - 1 empty line after workspaces
+    const linesToClear = 2 + basicWorkspaces.length + 1;
+    for (let i = 0; i < linesToClear; i++) {
+        services.console.write('\x1b[1A'); // Move cursor up one line
+        services.console.write('\x1b[2K'); // Clear entire line
+    }
+    // Re-print with full status information
+    services.console.log(chalk.bold('\nWorkspaces:'));
+    for (const workspace of result.workspaces) {
+        const statusIndicator = getStatusIndicator(workspace);
+        const activeIndicator = workspace.isActive ? chalk.green('* ') : '  ';
+        const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
+        services.console.log(`${activeIndicator}${chalk.cyan(workspace.name)} ${repoCount} ${statusIndicator}`);
+    }
 }
 export function registerListCommand(program) {
     program
         .command('list')
-        .description('List all workspaces in the target directory')
+        .alias('ls')
+        .description('List all workspaces with status indicators')
         .action(async () => {
         const services = createServices();
+        const useCases = createUseCases(services);
         try {
-            await runList(services);
+            await runList(useCases, services);
         }
         catch (error) {
             services.console.error(error.message);

package/dist/commands/prune.js

@@ -6,6 +6,12 @@ export async function runPrune(useCases, services, deps) {
     const { sourcePath, destPath } = services.config.getRequired();
     const config = services.config.load();
     services.console.log('Analyzing workspaces for pruning...\n');
+    // Fetch repos used across all workspaces
+    await useCases.fetchUsedRepos.execute({
+        destPath,
+        sourcePath,
+        fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+    });
     // Analyze workspaces to find prunable ones
     const result = await useCases.discoverPrunableWorkspaces.execute({
         destPath,
@@ -31,11 +37,6 @@ export async function runPrune(useCases, services, deps) {
         services.console.log(`    Status: ${chalk.green('clean')}`);
         services.console.log('');
     }
-    // Summary
-    const totalRepos = result.prunable.reduce((sum, ws) => sum + ws.repoCount, 0);
-    services.console.log(`${chalk.yellow('This will remove:')}`);
-    services.console.log(`  ${result.prunable.length} workspace(s)`);
-    services.console.log(`  ${totalRepos} worktree(s)`);
     const confirmed = await deps.confirm({
         message: 'Are you sure you want to prune these workspaces?',
         default: false,
@@ -78,6 +79,7 @@ export async function runPrune(useCases, services, deps) {
 export function registerPruneCommand(program) {
     program
         .command('prune')
+        .alias('clean')
         .description('Remove old workspaces with no uncommitted changes and commits older than 7 days')
         .action(async () => {
         const services = createServices();

package/dist/commands/remove.js

@@ -13,7 +13,11 @@ export async function runRemove(branchName, useCases, services, deps) {
     const worktreeDirs = services.workspaceDir.getWorktreeDirs(workspacePath);
     // Display status check if worktrees exist
     if (worktreeDirs.length > 0) {
-        await services.fetch.fetchRepos(worktreeDirs);
+        await useCases.fetchWorkspaceRepos.execute({
+            workspacePath,
+            sourcePath,
+            fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+        });
         services.console.log(`\nChecking for uncommitted changes and commits ahead of ${config.mainBranch}...`);
         const results = await services.status.checkAllWorktrees(worktreeDirs, config.mainBranch);
         for (const { repoName, status } of results) {

package/dist/commands/status.js

@@ -4,6 +4,7 @@ import { createUseCases } from '../usecases/usecases.js';
 import { StatusService } from '../lib/status.js';
 import { resolveWorkspace } from '../lib/workspaceResolver.js';
 export async function runStatus(branchName, useCases, services) {
+    const { sourcePath } = services.config.getRequired();
     const config = services.config.load();
     const { workspacePath } = resolveWorkspace(branchName, services.workspaceDir, services.config, services.process);
     services.console.log(`Workspace: ${chalk.cyan(workspacePath)}`);
@@ -12,6 +13,12 @@ export async function runStatus(branchName, useCases, services) {
         services.console.log('\nNo worktrees found in workspace.');
         return;
     }
+    // Fetch workspace repos
+    await useCases.fetchWorkspaceRepos.execute({
+        workspacePath,
+        sourcePath,
+        fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+    });
     services.console.log('');
     services.console.log(`\nStatus (comparing against ${chalk.cyan(config.mainBranch)}):\n`);
     const result = await useCases.checkWorkspaceStatus.execute({

package/dist/lib/config.js

@@ -10,6 +10,8 @@ const RawConfigSchema = z.object({
     'tmux': z.enum(['true', 'false']).optional(),
     'main-branch': z.string().optional(),
     'post-checkout': z.string().optional(),
+    'fetch-cache-ttl-seconds': z.string().optional(),
+    'per-repo-post-checkout': z.record(z.string(), z.string()).optional(),
 });
 // Parsed config schema (with proper types)
 const ParsedConfigSchema = z.object({
@@ -19,6 +21,8 @@ const ParsedConfigSchema = z.object({
     tmux: z.boolean().default(false),
     mainBranch: z.string().default('master'),
     postCheckout: z.string().optional(),
+    fetchCacheTtlSeconds: z.number().default(300),
+    perRepoPostCheckout: z.record(z.string(), z.string()).default({}),
 });
 // Required config schema (for getRequired)
 const RequiredConfigSchema = z.object({
@@ -33,8 +37,12 @@ const ConfigValueSchemas = {
     'tmux': z.enum(['true', 'false']),
     'main-branch': z.string(),
     'post-checkout': z.string(),
+    'fetch-cache-ttl-seconds': z.string().refine((val) => {
+        const num = parseInt(val, 10);
+        return !isNaN(num) && num >= 0;
+    }, { message: 'Must be a non-negative integer' }),
 };
-export const CONFIG_KEYS = ['source-path', 'dest-path', 'copy-files', 'tmux', 'main-branch', 'post-checkout'];
+export const CONFIG_KEYS = ['source-path', 'dest-path', 'copy-files', 'tmux', 'main-branch', 'post-checkout', 'fetch-cache-ttl-seconds'];
 /**
  * Pure utility functions (no I/O)
  */
@@ -80,6 +88,10 @@ export class ConfigService {
             tmux: raw.tmux === 'true',
             mainBranch: raw['main-branch'],
             postCheckout: raw['post-checkout'],
+            fetchCacheTtlSeconds: raw['fetch-cache-ttl-seconds']
+                ? parseInt(raw['fetch-cache-ttl-seconds'], 10)
+                : undefined,
+            perRepoPostCheckout: raw['per-repo-post-checkout'],
         });
     }
     getRequired() {
@@ -126,6 +138,10 @@ export class ConfigService {
                 value: raw['post-checkout'] ?? '(not set)',
                 isDefault: !raw['post-checkout'],
             },
+            'fetch-cache-ttl-seconds': {
+                value: raw['fetch-cache-ttl-seconds'] ?? `${config.fetchCacheTtlSeconds} (default)`,
+                isDefault: !raw['fetch-cache-ttl-seconds'],
+            },
         };
     }
 }

package/dist/lib/fetch.js

@@ -6,29 +6,49 @@ const FETCH_CONCURRENCY = 8;
 export class FetchService {
     git;
     console;
-    constructor(git, console) {
+    cache;
+    constructor(git, console, cache) {
         this.git = git;
         this.console = console;
+        this.cache = cache;
     }
-    async fetchRepos(repoPaths) {
+    async fetchRepos(repoPaths, options) {
         if (repoPaths.length === 0) {
             return;
         }
-        const total = repoPaths.length;
+        const silent = options?.silent ?? false;
+        const ttlSeconds = options?.ttlSeconds ?? 300;
+        // Filter repos based on cache
+        const reposToFetch = this.cache.filterReposToFetch(repoPaths, ttlSeconds);
+        const cachedCount = repoPaths.length - reposToFetch.length;
+        // Early return if all repos are cached
+        if (reposToFetch.length === 0) {
+            if (!silent) {
+                this.console.log(`All ${repoPaths.length} repos up to date (cached) ${chalk.green('✓')}`);
+            }
+            return;
+        }
+        const total = reposToFetch.length;
         let completed = 0;
         let failed = 0;
         const updateProgress = () => {
+            if (silent)
+                return;
             const percent = Math.floor((completed / total) * 100);
-            const message = `Fetching repos... ${completed}/${total} (${percent}%)`;
+            const cacheInfo = cachedCount > 0 ? ` (${cachedCount} cached)` : '';
+            const message = `Fetching ${completed}/${total} repos${cacheInfo} (${percent}%)`;
             this.console.write(`\r${message}`);
         };
         updateProgress();
         const processRepo = async (repoPath) => {
             try {
                 await this.git.fetch(repoPath);
+                // Update cache on successful fetch
+                this.cache.markFetched(repoPath);
             }
             catch (err) {
                 failed++;
+                // Do NOT update cache on failure - will retry next time
             }
             finally {
                 completed++;
@@ -38,21 +58,24 @@ export class FetchService {
         // Process repos with controlled concurrency
         let index = 0;
         const worker = async () => {
-            while (index < repoPaths.length) {
-                const repoPath = repoPaths[index++];
+            while (index < reposToFetch.length) {
+                const repoPath = reposToFetch[index++];
                 await processRepo(repoPath);
             }
         };
         // Start workers (up to concurrency limit)
-        const workers = Array.from({ length: Math.min(FETCH_CONCURRENCY, repoPaths.length) }, () => worker());
+        const workers = Array.from({ length: Math.min(FETCH_CONCURRENCY, reposToFetch.length) }, () => worker());
         await Promise.all(workers);
-        // Clear the progress line and show summary
-        this.console.write('\r');
-        if (failed > 0) {
-            this.console.log(`Fetched ${total - failed}/${total} repos ${chalk.yellow(`(${failed} failed)`)}`);
-        }
-        else {
-            this.console.log(`Fetched ${total} repos ${chalk.green('✓')}`);
+        if (!silent) {
+            // Clear the progress line and show summary
+            this.console.write('\r');
+            const cacheInfo = cachedCount > 0 ? ` (${cachedCount} cached)` : '';
+            if (failed > 0) {
+                this.console.log(`Fetched ${total - failed}/${total} repos${cacheInfo} ${chalk.yellow(`(${failed} failed)`)}`);
+            }
+            else {
+                this.console.log(`Fetched ${total} repos${cacheInfo} ${chalk.green('✓')}`);
+            }
         }
     }
 }

package/dist/lib/fetchCache.js

@@ -0,0 +1,97 @@
+import path from 'path';
+export class FetchCacheService {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    /**
+     * Check if a repository needs fetching based on TTL
+     * @param repoPath Absolute path to repository
+     * @param ttlSeconds TTL in seconds (0 = always fetch)
+     * @returns true if repo should be fetched
+     */
+    shouldFetch(repoPath, ttlSeconds) {
+        if (ttlSeconds === 0) {
+            return true; // Caching disabled
+        }
+        const cache = this.loadCache();
+        const cachedTimestamp = cache[repoPath];
+        if (!cachedTimestamp) {
+            return true; // Cache miss
+        }
+        const now = Date.now();
+        const age = now - cachedTimestamp;
+        const ttlMs = ttlSeconds * 1000;
+        return age > ttlMs; // Expired if older than TTL
+    }
+    /**
+     * Mark a repository as fetched with current timestamp
+     * @param repoPath Absolute path to repository
+     */
+    markFetched(repoPath) {
+        try {
+            const cache = this.loadCache();
+            cache[repoPath] = Date.now();
+            this.saveCache(cache);
+        }
+        catch (error) {
+            // Don't block operations on cache write errors
+            console.warn('Warning: Failed to update fetch cache:', error);
+        }
+    }
+    /**
+     * Filter repositories to only those that need fetching
+     * @param repoPaths Array of absolute repository paths
+     * @param ttlSeconds TTL in seconds
+     * @returns Array of repos that need fetching
+     */
+    filterReposToFetch(repoPaths, ttlSeconds) {
+        return repoPaths.filter(repoPath => this.shouldFetch(repoPath, ttlSeconds));
+    }
+    /**
+     * Load cache from disk
+     * @returns Cache data object
+     */
+    loadCache() {
+        const cachePath = this.getFetchCachePath();
+        try {
+            if (!this.fs.existsSync(cachePath)) {
+                return {};
+            }
+            const content = this.fs.readFileSync(cachePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            // Corrupted cache - delete and start fresh
+            console.warn('Warning: Corrupted fetch cache, resetting:', error);
+            try {
+                this.fs.rmSync(cachePath, { force: true });
+            }
+            catch {
+                // Ignore errors deleting corrupted cache
+            }
+            return {};
+        }
+    }
+    /**
+     * Save cache to disk
+     * @param cache Cache data to save
+     */
+    saveCache(cache) {
+        const cachePath = this.getFetchCachePath();
+        const cacheDir = path.dirname(cachePath);
+        // Ensure cache directory exists
+        if (!this.fs.existsSync(cacheDir)) {
+            this.fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        this.fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+    }
+    /**
+     * Get path to fetch cache file
+     * @returns Absolute path to ~/.config/flow/fetch-cache.json
+     */
+    getFetchCachePath() {
+        const home = process.env.HOME || process.env.USERPROFILE || '';
+        return path.join(home, '.config', 'flow', 'fetch-cache.json');
+    }
+}

package/dist/lib/postCheckout.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 /**
  * PostCheckoutService handles execution of post-checkout commands.
  */
@@ -6,17 +7,25 @@ export class PostCheckoutService {
     constructor(shell) {
         this.shell = shell;
     }
-    async runCommand(worktreeDirs, command) {
+    async runCommand(worktreeDirs, globalCommand, perRepoCommands) {
+        // Determine command for each worktree (per-repo overrides global)
+        const commandsToRun = worktreeDirs
+            .map((dir) => {
+            const repoName = path.basename(dir);
+            const command = perRepoCommands[repoName] ?? globalCommand;
+            return command ? { dir, command } : null;
+        })
+            .filter((x) => x !== null);
         let successCount = 0;
-        await Promise.allSettled(worktreeDirs.map(async (worktreeDir) => {
+        await Promise.allSettled(commandsToRun.map(async ({ dir, command }) => {
             try {
-                await this.shell.execFile('sh', ['-c', command], { cwd: worktreeDir });
+                await this.shell.execFile('sh', ['-c', command], { cwd: dir });
                 successCount++;
             }
             catch {
                 // Error handled by caller
             }
         }));
-        return { successCount, totalCount: worktreeDirs.length };
+        return { successCount, totalCount: commandsToRun.length };
     }
 }

package/dist/lib/services.js

@@ -9,6 +9,7 @@ import { WorkspaceDirectoryService } from './workspaceDirectory.js';
 import { WorktreeService } from './worktree.js';
 import { PostCheckoutService } from './postCheckout.js';
 import { FetchService } from './fetch.js';
+import { FetchCacheService } from './fetchCache.js';
 import { ParallelService } from './parallel.js';
 import { StatusService } from './status.js';
 import { TmuxService } from './tmux.js';
@@ -24,7 +25,8 @@ export function createServices() {
     const parallel = new ParallelService(console);
     const status = new StatusService(git);
     const tmux = new TmuxService(shell);
-    const fetch = new FetchService(git, console);
+    const fetchCache = new FetchCacheService(fs);
+    const fetch = new FetchService(git, console, fetchCache);
     const repos = new RepoService(fs, git);
     const postCheckout = new PostCheckoutService(shell);
     // Focused workspace services
@@ -38,6 +40,7 @@ export function createServices() {
         worktree,
         postCheckout,
         fetch,
+        fetchCache,
         parallel,
         status,
         tmux,

package/dist/lib/workspaceReposCollector.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+/**
+ * Collects all worktree directories and unique source repos across workspaces.
+ * This helper extracts common logic used by multiple use cases that need to
+ * fetch repos before analyzing workspace status.
+ */
+export function collectWorkspaceRepos(workspaces, workspaceDir, sourcePath) {
+    const uniqueSourceRepos = new Set();
+    const workspaceWorktrees = new Map();
+    for (const workspace of workspaces) {
+        const worktreeDirs = 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(sourcePath, repoName);
+                uniqueSourceRepos.add(sourceRepoPath);
+            });
+        }
+    }
+    return {
+        uniqueSourceRepos: Array.from(uniqueSourceRepos),
+        workspaceWorktrees,
+    };
+}

package/dist/usecases/checkWorkspaceStatus.js

@@ -3,16 +3,13 @@
  */
 export class CheckWorkspaceStatusUseCase {
     workspaceDir;
-    fetch;
     status;
-    constructor(workspaceDir, fetch, status) {
+    constructor(workspaceDir, 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

@@ -9,15 +9,13 @@ export class CheckoutWorkspaceUseCase {
     workspaceDir;
     worktree;
     repos;
-    fetch;
     parallel;
     tmux;
     postCheckout;
-    constructor(workspaceDir, worktree, repos, fetch, parallel, tmux, postCheckout) {
+    constructor(workspaceDir, worktree, repos, parallel, tmux, postCheckout) {
         this.workspaceDir = workspaceDir;
         this.worktree = worktree;
         this.repos = repos;
-        this.fetch = fetch;
         this.parallel = parallel;
         this.tmux = tmux;
         this.postCheckout = postCheckout;
@@ -28,16 +26,14 @@ export class CheckoutWorkspaceUseCase {
         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
+        // 2. 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
+        // 3. Create workspace directory
         const workspacePath = this.workspaceDir.createWorkspaceDir(params.destPath, params.branchName);
-        // 5. Create worktrees in parallel
+        // 4. 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);
@@ -45,9 +41,9 @@ export class CheckoutWorkspaceUseCase {
             this.worktree.copyConfigFilesToWorktree(repoPath, worktreeDest, params.copyFiles);
             return 'created';
         });
-        // 6. Copy AGENTS.md
+        // 5. Copy AGENTS.md
         this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
-        // 7. Create tmux session if enabled
+        // 6. Create tmux session if enabled
         let tmuxCreated = false;
         if (params.tmux) {
             try {
@@ -59,11 +55,11 @@ export class CheckoutWorkspaceUseCase {
                 // Don't fail
             }
         }
-        // 8. Run post-checkout if configured
+        // 7. Run post-checkout if configured
         let postCheckoutResult;
-        if (params.postCheckout) {
+        if (params.postCheckout || params.perRepoPostCheckout) {
             const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);
-            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout);
+            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout, params.perRepoPostCheckout ?? {});
         }
         return {
             workspacePath,

package/dist/usecases/createBranchWorkspace.js

@@ -2,31 +2,27 @@ 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.
+ * Orchestrates the entire workflow from workspace creation to post-checkout commands.
  */
 export class CreateBranchWorkspaceUseCase {
     workspaceDir;
     worktree;
     repos;
-    fetch;
     parallel;
     tmux;
     postCheckout;
-    constructor(workspaceDir, worktree, repos, fetch, parallel, tmux, postCheckout) {
+    constructor(workspaceDir, worktree, repos, 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
+        // 1. Create workspace directory
         const workspacePath = this.workspaceDir.createWorkspaceDir(params.destPath, params.branchName);
-        // 3. Create worktrees in parallel
+        // 2. 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);
@@ -34,9 +30,9 @@ export class CreateBranchWorkspaceUseCase {
             this.worktree.copyConfigFilesToWorktree(repoPath, worktreeDest, params.copyFiles);
             return 'created';
         });
-        // 4. Copy AGENTS.md if exists
+        // 3. Copy AGENTS.md if exists
         this.workspaceDir.copyAgentsMd(params.sourcePath, workspacePath);
-        // 5. Create tmux session if enabled
+        // 4. Create tmux session if enabled
         let tmuxCreated = false;
         if (params.tmux) {
             try {
@@ -48,11 +44,11 @@ export class CreateBranchWorkspaceUseCase {
                 // Don't fail, just return false
             }
         }
-        // 6. Run post-checkout command if configured
+        // 5. Run post-checkout command if configured
         let postCheckoutResult;
-        if (params.postCheckout) {
+        if (params.postCheckout || params.perRepoPostCheckout) {
             const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);
-            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout);
+            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout, params.perRepoPostCheckout ?? {});
         }
         return {
             workspacePath,

package/dist/usecases/discoverPrunableWorkspaces.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { StatusService as StatusServiceClass } from '../lib/status.js';
 /**
  * Use case for analyzing workspaces to find candidates for pruning.
@@ -6,12 +5,10 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class DiscoverPrunableWorkspacesUseCase {
     workspaceDir;
-    fetch;
     status;
     git;
-    constructor(workspaceDir, fetch, status, git) {
+    constructor(workspaceDir, status, git) {
         this.workspaceDir = workspaceDir;
-        this.fetch = fetch;
         this.status = status;
         this.git = git;
     }
@@ -19,30 +16,9 @@ export class DiscoverPrunableWorkspacesUseCase {
         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();
+        // Analyze each workspace
         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;

package/dist/usecases/fetchAllRepos.js

@@ -0,0 +1,16 @@
+/**
+ * Use case for fetching multiple repositories from source-path.
+ * Centralizes fetch logic that was previously scattered across multiple use cases.
+ */
+export class FetchAllReposUseCase {
+    fetch;
+    repos;
+    constructor(fetch, repos) {
+        this.fetch = fetch;
+        this.repos = repos;
+    }
+    async execute(params) {
+        const allRepos = this.repos.discoverRepos(params.sourcePath);
+        await this.fetch.fetchRepos(allRepos, { ttlSeconds: params.fetchCacheTtlSeconds });
+    }
+}

package/dist/usecases/fetchUsedRepos.js

@@ -0,0 +1,25 @@
+import { collectWorkspaceRepos } from '../lib/workspaceReposCollector.js';
+/**
+ * Use case for fetching all source repos used across all workspaces.
+ * This discovers all workspaces, collects their repos, and fetches them.
+ * Used by commands that need to analyze all workspaces (prune, list).
+ */
+export class FetchUsedReposUseCase {
+    workspaceDir;
+    fetch;
+    constructor(workspaceDir, fetch) {
+        this.workspaceDir = workspaceDir;
+        this.fetch = fetch;
+    }
+    async execute(params) {
+        // Discover all workspaces
+        const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        // Collect unique repos used across all workspaces
+        const { uniqueSourceRepos } = collectWorkspaceRepos(workspaces, this.workspaceDir, params.sourcePath);
+        // Fetch source repos
+        await this.fetch.fetchRepos(uniqueSourceRepos, {
+            silent: params.silent ?? false,
+            ttlSeconds: params.fetchCacheTtlSeconds,
+        });
+    }
+}

package/dist/usecases/fetchWorkspaceRepos.js

@@ -0,0 +1,30 @@
+import path from 'node:path';
+/**
+ * Use case for fetching all source repos needed by a single workspace.
+ * Discovers worktrees in the workspace and fetches their corresponding source repos.
+ * Used by commands operating on a specific workspace (remove, status).
+ */
+export class FetchWorkspaceReposUseCase {
+    workspaceDir;
+    fetch;
+    constructor(workspaceDir, fetch) {
+        this.workspaceDir = workspaceDir;
+        this.fetch = fetch;
+    }
+    async execute(params) {
+        // Get all worktree directories in the workspace
+        const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
+        // Map worktree directories to source repo paths
+        const sourceRepos = worktreeDirs.map((worktreePath) => {
+            const repoName = path.basename(worktreePath);
+            return path.join(params.sourcePath, repoName);
+        });
+        // Deduplicate repos (defensive - shouldn't have duplicates but be safe)
+        const uniqueSourceRepos = Array.from(new Set(sourceRepos));
+        // Fetch source repos
+        await this.fetch.fetchRepos(uniqueSourceRepos, {
+            silent: params.silent ?? false,
+            ttlSeconds: params.fetchCacheTtlSeconds,
+        });
+    }
+}

package/dist/usecases/listWorkspacesWithStatus.js

@@ -0,0 +1,39 @@
+/**
+ * Use case for listing all workspaces with their status information.
+ * Checks status for each workspace's worktrees.
+ */
+export class ListWorkspacesWithStatusUseCase {
+    workspaceDir;
+    status;
+    constructor(workspaceDir, status) {
+        this.workspaceDir = workspaceDir;
+        this.status = status;
+    }
+    async execute(params) {
+        const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        if (workspaces.length === 0) {
+            return { workspaces: [] };
+        }
+        // Check status and detect active workspace
+        const workspacesWithStatus = [];
+        for (const workspace of workspaces) {
+            const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
+            // Skip workspaces with no worktrees
+            if (!worktreeDirs || worktreeDirs.length === 0) {
+                continue;
+            }
+            // Check if this workspace is active (contains current working directory)
+            const isActive = this.workspaceDir.detectWorkspace(params.cwd, params.destPath) === workspace.path;
+            // Check status for all worktrees
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs, params.mainBranch);
+            workspacesWithStatus.push({
+                name: workspace.name,
+                path: workspace.path,
+                repoCount: workspace.repoCount,
+                isActive,
+                statuses,
+            });
+        }
+        return { workspaces: workspacesWithStatus };
+    }
+}

package/dist/usecases/removeWorkspace.js

@@ -9,23 +9,20 @@ export class RemoveWorkspaceUseCase {
     workspaceDir;
     worktree;
     repos;
-    fetch;
     status;
     tmux;
-    constructor(workspaceDir, worktree, repos, fetch, status, tmux) {
+    constructor(workspaceDir, worktree, repos, 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
+        // 1. 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)) {

package/dist/usecases/usecases.js

@@ -5,18 +5,26 @@ import { PushWorkspaceUseCase } from './pushWorkspace.js';
 import { PullWorkspaceUseCase } from './pullWorkspace.js';
 import { CheckWorkspaceStatusUseCase } from './checkWorkspaceStatus.js';
 import { DiscoverPrunableWorkspacesUseCase } from './discoverPrunableWorkspaces.js';
+import { ListWorkspacesWithStatusUseCase } from './listWorkspacesWithStatus.js';
+import { FetchAllReposUseCase } from './fetchAllRepos.js';
+import { FetchWorkspaceReposUseCase } from './fetchWorkspaceRepos.js';
+import { FetchUsedReposUseCase } from './fetchUsedRepos.js';
 /**
  * Factory function for creating all use cases with their service dependencies.
  * Use cases orchestrate workflows by coordinating multiple services.
  */
 export function createUseCases(services) {
     return {
-        createBranchWorkspace: new CreateBranchWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.fetch, services.parallel, services.tmux, services.postCheckout),
-        checkoutWorkspace: new CheckoutWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.fetch, services.parallel, services.tmux, services.postCheckout),
-        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.fetch, services.status, services.tmux),
+        fetchAllRepos: new FetchAllReposUseCase(services.fetch, services.repos),
+        fetchWorkspaceRepos: new FetchWorkspaceReposUseCase(services.workspaceDir, services.fetch),
+        fetchUsedRepos: new FetchUsedReposUseCase(services.workspaceDir, services.fetch),
+        createBranchWorkspace: new CreateBranchWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.parallel, services.tmux, services.postCheckout),
+        checkoutWorkspace: new CheckoutWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.parallel, services.tmux, services.postCheckout),
+        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.worktree, services.repos, services.status, services.tmux),
         pushWorkspace: new PushWorkspaceUseCase(services.workspaceDir, services.git, services.parallel),
         pullWorkspace: new PullWorkspaceUseCase(services.workspaceDir, services.git, services.parallel),
-        checkWorkspaceStatus: new CheckWorkspaceStatusUseCase(services.workspaceDir, services.fetch, services.status),
-        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.fetch, services.status, services.git),
+        checkWorkspaceStatus: new CheckWorkspaceStatusUseCase(services.workspaceDir, services.status),
+        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.status, services.git),
+        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.status),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "worktree-flow",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "Manage git worktrees across a poly-repo environment",
   "type": "module",
   "bin": {