recoder-shared/dist/collaboration/collaboration-service.d.ts

Shared types, utilities, and configurations for Recoder

/**
 * Collaboration Service
 * KILLER FEATURE: Complete real-time collaborative development system
 * Integrates WebSocket server, session management, and persistence
 */
import { EventEmitter } from 'events';
import { CollaborationUser, CollaborationSession } from './websocket-server';
import { SessionPersistence, UserPresence } from './session-manager';
import { CodeDocument, CodeOperation } from './code-sync-engine';
import { AICollaborationAgent, AIAgentRequest } from './ai-collaboration-agent';
export interface CollaborationServiceOptions {
    websocketPort?: number;
    persistence?: SessionPersistence;
    enableRedis?: boolean;
    redisUrl?: string;
}
export interface CollaborativeCodeGeneration {
    sessionId: string;
    prompt: string;
    initiatedBy: string;
    participants: string[];
    responses: {
        userId: string;
        code: string;
        vote?: 'approve' | 'reject' | 'suggest_changes';
        comments?: string;
    }[];
    finalCode?: string;
    status: 'pending' | 'voting' | 'completed' | 'cancelled';
}
export declare class CollaborationService extends EventEmitter {
    private websocketServer;
    private sessionManager;
    private codeSyncEngine;
    private realtimeSyncHandler;
    private aiAgentManager;
    private codeGenerations;
    constructor(options?: CollaborationServiceOptions);
    private setupEventHandlers;
    createSession(creator: CollaborationUser, sessionData: Partial<CollaborationSession>): Promise<CollaborationSession>;
    joinSession(sessionId: string, user: CollaborationUser): Promise<boolean>;
    leaveSession(sessionId: string, userId: string): Promise<boolean>;
    createCodeDocument(sessionId: string, filePath: string, content: string | undefined, createdBy: string): CodeDocument;
    getCodeDocument(documentId: string): CodeDocument | null;
    submitCodeOperation(operation: CodeOperation): void;
    getDocumentAnalytics(documentId: string): {
        documentId: string;
        filePath: string;
        version: number;
        collaborators: number;
        totalOperations: number;
        totalConflicts: number;
        lastModified: Date;
        operationsByType: Record<string, number>;
        operationsByAuthor: Record<string, number>;
        conflictResolutionStrategies: Record<string, number>;
        averageConflictResolutionTime: number;
    } | null;
    getUserCodeActivity(userId: string): import("./realtime-sync-handler").UserFileActivity | null;
    getDocumentCollaborators(documentId: string): string[];
    getAllCodeActivities(): import("./realtime-sync-handler").UserFileActivity[];
    addAIAgentsToSession(sessionId: string, agentNames: string[]): Promise<void>;
    addAIAgentTeamToSession(sessionId: string, teamName: string): Promise<void>;
    removeAIAgentsFromSession(sessionId: string, agentNames: string[]): Promise<void>;
    processParallelAIRequest(sessionId: string, request: string, agentNames?: string[]): Promise<{
        responses: Array<{
            agentName: string;
            response: string;
            confidence: number;
        }>;
        consensus?: string;
        executionTime: number;
    }>;
    submitRequestToAIAgent(sessionId: string, agentName: string, request: AIAgentRequest): Promise<void>;
    getAvailableAIAgents(): Array<{
        name: string;
        id: string;
        capabilities: string[];
        enabled: boolean;
    }>;
    getAvailableAIAgentTeams(): import("./ai-agent-manager").AIAgentTeam[];
    getSessionAIAgents(sessionId: string): AICollaborationAgent[];
    startCollaborativeCodeGeneration(sessionId: string, prompt: string, initiatedBy: string): Promise<string>;
    submitCodeGenerationResponse(generationId: string, userId: string, code: string, vote?: 'approve' | 'reject' | 'suggest_changes', comments?: string): Promise<void>;
    private finalizeCollaborativeGeneration;
    addAIAgent(sessionId: string, agentConfig: {
        name: string;
        capabilities: string[];
        model?: string;
        personality?: string;
    }): Promise<boolean>;
    removeAIAgent(sessionId: string, agentId: string): Promise<boolean>;
    updateUserPresence(userId: string, sessionId: string, presence: Partial<UserPresence>): void;
    getSessionPresence(sessionId: string): UserPresence[];
    private handleUserJoined;
    private handleUserLeft;
    private handleCodeChanged;
    private handleAIRequest;
    private handleChatMessage;
    private broadcastPresenceUpdate;
    private broadcastToSession;
    private handleAIAgentMessage;
    private handleAIAgentJoined;
    private handleAIAgentLeft;
    private detectFramework;
    private generateAIConsensus;
    getSessionAnalytics(sessionId: string): import("./session-manager").SessionAnalytics | null;
    getCollaborationStats(): Promise<{
        totalSessions: number;
        activeSessions: number;
        totalUsers: number;
        averageUsersPerSession: number;
    }>;
    shutdown(): Promise<void>;
}
export default CollaborationService;
//# sourceMappingURL=collaboration-service.d.ts.map