@hyperdrive.bot/gut 0.1.6 → 0.1.9

package/dist/services/focus.service.js

@@ -0,0 +1,614 @@
+import { EntityService } from './entity.service.js';
+export class FocusService {
+    configService;
+    entityService;
+    focusStack = [];
+    constructor(configService) {
+        this.configService = configService;
+        this.entityService = new EntityService(configService);
+    }
+    async addToFocus(entityNames, options = {}) {
+        const currentFocus = await this.getCurrentFocus();
+        const currentEntities = await this.getFocusedEntities();
+        const newEntities = [];
+        for (const name of entityNames) {
+            // Skip if already in focus
+            if (currentEntities.some(e => e.name === name)) {
+                continue;
+            }
+            let entity = this.entityService.findEntity(name);
+            // If entity not found and we have a type, try to find by type + name
+            if (!entity && options.entityType) {
+                entity = this.entityService.findEntityByTypeAndName(options.entityType, name);
+            }
+            if (!entity) {
+                const suggestion = options.entityType
+                    ? `Try: gut entity add ${name} ${options.entityType} <path>`
+                    : `Try: gut entity add ${name} <type> <path>`;
+                throw new Error(`Entity '${name}' not found. ${suggestion}`);
+            }
+            newEntities.push(entity);
+        }
+        if (newEntities.length === 0) {
+            throw new Error('All specified entities are already in focus');
+        }
+        const allEntities = [...currentEntities, ...newEntities];
+        const focus = {
+            duration: options.duration || currentFocus?.duration,
+            entities: allEntities,
+            mode: options.mode || currentFocus?.mode,
+            name: allEntities.map(e => e.name).join(', '),
+            path: allEntities.length === 1 ? allEntities[0].path : '.',
+            timestamp: Date.now(),
+            type: allEntities.length === 1 ? allEntities[0].type : 'multiple',
+        };
+        // Generate focus context for AI
+        await this.generateFocusContext(focus);
+        this.configService.saveFocus(focus);
+    }
+    async clearFocus() {
+        const currentFocus = await this.getCurrentFocus();
+        if (currentFocus) {
+            // Save to history before clearing
+            this.configService.addToHistory(currentFocus);
+        }
+        this.configService.saveFocus(null);
+    }
+    clearFocusStack() {
+        const count = this.focusStack.length;
+        this.focusStack = [];
+        return count;
+    }
+    async getCurrentFocus() {
+        return this.configService.getFocus();
+    }
+    async getFocusDescription() {
+        const focus = await this.getCurrentFocus();
+        if (!focus)
+            return 'No focus set';
+        const entities = await this.getFocusedEntities();
+        if (entities.length === 0)
+            return 'Invalid focus';
+        if (entities.length === 1) {
+            const modeText = focus.mode ? ` (${focus.mode})` : '';
+            return `${entities[0].name} (${entities[0].type})${modeText}`;
+        }
+        const modeText = focus.mode ? ` (${focus.mode})` : '';
+        return `${entities.length} entities: ${entities.map(e => e.name).join(', ')}${modeText}`;
+    }
+    async getFocusedEntities() {
+        const focus = await this.getCurrentFocus();
+        if (!focus)
+            return [];
+        // Handle multi-entity focus
+        if (focus.entities && focus.entities.length > 0) {
+            return focus.entities;
+        }
+        // Handle single entity focus (backward compatibility)
+        const entity = this.entityService.findEntity(focus.name);
+        return entity ? [entity] : [];
+    }
+    getFocusStack() {
+        return [...this.focusStack];
+    }
+    getRecentFocus(limit = 5) {
+        const history = this.configService.getHistory();
+        return history.slice(-limit).reverse();
+    }
+    async isFocused(entityName) {
+        const focusedEntities = await this.getFocusedEntities();
+        return focusedEntities.some(e => e.name === entityName);
+    }
+    async popFocusFromStack() {
+        return this.focusStack.pop() || null;
+    }
+    async pushFocusToStack() {
+        const currentFocus = await this.getCurrentFocus();
+        if (currentFocus) {
+            this.focusStack.push(currentFocus);
+        }
+    }
+    async setFocus(entityNames, options = {}) {
+        if (entityNames.length === 0) {
+            throw new Error('No entities specified');
+        }
+        const entities = [];
+        for (const name of entityNames) {
+            let entity = this.entityService.findEntity(name);
+            // If entity not found and we have a type, try to find by type + name
+            if (!entity && options.entityType) {
+                entity = this.entityService.findEntityByTypeAndName(options.entityType, name);
+            }
+            if (!entity) {
+                // If still not found, suggest creating it
+                const suggestion = options.entityType
+                    ? `Try: gut entity add ${name} ${options.entityType} <path>`
+                    : `Try: gut entity add ${name} <type> <path>`;
+                throw new Error(`Entity '${name}' not found. ${suggestion}`);
+            }
+            entities.push(entity);
+        }
+        const focus = {
+            duration: options.duration,
+            entities,
+            mode: options.mode,
+            name: entities.length === 1 ? entities[0].name : entities.map(e => e.name).join(', '),
+            path: entities.length === 1 ? entities[0].path : '.',
+            timestamp: Date.now(),
+            type: entities.length === 1 ? entities[0].type : 'multiple',
+        };
+        // Generate focus context for AI
+        await this.generateFocusContext(focus);
+        this.configService.saveFocus(focus);
+    }
+    async switchToPrevious() {
+        const history = this.configService.getHistory();
+        if (history.length < 2) {
+            throw new Error('No previous focus in history');
+        }
+        const previousEntry = history[1]; // Second entry is the previous (first is current)
+        // Set focus to the previous entities
+        await this.setFocus(previousEntry.entities);
+    }
+    async assessComplexity(entity) {
+        // Would analyze actual complexity metrics
+        const metadata = entity.metadata || {};
+        const hasBusinessData = Boolean(metadata.business);
+        const hasRelationships = Boolean(metadata.relationships);
+        if (hasBusinessData && hasRelationships)
+            return 'high';
+        if (hasBusinessData || hasRelationships)
+            return 'medium';
+        return 'low';
+    }
+    async assessInterruptionRisk(focus) {
+        const timeOfDay = new Date().getHours();
+        const { mode } = focus;
+        // Higher risk during business hours for strategic work
+        if (mode === 'strategy' && timeOfDay >= 9 && timeOfDay <= 17)
+            return 'high';
+        if (timeOfDay >= 14 && timeOfDay <= 16)
+            return 'medium'; // Meeting hours
+        return 'low';
+    }
+    async assessSuccessProbability(focus) {
+        // Would use actual success rate data
+        const { mode } = focus;
+        const successRates = {
+            audit: '90%',
+            debug: '70%',
+            delivery: '85%',
+            proposal: '65%',
+            research: '80%',
+            strategy: '75%',
+        };
+        return successRates[mode || 'delivery'] || '75%';
+    }
+    // Context intelligence helpers
+    determineContextType(focus) {
+        if (focus.entities && focus.entities.length > 1)
+            return 'multi_entity';
+        if (focus.mode === 'strategy')
+            return 'strategic';
+        if (focus.mode === 'delivery')
+            return 'tactical';
+        return 'general';
+    }
+    estimateFocusDuration(focus) {
+        const { mode } = focus;
+        const durations = {
+            audit: '60-90 minutes',
+            debug: '45-60 minutes',
+            delivery: '90 minutes',
+            proposal: '2-4 hours',
+            research: '1-2 hours',
+            strategy: '2-3 hours',
+        };
+        return durations[mode || 'delivery'] || '1 hour';
+    }
+    async generateAdaptiveSuggestions(focus, entity) {
+        const timeOfDay = new Date().getHours();
+        const dayOfWeek = new Date().getDay();
+        return {
+            contextSpecificTips: await this.getContextSpecificTips(focus),
+            dayBasedSuggestions: this.getDayBasedSuggestions(dayOfWeek, focus.mode),
+            productivityOptimizations: await this.getProductivityOptimizations(focus),
+            timeBasedSuggestions: this.getTimeBasedSuggestions(timeOfDay, focus.mode),
+            workflowSuggestions: await this.getWorkflowSuggestions(entity, focus.mode),
+        };
+    }
+    async generateAIContext(focus) {
+        if (!focus.entities || focus.entities.length === 0) {
+            return {};
+        }
+        const primaryEntity = focus.entities[0];
+        const persona = this.getPersonaForMode(focus.mode, primaryEntity.type);
+        // Enhanced context with learning and adaptation
+        const context = {
+            adaptiveSuggestions: await this.generateAdaptiveSuggestions(focus, primaryEntity),
+            availableData: await this.getAvailableDataForEntity(primaryEntity),
+            collaborationContext: await this.generateCollaborationContext(primaryEntity),
+            // Enhanced AI features
+            contextIntelligence: await this.generateContextIntelligence(focus, primaryEntity),
+            knowledgeScope: this.getKnowledgeScopeForMode(focus.mode, primaryEntity),
+            learningInsights: await this.generateLearningInsights(primaryEntity),
+            performanceContext: await this.generatePerformanceContext(focus),
+            persona,
+            restrictedKnowledge: this.getRestrictedKnowledgeForMode(focus.mode, primaryEntity.type),
+            suggestedActions: await this.getSuggestedActionsForMode(focus.mode, primaryEntity),
+        };
+        return context;
+    }
+    async generateCollaborationContext(entity) {
+        return {
+            collaborationPatterns: await this.getCollaborationPatterns(entity),
+            communicationPreferences: await this.getCommunicationPreferences(entity),
+            coordinationNeeds: await this.getCoordinationNeeds(entity),
+            sharedResources: await this.getSharedResources(entity),
+            teamMembers: await this.getActiveTeamMembers(entity),
+        };
+    }
+    // Enhanced AI Context Methods
+    async generateContextIntelligence(focus, entity) {
+        return {
+            complexityLevel: await this.assessComplexity(entity),
+            contextType: this.determineContextType(focus),
+            estimatedDuration: this.estimateFocusDuration(focus),
+            interruptionLikelihood: await this.assessInterruptionRisk(focus),
+            recommendedApproach: await this.getRecommendedApproach(focus),
+            successProbability: await this.assessSuccessProbability(focus),
+        };
+    }
+    async generateFocusContext(focus) {
+        const context = {
+            aiContext: await this.generateAIContext(focus),
+            currentFocus: focus,
+            duration: focus.duration,
+            entityName: focus.entities?.[0]?.name,
+            entityType: focus.entities?.[0]?.type,
+            mode: focus.mode,
+            startTime: new Date().toISOString(),
+        };
+        // Save context to focus/context.yaml
+        await this.configService.saveFocusContext(context);
+    }
+    async generateLearningInsights(entity) {
+        return {
+            commonPitfalls: await this.getCommonPitfalls(entity),
+            historicalPatterns: await this.getHistoricalPatterns(entity),
+            learningOpportunities: await this.getLearningOpportunities(entity),
+            similarEntityLessons: await this.getSimilarEntityLessons(entity),
+            successFactors: await this.getSuccessFactors(entity),
+        };
+    }
+    async generatePerformanceContext(focus) {
+        return {
+            benchmarks: await this.getBenchmarks(focus),
+            bottlenecks: await this.identifyBottlenecks(focus),
+            currentVelocity: await this.getCurrentVelocity(focus),
+            optimizationOpportunities: await this.getOptimizationOpportunities(focus),
+            performanceTrends: await this.getPerformanceTrends(focus),
+        };
+    }
+    // Collaboration context helpers
+    async getActiveTeamMembers(_entity) {
+        return { active: ['Alice', 'Bob'], available: ['Charlie'] };
+    }
+    async getAvailableDataForEntity(entity) {
+        // Enhanced data collection
+        const data = {
+            businessContext: await this.getBusinessContext(entity),
+            entityMetadata: entity.metadata || {},
+            performanceMetrics: await this.getPerformanceMetrics(entity),
+            recentActivity: await this.getRecentActivity(entity),
+            recentPatterns: await this.getRecentPatterns(entity),
+            // Additional context data
+            relatedEntities: await this.getRelatedEntities(entity),
+            teamMembers: await this.getTeamMembers(entity),
+            technicalContext: await this.getTechnicalContext(entity),
+        };
+        return data;
+    }
+    async getBenchmarks(_focus) {
+        return { benchmarks: { quality: '95%', satisfaction: '88%', velocity: '90%' } };
+    }
+    async getBusinessContext(entity) {
+        const metadata = entity.metadata?.business || {};
+        return {
+            businessImpact: 'medium', // Would be calculated
+            clientSatisfaction: 'high', // Would come from actual data
+            contractValue: metadata.contract_value,
+            priority: metadata.priority || 'medium',
+            status: metadata.status || 'active',
+            teamSize: metadata.team_size,
+        };
+    }
+    async getCollaborationPatterns(_entity) {
+        return { patterns: ['morning_standups', 'afternoon_reviews', 'async_communication'] };
+    }
+    async getCommonPitfalls(_entity) {
+        return { pitfalls: ['Over-engineering', 'Insufficient testing', 'Poor documentation'] };
+    }
+    async getCommunicationPreferences(_entity) {
+        return { preferences: ['slack_for_quick', 'email_for_formal', 'meetings_for_complex'] };
+    }
+    async getContextSpecificTips(focus) {
+        const { mode } = focus;
+        const tips = {
+            audit: ['Be thorough but efficient', 'Use checklists', 'Focus on high-impact issues'],
+            delivery: ['Use TDD approach', 'Commit frequently', 'Write clear commit messages'],
+            strategy: ['Take breaks to think', 'Consider multiple perspectives', 'Document assumptions'],
+        };
+        return tips[mode || 'delivery'] || ['Stay focused on the goal'];
+    }
+    async getCoordinationNeeds(_entity) {
+        return { needs: ['sync_with_backend_team', 'client_approval_needed'] };
+    }
+    // Performance context helpers
+    async getCurrentVelocity(_focus) {
+        return { trend: 'stable', velocity: '85%' };
+    }
+    getDayBasedSuggestions(day, _mode) {
+        const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+        if (day === 1)
+            return ['Monday - good for planning and goal setting'];
+        if (day === 5)
+            return ['Friday - good for reviews and documentation'];
+        return [`${days[day]} - maintain steady progress`];
+    }
+    // Additional helper methods (simplified implementations)
+    async getHistoricalPatterns(_entity) {
+        return { commonIssues: ['scope_creep', 'technical_debt'], successRate: '85%' };
+    }
+    getKnowledgeScopeForMode(mode, entity) {
+        const baseScope = [`${entity.name}_complete_context`];
+        if (!mode)
+            return baseScope;
+        const modeScopes = {
+            audit: ['compliance_requirements', 'security_analysis', 'performance_metrics'],
+            debug: ['error_analysis', 'system_diagnostics', 'troubleshooting_patterns'],
+            delivery: ['technical_implementation', 'code_architecture', 'development_patterns'],
+            proposal: ['business_proposals', 'technical_specifications', 'pricing_strategy'],
+            research: ['market_analysis', 'competitive_intelligence', 'technology_research'],
+            strategy: ['business_context', 'strategic_planning', 'cross_entity_insights'],
+        };
+        return [...baseScope, ...(modeScopes[mode] || [])];
+    }
+    async getLearningOpportunities(_entity) {
+        return { opportunities: ['New technology adoption', 'Process improvement', 'Skill development'] };
+    }
+    async getOptimizationOpportunities(_focus) {
+        return { opportunities: ['automate_testing', 'improve_ci_cd', 'reduce_technical_debt'] };
+    }
+    async getPerformanceMetrics(_entity) {
+        // Would integrate with actual metrics
+        return {
+            deploymentFrequency: '2x/week',
+            qualityScore: '92/100',
+            technicalDebt: 'low',
+            testCoverage: '78%',
+            velocity: '85%',
+        };
+    }
+    async getPerformanceTrends(_focus) {
+        return { trends: ['improving_quality', 'stable_velocity', 'decreasing_bugs'] };
+    }
+    getPersonaForMode(mode, entityType) {
+        if (!mode)
+            return 'general_developer';
+        const personas = {
+            audit: {
+                client: 'business_auditor',
+                company: 'internal_auditor',
+                delivery: 'delivery_auditor',
+                initiative: 'project_auditor',
+                module: 'module_auditor',
+                prospect: 'due_diligence_analyst',
+                service: 'service_auditor',
+                system: 'technical_auditor',
+                tool: 'tools_auditor',
+            },
+            debug: {
+                client: 'client_debugger',
+                company: 'internal_debugger',
+                delivery: 'delivery_debugger',
+                initiative: 'project_debugger',
+                module: 'module_debugger',
+                prospect: 'prospect_debugger',
+                service: 'service_debugger',
+                system: 'systems_debugger',
+                tool: 'tools_debugger',
+            },
+            delivery: {
+                client: 'senior_developer_client_delivery',
+                company: 'internal_systems_developer',
+                delivery: 'senior_developer',
+                initiative: 'project_technical_lead',
+                module: 'module_developer',
+                prospect: 'technical_consultant_prospect_analysis',
+                service: 'service_developer',
+                system: 'systems_architect',
+                tool: 'tools_developer',
+            },
+            proposal: {
+                client: 'client_proposal_writer',
+                company: 'internal_proposal_consultant',
+                delivery: 'delivery_proposal_specialist',
+                initiative: 'initiative_proposal_lead',
+                module: 'module_proposal_writer',
+                prospect: 'prospect_proposal_specialist',
+                service: 'service_proposal_consultant',
+                system: 'technical_proposal_architect',
+                tool: 'tools_proposal_specialist',
+            },
+            research: {
+                client: 'client_researcher',
+                company: 'internal_researcher',
+                delivery: 'delivery_researcher',
+                initiative: 'project_researcher',
+                module: 'module_researcher',
+                prospect: 'market_researcher',
+                service: 'service_researcher',
+                system: 'technical_researcher',
+                tool: 'tools_researcher',
+            },
+            strategy: {
+                client: 'ceo_strategic_advisor',
+                company: 'executive_strategic_planner',
+                delivery: 'delivery_strategy_consultant',
+                initiative: 'strategic_initiative_leader',
+                module: 'module_strategy_architect',
+                prospect: 'business_development_strategist',
+                service: 'service_strategy_consultant',
+                system: 'technical_strategy_architect',
+                tool: 'tools_strategy_planner',
+            },
+        };
+        return personas[mode]?.[entityType] || 'general_consultant';
+    }
+    async getProductivityOptimizations(_focus) {
+        return [
+            'Minimize context switching',
+            'Use focus mode in tools',
+            'Set clear session goals',
+            'Take regular breaks',
+        ];
+    }
+    // Helper methods for enhanced context
+    async getRecentActivity(_entity) {
+        // Would integrate with git service to get actual activity
+        return {
+            activeBranches: ['feature/new-ui', 'bugfix/auth-issue'],
+            commitsLastWeek: 12,
+            filesChanged: 8,
+            lastCommit: '2 hours ago',
+        };
+    }
+    async getRecentPatterns(_entity) {
+        return {
+            collaborationPatterns: ['pair_programming', 'code_reviews'],
+            commonCommitPatterns: ['feature', 'bugfix', 'refactor'],
+            frequentFiles: ['src/components/', 'docs/', 'tests/'],
+            workRhythms: ['morning_coding', 'afternoon_reviews'],
+        };
+    }
+    async getRecommendedApproach(focus) {
+        const { mode } = focus;
+        const approaches = {
+            audit: ['Systematic review', 'Checklist approach', 'Document findings'],
+            debug: ['Reproduce issue first', 'Isolate variables', 'Test fixes thoroughly'],
+            delivery: ['Start with tests', 'Small incremental changes', 'Regular commits'],
+            strategy: ['Gather all context first', 'Think before acting', 'Document decisions'],
+        };
+        return approaches[mode || 'delivery'] || ['Focus on one thing at a time'];
+    }
+    async getRelatedEntities(entity) {
+        const allEntities = this.entityService.getAllEntities();
+        const related = allEntities.filter(e => e.metadata?.relationships?.similar_entities?.includes(entity.name)
+            || e.metadata?.relationships?.dependent_systems?.includes(entity.name));
+        return related.map(e => ({
+            name: e.name,
+            relationship: 'similar', // Would determine actual relationship
+            type: e.type,
+        }));
+    }
+    getRestrictedKnowledgeForMode(mode, entityType) {
+        // Define what knowledge should be restricted based on mode and entity type
+        const restrictions = {
+            'audit-client': [], // Full access for client audit work
+            'delivery-client': [], // Full access for client delivery work
+            'delivery-prospect': ['financial_details', 'internal_costs'], // Limited financial access for prospects
+            'research-prospect': ['internal_strategies', 'competitive_pricing'], // Limited strategic access for research
+            'strategy-client': [], // Full access for client strategy work
+        };
+        const key = mode && entityType ? `${mode}-${entityType}` : 'default';
+        return restrictions[key] || [];
+    }
+    async getSharedResources(_entity) {
+        return { resources: ['shared_docs', 'design_system', 'api_documentation'] };
+    }
+    async getSimilarEntityLessons(_entity) {
+        return { lessons: ['Start with MVP', 'Regular client communication'] };
+    }
+    async getSuccessFactors(_entity) {
+        return { factors: ['Clear requirements', 'Regular feedback', 'Good team communication'] };
+    }
+    async getSuggestedActionsForMode(mode, entity) {
+        if (!mode)
+            return [`Review ${entity.name} status`];
+        const actionSuggestions = {
+            audit: [
+                `Audit ${entity.name} compliance status`,
+                'Review security measures',
+                'Analyze performance metrics',
+            ],
+            debug: [
+                `Investigate ${entity.name} issues`,
+                'Check error logs and monitoring',
+                'Review system diagnostics',
+            ],
+            delivery: [
+                `Review ${entity.name} development progress`,
+                'Check for pending code reviews',
+                'Update technical documentation',
+            ],
+            proposal: [
+                `Prepare ${entity.name} proposal materials`,
+                'Update pricing and scope',
+                'Review client requirements',
+            ],
+            research: [
+                `Research ${entity.name} market position`,
+                'Analyze competitive landscape',
+                'Evaluate new technologies',
+            ],
+            strategy: [
+                `Analyze ${entity.name} business performance`,
+                'Review strategic objectives',
+                'Plan next quarter initiatives',
+            ],
+        };
+        return actionSuggestions[mode] || [];
+    }
+    async getTeamMembers(_entity) {
+        // Would integrate with team management system
+        return {
+            activeContributors: ['Alice', 'Bob', 'Charlie'],
+            expertiseAreas: {
+                Alice: ['frontend', 'ui/ux'],
+                Bob: ['backend', 'api'],
+                Charlie: ['devops', 'infrastructure'],
+            },
+            recentCollaborators: ['Alice', 'Bob'],
+        };
+    }
+    async getTechnicalContext(_entity) {
+        return {
+            architecturePatterns: ['component-based', 'microservices'],
+            deploymentStatus: 'production',
+            performanceStatus: 'good',
+            securityStatus: 'compliant',
+            techStack: ['React', 'TypeScript', 'Node.js'], // Would be detected
+        };
+    }
+    getTimeBasedSuggestions(hour, _mode) {
+        if (hour >= 9 && hour <= 11)
+            return ['Peak focus time - tackle complex tasks'];
+        if (hour >= 14 && hour <= 16)
+            return ['Post-lunch dip - consider lighter tasks'];
+        if (hour >= 16 && hour <= 18)
+            return ['Good time for reviews and planning'];
+        return ['Adjust work intensity based on energy levels'];
+    }
+    async getWorkflowSuggestions(_entity, _mode) {
+        return [
+            'Start with quick wins',
+            'Batch similar tasks',
+            'Use time-boxing',
+            'Regular progress checks',
+        ];
+    }
+    async identifyBottlenecks(_focus) {
+        return { bottlenecks: ['code_review_delays', 'dependency_waiting'] };
+    }
+}

