worktree-flow 0.0.18 → 0.0.20

package/README.md

@@ -87,7 +87,7 @@ Drop a workspace and all its worktrees. Fetches latest, checks for uncommitted c
 
 ### `flow prune`
 
-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.
+Remove workspaces interactively. Displays full workspace status (identical to `flow list`), then excludes any workspaces with uncommitted changes or errors from the selection prompt. Resolve issues before pruning those workspaces.
 
 ### `flow fetch [name]`
 

package/dist/cli.js

@@ -19,18 +19,23 @@ program
     .name('flow')
     .description('Manage git worktrees across a poly-repo environment')
     .version('0.1.0');
+// Getting Started
+registerQuickstartCommand(program);
 registerConfigCommand(program);
+// Workspaces
 registerCreateCommand(program);
-registerAttachCommand(program);
-registerBranchCommand(program);
 registerCheckoutCommand(program);
 registerListCommand(program);
-registerPullCommand(program);
-registerPushCommand(program);
+registerAttachCommand(program);
 registerDropCommand(program);
-registerStatusCommand(program);
 registerPruneCommand(program);
+// Git Operations
+registerStatusCommand(program);
+registerPullCommand(program);
+registerPushCommand(program);
 registerFetchCommand(program);
+// Extras
 registerTmuxCommand(program);
-registerQuickstartCommand(program);
+// Deprecated
+registerBranchCommand(program);
 program.parse();

package/dist/commands/attach.js

