bc-code-intelligence-mcp/dist/types/session-types.d.ts

BC Code Intelligence MCP Server - Complete Specialist Bundle with AI-driven expert consultation, seamless handoffs, and context-preserving workflows

/**
 * Session Management Types for BC Code Intelligence Specialists
 *
 * Provides interfaces for persistent, contextual conversations with specialist personas.
 * Supports in-memory sessions by default with configurable persistence through layer system.
 */
export interface SessionMessage {
    id: string;
    timestamp: Date;
    type: 'user' | 'specialist';
    specialistId?: string;
    content: string;
    metadata?: {
        files?: string[];
        codeSnippets?: string[];
        topics?: string[];
    };
}
export interface SessionContext {
    problem?: string;
    codebaseContext?: {
        files: string[];
        objects: string[];
        project?: string;
    };
    methodology_context?: {
        methodology_id: string;
        methodology_title: string;
        current_phase: string;
        phase_progress: Record<string, any>;
        confirmed_by_user: boolean;
        suggested_at: Date;
    };
    solutions: string[];
    recommendations: string[];
    nextSteps: string[];
    userPreferences: {
        communicationStyle?: 'detailed' | 'concise' | 'conversational';
        expertiseLevel?: 'beginner' | 'intermediate' | 'expert';
        preferredTopics?: string[];
        workingStyle?: string;
    };
}
export interface SpecialistSession {
    sessionId: string;
    specialistId: string;
    userId: string;
    startTime: Date;
    lastActivity: Date;
    status: 'active' | 'paused' | 'completed' | 'transferred';
    messages: SessionMessage[];
    messageCount: number;
    context: SessionContext;
    methodology_context?: {
        methodology_id: string;
        methodology_title: string;
        current_phase: string;
        phase_progress: Record<string, any>;
        confirmed_by_user: boolean;
        suggested_at: Date;
    };
    transferredFrom?: string;
    transferredTo?: string;
    tags?: string[];
}
export interface SessionSummary {
    sessionId: string;
    specialistId: string;
    startTime: Date;
    lastActivity: Date;
    status: SpecialistSession['status'];
    messageCount: number;
    primaryTopics: string[];
    keyInsights: string[];
}
export interface SessionStorageConfig {
    type: 'memory' | 'file' | 'database' | 'mcp';
    config?: {
        directory?: string;
        filename?: string;
        connectionString?: string;
        tableName?: string;
        mcpServer?: string;
        mcpTools?: string[];
    };
    retention?: {
        maxAge?: number;
        maxSessions?: number;
        autoCleanup?: boolean;
    };
    privacy?: {
        includeMessages?: boolean;
        includeCode?: boolean;
        includeFiles?: boolean;
        anonymizeContent?: boolean;
    };
}
export interface SessionStorage {
    createSession(session: SpecialistSession): Promise<void>;
    getSession(sessionId: string): Promise<SpecialistSession | null>;
    updateSession(session: SpecialistSession): Promise<void>;
    deleteSession(sessionId: string): Promise<void>;
    getUserSessions(userId: string): Promise<SessionSummary[]>;
    getActiveSessions(userId: string): Promise<SessionSummary[]>;
    getSpecialistSessions(specialistId: string): Promise<SessionSummary[]>;
    cleanupExpiredSessions(): Promise<number>;
    getUserSessionCount(userId: string): Promise<number>;
}
export interface SessionManager {
    startSession(specialistId: string, userId: string, initialMessage?: string): Promise<SpecialistSession>;
    getSession(sessionId: string): Promise<SpecialistSession | null>;
    continueSession(sessionId: string, message: string): Promise<SpecialistSession>;
    transferSession(sessionId: string, toSpecialistId: string): Promise<SpecialistSession>;
    endSession(sessionId: string): Promise<void>;
    listUserSessions(userId: string): Promise<SessionSummary[]>;
    listActiveSessions(userId: string): Promise<SessionSummary[]>;
    addMessage(sessionId: string, message: SessionMessage): Promise<void>;
    updateContext(sessionId: string, context: Partial<SessionContext>): Promise<void>;
    cleanupSessions(): Promise<number>;
}
export interface SessionEvents {
    sessionStarted: (session: SpecialistSession) => void;
    sessionEnded: (sessionId: string) => void;
    sessionTransferred: (sessionId: string, fromSpecialist: string, toSpecialist: string) => void;
    messageAdded: (sessionId: string, message: SessionMessage) => void;
}
//# sourceMappingURL=session-types.d.ts.map