tabby-ai-assistant 1.0.0

package/src/services/core/ai-provider-manager.service.ts

@@ -0,0 +1,314 @@
+import { Injectable } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { BaseAiProvider, ProviderManager, ProviderInfo, ProviderEvent } from '../../types/provider.types';
+import { LoggerService } from './logger.service';
+
+/**
+ * AI提供商管理器
+ * 负责注册、管理和切换不同的AI提供商
+ */
+@Injectable({ providedIn: 'root' })
+export class AiProviderManagerService implements ProviderManager {
+    private providers = new Map<string, BaseAiProvider>();
+    private activeProvider: string | null = null;
+    private eventSubject = new Subject<ProviderEvent>();
+
+    constructor(private logger: LoggerService) {}
+
+    /**
+     * 注册AI提供商
+     */
+    registerProvider(provider: BaseAiProvider): void {
+        if (this.providers.has(provider.name)) {
+            this.logger.warn(`Provider ${provider.name} is already registered, replacing...`);
+        }
+
+        this.providers.set(provider.name, provider);
+        this.logger.info(`Provider registered: ${provider.name}`);
+
+        // 如果没有激活的提供商，自动设置第一个为默认
+        if (!this.activeProvider) {
+            this.setActiveProvider(provider.name);
+        }
+
+        // 发送事件
+        this.emitEvent({
+            type: 'config_changed',
+            provider: provider.name,
+            timestamp: new Date()
+        });
+    }
+
+    /**
+     * 注销AI提供商
+     */
+    unregisterProvider(name: string): void {
+        if (!this.providers.has(name)) {
+            this.logger.warn(`Provider ${name} not found, cannot unregister`);
+            return;
+        }
+
+        this.providers.delete(name);
+
+        // 如果删除的是当前激活的提供商，切换到其他提供商
+        if (this.activeProvider === name) {
+            const remainingProviders = Array.from(this.providers.keys());
+            if (remainingProviders.length > 0) {
+                this.setActiveProvider(remainingProviders[0]);
+            } else {
+                this.activeProvider = null;
+            }
+        }
+
+        this.logger.info(`Provider unregistered: ${name}`);
+    }
+
+    /**
+     * 获取指定提供商
+     */
+    getProvider(name: string): BaseAiProvider | undefined {
+        return this.providers.get(name);
+    }
+
+    /**
+     * 获取所有提供商
+     */
+    getAllProviders(): BaseAiProvider[] {
+        return Array.from(this.providers.values());
+    }
+
+    /**
+     * 获取当前激活的提供商
+     */
+    getActiveProvider(): BaseAiProvider | undefined {
+        if (!this.activeProvider) {
+            return undefined;
+        }
+        return this.providers.get(this.activeProvider);
+    }
+
+    /**
+     * 设置激活的提供商
+     */
+    setActiveProvider(name: string): boolean {
+        if (!this.providers.has(name)) {
+            this.logger.error(`Provider ${name} not found`);
+            return false;
+        }
+
+        const previousProvider = this.activeProvider;
+        this.activeProvider = name;
+
+        this.logger.info(`Active provider changed: ${previousProvider} -> ${name}`);
+
+        // 发送事件
+        this.emitEvent({
+            type: 'config_changed',
+            provider: name,
+            timestamp: new Date()
+        });
+
+        return true;
+    }
+
+    /**
+     * 获取提供商信息
+     */
+    getProviderInfo(name: string): ProviderInfo | undefined {
+        const provider = this.providers.get(name);
+        return provider ? provider.getInfo() : undefined;
+    }
+
+    /**
+     * 获取所有提供商信息
+     */
+    getAllProviderInfo(): ProviderInfo[] {
+        return this.getAllProviders().map(provider => provider.getInfo());
+    }
+
+    /**
+     * 检查提供商是否存在
+     */
+    hasProvider(name: string): boolean {
+        return this.providers.has(name);
+    }
+
+    /**
+     * 获取提供商数量
+     */
+    getProviderCount(): number {
+        return this.providers.size;
+    }
+
+    /**
+     * 获取当前激活的提供商名称
+     */
+    getActiveProviderName(): string | null {
+        return this.activeProvider;
+    }
+
+    /**
+     * 验证所有提供商配置
+     */
+    async validateAllProviders(): Promise<{ name: string; valid: boolean; errors: string[] }[]> {
+        const results = [];
+
+        for (const [name, provider] of this.providers) {
+            try {
+                const validation = provider.validateConfig();
+                results.push({
+                    name,
+                    valid: validation.valid,
+                    errors: validation.errors || []
+                });
+            } catch (error) {
+                results.push({
+                    name,
+                    valid: false,
+                    errors: [`Validation error: ${error instanceof Error ? error.message : String(error)}`]
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * 检查所有提供商健康状态
+     */
+    async checkAllProvidersHealth(): Promise<{ provider: string; status: string; latency?: number }[]> {
+        const results = [];
+
+        for (const [name, provider] of this.providers) {
+            try {
+                const start = Date.now();
+                const health = await provider.healthCheck();
+                const latency = Date.now() - start;
+
+                results.push({
+                    provider: name,
+                    status: health,
+                    latency
+                });
+            } catch (error) {
+                results.push({
+                    provider: name,
+                    status: 'unhealthy'
+                });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * 获取启用的提供商
+     */
+    getEnabledProviders(): BaseAiProvider[] {
+        return this.getAllProviders().filter(provider => {
+            const config = provider.getConfig();
+            return config?.enabled !== false;
+        });
+    }
+
+    /**
+     * 获取启用的提供商名称
+     */
+    getEnabledProviderNames(): string[] {
+        return this.getEnabledProviders().map(p => p.name);
+    }
+
+    /**
+     * 切换到下一个启用的提供商
+     */
+    switchToNextProvider(): boolean {
+        const enabledProviders = this.getEnabledProviders();
+        if (enabledProviders.length === 0) {
+            return false;
+        }
+
+        const currentIndex = enabledProviders.findIndex(p => p.name === this.activeProvider);
+        const nextIndex = (currentIndex + 1) % enabledProviders.length;
+        const nextProvider = enabledProviders[nextIndex];
+
+        return this.setActiveProvider(nextProvider.name);
+    }
+
+    /**
+     * 切换到上一个启用的提供商
+     */
+    switchToPreviousProvider(): boolean {
+        const enabledProviders = this.getEnabledProviders();
+        if (enabledProviders.length === 0) {
+            return false;
+        }
+
+        const currentIndex = enabledProviders.findIndex(p => p.name === this.activeProvider);
+        const prevIndex = currentIndex === 0 ? enabledProviders.length - 1 : currentIndex - 1;
+        const prevProvider = enabledProviders[prevIndex];
+
+        return this.setActiveProvider(prevProvider.name);
+    }
+
+    /**
+     * 订阅提供商事件
+     */
+    onEvent(): Observable<ProviderEvent> {
+        return this.eventSubject.asObservable();
+    }
+
+    /**
+     * 获取所有启用的提供商中性能最好的（延迟最低）
+     */
+    async getBestPerformingProvider(): Promise<BaseAiProvider | null> {
+        const healthStatus = await this.checkAllProvidersHealth();
+        const healthyProviders = healthStatus
+            .filter(h => h.status === 'healthy')
+            .sort((a, b) => (a.latency || 0) - (b.latency || 0));
+
+        if (healthyProviders.length === 0) {
+            return null;
+        }
+
+        const bestProviderName = healthyProviders[0].provider;
+        return this.providers.get(bestProviderName) || null;
+    }
+
+    /**
+     * 发送事件
+     */
+    private emitEvent(event: ProviderEvent): void {
+        this.eventSubject.next(event);
+    }
+
+    /**
+     * 获取提供商统计信息
+     */
+    getStats(): {
+        totalProviders: number;
+        enabledProviders: number;
+        activeProvider: string | null;
+        providers: { name: string; enabled: boolean; healthy: boolean }[];
+    } {
+        const providers = this.getAllProviders();
+        return {
+            totalProviders: providers.length,
+            enabledProviders: this.getEnabledProviders().length,
+            activeProvider: this.activeProvider,
+            providers: providers.map(p => ({
+                name: p.name,
+                enabled: p.getConfig()?.enabled !== false,
+                healthy: true // TODO: 实现健康检查缓存
+            }))
+        };
+    }
+
+    /**
+     * 重置所有提供商
+     */
+    reset(): void {
+        this.providers.clear();
+        this.activeProvider = null;
+        this.logger.info('All providers reset');
+    }
+}

package/src/services/core/config-provider.service.ts

@@ -0,0 +1,347 @@
+import { Injectable } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { LoggerService } from './logger.service';
+import { SecurityConfig } from '../../types/security.types';
+import { ProviderConfig } from '../../types/provider.types';
+
+/**
+ * AI助手配置
+ */
+export interface AiAssistantConfig {
+    enabled: boolean;
+    defaultProvider: string;
+    chatHistoryEnabled: boolean;
+    maxChatHistory: number;
+    autoSaveChat: boolean;
+    theme: 'light' | 'dark' | 'auto';
+    language: string;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    security: SecurityConfig;
+    providers: { [name: string]: ProviderConfig };
+    hotkeys: {
+        openChat: string;
+        generateCommand: string;
+        explainCommand: string;
+    };
+    ui: {
+        showTooltips: boolean;
+        compactMode: boolean;
+        fontSize: number;
+    };
+}
+
+const DEFAULT_CONFIG: AiAssistantConfig = {
+    enabled: true,
+    defaultProvider: 'openai',
+    chatHistoryEnabled: true,
+    maxChatHistory: 100,
+    autoSaveChat: true,
+    theme: 'auto',
+    language: 'zh-CN',
+    logLevel: 'info',
+    security: {
+        enablePasswordProtection: false,
+        consentExpiryDays: 30,
+        maxConsentAge: 30,
+        enableRiskAssessment: true,
+        autoApproveLowRisk: true,
+        promptForMediumRisk: true,
+        requirePasswordForHighRisk: true,
+        dangerousPatterns: [
+            'rm -rf /',
+            'sudo rm -rf /',
+            'format',
+            'dd if=',
+            '> /dev/null',
+            'fork\\('
+        ],
+        allowedCommands: [],
+        forbiddenCommands: []
+    },
+    providers: {},
+    hotkeys: {
+        openChat: 'Ctrl-Shift-A',
+        generateCommand: 'Ctrl-Shift-G',
+        explainCommand: 'Ctrl-Shift-E'
+    },
+    ui: {
+        showTooltips: true,
+        compactMode: false,
+        fontSize: 14
+    }
+};
+
+@Injectable({ providedIn: 'root' })
+export class ConfigProviderService {
+    private config: AiAssistantConfig = { ...DEFAULT_CONFIG };
+    private configChange$ = new Subject<{ key: string; value: any }>();
+
+    constructor(private logger: LoggerService) {
+        this.loadConfig();
+    }
+
+    /**
+     * 加载配置
+     */
+    private loadConfig(): void {
+        try {
+            const stored = localStorage.getItem('ai-assistant-config');
+            if (stored) {
+                const parsed = JSON.parse(stored);
+                this.config = { ...DEFAULT_CONFIG, ...parsed };
+                this.logger.info('Configuration loaded from storage');
+            } else {
+                this.logger.info('No stored configuration found, using defaults');
+            }
+        } catch (error) {
+            this.logger.error('Failed to load configuration', error);
+            this.config = { ...DEFAULT_CONFIG };
+        }
+    }
+
+    /**
+     * 保存配置
+     */
+    private saveConfig(): void {
+        try {
+            localStorage.setItem('ai-assistant-config', JSON.stringify(this.config));
+            this.logger.debug('Configuration saved to storage');
+        } catch (error) {
+            this.logger.error('Failed to save configuration', error);
+        }
+    }
+
+    /**
+     * 获取完整配置
+     */
+    getConfig(): AiAssistantConfig {
+        return { ...this.config };
+    }
+
+    /**
+     * 设置完整配置
+     */
+    setConfig(config: Partial<AiAssistantConfig>): void {
+        this.config = { ...this.config, ...config };
+        this.saveConfig();
+        this.configChange$.next({ key: '*', value: this.config });
+        this.logger.info('Configuration updated');
+    }
+
+    /**
+     * 获取指定配置项
+     */
+    get<T>(key: string, defaultValue?: T): T | undefined {
+        const keys = key.split('.');
+        let value: any = this.config;
+
+        for (const k of keys) {
+            if (value === null || value === undefined) {
+                return defaultValue;
+            }
+            value = value[k];
+        }
+
+        return value !== undefined ? value : defaultValue;
+    }
+
+    /**
+     * 设置指定配置项
+     */
+    set<T>(key: string, value: T): void {
+        const keys = key.split('.');
+        const lastKey = keys.pop()!;
+
+        // 导航到父对象
+        let target: any = this.config;
+        for (const k of keys) {
+            if (!(k in target) || typeof target[k] !== 'object') {
+                target[k] = {};
+            }
+            target = target[k];
+        }
+
+        // 设置值
+        target[lastKey] = value;
+        this.saveConfig();
+        this.configChange$.next({ key, value });
+
+        this.logger.debug('Configuration item updated', { key, value });
+    }
+
+    /**
+     * 获取提供商配置
+     */
+    getProviderConfig(name: string): ProviderConfig | null {
+        return this.config.providers[name] || null;
+    }
+
+    /**
+     * 设置提供商配置
+     */
+    setProviderConfig(name: string, config: ProviderConfig): void {
+        this.config.providers[name] = config;
+        this.saveConfig();
+        this.configChange$.next({ key: `providers.${name}`, value: config });
+        this.logger.info('Provider configuration updated', { provider: name });
+    }
+
+    /**
+     * 删除提供商配置
+     */
+    deleteProviderConfig(name: string): void {
+        delete this.config.providers[name];
+        this.saveConfig();
+        this.configChange$.next({ key: `providers.${name}`, value: null });
+        this.logger.info('Provider configuration deleted', { provider: name });
+    }
+
+    /**
+     * 获取所有提供商配置
+     */
+    getAllProviderConfigs(): { [name: string]: ProviderConfig } {
+        return { ...this.config.providers };
+    }
+
+    /**
+     * 获取默认提供商
+     */
+    getDefaultProvider(): string {
+        return this.config.defaultProvider;
+    }
+
+    /**
+     * 设置默认提供商
+     */
+    setDefaultProvider(name: string): void {
+        this.config.defaultProvider = name;
+        this.saveConfig();
+        this.configChange$.next({ key: 'defaultProvider', value: name });
+        this.logger.info('Default provider changed', { provider: name });
+    }
+
+    /**
+     * 获取安全配置
+     */
+    getSecurityConfig(): SecurityConfig {
+        return { ...this.config.security };
+    }
+
+    /**
+     * 更新安全配置
+     */
+    updateSecurityConfig(config: Partial<SecurityConfig>): void {
+        this.config.security = { ...this.config.security, ...config };
+        this.saveConfig();
+        this.configChange$.next({ key: 'security', value: this.config.security });
+        this.logger.info('Security configuration updated');
+    }
+
+    /**
+     * 获取启用状态
+     */
+    isEnabled(): boolean {
+        return this.config.enabled;
+    }
+
+    /**
+     * 设置启用状态
+     */
+    setEnabled(enabled: boolean): void {
+        this.config.enabled = enabled;
+        this.saveConfig();
+        this.configChange$.next({ key: 'enabled', value: enabled });
+        this.logger.info('AI Assistant enabled state changed', { enabled });
+    }
+
+    /**
+     * 获取日志级别
+     */
+    getLogLevel(): string {
+        return this.config.logLevel;
+    }
+
+    /**
+     * 设置日志级别
+     */
+    setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): void {
+        this.config.logLevel = level;
+        this.saveConfig();
+        this.configChange$.next({ key: 'logLevel', value: level });
+        this.logger.info('Log level changed', { level });
+    }
+
+    /**
+     * 重置为默认配置
+     */
+    reset(): void {
+        this.config = { ...DEFAULT_CONFIG };
+        this.saveConfig();
+        this.configChange$.next({ key: '*', value: this.config });
+        this.logger.info('Configuration reset to defaults');
+    }
+
+    /**
+     * 订阅配置变化
+     */
+    onConfigChange(): Observable<{ key: string; value: any }> {
+        return this.configChange$.asObservable();
+    }
+
+    /**
+     * 导出配置
+     */
+    exportConfig(): string {
+        // 排除敏感信息（如API密钥）
+        const exportData = { ...this.config };
+        if (exportData.providers) {
+            Object.keys(exportData.providers).forEach(name => {
+                if (exportData.providers[name].apiKey) {
+                    exportData.providers[name].apiKey = '***MASKED***';
+                }
+            });
+        }
+        return JSON.stringify(exportData, null, 2);
+    }
+
+    /**
+     * 导入配置
+     */
+    importConfig(configJson: string): void {
+        try {
+            const imported = JSON.parse(configJson);
+            this.setConfig(imported);
+            this.logger.info('Configuration imported successfully');
+        } catch (error) {
+            this.logger.error('Failed to import configuration', error);
+            throw new Error('Invalid configuration format');
+        }
+    }
+
+    /**
+     * 验证配置
+     */
+    validateConfig(): { valid: boolean; errors: string[] } {
+        const errors: string[] = [];
+
+        // 验证默认提供商
+        if (!this.config.providers[this.config.defaultProvider]) {
+            errors.push('Default provider configuration not found');
+        }
+
+        // 验证安全配置
+        if (this.config.security.consentExpiryDays < 1) {
+            errors.push('Consent expiry days must be at least 1');
+        }
+
+        // 验证聊天历史配置
+        if (this.config.maxChatHistory < 0) {
+            errors.push('Max chat history must be non-negative');
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}