package/dist/services/git.service.d.ts

@@ -0,0 +1,39 @@
+import { RepoStatus } from '../models/entity.model.js';
+export interface GitOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface CommitOptions {
+    all?: boolean;
+    amend?: boolean;
+}
+export interface PushOptions {
+    force?: boolean;
+    setUpstream?: boolean;
+    tags?: boolean;
+}
+export interface PullOptions {
+    noFf?: boolean;
+    rebase?: boolean;
+    strategy?: string;
+}
+export declare class GitService {
+    add(repoPath: string, files: string[]): Promise<void>;
+    addRemote(repoPath: string, name: string, url: string): Promise<void>;
+    checkout(repoPath: string, branch: string): Promise<void>;
+    clone(url: string, destination: string, depth?: number): Promise<void>;
+    commit(repoPath: string, message: string, options?: CommitOptions): Promise<void>;
+    createBranch(repoPath: string, branch: string, checkout?: boolean): Promise<void>;
+    exec(args: string[], options?: GitOptions): Promise<string>;
+    execSync(args: string[], options?: GitOptions): string;
+    fetch(repoPath: string): Promise<void>;
+    getCurrentBranch(repoPath: string): Promise<string>;
+    getRemoteUrl(repoPath: string, remote?: string): Promise<null | string>;
+    getStatus(repoPath: string): Promise<RepoStatus>;
+    hasChanges(repoPath: string): Promise<boolean>;
+    hasRemote(repoPath: string, remote?: string): Promise<boolean>;
+    init(repoPath: string): Promise<void>;
+    isRepository(repoPath: string): Promise<boolean>;
+    pull(repoPath: string, options?: PullOptions): Promise<void>;
+    push(repoPath: string, options?: PushOptions): Promise<void>;
+}