@@ -105,6 +105,7 @@ export async function runAttach(branchName, useCases, services, deps) {
 export function registerAttachCommand(program) {
     program
         .command('attach [branch-name]')
+        .helpGroup('Workspaces')
         .description('Attach repos to an existing workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/branch.js

@@ -3,6 +3,7 @@ import { createServices } from '../lib/services.js';
 export function registerBranchCommand(program) {
     program
         .command('branch <branch-name>')
+        .helpGroup('Deprecated')
         .description(chalk.dim('Deprecated: use "flow create <branch-name>" instead'))
         .action(async () => {
         const services = createServices();

package/dist/commands/checkout.js

@@ -101,6 +101,7 @@ export async function runCheckout(branchName, useCases, services, deps) {
 export function registerCheckoutCommand(program) {
     program
         .command('checkout <branch-name>')
+        .helpGroup('Workspaces')
         .description('Checkout an existing branch across repos')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/config.js

@@ -5,6 +5,7 @@ import { createServices } from '../lib/services.js';
 export function registerConfigCommand(program) {
     const configCmd = program
         .command('config')
+        .helpGroup('Getting Started')
         .description('Manage flow configuration');
     configCmd
         .command('set <key> <value>')

package/dist/commands/create.js

@@ -103,6 +103,7 @@ export async function runCreate(branchName, useCases, services, deps) {
 export function registerCreateCommand(program) {
     program
         .command('create <branch-name>')
+        .helpGroup('Workspaces')
         .description('Create branches and worktrees for selected repos')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/drop.js

@@ -1,41 +1,44 @@
+import path from 'node:path';
 import chalk from 'chalk';
 import confirm from '@inquirer/confirm';
 import { createServices } from '../lib/services.js';
 import { createUseCases } from '../usecases/usecases.js';
-import { StatusService } from '../lib/status.js';
 import { resolveWorkspace } from '../lib/workspaceResolver.js';
+import { logStatusFetching, logStatus } from './helpers.js';
+import { StatusService } from '../lib/status.js';
+import { WorkspaceHasIssuesError } from '../lib/errors.js';
 export async function runDrop(branchName, useCases, services, deps) {
     const { sourcePath } = services.config.getRequired();
     const config = services.config.load();
     const { workspacePath, displayName: branchNameForDisplay } = resolveWorkspace(branchName, services.workspaceDir, services.config, services.process);
-    services.console.log(`Checking workspace: ${chalk.cyan(workspacePath)}`);
     // Get worktree dirs to show what will be removed
     const worktreeDirs = services.workspaceDir.getWorktreeDirs(workspacePath);
     // Display status check if worktrees exist
     if (worktreeDirs.length > 0) {
+        const workspaceName = path.basename(workspacePath);
+        const repoCount = worktreeDirs.length;
+        // Phase 1: Show header with fetching indicator
+        const loadingLines = logStatusFetching('Workspace:', [{ name: workspaceName, repoCount }], services.console);
+        // Fetch workspace repos (silently)
         await useCases.fetchWorkspaceRepos.execute({
             workspacePath,
             sourcePath,
             fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+            silent: true,
         });
-        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';
-        const results = await services.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
-        for (const { repoName, status } of results) {
-            const baseBranch = getBaseBranch(repoName);
-            const message = StatusService.getStatusMessage(status, baseBranch);
-            if (StatusService.hasIssues(status)) {
-                services.console.log(`${repoName}... ${chalk.red(message)}`);
-            }
-            else {
-                services.console.log(`${repoName}... ${chalk.green(message)}`);
-            }
+        const statusResult = await useCases.checkWorkspaceStatus.execute({
+            workspacePath,
+        });
+        // Phase 2: Clear Phase 1 lines and re-render with full status
+        logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: statusResult.statuses }], loadingLines, services.console);
+        // Block if any repos have uncommitted changes — user must resolve them first
+        const reposWithIssues = statusResult.statuses.filter(({ status }) => StatusService.hasIssues(status));
+        if (reposWithIssues.length > 0) {
+            throw new WorkspaceHasIssuesError(`${reposWithIssues.length} repo(s) have uncommitted changes or errors. Resolve them before dropping.`);
         }
     }
     else {
-        services.console.log('No worktrees found in workspace.');
+        services.console.log('\nNo worktrees found in workspace.');
     }
     // Show what will be removed
     services.console.log(`\n${chalk.yellow('This will remove:')}`);
@@ -90,6 +93,7 @@ export async function runDrop(branchName, useCases, services, deps) {
 export function registerDropCommand(program) {
     program
         .command('drop [branch-name]')
+        .helpGroup('Workspaces')
         .description('Drop a workspace and all its worktrees (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/fetch.js

@@ -28,6 +28,7 @@ export async function runFetch(branchName, useCases, services) {
 export function registerFetchCommand(program) {
     program
         .command('fetch [branch-name]')
+        .helpGroup('Git Operations')
         .description('Fetch repos (workspace-scoped if branch provided, all workspaces otherwise)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/helpers.js

@@ -3,15 +3,11 @@ import { StatusService } from '../lib/status.js';
 /**
  * Format a single repo's status as a display line, consistent across list and status commands.
  */
-export function formatRepoStatusLine(repoName, status, baseBranch) {
-    const statusMessage = StatusService.getStatusMessage(status, baseBranch);
+export function formatRepoStatusLine(repoName, status) {
+    const statusMessage = StatusService.getStatusMessage(status);
     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)');
-    return `    ${indicator} ${chalk.yellow(repoName)}: ${message}${trackingInfo}`;
+    return `    ${chalk.yellow(repoName)}: ${message}`;
 }
 /**
  * Render Phase 1: print a header and workspace rows with a "fetching..." indicator.
@@ -30,7 +26,7 @@ export function logStatusFetching(header, workspaces, console) {
 /**
  * Render Phase 2: clear the Phase 1 lines then print the header and full workspace status.
  */
-export function logStatus(header, workspaces, linesToClear, getBaseBranch, console) {
+export function logStatus(header, workspaces, linesToClear, console) {
     for (let i = 0; i < linesToClear; i++) {
         console.write('\x1b[1A'); // Move cursor up one line
         console.write('\x1b[2K'); // Clear entire line
@@ -41,8 +37,7 @@ export function logStatus(header, workspaces, linesToClear, getBaseBranch, conso
         const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
         console.log(`${activeIndicator}${chalk.cyan(workspace.name)} ${repoCount}`);
         for (const { repoName, status } of workspace.statuses) {
-            const baseBranch = getBaseBranch(workspace.path, repoName);
-            console.log(formatRepoStatusLine(repoName, status, baseBranch));
+            console.log(formatRepoStatusLine(repoName, status));
         }
         console.log('');
     }
@@ -71,34 +66,3 @@ export function buildRepoCheckboxChoices(repos, services, preSelected, createSep
     }
     return choices;
 }
-/**
- * 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

@@ -27,12 +27,13 @@ export async function runList(useCases, services) {
         cwd,
     });
     // Phase 4: Clear previous output and re-print with full status
-    logStatus('Workspaces:', result.workspaces, loadingLines, (wsPath, repoName) => services.workspaceConfig.load(wsPath).baseBranches[repoName] || 'master', services.console);
+    logStatus('Workspaces:', result.workspaces, loadingLines, services.console);
 }
 export function registerListCommand(program) {
     program
         .command('list')
         .alias('ls')
+        .helpGroup('Workspaces')
         .description('List all workspaces with status indicators')
         .action(async () => {
         const services = createServices();

package/dist/commands/prune.js

@@ -3,7 +3,8 @@ 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';
+import { logStatusFetching, logStatus } from './helpers.js';
+import { StatusService } from '../lib/status.js';
 export async function runPrune(useCases, services, deps) {
     const { sourcePath, destPath } = services.config.getRequired();
     const config = services.config.load();
@@ -14,11 +15,14 @@ export async function runPrune(useCases, services, deps) {
         services.console.log('No workspaces found.');
         services.process.exit(0);
     }
+    // Phase 1: Show basic list with fetching indicator
+    const loadingLines = logStatusFetching('Workspaces:', basicWorkspaces, services.console);
     // Fetch repos used across all workspaces
     await useCases.fetchUsedRepos.execute({
         destPath,
         sourcePath,
         fetchCacheTtlSeconds: config.fetchCacheTtlSeconds,
+        silent: true,
     });
     // Get full status for all workspaces
     const result = await useCases.listWorkspacesWithStatus.execute({
@@ -26,12 +30,31 @@ export async function runPrune(useCases, services, deps) {
         sourcePath,
         cwd,
     });
-    // Format choices for checkbox prompt
-    const choices = result.workspaces.map(workspace => {
-        const statusIndicator = getStatusIndicator(workspace);
+    // Phase 2: Clear Phase 1 and re-print with full status (same as `list` command)
+    logStatus('Workspaces:', result.workspaces, loadingLines, services.console);
+    // Partition workspaces into prunable (no issues) and skipped (has issues)
+    const prunableWorkspaces = result.workspaces.filter(ws => !ws.statuses.some(({ status }) => StatusService.hasIssues(status)));
+    const skippedWorkspaces = result.workspaces.filter(ws => ws.statuses.some(({ status }) => StatusService.hasIssues(status)));
+    // Log skipped workspaces with reason
+    for (const ws of skippedWorkspaces) {
+        const hasDirty = ws.statuses.some(s => s.status.type === 'dirty');
+        const hasError = ws.statuses.some(s => s.status.type === 'error');
+        const reason = hasDirty ? 'uncommitted changes' : hasError ? 'errors' : 'issues';
+        services.console.log(`${chalk.yellow('⚠')} Skipping ${chalk.cyan(ws.name)} (${reason})`);
+    }
+    // Newline if there were skipped workspaces
+    if (skippedWorkspaces.length)
+        console.log('');
+    // If no prunable workspaces remain, exit
+    if (prunableWorkspaces.length === 0) {
+        services.console.log('\nAll workspaces have uncommitted changes or errors. Resolve them before pruning.');
+        services.process.exit(0);
+    }
+    // Format choices for checkbox prompt (only prunable workspaces)
+    const choices = prunableWorkspaces.map(workspace => {
         const repoCount = chalk.dim(`(${workspace.repoCount} repo${workspace.repoCount === 1 ? '' : 's'})`);
         return {
-            name: `${chalk.cyan(workspace.name)} ${repoCount} ${statusIndicator}`,
+            name: `${chalk.cyan(workspace.name)} ${repoCount}`,
             value: workspace.name,
         };
     });
@@ -46,7 +69,7 @@ export async function runPrune(useCases, services, deps) {
         services.process.exit(0);
     }
     // Get full workspace objects for selected items
-    const selectedWorkspaces = result.workspaces.filter(w => selected.includes(w.name));
+    const selectedWorkspaces = prunableWorkspaces.filter(w => selected.includes(w.name));
     // Confirm deletion
     const confirmed = await deps.confirm({
         message: `Are you sure you want to prune ${selected.length} workspace(s)?`,
@@ -89,6 +112,7 @@ export async function runPrune(useCases, services, deps) {
 export function registerPruneCommand(program) {
     program
         .command('prune')
+        .helpGroup('Workspaces')
         .description('Select and remove workspaces')
         .action(async () => {
         const services = createServices();

package/dist/commands/pull.js

@@ -16,6 +16,7 @@ export async function runPull(branchName, useCases, services) {
 export function registerPullCommand(program) {
     program
         .command('pull [branch-name]')
+        .helpGroup('Git Operations')
         .description('Pull all repos in a workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/push.js

@@ -16,6 +16,7 @@ export async function runPush(branchName, useCases, services) {
 export function registerPushCommand(program) {
     program
         .command('push [branch-name]')
+        .helpGroup('Git Operations')
         .description('Push all repos in a workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/quickstart.js

@@ -143,6 +143,7 @@ export async function runQuickstart(services, deps) {
 export function registerQuickstartCommand(program) {
     program
         .command('quickstart')
+        .helpGroup('Getting Started')
         .description('Interactive setup wizard for first-time configuration')
         .action(async () => {
         const services = createServices();

package/dist/commands/status.js

@@ -26,14 +26,13 @@ export async function runStatus(branchName, useCases, services) {
     const result = await useCases.checkWorkspaceStatus.execute({
         workspacePath,
     });
-    // Load workspace config to get per-repo base branches
-    const workspaceConfig = services.workspaceConfig.load(workspacePath);
     // Phase 2: Clear Phase 1 lines and re-render with full status
-    logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: result.statuses }], loadingLines, (_, repoName) => workspaceConfig.baseBranches[repoName] || 'master', services.console);
+    logStatus('Workspace:', [{ name: workspaceName, path: workspacePath, repoCount, isActive: false, statuses: result.statuses }], loadingLines, services.console);
 }
 export function registerStatusCommand(program) {
     program
         .command('status [branch-name]')
+        .helpGroup('Git Operations')
         .description('Show status of all worktrees in a workspace (auto-detects from current directory if branch not provided)')
         .action(async (branchName) => {
         const services = createServices();

package/dist/commands/tmux.js

@@ -27,6 +27,7 @@ export async function runTmuxSync(useCases, services) {
 export function registerTmuxCommand(program) {
     const tmuxCommand = program
         .command('tmux')
+        .helpGroup('Extras')
         .description('Manage tmux sessions for workspaces');
     tmuxCommand
         .command('sync')

package/dist/lib/git.js

@@ -36,6 +36,15 @@ export class GitService {
             }
         }
     }
+    async remoteTrackingBranchExists(repoPath, branch) {
+        try {
+            await this.exec(repoPath, ['rev-parse', '--verify', `origin/${branch}`]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async findFirstExistingBranch(repoPath, candidates) {
         for (const branch of candidates) {
             const exists = await this.localRemoteBranchExists(repoPath, branch);
@@ -76,55 +85,36 @@ export class GitService {
             return null;
         }
     }
-    async hasUncommittedChanges(repoPath) {
+    async getStatusCounts(repoPath) {
         const output = await this.exec(repoPath, ['status', '--porcelain']);
-        return output.length > 0;
-    }
-    async originBranchExists(repoPath) {
-        try {
-            const branch = await this.getCurrentBranch(repoPath);
-            await this.exec(repoPath, ['rev-parse', '--verify', `origin/${branch}`]);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async isAheadOfOrigin(repoPath) {
-        try {
-            const branch = await this.getCurrentBranch(repoPath);
-            const output = await this.exec(repoPath, ['rev-list', '--count', `origin/${branch}..HEAD`]);
-            return parseInt(output, 10) > 0;
-        }
-        catch {
-            return false;
+        const lines = output.split('\n').filter(line => line.length > 0);
+        let untracked = 0;
+        let uncommitted = 0;
+        for (const line of lines) {
+            if (line.startsWith('??')) {
+                untracked++;
+            }
+            else {
+                uncommitted++;
+            }
         }
+        return { untracked, uncommitted };
     }
-    async isBehindOrigin(repoPath) {
+    async getUnpushedCommitCount(repoPath) {
         try {
             const branch = await this.getCurrentBranch(repoPath);
-            const output = await this.exec(repoPath, ['rev-list', '--count', `HEAD..origin/${branch}`]);
-            return parseInt(output, 10) > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    async isAheadOfMain(repoPath, mainBranch) {
-        try {
-            // Use git cherry to detect if commits exist in main via patch equivalence
-            // cherry outputs nothing if all commits are equivalent to main
-            // Format: "+ hash message" for unmerged, "- hash message" for already merged
-            const output = await this.exec(repoPath, ['cherry', `origin/${mainBranch}`, 'HEAD']);
-            // Filter to only unmerged commits (those starting with +)
-            const unmergedCommits = output
-                .split('\n')
-                .filter(line => line.trim().startsWith('+'));
-            return unmergedCommits.length > 0;
+            try {
+                const output = await this.exec(repoPath, ['rev-list', '--count', `origin/${branch}..HEAD`]);
+                return parseInt(output.trim(), 10);
+            }
+            catch {
+                // origin/<branch> doesn't exist yet — count commits not reachable from any remote ref
+                const output = await this.exec(repoPath, ['rev-list', '--count', 'HEAD', '--not', '--remotes']);
+                return parseInt(output.trim(), 10);
+            }
         }
         catch {
-            // If we can't determine, assume there are changes to be safe
-            return true;
+            return 0;
         }
     }
     async createBranch(repoPath, branchName, startPoint) {

package/dist/lib/status.js

@@ -6,54 +6,56 @@ export class StatusService {
     constructor(git) {
         this.git = git;
     }
-    async getWorktreeStatus(worktreePath, baseBranch) {
+    async getWorktreeStatus(worktreePath) {
         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', 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', currentBranch, upstreamBranch };
-            }
-            return { type: 'clean', comparedTo: 'main', currentBranch, upstreamBranch };
+            const { untracked, uncommitted } = await this.git.getStatusCounts(worktreePath);
+            const unpushed = await this.git.getUnpushedCommitCount(worktreePath);
+            const type = untracked > 0 || uncommitted > 0 ? 'dirty' : 'clean';
+            return { type, untracked, uncommitted, unpushed, currentBranch, upstreamBranch };
         }
         catch (err) {
             return {
                 type: 'error',
+                untracked: 0,
+                uncommitted: 0,
+                unpushed: 0,
                 error: err.stderr || err.message,
             };
         }
     }
-    static getStatusMessage(status, baseBranch) {
-        switch (status.type) {
-            case 'clean':
-                return 'up to date';
-            case 'uncommitted':
-                return 'uncommitted changes';
-            case 'ahead':
-                return `ahead of ${baseBranch}`;
-            case 'error':
-                return `error: ${status.error}`;
+    static getStatusMessage(status) {
+        if (status.type === 'error') {
+            return `error: ${status.error}`;
         }
+        if (status.type === 'clean' && status.unpushed === 0) {
+            return 'clean';
+        }
+        const parts = [];
+        if (status.untracked > 0) {
+            parts.push(`${status.untracked} untracked`);
+        }
+        if (status.uncommitted > 0) {
+            parts.push(`${status.uncommitted} modified`);
+        }
+        if (status.unpushed > 0) {
+            parts.push(`${status.unpushed} unpushed commit${status.unpushed === 1 ? '' : 's'}`);
+        }
+        return parts.length > 0 ? parts.join(', ') : 'clean';
     }
     static hasIssues(status) {
-        return (status.type === 'uncommitted' ||
+        return (status.untracked > 0 ||
+            status.uncommitted > 0 ||
             status.type === 'error');
     }
     /**
      * Check status of all worktrees in parallel
      */
-    async checkAllWorktrees(worktreeDirs, getBaseBranch) {
+    async checkAllWorktrees(worktreeDirs) {
         const results = await Promise.all(worktreeDirs.map(async (worktreePath) => {
             const repoName = worktreePath.split('/').pop() || worktreePath;
-            const baseBranch = getBaseBranch(repoName);
-            const status = await this.getWorktreeStatus(worktreePath, baseBranch);
+            const status = await this.getWorktreeStatus(worktreePath);
             return { repoName, status };
         }));
         return results;
@@ -61,8 +63,8 @@ export class StatusService {
     /**
      * Find repos with issues (for removal validation)
      */
-    async findReposWithIssues(worktreeDirs, getBaseBranch) {
-        const results = await this.checkAllWorktrees(worktreeDirs, getBaseBranch);
+    async findReposWithIssues(worktreeDirs) {
+        const results = await this.checkAllWorktrees(worktreeDirs);
         return results
             .filter(({ status }) => StatusService.hasIssues(status))
             .map(({ repoName }) => repoName);

package/dist/usecases/checkWorkspaceStatus.js

@@ -3,19 +3,14 @@
  */
 export class CheckWorkspaceStatusUseCase {
     workspaceDir;
-    workspaceConfig;
     status;
-    constructor(workspaceDir, workspaceConfig, status) {
+    constructor(workspaceDir, status) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.status = status;
     }
     async execute(params) {
         const worktreeDirs = this.workspaceDir.getWorktreeDirs(params.workspacePath);
-        // Load workspace config to get per-repo base branches
-        const config = this.workspaceConfig.load(params.workspacePath);
-        const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
-        const statuses = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
+        const statuses = await this.status.checkAllWorktrees(worktreeDirs);
         return { statuses };
     }
 }

package/dist/usecases/createBranch.js

@@ -25,8 +25,10 @@ export class CreateBranchUseCase {
         // 3. If the target branch already exists, skip creation and use it as-is
         const targetBranchExists = await this.git.localRemoteBranchExists(params.repoPath, params.branchName);
         if (!targetBranchExists) {
-            // 4. Create the branch from origin/<actualBaseBranch>
-            await this.git.createBranch(params.repoPath, params.branchName, `origin/${actualBaseBranch}`);
+            // 4. Prefer origin/<actualBaseBranch> as start point; fall back to local branch
+            const originExists = await this.git.remoteTrackingBranchExists(params.repoPath, actualBaseBranch);
+            const startPoint = originExists ? `origin/${actualBaseBranch}` : actualBaseBranch;
+            await this.git.createBranch(params.repoPath, params.branchName, startPoint);
         }
         // 5. Return the actual base branch used
         return {

package/dist/usecases/discoverPrunableWorkspaces.js

@@ -5,12 +5,10 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class DiscoverPrunableWorkspacesUseCase {
     workspaceDir;
-    workspaceConfig;
     status;
     git;
-    constructor(workspaceDir, workspaceConfig, status, git) {
+    constructor(workspaceDir, status, git) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.status = status;
         this.git = git;
     }
@@ -25,11 +23,8 @@ export class DiscoverPrunableWorkspacesUseCase {
             if (!worktreeDirs || worktreeDirs.length === 0) {
                 continue;
             }
-            // Load workspace config to get per-repo base branches
-            const config = this.workspaceConfig.load(workspace.path);
-            const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
             // Check status for all worktrees
-            const statuses = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs);
             // Skip if any worktree has issues
             const hasAnyIssues = statuses.some(({ status }) => StatusServiceClass.hasIssues(status));
             if (hasAnyIssues) {

package/dist/usecases/listWorkspacesWithStatus.js

@@ -4,11 +4,9 @@
  */
 export class ListWorkspacesWithStatusUseCase {
     workspaceDir;
-    workspaceConfig;
     status;
-    constructor(workspaceDir, workspaceConfig, status) {
+    constructor(workspaceDir, status) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.status = status;
     }
     async execute(params) {
@@ -26,11 +24,8 @@ export class ListWorkspacesWithStatusUseCase {
             }
             // Check if this workspace is active (contains current working directory)
             const isActive = this.workspaceDir.detectWorkspace(params.cwd, params.destPath) === workspace.path;
-            // Load workspace config to get per-repo base branches
-            const config = this.workspaceConfig.load(workspace.path);
-            const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
             // Check status for all worktrees
-            const statuses = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
+            const statuses = await this.status.checkAllWorktrees(worktreeDirs);
             workspacesWithStatus.push({
                 name: workspace.name,
                 path: workspace.path,

package/dist/usecases/removeWorkspace.js

@@ -7,14 +7,12 @@ import { StatusService as StatusServiceClass } from '../lib/status.js';
  */
 export class RemoveWorkspaceUseCase {
     workspaceDir;
-    workspaceConfig;
     worktree;
     repos;
     status;
     tmux;
-    constructor(workspaceDir, workspaceConfig, worktree, repos, status, tmux) {
+    constructor(workspaceDir, worktree, repos, status, tmux) {
         this.workspaceDir = workspaceDir;
-        this.workspaceConfig = workspaceConfig;
         this.worktree = worktree;
         this.repos = repos;
         this.status = status;
@@ -25,16 +23,12 @@ export class RemoveWorkspaceUseCase {
         const issuesFound = [];
         // 1. Check status if worktrees exist
         if (worktreeDirs.length > 0) {
-            // Load workspace config to get per-repo base branches
-            const config = this.workspaceConfig.load(params.workspacePath);
-            const getBaseBranch = (repoName) => config.baseBranches[repoName] || 'master';
-            const results = await this.status.checkAllWorktrees(worktreeDirs, getBaseBranch);
+            const results = await this.status.checkAllWorktrees(worktreeDirs);
             for (const { repoName, status } of results) {
                 if (StatusServiceClass.hasIssues(status)) {
-                    const baseBranch = getBaseBranch(repoName);
                     issuesFound.push({
                         repoName,
-                        issue: StatusServiceClass.getStatusMessage(status, baseBranch),
+                        issue: StatusServiceClass.getStatusMessage(status),
                     });
                 }
             }

package/dist/usecases/usecases.js

@@ -21,12 +21,12 @@ export function createUseCases(services) {
         fetchAllRepos: new FetchAllReposUseCase(services.fetch, services.repos),
         fetchWorkspaceRepos: new FetchWorkspaceReposUseCase(services.workspaceDir, services.fetch),
         fetchUsedRepos: new FetchUsedReposUseCase(services.workspaceDir, services.fetch),
-        removeWorkspace: new RemoveWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.worktree, services.repos, services.status, services.tmux),
+        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.workspaceConfig, services.status),
-        discoverPrunableWorkspaces: new DiscoverPrunableWorkspacesUseCase(services.workspaceDir, services.workspaceConfig, services.status, services.git),
-        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.workspaceConfig, services.status),
+        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),
         createWorkspace: new CreateWorkspaceUseCase(services.workspaceDir, services.workspaceConfig, services.tmux),
         createBranch: new CreateBranchUseCase(services.git),

package/package.json

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