gitset/dist/core/config-manager.js

Enhanced git init with user configuration management

import { spawn } from 'cross-spawn';
import { ValidationUtils } from '../utils/validation.js';
export class ConfigManager {
    validationUtils;
    constructor(validationUtils) {
        this.validationUtils = validationUtils || new ValidationUtils();
    }
    async validateDirectory(directoryPath) {
        return await this.validationUtils.validateDirectoryPath(directoryPath);
    }
    async initializeRepository(directory, userInfo) {
        const errors = [];
        const warnings = [];
        try {
            // Ensure directory exists
            await this.validationUtils.ensureDirectoryExists(directory);
            // Check if Git repository already exists
            const hasGit = await this.hasGitDirectory(directory);
            if (hasGit) {
                // Only update configuration for existing repository
                await this.setLocalConfig(directory, userInfo);
                warnings.push('Git repository already exists. Only updated user configuration.');
            }
            else {
                // Initialize new Git repository
                const initResult = await this.executeGitCommand(['init'], directory);
                if (!initResult.success) {
                    errors.push(`Failed to initialize git repository: ${initResult.stderr}`);
                    return {
                        success: false,
                        directory,
                        userInfo,
                        errors,
                        warnings
                    };
                }
                // Set local user configuration
                await this.setLocalConfig(directory, userInfo);
            }
            return {
                success: true,
                directory,
                userInfo,
                errors: [],
                warnings
            };
        }
        catch (error) {
            errors.push(`Repository initialization failed: ${error}`);
            return {
                success: false,
                directory,
                userInfo,
                errors,
                warnings
            };
        }
    }
    async setLocalConfig(directory, userInfo) {
        const commands = [
            ['config', 'user.name', userInfo.name],
            ['config', 'user.email', userInfo.email]
        ];
        for (const command of commands) {
            const result = await this.executeGitCommand(command, directory);
            if (!result.success) {
                throw new Error(`Failed to set ${command[1]}: ${result.stderr}`);
            }
        }
    }
    async checkExistingRepository(directory) {
        try {
            const result = await this.executeGitCommand(['rev-parse', '--git-dir'], directory);
            return result.success;
        }
        catch {
            return false;
        }
    }
    async hasGitDirectory(directory) {
        try {
            const path = await import('path');
            const fs = await import('fs/promises');
            const resolvedPath = path.resolve(directory);
            const gitPath = path.join(resolvedPath, '.git');
            const stats = await fs.stat(gitPath);
            return stats.isDirectory();
        }
        catch {
            return false;
        }
    }
    async getLocalConfig(directory) {
        try {
            const nameResult = await this.executeGitCommand(['config', 'user.name'], directory);
            const emailResult = await this.executeGitCommand(['config', 'user.email'], directory);
            return {
                name: nameResult.success ? nameResult.stdout.trim() : '',
                email: emailResult.success ? emailResult.stdout.trim() : '',
                source: 'local'
            };
        }
        catch {
            return {
                name: '',
                email: '',
                source: 'local'
            };
        }
    }
    async executeGitCommand(args, cwd) {
        return new Promise((resolve) => {
            const options = cwd ? { cwd } : {};
            const child = spawn('git', args, options);
            let stdout = '';
            let stderr = '';
            child.stdout?.on('data', (data) => {
                stdout += data.toString();
            });
            child.stderr?.on('data', (data) => {
                stderr += data.toString();
            });
            child.on('close', (code) => {
                resolve({
                    success: code === 0,
                    stdout,
                    stderr
                });
            });
            child.on('error', (error) => {
                resolve({
                    success: false,
                    stdout: '',
                    stderr: error.message
                });
            });
        });
    }
}
//# sourceMappingURL=config-manager.js.map