@hyperdrive.bot/gut 0.1.4 → 0.1.6

package/dist/services/focus.service.js

@@ -1,587 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FocusService = void 0;
-const entity_service_1 = require("./entity.service");
-class FocusService {
-    configService;
-    entityService;
-    focusStack = [];
-    constructor(configService) {
-        this.configService = configService;
-        this.entityService = new entity_service_1.EntityService(configService);
-    }
-    async getCurrentFocus() {
-        return this.configService.getFocus();
-    }
-    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] : [];
-    }
-    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 = {
-            type: entities.length === 1 ? entities[0].type : 'multiple',
-            name: entities.length === 1 ? entities[0].name : entities.map(e => e.name).join(', '),
-            path: entities.length === 1 ? entities[0].path : '.',
-            timestamp: Date.now(),
-            entities: entities,
-            mode: options.mode,
-            duration: options.duration
-        };
-        // Generate focus context for AI
-        await this.generateFocusContext(focus);
-        this.configService.saveFocus(focus);
-    }
-    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 = {
-            type: allEntities.length === 1 ? allEntities[0].type : 'multiple',
-            name: allEntities.map(e => e.name).join(', '),
-            path: allEntities.length === 1 ? allEntities[0].path : '.',
-            timestamp: Date.now(),
-            entities: allEntities,
-            mode: options.mode || currentFocus?.mode,
-            duration: options.duration || currentFocus?.duration
-        };
-        // 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);
-    }
-    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);
-    }
-    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 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 pushFocusToStack() {
-        const currentFocus = await this.getCurrentFocus();
-        if (currentFocus) {
-            this.focusStack.push(currentFocus);
-        }
-    }
-    async popFocusFromStack() {
-        return this.focusStack.pop() || null;
-    }
-    getFocusStack() {
-        return [...this.focusStack];
-    }
-    async generateFocusContext(focus) {
-        const context = {
-            current_focus: focus,
-            entity_type: focus.entities?.[0]?.type,
-            entity_name: focus.entities?.[0]?.name,
-            mode: focus.mode,
-            duration: focus.duration,
-            start_time: new Date().toISOString(),
-            ai_context: await this.generateAIContext(focus)
-        };
-        // Save context to focus/context.yaml
-        await this.configService.saveFocusContext(context);
-    }
-    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 = {
-            persona,
-            knowledge_scope: this.getKnowledgeScopeForMode(focus.mode, primaryEntity),
-            available_data: await this.getAvailableDataForEntity(primaryEntity),
-            suggested_actions: await this.getSuggestedActionsForMode(focus.mode, primaryEntity),
-            restricted_knowledge: this.getRestrictedKnowledgeForMode(focus.mode, primaryEntity.type),
-            // Enhanced AI features
-            context_intelligence: await this.generateContextIntelligence(focus),
-            learning_insights: await this.generateLearningInsights(primaryEntity),
-            adaptive_suggestions: await this.generateAdaptiveSuggestions(focus),
-            collaboration_context: await this.generateCollaborationContext(primaryEntity),
-            performance_context: await this.generatePerformanceContext(focus)
-        };
-        return context;
-    }
-    getPersonaForMode(mode, entityType) {
-        if (!mode)
-            return 'general_developer';
-        const personas = {
-            delivery: {
-                client: 'senior_developer_client_delivery',
-                prospect: 'technical_consultant_prospect_analysis',
-                company: 'internal_systems_developer',
-                initiative: 'project_technical_lead',
-                system: 'systems_architect',
-                delivery: 'senior_developer',
-                module: 'module_developer',
-                service: 'service_developer',
-                tool: 'tools_developer'
-            },
-            strategy: {
-                client: 'ceo_strategic_advisor',
-                prospect: 'business_development_strategist',
-                company: 'executive_strategic_planner',
-                initiative: 'strategic_initiative_leader',
-                system: 'technical_strategy_architect',
-                delivery: 'delivery_strategy_consultant',
-                module: 'module_strategy_architect',
-                service: 'service_strategy_consultant',
-                tool: 'tools_strategy_planner'
-            },
-            audit: {
-                client: 'business_auditor',
-                prospect: 'due_diligence_analyst',
-                company: 'internal_auditor',
-                initiative: 'project_auditor',
-                system: 'technical_auditor',
-                delivery: 'delivery_auditor',
-                module: 'module_auditor',
-                service: 'service_auditor',
-                tool: 'tools_auditor'
-            }
-        };
-        return personas[mode]?.[entityType] || 'general_consultant';
-    }
-    getKnowledgeScopeForMode(mode, entity) {
-        const baseScope = [`${entity.name}_complete_context`];
-        if (!mode)
-            return baseScope;
-        const modeScopes = {
-            delivery: ['technical_implementation', 'code_architecture', 'development_patterns'],
-            strategy: ['business_context', 'strategic_planning', 'cross_entity_insights'],
-            audit: ['compliance_requirements', 'security_analysis', 'performance_metrics'],
-            debug: ['error_analysis', 'system_diagnostics', 'troubleshooting_patterns'],
-            research: ['market_analysis', 'competitive_intelligence', 'technology_research'],
-            proposal: ['business_proposals', 'technical_specifications', 'pricing_strategy']
-        };
-        return [...baseScope, ...(modeScopes[mode] || [])];
-    }
-    async getAvailableDataForEntity(entity) {
-        const entityPath = this.configService.getWorkspaceRoot();
-        // Enhanced data collection
-        const data = {
-            entity_metadata: entity.metadata || {},
-            recent_activity: await this.getRecentActivity(entity),
-            team_members: await this.getTeamMembers(entity),
-            performance_metrics: await this.getPerformanceMetrics(entity),
-            // Additional context data
-            related_entities: await this.getRelatedEntities(entity),
-            recent_patterns: await this.getRecentPatterns(entity),
-            business_context: await this.getBusinessContext(entity),
-            technical_context: await this.getTechnicalContext(entity)
-        };
-        return data;
-    }
-    async getSuggestedActionsForMode(mode, entity) {
-        if (!mode)
-            return [`Review ${entity.name} status`];
-        const actionSuggestions = {
-            delivery: [
-                `Review ${entity.name} development progress`,
-                'Check for pending code reviews',
-                'Update technical documentation'
-            ],
-            strategy: [
-                `Analyze ${entity.name} business performance`,
-                'Review strategic objectives',
-                'Plan next quarter initiatives'
-            ],
-            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'
-            ],
-            research: [
-                `Research ${entity.name} market position`,
-                'Analyze competitive landscape',
-                'Evaluate new technologies'
-            ],
-            proposal: [
-                `Prepare ${entity.name} proposal materials`,
-                'Update pricing and scope',
-                'Review client requirements'
-            ]
-        };
-        return actionSuggestions[mode] || [];
-    }
-    getRestrictedKnowledgeForMode(mode, entityType) {
-        // Define what knowledge should be restricted based on mode and entity type
-        const restrictions = {
-            'delivery-client': [], // Full access for client delivery work
-            'strategy-client': [], // Full access for client strategy work
-            'audit-client': [], // Full access for client audit work
-            'delivery-prospect': ['financial_details', 'internal_costs'], // Limited financial access for prospects
-            'research-prospect': ['internal_strategies', 'competitive_pricing'] // Limited strategic access for research
-        };
-        const key = mode && entityType ? `${mode}-${entityType}` : 'default';
-        return restrictions[key] || [];
-    }
-    // Enhanced AI Context Methods
-    async generateContextIntelligence(focus) {
-        const primaryEntity = focus.entities?.[0];
-        if (!primaryEntity)
-            return {};
-        return {
-            context_type: this.determineContextType(focus),
-            complexity_level: await this.assessComplexity(primaryEntity),
-            estimated_duration: this.estimateFocusDuration(focus),
-            interruption_likelihood: await this.assessInterruptionRisk(focus),
-            success_probability: await this.assessSuccessProbability(focus),
-            recommended_approach: await this.getRecommendedApproach(focus)
-        };
-    }
-    async generateLearningInsights(entity) {
-        return {
-            historical_patterns: await this.getHistoricalPatterns(entity),
-            similar_entity_lessons: await this.getSimilarEntityLessons(entity),
-            common_pitfalls: await this.getCommonPitfalls(entity),
-            success_factors: await this.getSuccessFactors(entity),
-            learning_opportunities: await this.getLearningOpportunities(entity)
-        };
-    }
-    async generateAdaptiveSuggestions(focus) {
-        const primaryEntity = focus.entities?.[0];
-        if (!primaryEntity)
-            return {};
-        const timeOfDay = new Date().getHours();
-        const dayOfWeek = new Date().getDay();
-        return {
-            time_based_suggestions: this.getTimeBasedSuggestions(timeOfDay, focus.mode),
-            day_based_suggestions: this.getDayBasedSuggestions(dayOfWeek, focus.mode),
-            context_specific_tips: await this.getContextSpecificTips(focus),
-            productivity_optimizations: await this.getProductivityOptimizations(focus),
-            workflow_suggestions: await this.getWorkflowSuggestions(primaryEntity, focus.mode)
-        };
-    }
-    async generateCollaborationContext(entity) {
-        return {
-            team_members: await this.getActiveTeamMembers(entity),
-            collaboration_patterns: await this.getCollaborationPatterns(entity),
-            communication_preferences: await this.getCommunicationPreferences(entity),
-            shared_resources: await this.getSharedResources(entity),
-            coordination_needs: await this.getCoordinationNeeds(entity)
-        };
-    }
-    async generatePerformanceContext(focus) {
-        return {
-            current_velocity: await this.getCurrentVelocity(focus),
-            performance_trends: await this.getPerformanceTrends(focus),
-            bottlenecks: await this.identifyBottlenecks(focus),
-            optimization_opportunities: await this.getOptimizationOpportunities(focus),
-            benchmarks: await this.getBenchmarks(focus)
-        };
-    }
-    // Helper methods for enhanced context
-    async getRecentActivity(entity) {
-        // Would integrate with git service to get actual activity
-        return {
-            commits_last_week: 12,
-            files_changed: 8,
-            last_commit: '2 hours ago',
-            active_branches: ['feature/new-ui', 'bugfix/auth-issue']
-        };
-    }
-    async getTeamMembers(entity) {
-        // Would integrate with team management system
-        return {
-            active_contributors: ['Alice', 'Bob', 'Charlie'],
-            recent_collaborators: ['Alice', 'Bob'],
-            expertise_areas: {
-                'Alice': ['frontend', 'ui/ux'],
-                'Bob': ['backend', 'api'],
-                'Charlie': ['devops', 'infrastructure']
-            }
-        };
-    }
-    async getPerformanceMetrics(entity) {
-        // Would integrate with actual metrics
-        return {
-            velocity: '85%',
-            quality_score: '92/100',
-            technical_debt: 'low',
-            test_coverage: '78%',
-            deployment_frequency: '2x/week'
-        };
-    }
-    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,
-            type: e.type,
-            relationship: 'similar' // Would determine actual relationship
-        }));
-    }
-    async getRecentPatterns(entity) {
-        return {
-            frequent_files: ['src/components/', 'docs/', 'tests/'],
-            common_commit_patterns: ['feature', 'bugfix', 'refactor'],
-            work_rhythms: ['morning_coding', 'afternoon_reviews'],
-            collaboration_patterns: ['pair_programming', 'code_reviews']
-        };
-    }
-    async getBusinessContext(entity) {
-        const metadata = entity.metadata?.business || {};
-        return {
-            priority: metadata.priority || 'medium',
-            status: metadata.status || 'active',
-            contract_value: metadata.contract_value,
-            team_size: metadata.team_size,
-            client_satisfaction: 'high', // Would come from actual data
-            business_impact: 'medium' // Would be calculated
-        };
-    }
-    async getTechnicalContext(entity) {
-        return {
-            tech_stack: ['React', 'TypeScript', 'Node.js'], // Would be detected
-            architecture_patterns: ['component-based', 'microservices'],
-            deployment_status: 'production',
-            performance_status: 'good',
-            security_status: 'compliant'
-        };
-    }
-    // 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';
-    }
-    async assessComplexity(entity) {
-        // Would analyze actual complexity metrics
-        const metadata = entity.metadata || {};
-        const hasBusinessData = !!metadata.business;
-        const hasRelationships = !!metadata.relationships;
-        if (hasBusinessData && hasRelationships)
-            return 'high';
-        if (hasBusinessData || hasRelationships)
-            return 'medium';
-        return 'low';
-    }
-    estimateFocusDuration(focus) {
-        const mode = focus.mode;
-        const durations = {
-            delivery: '90 minutes',
-            strategy: '2-3 hours',
-            audit: '60-90 minutes',
-            debug: '45-60 minutes',
-            research: '1-2 hours',
-            proposal: '2-4 hours'
-        };
-        return durations[mode || 'delivery'] || '1 hour';
-    }
-    async assessInterruptionRisk(focus) {
-        const timeOfDay = new Date().getHours();
-        const mode = focus.mode;
-        // 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.mode;
-        const successRates = {
-            delivery: '85%',
-            strategy: '75%',
-            audit: '90%',
-            debug: '70%',
-            research: '80%',
-            proposal: '65%'
-        };
-        return successRates[mode || 'delivery'] || '75%';
-    }
-    async getRecommendedApproach(focus) {
-        const mode = focus.mode;
-        const approaches = {
-            delivery: ['Start with tests', 'Small incremental changes', 'Regular commits'],
-            strategy: ['Gather all context first', 'Think before acting', 'Document decisions'],
-            audit: ['Systematic review', 'Checklist approach', 'Document findings'],
-            debug: ['Reproduce issue first', 'Isolate variables', 'Test fixes thoroughly']
-        };
-        return approaches[mode || 'delivery'] || ['Focus on one thing at a time'];
-    }
-    // Additional helper methods (simplified implementations)
-    async getHistoricalPatterns(entity) {
-        return { success_rate: '85%', common_issues: ['scope_creep', 'technical_debt'] };
-    }
-    async getSimilarEntityLessons(entity) {
-        return { lessons: ['Start with MVP', 'Regular client communication'] };
-    }
-    async getCommonPitfalls(entity) {
-        return { pitfalls: ['Over-engineering', 'Insufficient testing', 'Poor documentation'] };
-    }
-    async getSuccessFactors(entity) {
-        return { factors: ['Clear requirements', 'Regular feedback', 'Good team communication'] };
-    }
-    async getLearningOpportunities(entity) {
-        return { opportunities: ['New technology adoption', 'Process improvement', 'Skill development'] };
-    }
-    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'];
-    }
-    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`];
-    }
-    async getContextSpecificTips(focus) {
-        const mode = focus.mode;
-        const tips = {
-            delivery: ['Use TDD approach', 'Commit frequently', 'Write clear commit messages'],
-            strategy: ['Take breaks to think', 'Consider multiple perspectives', 'Document assumptions'],
-            audit: ['Be thorough but efficient', 'Use checklists', 'Focus on high-impact issues']
-        };
-        return tips[mode || 'delivery'] || ['Stay focused on the goal'];
-    }
-    async getProductivityOptimizations(focus) {
-        return [
-            'Minimize context switching',
-            'Use focus mode in tools',
-            'Set clear session goals',
-            'Take regular breaks'
-        ];
-    }
-    async getWorkflowSuggestions(entity, mode) {
-        return [
-            'Start with quick wins',
-            'Batch similar tasks',
-            'Use time-boxing',
-            'Regular progress checks'
-        ];
-    }
-    // Collaboration context helpers
-    async getActiveTeamMembers(entity) {
-        return { active: ['Alice', 'Bob'], available: ['Charlie'] };
-    }
-    async getCollaborationPatterns(entity) {
-        return { patterns: ['morning_standups', 'afternoon_reviews', 'async_communication'] };
-    }
-    async getCommunicationPreferences(entity) {
-        return { preferences: ['slack_for_quick', 'email_for_formal', 'meetings_for_complex'] };
-    }
-    async getSharedResources(entity) {
-        return { resources: ['shared_docs', 'design_system', 'api_documentation'] };
-    }
-    async getCoordinationNeeds(entity) {
-        return { needs: ['sync_with_backend_team', 'client_approval_needed'] };
-    }
-    // Performance context helpers
-    async getCurrentVelocity(focus) {
-        return { velocity: '85%', trend: 'stable' };
-    }
-    async getPerformanceTrends(focus) {
-        return { trends: ['improving_quality', 'stable_velocity', 'decreasing_bugs'] };
-    }
-    async identifyBottlenecks(focus) {
-        return { bottlenecks: ['code_review_delays', 'dependency_waiting'] };
-    }
-    async getOptimizationOpportunities(focus) {
-        return { opportunities: ['automate_testing', 'improve_ci_cd', 'reduce_technical_debt'] };
-    }
-    async getBenchmarks(focus) {
-        return { benchmarks: { velocity: '90%', quality: '95%', satisfaction: '88%' } };
-    }
-}
-exports.FocusService = FocusService;

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

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