worktree-flow 0.0.1

package/dist/commands/remove.js

@@ -0,0 +1,98 @@
+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';
+export async function runRemove(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) {
+        await services.fetch.fetchRepos(worktreeDirs);
+        services.console.log(`\nChecking for uncommitted changes and commits ahead of ${config.mainBranch}...`);
+        const results = await services.status.checkAllWorktrees(worktreeDirs, config.mainBranch);
+        for (const { repoName, status } of results) {
+            const message = StatusService.getStatusMessage(status, config.mainBranch);
+            if (StatusService.hasIssues(status)) {
+                services.console.log(`${repoName}... ${chalk.red(message)}`);
+            }
+            else {
+                services.console.log(`${repoName}... ${chalk.green(message)}`);
+            }
+        }
+    }
+    else {
+        services.console.log('No worktrees found in workspace.');
+    }
+    // Show what will be removed
+    services.console.log(`\n${chalk.yellow('This will remove:')}`);
+    services.console.log(`  Directory: ${chalk.cyan(workspacePath)}`);
+    if (worktreeDirs.length > 0) {
+        services.console.log(`  Worktrees: ${worktreeDirs.length} repo(s)`);
+    }
+    if (config.tmux) {
+        services.console.log(`  Tmux session: ${chalk.cyan(branchNameForDisplay)}`);
+    }
+    const confirmed = await deps.confirm({
+        message: 'Are you sure you want to remove this workspace?',
+        default: false,
+    });
+    if (!confirmed) {
+        services.console.log('\nCancelled.');
+        services.process.exit(0);
+    }
+    // Execute use case (will throw if there are issues)
+    services.console.log('\nRemoving workspace...');
+    const result = await useCases.removeWorkspace.execute({
+        workspacePath,
+        branchName: branchNameForDisplay,
+        sourcePath,
+        mainBranch: config.mainBranch,
+        tmux: config.tmux,
+    });
+    // Display worktree removal results
+    if (worktreeDirs.length > 0) {
+        for (const { repo, error } of result.removalErrors) {
+            if (error === 'source repo not found') {
+                services.console.log(`${repo}... ${chalk.yellow('source repo not found, skipping worktree removal')}`);
+            }
+            else {
+                services.console.log(`${repo}... ${chalk.red(`error: ${error}`)}`);
+            }
+        }
+        const successfulRemovals = result.worktreesTotal - result.removalErrors.length;
+        for (let i = 0; i < successfulRemovals; i++) {
+            services.console.log(`${worktreeDirs[i].split('/').pop()}... ${chalk.green('removed')}`);
+        }
+        services.console.log(`\nRemoved ${result.worktreesRemoved}/${result.worktreesTotal} worktree(s).`);
+    }
+    // Display results
+    if (result.workspaceDirRemoved) {
+        services.console.log(`${chalk.green('Removed:')} ${workspacePath}`);
+    }
+    if (result.tmuxKilled) {
+        services.console.log(`${chalk.green('Killed tmux session:')} ${branchNameForDisplay}`);
+    }
+    services.console.log(`\n${chalk.green('Successfully removed workspace:')} ${branchNameForDisplay}`);
+}
+export function registerRemoveCommand(program) {
+    program
+        .command('remove [branch-name]')
+        .description('Remove a workspace and all its worktrees (auto-detects from current directory if branch not provided)')
+        .action(async (branchName) => {
+        const services = createServices();
+        const useCases = createUseCases(services);
+        try {
+            await runRemove(branchName, useCases, services, { confirm });
+        }
+        catch (error) {
+            services.console.error(error.message);
+            services.process.exit(1);
+        }
+    });
+}

package/dist/commands/status.js

