worktree-flow 0.0.12 → 0.0.14

package/README.md

@@ -126,6 +126,8 @@ Configure different commands for specific repos by editing `~/.config/flow/confi
 
 Repos with per-repo commands use those; others fall back to the global `post-checkout` command.
 
+When tmux is enabled, post-checkout commands run in the corresponding tmux panes instead of executing directly. This lets you see the output in real-time within your tmux session.
+
 ## AGENTS.md
 
 If an `AGENTS.md` file exists at the root of your source-path, it will be copied into each workspace. This is useful for providing AI coding agents with context about your multi-repo setup.

package/dist/commands/list.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
-import { getStatusIndicator } from './helpers.js';
+import { StatusService } from '../lib/status.js';
 export async function runList(useCases, services) {
     const { destPath, sourcePath } = services.config.getRequired();
     const config = services.config.load();
@@ -45,10 +45,25 @@ export async function runList(useCases, services) {
     // 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}`);
+        services.console.log(`${activeIndicator}${chalk.cyan(workspace.name)} ${repoCount}`);
+        // Load workspace config to get per-repo base branches
+        const workspaceConfig = services.workspaceConfig.load(workspace.path);
+        const getBaseBranch = (repoName) => workspaceConfig.baseBranches[repoName] || 'master';
+        // Display each repo with its status and tracking branch
+        for (const { repoName, status } of workspace.statuses) {
+            const baseBranch = getBaseBranch(repoName);
+            const statusMessage = StatusService.getStatusMessage(status, baseBranch);
+            const hasIssues = StatusService.hasIssues(status);
+            const indicator = hasIssues ? chalk.red('✗') : chalk.green('✓');
+            const message = hasIssues ? chalk.red(statusMessage) : chalk.green(statusMessage);
+            const trackingInfo = status.upstreamBranch
+                ? chalk.dim(` → ${status.upstreamBranch}`)
+                : chalk.dim(' (no upstream)');
+            services.console.log(`    ${indicator} ${chalk.yellow(repoName)}: ${message}${trackingInfo}`);
+        }
+        services.console.log(''); // Blank line between workspaces
     }
 }
 export function registerListCommand(program) {

package/dist/lib/git.js

@@ -45,7 +45,7 @@ export class GitService {
         return null;
     }
     async addWorktreeNewBranch(repoPath, worktreePath, branch, sourceBranch) {
-        const args = ['worktree', 'add', '-b', branch, worktreePath];
+        const args = ['worktree', 'add', '--no-track', '-b', branch, worktreePath];
         if (sourceBranch) {
             args.push(sourceBranch);
         }
@@ -67,6 +67,15 @@ export class GitService {
         const output = await this.exec(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD']);
         return output.trim();
     }
+    async getUpstreamBranch(worktreePath) {
+        try {
+            const output = await this.exec(worktreePath, ['rev-parse', '--abbrev-ref', '@{u}']);
+            return output.trim();
+        }
+        catch {
+            return null;
+        }
+    }
     async hasUncommittedChanges(repoPath) {
         const output = await this.exec(repoPath, ['status', '--porcelain']);
         return output.length > 0;

package/dist/lib/postCheckout.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 /**
  * PostCheckoutService handles execution of post-checkout commands.
  */
@@ -7,25 +6,7 @@ export class PostCheckoutService {
     constructor(shell) {
         this.shell = shell;
     }
-    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(commandsToRun.map(async ({ dir, command }) => {
-            try {
-                await this.shell.execFile('sh', ['-c', command], { cwd: dir });
-                successCount++;
-            }
-            catch {
-                // Error handled by caller
-            }
-        }));
-        return { successCount, totalCount: commandsToRun.length };
+    async runCommandInDirectory(directory, command) {
+        await this.shell.execFile('sh', ['-c', command], { cwd: directory });
     }
 }

package/dist/lib/status.js

@@ -8,17 +8,20 @@ export class StatusService {
     }
     async getWorktreeStatus(worktreePath, baseBranch) {
         try {
+            // Get branch information
+            const currentBranch = await this.git.getCurrentBranch(worktreePath);
+            const upstreamBranch = await this.git.getUpstreamBranch(worktreePath);
             // Check for uncommitted changes first
             const hasUncommitted = await this.git.hasUncommittedChanges(worktreePath);
             if (hasUncommitted) {
-                return { type: 'uncommitted' };
+                return { type: 'uncommitted', currentBranch, upstreamBranch };
             }
             // Compare against base branch using git cherry (handles squash merges)
             const isAhead = await this.git.isAheadOfMain(worktreePath, baseBranch);
             if (isAhead) {
-                return { type: 'ahead', comparedTo: 'main' };
+                return { type: 'ahead', comparedTo: 'main', currentBranch, upstreamBranch };
             }
-            return { type: 'clean', comparedTo: 'main' };
+            return { type: 'clean', comparedTo: 'main', currentBranch, upstreamBranch };
         }
         catch (err) {
             return {

package/dist/lib/tmux.js

@@ -44,6 +44,15 @@ export class TmuxService {
             }
         }
     }
+    async sendKeysToPane(sessionName, paneIndex, command) {
+        await this.shell.execFile('tmux', [
+            'send-keys',
+            '-t',
+            `${sessionName}:0.${paneIndex}`,
+            command,
+            'Enter',
+        ]);
+    }
     async killSession(sessionName) {
         try {
             await this.shell.execFile('tmux', ['kill-session', '-t', sessionName]);

package/dist/usecases/checkoutWorkspace.js

@@ -13,8 +13,8 @@ export class CheckoutWorkspaceUseCase {
     git;
     parallel;
     tmux;
-    postCheckout;
-    constructor(workspaceDir, workspaceConfig, worktree, repos, git, parallel, tmux, postCheckout) {
+    runPostCheckout;
+    constructor(workspaceDir, workspaceConfig, worktree, repos, git, parallel, tmux, runPostCheckout) {
         this.workspaceDir = workspaceDir;
         this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
@@ -22,7 +22,7 @@ export class CheckoutWorkspaceUseCase {
         this.git = git;
         this.parallel = parallel;
         this.tmux = tmux;
-        this.postCheckout = postCheckout;
+        this.runPostCheckout = runPostCheckout;
     }
     async execute(params) {
         // 1. Discover all repos
@@ -69,11 +69,13 @@ export class CheckoutWorkspaceUseCase {
             }
         }
         // 9. Run post-checkout if configured
-        let postCheckoutResult;
-        if (params.postCheckout || params.perRepoPostCheckout) {
-            const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);
-            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout, params.perRepoPostCheckout ?? {});
-        }
+        const postCheckoutResult = await this.runPostCheckout.execute({
+            workspacePath,
+            sessionName: tmuxCreated ? params.branchName : undefined,
+            tmuxEnabled: tmuxCreated,
+            postCheckout: params.postCheckout,
+            perRepoPostCheckout: params.perRepoPostCheckout,
+        });
         return {
             workspacePath,
             matchingRepos: matching.length,

package/dist/usecases/createBranchWorkspace.js

@@ -12,8 +12,8 @@ export class CreateBranchWorkspaceUseCase {
     git;
     parallel;
     tmux;
-    postCheckout;
-    constructor(workspaceDir, workspaceConfig, worktree, repos, git, parallel, tmux, postCheckout) {
+    runPostCheckout;
+    constructor(workspaceDir, workspaceConfig, worktree, repos, git, parallel, tmux, runPostCheckout) {
         this.workspaceDir = workspaceDir;
         this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
@@ -21,7 +21,7 @@ export class CreateBranchWorkspaceUseCase {
         this.git = git;
         this.parallel = parallel;
         this.tmux = tmux;
-        this.postCheckout = postCheckout;
+        this.runPostCheckout = runPostCheckout;
     }
     async execute(params) {
         // 1. Create workspace directory
@@ -66,11 +66,13 @@ export class CreateBranchWorkspaceUseCase {
             }
         }
         // 6. Run post-checkout command if configured
-        let postCheckoutResult;
-        if (params.postCheckout || params.perRepoPostCheckout) {
-            const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspacePath);
-            postCheckoutResult = await this.postCheckout.runCommand(worktreeDirs, params.postCheckout, params.perRepoPostCheckout ?? {});
-        }
+        const postCheckoutResult = await this.runPostCheckout.execute({
+            workspacePath,
+            sessionName: tmuxCreated ? params.branchName : undefined,
+            tmuxEnabled: tmuxCreated,
+            postCheckout: params.postCheckout,
+            perRepoPostCheckout: params.perRepoPostCheckout,
+        });
         return {
             workspacePath,
             successCount,

package/dist/usecases/resumeTmuxSessions.js

@@ -1,19 +1,14 @@
-import path from 'node:path';
 /**
  * Use case for resuming tmux sessions across all workspaces.
  * Creates sessions for workspaces that don't already have one.
- * Only creates splits for directories that match repos from source-path.
+ * Creates splits for all git directories (directories with .git).
  */
 export class ResumeTmuxSessionsUseCase {
     workspaceDir;
     tmux;
-    repos;
-    config;
-    constructor(workspaceDir, tmux, repos, config) {
+    constructor(workspaceDir, tmux) {
         this.workspaceDir = workspaceDir;
         this.tmux = tmux;
-        this.repos = repos;
-        this.config = config;
     }
     async execute(params) {
         // 1. List all workspaces
@@ -27,24 +22,16 @@ export class ResumeTmuxSessionsUseCase {
                 errors: [],
             };
         }
-        // 2. Get valid repo names from source-path
-        const { sourcePath } = this.config.getRequired();
-        const repoPaths = this.repos.discoverRepos(sourcePath);
-        const validRepoNames = new Set(repoPaths.map(repoPath => path.basename(repoPath)));
         let sessionsCreated = 0;
         let sessionsSkipped = 0;
         const errors = [];
-        // 3. Try to create tmux session for each workspace
+        // 2. Try to create tmux session for each workspace
         for (const workspace of workspaces) {
             try {
-                const allWorktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
-                // Filter to only include directories that match repo names from source-path
-                const filteredWorktreeDirs = allWorktreeDirs.filter(worktreeDir => {
-                    const dirName = path.basename(worktreeDir);
-                    return validRepoNames.has(dirName);
-                });
+                // Get all git directories (getWorktreeDirs now filters to only include dirs with .git)
+                const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
                 // Try to create session - will throw on duplicate session
-                await this.tmux.createSession(workspace.path, workspace.name, filteredWorktreeDirs);
+                await this.tmux.createSession(workspace.path, workspace.name, worktreeDirs);
                 sessionsCreated++;
             }
             catch (error) {

package/dist/usecases/runPostCheckout.js

@@ -0,0 +1,49 @@
+import path from 'node:path';
+/**
+ * Use case for running post-checkout commands.
+ * Runs commands either directly in worktree directories or in tmux panes.
+ */
+export class RunPostCheckoutUseCase {
+    workspaceDir;
+    postCheckout;
+    tmux;
+    constructor(workspaceDir, postCheckout, tmux) {
+        this.workspaceDir = workspaceDir;
+        this.postCheckout = postCheckout;
+        this.tmux = tmux;
+    }
+    async execute(params) {
+        // Skip if no commands configured
+        if (!params.postCheckout && (!params.perRepoPostCheckout || Object.keys(params.perRepoPostCheckout).length === 0)) {
+            return undefined;
+        }
+        // Get worktree directories
+        const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
+        // Map each worktree to its command (per-repo overrides global)
+        const commandsToRun = worktreeDirs
+            .map((dir, index) => {
+            const repoName = path.basename(dir);
+            const command = params.perRepoPostCheckout?.[repoName] ?? params.postCheckout;
+            return command ? { dir, command, paneIndex: index + 1 } : null;
+        })
+            .filter((x) => x !== null);
+        // Run commands in parallel
+        let successCount = 0;
+        await Promise.allSettled(commandsToRun.map(async ({ dir, command, paneIndex }) => {
+            try {
+                if (params.tmuxEnabled && params.sessionName) {
+                    // Panes are indexed from 0, first pane (root) is 0, worktrees start at 1
+                    await this.tmux.sendKeysToPane(params.sessionName, paneIndex, command);
+                }
+                else {
+                    await this.postCheckout.runCommandInDirectory(dir, command);
+                }
+                successCount++;
+            }
+            catch {
+                // Error handled by counting successes
+            }
+        }));
+        return { successCount, totalCount: commandsToRun.length };
+    }
+}

package/dist/usecases/usecases.js

@@ -10,23 +10,27 @@ import { FetchAllReposUseCase } from './fetchAllRepos.js';
 import { FetchWorkspaceReposUseCase } from './fetchWorkspaceRepos.js';
 import { FetchUsedReposUseCase } from './fetchUsedRepos.js';
 import { ResumeTmuxSessionsUseCase } from './resumeTmuxSessions.js';
+import { RunPostCheckoutUseCase } from './runPostCheckout.js';
 /**
  * Factory function for creating all use cases with their service dependencies.
  * Use cases orchestrate workflows by coordinating multiple services.
  */
 export function createUseCases(services) {
+    // Create use cases that are dependencies first
+    const runPostCheckout = new RunPostCheckoutUseCase(services.workspaceDir, services.postCheckout, services.tmux);
     return {
         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.workspaceConfig, services.worktree, services.repos, services.git, services.parallel, services.tmux, services.postCheckout),
-        checkoutWorkspace: new CheckoutWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.git, services.parallel, services.tmux, services.postCheckout),
+        createBranchWorkspace: new CreateBranchWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.git, services.parallel, services.tmux, runPostCheckout),
+        checkoutWorkspace: new CheckoutWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.git, services.parallel, services.tmux, runPostCheckout),
         removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, 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.workspaceConfig, services.status),
         discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.workspaceConfig, services.status, services.git),
         listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.workspaceConfig, services.status),
-        resumeTmuxSessions: new ResumeTmuxSessionsUseCase(services.workspaceDir, services.tmux, services.repos, services.config),
+        resumeTmuxSessions: new ResumeTmuxSessionsUseCase(services.workspaceDir, services.tmux),
+        runPostCheckout,
     };
 }

package/package.json

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