worktree-flow 0.0.3 → 0.0.4

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.
 

package/dist/commands/list.js

@@ -1,26 +1,87 @@
 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 and check status
+    const result = await useCases.listWorkspacesWithStatus.execute({
+        destPath,
+        sourcePath,
+        mainBranch: config.mainBranch,
+        cwd,
+    });
+    // Phase 3: 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

@@ -31,11 +31,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 +73,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/lib/fetch.js

@@ -10,14 +10,17 @@ export class FetchService {
         this.git = git;
         this.console = console;
     }
-    async fetchRepos(repoPaths) {
+    async fetchRepos(repoPaths, options) {
         if (repoPaths.length === 0) {
             return;
         }
+        const silent = options?.silent ?? false;
         const total = repoPaths.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}%)`;
             this.console.write(`\r${message}`);
@@ -46,13 +49,15 @@ export class FetchService {
         // Start workers (up to concurrency limit)
         const workers = Array.from({ length: Math.min(FETCH_CONCURRENCY, repoPaths.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');
+            if (failed > 0) {
+                this.console.log(`Fetched ${total - failed}/${total} repos ${chalk.yellow(`(${failed} failed)`)}`);
+            }
+            else {
+                this.console.log(`Fetched ${total} repos ${chalk.green('✓')}`);
+            }
         }
     }
 }

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/discoverPrunableWorkspaces.js

@@ -1,5 +1,5 @@
-import path from 'node:path';
 import { StatusService as StatusServiceClass } from '../lib/status.js';
+import { collectWorkspaceRepos } from '../lib/workspaceReposCollector.js';
 /**
  * Use case for analyzing workspaces to find candidates for pruning.
  * Returns workspaces where all worktrees have no issues and commits are older than specified days.
@@ -20,25 +20,12 @@ export class DiscoverPrunableWorkspacesUseCase {
         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();
-        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);
-                });
-            }
-        }
+        const { uniqueSourceRepos, workspaceWorktrees } = collectWorkspaceRepos(workspaces, this.workspaceDir, params.sourcePath);
         // 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));
+        if (uniqueSourceRepos.length > 0) {
+            await this.fetch.fetchRepos(uniqueSourceRepos);
         }
         // Now analyze each workspace
         for (const workspace of workspaces) {

package/dist/usecases/listWorkspacesWithStatus.js

@@ -0,0 +1,48 @@
+import { collectWorkspaceRepos } from '../lib/workspaceReposCollector.js';
+/**
+ * Use case for listing all workspaces with their status information.
+ * Fetches all repos and checks status for each workspace's worktrees.
+ */
+export class ListWorkspacesWithStatusUseCase {
+    workspaceDir;
+    fetch;
+    status;
+    constructor(workspaceDir, fetch, status) {
+        this.workspaceDir = workspaceDir;
+        this.fetch = fetch;
+        this.status = status;
+    }
+    async execute(params) {
+        const workspaces = this.workspaceDir.listWorkspaces(params.destPath);
+        if (workspaces.length === 0) {
+            return { workspaces: [] };
+        }
+        // Collect all worktree directories and unique source repos across all workspaces
+        const { uniqueSourceRepos, workspaceWorktrees } = collectWorkspaceRepos(workspaces, this.workspaceDir, params.sourcePath);
+        // Fetch all unique source repos once (silently to avoid UI jumping)
+        if (uniqueSourceRepos.length > 0) {
+            await this.fetch.fetchRepos(uniqueSourceRepos, { silent: true });
+        }
+        // Check status and detect active workspace
+        const workspacesWithStatus = [];
+        for (const workspace of workspaces) {
+            const worktreeDirs = workspaceWorktrees.get(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/usecases.js

@@ -5,6 +5,7 @@ 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';
 /**
  * Factory function for creating all use cases with their service dependencies.
  * Use cases orchestrate workflows by coordinating multiple services.
@@ -18,5 +19,6 @@ export function createUseCases(services) {
         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),
+        listWorkspacesWithStatus: new ListWorkspacesWithStatusUseCase(services.workspaceDir, services.fetch, services.status),
     };
 }

package/package.json

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