@@ -0,0 +1,52 @@
+import chalk from 'chalk';
+import { createServices } from '../lib/services.js';
+import { createUseCases } from '../usecases/usecases.js';
+import { StatusService } from '../lib/status.js';
+import { resolveWorkspace } from '../lib/workspaceResolver.js';
+export async function runStatus(branchName, useCases, services) {
+    const config = services.config.load();
+    const { workspacePath } = resolveWorkspace(branchName, services.workspaceDir, services.config, services.process);
+    services.console.log(`Workspace: ${chalk.cyan(workspacePath)}`);
+    const worktreeDirs = services.workspaceDir.getWorktreeDirs(workspacePath);
+    if (worktreeDirs.length === 0) {
+        services.console.log('\nNo worktrees found in workspace.');
+        return;
+    }
+    services.console.log('');
+    services.console.log(`\nStatus (comparing against ${chalk.cyan(config.mainBranch)}):\n`);
+    const result = await useCases.checkWorkspaceStatus.execute({
+        workspacePath,
+        mainBranch: config.mainBranch,
+    });
+    let cleanCount = 0;
+    let issuesCount = 0;
+    for (const { repoName, status } of result.statuses) {
+        const message = StatusService.getStatusMessage(status, config.mainBranch);
+        if (StatusService.hasIssues(status)) {
+            services.console.log(`  ${chalk.red('✗')} ${repoName}: ${chalk.red(message)}`);
+            issuesCount++;
+        }
+        else {
+            services.console.log(`  ${chalk.green('✓')} ${repoName}: ${chalk.green(message)}`);
+            cleanCount++;
+        }
+    }
+    services.console.log('');
+    services.console.log(`Summary: ${chalk.green(`${cleanCount} up to date`)}, ${issuesCount > 0 ? chalk.red(`${issuesCount} with issues`) : chalk.green('0 with issues')}`);
+}
+export function registerStatusCommand(program) {
+    program
+        .command('status [branch-name]')
+        .description('Show status of all worktrees in a workspace (auto-detects from current directory if branch not provided)')
+        .action(async (branchName) => {
+        const services = createServices();
+        const useCases = createUseCases(services);
+        try {
+            await runStatus(branchName, useCases, services);
+        }
+        catch (error) {
+            services.console.error(error.message);
+            services.process.exit(1);
+        }
+    });
+}

package/dist/lib/config.js

@@ -0,0 +1,131 @@
+import path from 'node:path';
+import os from 'node:os';
+import { z } from 'zod';
+import { ConfigNotSetError } from './errors.js';
+// Raw config schema (as stored in JSON)
+const RawConfigSchema = z.object({
+    'source-path': z.string().optional(),
+    'dest-path': z.string().optional(),
+    'copy-files': z.string().optional(),
+    'tmux': z.enum(['true', 'false']).optional(),
+    'main-branch': z.string().optional(),
+    'post-checkout': z.string().optional(),
+});
+// Parsed config schema (with proper types)
+const ParsedConfigSchema = z.object({
+    sourcePath: z.string().optional(),
+    destPath: z.string().optional(),
+    copyFiles: z.string().default('.env'),
+    tmux: z.boolean().default(false),
+    mainBranch: z.string().default('master'),
+    postCheckout: z.string().optional(),
+});
+// Required config schema (for getRequired)
+const RequiredConfigSchema = z.object({
+    sourcePath: z.string(),
+    destPath: z.string(),
+});
+// Schema for setting individual config values
+const ConfigValueSchemas = {
+    'source-path': z.string().transform((val) => path.resolve(val)),
+    'dest-path': z.string().transform((val) => path.resolve(val)),
+    'copy-files': z.string(),
+    'tmux': z.enum(['true', 'false']),
+    'main-branch': z.string(),
+    'post-checkout': z.string(),
+};
+export const CONFIG_KEYS = ['source-path', 'dest-path', 'copy-files', 'tmux', 'main-branch', 'post-checkout'];
+/**
+ * Pure utility functions (no I/O)
+ */
+export function validateAndTransformConfigValue(key, value) {
+    const schema = ConfigValueSchemas[key];
+    return schema.parse(value);
+}
+export function isValidKey(key) {
+    return CONFIG_KEYS.includes(key);
+}
+export function getConfigPath() {
+    return path.join(os.homedir(), '.config', 'flow', 'config.json');
+}
+/**
+ * ConfigService handles all configuration operations.
+ */
+export class ConfigService {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    loadRaw() {
+        const configPath = getConfigPath();
+        if (!this.fs.existsSync(configPath)) {
+            return {};
+        }
+        const raw = this.fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return RawConfigSchema.parse(parsed);
+    }
+    saveRaw(config) {
+        const configPath = getConfigPath();
+        this.fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        const validated = RawConfigSchema.parse(config);
+        this.fs.writeFileSync(configPath, JSON.stringify(validated, null, 2) + '\n');
+    }
+    load() {
+        const raw = this.loadRaw();
+        return ParsedConfigSchema.parse({
+            sourcePath: raw['source-path'],
+            destPath: raw['dest-path'],
+            copyFiles: raw['copy-files'],
+            tmux: raw.tmux === 'true',
+            mainBranch: raw['main-branch'],
+            postCheckout: raw['post-checkout'],
+        });
+    }
+    getRequired() {
+        const config = this.load();
+        const result = RequiredConfigSchema.safeParse({
+            sourcePath: config.sourcePath,
+            destPath: config.destPath,
+        });
+        if (!result.success) {
+            throw new ConfigNotSetError('flow is not configured. Run:\n' +
+                '  flow config set source-path <path>\n' +
+                '  flow config set dest-path <path>');
+        }
+        return result.data;
+    }
+    /**
+     * Get config display values (formatted for CLI output)
+     */
+    getDisplayConfig() {
+        const raw = this.loadRaw();
+        const config = this.load();
+        return {
+            'source-path': {
+                value: raw['source-path'] ?? '(not set)',
+                isDefault: !raw['source-path'],
+            },
+            'dest-path': {
+                value: raw['dest-path'] ?? '(not set)',
+                isDefault: !raw['dest-path'],
+            },
+            'copy-files': {
+                value: raw['copy-files'] ?? `${config.copyFiles} (default)`,
+                isDefault: !raw['copy-files'],
+            },
+            'tmux': {
+                value: raw.tmux ?? `${config.tmux} (default)`,
+                isDefault: !raw.tmux,
+            },
+            'main-branch': {
+                value: raw['main-branch'] ?? `${config.mainBranch} (default)`,
+                isDefault: !raw['main-branch'],
+            },
+            'post-checkout': {
+                value: raw['post-checkout'] ?? '(not set)',
+                isDefault: !raw['post-checkout'],
+            },
+        };
+    }
+}

