worktree-flow 0.0.9 → 0.0.11

package/README.md

@@ -80,15 +80,15 @@ Fetches all repos before checking status to ensure accurate information. The sta
 
 ### `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.
+Remove a workspace and all its worktrees. Fetches latest, checks for uncommitted changes, and prompts for confirmation before removing. Committed changes are safe to remove since they're preserved in git history.
 
 ### `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.
+Remove workspaces interactively. Shows all workspaces with their status (similar to `flow list`) and lets you select which ones to prune. Only workspaces with no uncommitted changes can be successfully removed.
 
 ### `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.
+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 that matches a repo from source-path) using a tiled layout. Skips workspaces that already have active sessions.
 
 Requires `tmux` to be installed and the `tmux` config option to be enabled.
 

package/dist/commands/helpers.js

@@ -0,0 +1,32 @@
+import chalk from 'chalk';
+/**
+ * Get a human-readable status indicator for a workspace based on its worktree statuses.
+ */
+export 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');
+    }
+}

package/dist/commands/list.js

@@ -1,34 +1,7 @@
 import chalk from 'chalk';
 import { createServices } from '../lib/services.js';
 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');
-    }
-}
+import { getStatusIndicator } from './helpers.js';
 export async function runList(useCases, services) {
     const { destPath, sourcePath } = services.config.getRequired();
     const config = services.config.load();

package/dist/commands/prune.js

@@ -1,43 +1,55 @@
 import chalk from 'chalk';
+import checkbox from '@inquirer/checkbox';
 import confirm from '@inquirer/confirm';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
+import { getStatusIndicator } from './helpers.js';
 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');
+    const cwd = services.process.cwd();
+    // Check if workspaces exist
+    const basicWorkspaces = services.workspaceDir.listWorkspaces(destPath);
+    if (basicWorkspaces.length === 0) {
+        services.console.log('No workspaces found.');
+        services.process.exit(0);
+    }
     // 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({
+    // Get full status for all workspaces
+    const result = await useCases.listWorkspacesWithStatus.execute({
         destPath,
         sourcePath,
-        daysOld: 7,
+        cwd,
+    });
+    // Format choices for checkbox prompt
+    const choices = result.workspaces.map(workspace => {
+        const statusIndicator = getStatusIndicator(workspace);
+        const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
+        return {
+            name: `${chalk.cyan(workspace.name)} ${repoCount} ${statusIndicator}`,
+            value: workspace.name,
+        };
     });
-    if (result.prunable.length === 0) {
-        services.console.log('No workspaces to prune.');
-        services.console.log(`\nWorkspaces are prunable when:`);
-        services.console.log(`  - All worktrees have no uncommitted changes`);
-        services.console.log(`  - All worktrees are not ahead of their base branch`);
-        services.console.log(`  - Last commit is more than 7 days old`);
+    // Let user select workspaces to prune
+    const selected = await deps.checkbox({
+        message: 'Select workspaces to prune:',
+        choices,
+        pageSize: 20,
+    });
+    if (selected.length === 0) {
+        services.console.log('No workspaces selected.');
         services.process.exit(0);
     }
-    // Display prunable workspaces
-    services.console.log(`${chalk.yellow('Found')} ${chalk.cyan(result.prunable.length)} ${chalk.yellow('workspace(s) that can be pruned:')}\n`);
-    for (const workspace of result.prunable) {
-        const daysOld = Math.floor((Date.now() - workspace.oldestCommitDate.getTime()) / (1000 * 60 * 60 * 24));
-        services.console.log(`  ${chalk.cyan(workspace.name)}`);
-        services.console.log(`    Repos: ${workspace.repoCount}`);
-        services.console.log(`    Last commit: ${daysOld} days ago`);
-        services.console.log(`    Status: ${chalk.green('clean')}`);
-        services.console.log('');
-    }
+    // Get full workspace objects for selected items
+    const selectedWorkspaces = result.workspaces.filter(w => selected.includes(w.name));
+    // Confirm deletion
     const confirmed = await deps.confirm({
-        message: 'Are you sure you want to prune these workspaces?',
+        message: `Are you sure you want to prune ${selected.length} workspace(s)?`,
         default: false,
     });
     if (!confirmed) {
@@ -48,7 +60,7 @@ export async function runPrune(useCases, services, deps) {
     services.console.log('\nPruning workspaces...\n');
     let successCount = 0;
     let errorCount = 0;
-    for (const workspace of result.prunable) {
+    for (const workspace of selectedWorkspaces) {
         try {
             services.console.log(`Removing ${chalk.cyan(workspace.name)}...`);
             await useCases.removeWorkspace.execute({
@@ -78,12 +90,12 @@ export function registerPruneCommand(program) {
     program
         .command('prune')
         .alias('clean')
-        .description('Remove old workspaces with no uncommitted changes and commits older than 7 days')
+        .description('Select and remove workspaces')
         .action(async () => {
         const services = createServices();
         const useCases = createUseCases(services);
         try {
-            await runPrune(useCases, services, { confirm });
+            await runPrune(useCases, services, { checkbox, confirm });
         }
         catch (error) {
             services.console.error(error.message);

package/dist/commands/remove.js

@@ -18,7 +18,7 @@ export async function runRemove(branchName, useCases, services, deps) {
             sourcePath,
             fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
         });
-        services.console.log(`\nChecking for uncommitted changes and commits ahead of base branch...`);
+        services.console.log(`\nChecking for uncommitted changes...`);
         // Load workspace config to get per-repo base branches
         const workspaceConfig = services.workspaceConfig.load(workspacePath);
         const getBaseBranch = (repoName) => workspaceConfig.baseBranches[repoName] || 'master';

package/dist/lib/status.js

@@ -41,7 +41,6 @@ export class StatusService {
     }
     static hasIssues(status) {
         return (status.type === 'uncommitted' ||
-            status.type === 'ahead' ||
             status.type === 'error');
     }
     /**

package/dist/usecases/createBranchWorkspace.js

@@ -45,7 +45,7 @@ export class CreateBranchWorkspaceUseCase {
             }
             // Track the actual base branch used
             baseBranches[name] = actualBaseBranch;
-            await this.worktree.createWorktreeWithBranch(repoPath, worktreeDest, params.branchName, actualBaseBranch);
+            await this.worktree.createWorktreeWithBranch(repoPath, worktreeDest, params.branchName, `origin/${actualBaseBranch}`);
             this.worktree.copyConfigFilesToWorktree(repoPath, worktreeDest, params.copyFiles);
             return 'created';
         });

package/dist/usecases/removeWorkspace.js

@@ -39,7 +39,7 @@ export class RemoveWorkspaceUseCase {
                 }
             }
             if (issuesFound.length > 0) {
-                throw new WorkspaceHasIssuesError(`${issuesFound.length} repo(s) have uncommitted or unmerged changes.`);
+                throw new WorkspaceHasIssuesError(`${issuesFound.length} repo(s) have uncommitted changes or errors.`);
             }
         }
         // 2. Remove all worktrees

package/dist/usecases/resumeTmuxSessions.js

@@ -1,26 +1,50 @@
+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.
  */
 export class ResumeTmuxSessionsUseCase {
     workspaceDir;
     tmux;
-    constructor(workspaceDir, tmux) {
+    repos;
+    config;
+    constructor(workspaceDir, tmux, repos, config) {
         this.workspaceDir = workspaceDir;
         this.tmux = tmux;
+        this.repos = repos;
+        this.config = config;
     }
     async execute(params) {
         // 1. List all workspaces
         const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        // Early return if no workspaces
+        if (workspaces.length === 0) {
+            return {
+                totalWorkspaces: 0,
+                sessionsCreated: 0,
+                sessionsSkipped: 0,
+                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 = [];
-        // 2. Try to create tmux session for each workspace
+        // 3. Try to create tmux session for each workspace
         for (const workspace of workspaces) {
             try {
-                const worktreeDirs = this.workspaceDir.getWorktreeDirs(workspace.path);
+                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);
+                });
                 // Try to create session - will throw on duplicate session
-                await this.tmux.createSession(workspace.path, workspace.name, worktreeDirs);
+                await this.tmux.createSession(workspace.path, workspace.name, filteredWorktreeDirs);
                 sessionsCreated++;
             }
             catch (error) {

package/dist/usecases/usecases.js

@@ -27,6 +27,6 @@ export function createUseCases(services) {
         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),
+        resumeTmuxSessions: new ResumeTmuxSessionsUseCase(services.workspaceDir, services.tmux, services.repos, services.config),
     };
 }

package/package.json

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