worktree-flow 0.0.7 → 0.0.8

package/README.md

@@ -4,6 +4,7 @@
 
 [![npm version](https://img.shields.io/npm/v/worktree-flow)](https://www.npmjs.com/package/worktree-flow)
 [![npm downloads](https://img.shields.io/npm/dm/worktree-flow)](https://www.npmjs.com/package/worktree-flow)
+[![Build](https://github.com/simonpratt/worktree-flow/actions/workflows/build.yml/badge.svg)](https://github.com/simonpratt/worktree-flow/actions/workflows/build.yml)
 [![license](https://img.shields.io/npm/l/worktree-flow)](https://github.com/simonpratt/worktree-flow/blob/master/LICENSE)
 
 Stop juggling branches across repos. `flow` creates isolated workspaces with git worktrees from multiple repositories, all on the same branch, with a single command.
@@ -85,6 +86,12 @@ Remove a workspace and all its worktrees. Fetches latest, checks for uncommitted
 
 Remove stale workspaces in bulk. Finds workspaces where all worktrees are clean, fully merged, and haven't been committed to in over 7 days.
 
+### `flow tmux resume`
+
+Create tmux sessions for all workspaces that don't already have one. Each session is created with split panes (one for the workspace root and one for each worktree) using a tiled layout. Skips workspaces that already have active sessions.
+
+Requires `tmux` to be installed and the `tmux` config option to be enabled.
+
 ### `flow config set <key> <value>`
 
 Configure flow settings. See [Configuration](#configuration) below.

package/dist/cli.js

@@ -10,6 +10,7 @@ import { registerRemoveCommand } from './commands/remove.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerPruneCommand } from './commands/prune.js';
 import { registerFetchCommand } from './commands/fetch.js';
+import { registerTmuxCommand } from './commands/tmux.js';
 const program = new Command();
 program
     .name('flow')
@@ -25,4 +26,5 @@ registerRemoveCommand(program);
 registerStatusCommand(program);
 registerPruneCommand(program);
 registerFetchCommand(program);
+registerTmuxCommand(program);
 program.parse();

package/dist/commands/config.js

@@ -45,6 +45,16 @@ export function registerConfigCommand(program) {
             const displayValue = isDefault ? chalk.gray(value) : chalk.green(value);
             services.console.log(`  ${chalk.cyan(key)}: ${displayValue}`);
         }
+        // Display per-repo post-checkout commands
+        const perRepoCommands = displayConfig.perRepoPostCheckout;
+        if (Object.keys(perRepoCommands).length > 0) {
+            services.console.log('');
+            services.console.log(chalk.bold('Per-repo post-checkout commands:'));
+            services.console.log('');
+            for (const [repo, command] of Object.entries(perRepoCommands)) {
+                services.console.log(`  ${chalk.cyan(repo)}: ${chalk.green(command)}`);
+            }
+        }
         services.console.log('');
     });
 }

package/dist/commands/tmux.js

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import { createServices } from '../lib/services.js';
+import { createUseCases } from '../usecases/usecases.js';
+export async function runTmuxResume(useCases, services) {
+    const { destPath } = services.config.getRequired();
+    const result = await useCases.resumeTmuxSessions.execute({ destPath });
+    if (result.totalWorkspaces === 0) {
+        services.console.log('No workspaces found.');
+        return;
+    }
+    // Display results
+    if (result.sessionsCreated > 0) {
+        services.console.log(chalk.green(`✓ Created ${result.sessionsCreated} tmux session${result.sessionsCreated === 1 ? '' : 's'}`));
+    }
+    if (result.sessionsSkipped > 0) {
+        services.console.log(chalk.blue(`○ Skipped ${result.sessionsSkipped} existing session${result.sessionsSkipped === 1 ? '' : 's'}`));
+    }
+    if (result.errors.length > 0) {
+        services.console.log(chalk.red('\nErrors:'));
+        for (const error of result.errors) {
+            services.console.log(chalk.red(`  ${error.workspace}: ${error.error}`));
+        }
+    }
+    // Summary
+    services.console.log(chalk.dim(`\nTotal: ${result.totalWorkspaces} workspace${result.totalWorkspaces === 1 ? '' : 's'}`));
+}
+export function registerTmuxCommand(program) {
+    const tmuxCommand = program
+        .command('tmux')
+        .description('Manage tmux sessions for workspaces');
+    tmuxCommand
+        .command('resume')
+        .description('Create tmux sessions for all workspaces that don\'t have one')
+        .action(async () => {
+        const services = createServices();
+        const useCases = createUseCases(services);
+        try {
+            await runTmuxResume(useCases, services);
+        }
+        catch (error) {
+            services.console.error(error.message);
+            services.process.exit(1);
+        }
+    });
+}

package/dist/lib/config.js

@@ -142,6 +142,7 @@ export class ConfigService {
                 value: raw['fetch-cache-ttl-seconds'] ?? `${config.fetchCacheTtlSeconds} (default)`,
                 isDefault: !raw['fetch-cache-ttl-seconds'],
             },
+            perRepoPostCheckout: config.perRepoPostCheckout,
         };
     }
 }

package/dist/usecases/resumeTmuxSessions.js

@@ -0,0 +1,47 @@
+/**
+ * Use case for resuming tmux sessions across all workspaces.
+ * Creates sessions for workspaces that don't already have one.
+ */
+export class ResumeTmuxSessionsUseCase {
+    workspaceDir;
+    tmux;
+    constructor(workspaceDir, tmux) {
+        this.workspaceDir = workspaceDir;
+        this.tmux = tmux;
+    }
+    async execute(params) {
+        // 1. List all workspaces
+        const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        let sessionsCreated = 0;
+        let sessionsSkipped = 0;
+        const errors = [];
+        // 2. Try to create tmux session for each workspace
+        for (const workspace of workspaces) {
+            try {
+                const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
+                // Try to create session - will throw on duplicate session
+                await this.tmux.createSession(workspace.path, workspace.name, worktreeDirs);
+                sessionsCreated++;
+            }
+            catch (error) {
+                // Check if session already exists
+                if (error.message?.includes('duplicate session')) {
+                    sessionsSkipped++;
+                }
+                else {
+                    // Other error
+                    errors.push({
+                        workspace: workspace.name,
+                        error: error.message || 'Unknown error',
+                    });
+                }
+            }
+        }
+        return {
+            totalWorkspaces: workspaces.length,
+            sessionsCreated,
+            sessionsSkipped,
+            errors,
+        };
+    }
+}

package/dist/usecases/usecases.js

@@ -9,6 +9,7 @@ import { ListWorkspacesWithStatusUseCase } from './listWorkspacesWithStatus.js';
 import { FetchAllReposUseCase } from './fetchAllRepos.js';
 import { FetchWorkspaceReposUseCase } from './fetchWorkspaceRepos.js';
 import { FetchUsedReposUseCase } from './fetchUsedRepos.js';
+import { ResumeTmuxSessionsUseCase } from './resumeTmuxSessions.js';
 /**
  * Factory function for creating all use cases with their service dependencies.
  * Use cases orchestrate workflows by coordinating multiple services.
@@ -26,5 +27,6 @@ export function createUseCases(services) {
         checkWorkspaceStatus: new CheckWorkspaceStatusUseCase(services.workspaceDir, services.status),
         discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.status, services.git),
         listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.status),
+        resumeTmuxSessions: new ResumeTmuxSessionsUseCase(services.workspaceDir, services.tmux),
     };
 }

package/package.json

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