package/dist/lib/errors.js

@@ -0,0 +1,39 @@
+/**
+ * Domain-specific error classes.
+ */
+export class ConfigNotSetError extends Error {
+    constructor(message = 'Configuration not set') {
+        super(message);
+        this.name = 'ConfigNotSetError';
+    }
+}
+export class WorkspaceNotFoundError extends Error {
+    constructor(path) {
+        super(`Workspace not found: ${path}`);
+        this.name = 'WorkspaceNotFoundError';
+    }
+}
+export class WorkspaceAlreadyExistsError extends Error {
+    constructor(path) {
+        super(`Workspace already exists: ${path}`);
+        this.name = 'WorkspaceAlreadyExistsError';
+    }
+}
+export class NoReposFoundError extends Error {
+    constructor(path) {
+        super(`No git repositories found in ${path}`);
+        this.name = 'NoReposFoundError';
+    }
+}
+export class WorkspaceHasIssuesError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'WorkspaceHasIssuesError';
+    }
+}
+export class NotInWorkspaceError extends Error {
+    constructor(destPath) {
+        super(`Not inside a flow workspace.\nNavigate to a directory under ${destPath}/.`);
+        this.name = 'NotInWorkspaceError';
+    }
+}

package/dist/lib/fetch.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+const FETCH_CONCURRENCY = 8;
+/**
+ * FetchService handles parallel fetching of multiple repos.
+ */
+export class FetchService {
+    git;
+    console;
+    constructor(git, console) {
+        this.git = git;
+        this.console = console;
+    }
+    async fetchRepos(repoPaths) {
+        if (repoPaths.length === 0) {
+            return;
+        }
+        const total = repoPaths.length;
+        let completed = 0;
+        let failed = 0;
+        const updateProgress = () => {
+            const percent = Math.floor((completed / total) * 100);
+            const message = `Fetching repos... ${completed}/${total} (${percent}%)`;
+            this.console.write(`\r${message}`);
+        };
+        updateProgress();
+        const processRepo = async (repoPath) => {
+            try {
+                await this.git.fetch(repoPath);
+            }
+            catch (err) {
+                failed++;
+            }
+            finally {
+                completed++;
+                updateProgress();
+            }
+        };
+        // Process repos with controlled concurrency
+        let index = 0;
+        const worker = async () => {
+            while (index < repoPaths.length) {
+                const repoPath = repoPaths[index++];
+                await processRepo(repoPath);
+            }
+        };
+        // 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('✓')}`);
+        }
+    }
+}

package/dist/lib/git.js

@@ -0,0 +1,124 @@
+/**
+ * GitService handles all git operations.
+ */
+export class GitService {
+    shell;
+    constructor(shell) {
+        this.shell = shell;
+    }
+    async exec(repoPath, args) {
+        const { stdout } = await this.shell.execFile('git', ['-C', repoPath, ...args], {
+            encoding: 'utf-8',
+        });
+        return stdout;
+    }
+    async fetch(repoPath) {
+        await this.exec(repoPath, ['fetch', '--all', '--prune']);
+    }
+    async remoteBranchExists(repoPath, branch) {
+        const output = await this.exec(repoPath, ['ls-remote', '--heads', 'origin', branch]);
+        return output.length > 0;
+    }
+    async localRemoteBranchExists(repoPath, branch) {
+        try {
+            await this.exec(repoPath, ['rev-parse', '--verify', `origin/${branch}`]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async addWorktreeNewBranch(repoPath, worktreePath, branch, sourceBranch) {
+        const args = ['worktree', 'add', '-b', branch, worktreePath];
+        if (sourceBranch) {
+            args.push(sourceBranch);
+        }
+        await this.exec(repoPath, args);
+    }
+    async addWorktree(repoPath, worktreePath, branch) {
+        await this.exec(repoPath, ['worktree', 'add', worktreePath, branch]);
+    }
+    async pull(worktreePath) {
+        await this.exec(worktreePath, ['pull']);
+    }
+    async push(worktreePath) {
+        await this.exec(worktreePath, ['push']);
+    }
+    async pushSetUpstream(worktreePath, branch) {
+        await this.exec(worktreePath, ['push', '--set-upstream', 'origin', branch]);
+    }
+    async getCurrentBranch(worktreePath) {
+        const output = await this.exec(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+        return output.trim();
+    }
+    async hasUncommittedChanges(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;
+        }
+    }
+    async isBehindOrigin(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 {
+            // Check if there's a diff between current branch and main
+            const output = await this.exec(repoPath, ['diff', `origin/${mainBranch}...HEAD`]);
+            return output.length > 0;
+        }
+        catch {
+            // If we can't determine, assume there are changes to be safe
+            return true;
+        }
+    }
+    async removeWorktree(repoPath, worktreePath) {
+        await this.exec(repoPath, ['worktree', 'remove', worktreePath]);
+    }
+    async getLastCommitDate(repoPath) {
+        const output = await this.exec(repoPath, ['log', '-1', '--format=%aI', 'HEAD']);
+        return new Date(output.trim());
+    }
+    /**
+     * Push with automatic set-upstream retry if no upstream is configured
+     */
+    async pushWithRetry(worktreePath) {
+        try {
+            await this.push(worktreePath);
+            return 'pushed';
+        }
+        catch (err) {
+            const stderr = err.stderr || err.message || '';
+            if (stderr.includes('no upstream') || stderr.includes('has no upstream')) {
+                const branch = (await this.getCurrentBranch(worktreePath)).trim();
+                await this.pushSetUpstream(worktreePath, branch);
+                return 'pushed (set upstream)';
+            }
+            throw err;
+        }
+    }
+}

package/dist/lib/parallel.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+/**
+ * ParallelService handles parallel processing with console feedback.
+ */
+export class ParallelService {
+    console;
+    constructor(console) {
+        this.console = console;
+    }
+    async processInParallel(items, getName, processor) {
+        const results = await Promise.allSettled(items.map(async (item) => {
+            const name = getName(item);
+            try {
+                const message = await processor(item, name);
+                this.console.log(chalk.green(`  ${name}: ${message}`));
+                return { success: true };
+            }
+            catch (err) {
+                const errorMsg = err.stderr || err.message || 'unknown error';
+                this.console.error(chalk.red(`  ${name}: ${errorMsg}`));
+                return { success: false };
+            }
+        }));
+        return results.filter((r) => r.status === 'fulfilled' && r.value.success).length;
+    }
+}

package/dist/lib/postCheckout.js

@@ -0,0 +1,22 @@
+/**
+ * PostCheckoutService handles execution of post-checkout commands.
+ */
+export class PostCheckoutService {
+    shell;
+    constructor(shell) {
+        this.shell = shell;
+    }
+    async runCommand(worktreeDirs, command) {
+        let successCount = 0;
+        await Promise.allSettled(worktreeDirs.map(async (worktreeDir) => {
+            try {
+                await this.shell.execFile('sh', ['-c', command], { cwd: worktreeDir });
+                successCount++;
+            }
+            catch {
+                // Error handled by caller
+            }
+        }));
+        return { successCount, totalCount: worktreeDirs.length };
+    }
+}

package/dist/lib/repos.js

@@ -0,0 +1,63 @@
+import path from 'node:path';
+/**
+ * RepoService handles repository discovery and operations.
+ */
+export class RepoService {
+    fs;
+    git;
+    constructor(fs, git) {
+        this.fs = fs;
+        this.git = git;
+    }
+    discoverRepos(sourcePath) {
+        const entries = this.fs.readdirSync(sourcePath, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(sourcePath, entry.name))
+            .filter((dirPath) => this.fs.existsSync(path.join(dirPath, '.git')))
+            .sort();
+    }
+    static getRepoName(repoPath) {
+        return path.basename(repoPath);
+    }
+    /**
+     * Find all repos that have a specific branch (checking local remote-tracking branches)
+     */
+    async findReposWithBranch(repos, branchName) {
+        if (!this.git) {
+            throw new Error('RepoService not configured with git service');
+        }
+        const results = [];
+        const matching = [];
+        for (const repoPath of repos) {
+            const repoName = RepoService.getRepoName(repoPath);
+            try {
+                const hasBranch = await this.git.localRemoteBranchExists(repoPath, branchName);
+                results.push({ repoPath, repoName, hasBranch });
+                if (hasBranch) {
+                    matching.push(repoPath);
+                }
+            }
+            catch (err) {
+                results.push({
+                    repoPath,
+                    repoName,
+                    hasBranch: false,
+                    error: err.stderr || err.message,
+                });
+            }
+        }
+        return { matching, results };
+    }
+    /**
+     * Format repo choices for checkbox selection
+     */
+    formatRepoChoices(repos) {
+        return repos
+            .map(repoPath => ({
+            name: RepoService.getRepoName(repoPath),
+            value: repoPath,
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+}

package/dist/lib/services.js

@@ -0,0 +1,47 @@
+/**
+ * Service factory for creating all services with production adapters.
+ */
+import { NodeFileSystem, NodeShell, NodeConsole, NodeProcess } from '../adapters/node.js';
+import { ConfigService } from './config.js';
+import { GitService } from './git.js';
+import { RepoService } from './repos.js';
+import { WorkspaceDirectoryService } from './workspaceDirectory.js';
+import { WorktreeService } from './worktree.js';
+import { PostCheckoutService } from './postCheckout.js';
+import { FetchService } from './fetch.js';
+import { ParallelService } from './parallel.js';
+import { StatusService } from './status.js';
+import { TmuxService } from './tmux.js';
+export function createServices() {
+    // Create adapters
+    const fs = new NodeFileSystem();
+    const shell = new NodeShell();
+    const console = new NodeConsole();
+    const process = new NodeProcess();
+    // Create services (no service-to-service dependencies)
+    const config = new ConfigService(fs);
+    const git = new GitService(shell);
+    const parallel = new ParallelService(console);
+    const status = new StatusService(git);
+    const tmux = new TmuxService(shell);
+    const fetch = new FetchService(git, console);
+    const repos = new RepoService(fs, git);
+    const postCheckout = new PostCheckoutService(shell);
+    // Focused workspace services
+    const workspaceDir = new WorkspaceDirectoryService(fs);
+    const worktree = new WorktreeService(fs, git);
+    return {
+        config,
+        git,
+        repos,
+        workspaceDir,
+        worktree,
+        postCheckout,
+        fetch,
+        parallel,
+        status,
+        tmux,
+        console,
+        process,
+    };
+}