tabby-ai-assistant 1.0.13 → 1.0.16

package/src/components/chat/chat-interface.component.ts

@@ -1,7 +1,7 @@
 import { Component, OnInit, OnDestroy, ViewChild, ElementRef, AfterViewChecked, ViewEncapsulation } from '@angular/core';
 import { Subject } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
-import { ChatMessage, MessageRole, StreamEvent } from '../../types/ai.types';
+import { ChatMessage, MessageRole, StreamEvent, AgentStreamEvent } from '../../types/ai.types';
 import { AiAssistantService } from '../../services/core/ai-assistant.service';
 import { ConfigProviderService } from '../../services/core/config-provider.service';
 import { LoggerService } from '../../services/core/logger.service';
@@ -191,7 +191,168 @@ export class ChatInterfaceComponent implements OnInit, OnDestroy, AfterViewCheck
     }
 
     /**
-     * 处理发送消息
+     * 处理发送消息（使用 Agent 循环模式）
+     */
+    async onSendMessageWithAgent(content: string): Promise<void> {
+        if (!content.trim() || this.isLoading) {
+            return;
+        }
+
+        // 添加用户消息
+        const userMessage: ChatMessage = {
+            id: this.generateId(),
+            role: MessageRole.USER,
+            content: content.trim(),
+            timestamp: new Date()
+        };
+        this.messages.push(userMessage);
+
+        // 滚动到底部
+        setTimeout(() => this.scrollToBottom(), 0);
+
+        // 清空输入框
+        content = '';
+
+        // 显示加载状态
+        this.isLoading = true;
+
+        // 创建一个临时的 AI 消息用于流式更新
+        const aiMessage: ChatMessage = {
+            id: this.generateId(),
+            role: MessageRole.ASSISTANT,
+            content: '',  // 初始为空
+            timestamp: new Date()
+        };
+        this.messages.push(aiMessage);
+
+        // 工具调用状态跟踪
+        const toolStatus = new Map<string, { name: string; startTime: number }>();
+
+        try {
+            // 使用 Agent 循环流式 API
+            this.aiService.chatStreamWithAgentLoop({
+                messages: this.messages.slice(0, -1),  // 排除刚添加的空 AI 消息
+                maxTokens: 2000,
+                temperature: 0.7
+            }, {
+                maxRounds: 5
+            }).pipe(
+                takeUntil(this.destroy$)
+            ).subscribe({
+                next: (event: AgentStreamEvent) => {
+                    switch (event.type) {
+                        case 'text_delta':
+                            // 流式显示文本
+                            if (event.textDelta) {
+                                aiMessage.content += event.textDelta;
+                                this.shouldScrollToBottom = true;
+                            }
+                            break;
+
+                        case 'tool_use_start':
+                            // 显示工具开始
+                            const toolName = event.toolCall?.name || 'unknown';
+                            aiMessage.content += `\n\n🔧 ${this.t.chatInterface.executingTool} ${toolName}...`;
+                            if (event.toolCall?.id) {
+                                toolStatus.set(event.toolCall.id, {
+                                    name: toolName,
+                                    startTime: Date.now()
+                                });
+                            }
+                            this.shouldScrollToBottom = true;
+                            break;
+
+                        case 'tool_executing':
+                            // 工具正在执行（额外状态）
+                            break;
+
+                        case 'tool_executed':
+                            // 工具执行完成 - 更新状态
+                            if (event.toolCall && event.toolResult) {
+                                const name = toolStatus.get(event.toolCall.id)?.name || event.toolCall.name || 'unknown';
+                                const duration = event.toolResult.duration || 0;
+
+                                // 替换等待提示为完成状态
+                                aiMessage.content = aiMessage.content.replace(
+                                    new RegExp(`🔧 ${this.t.chatInterface.executingTool} ${name}\\.\\.\\.`),
+                                    `✅ ${name} (${duration}ms)`
+                                );
+
+                                // 显示工具输出预览
+                                if (event.toolResult.content && !event.toolResult.is_error) {
+                                    const preview = event.toolResult.content.substring(0, 500);
+                                    const truncated = event.toolResult.content.length > 500 ? '...' : '';
+                                    aiMessage.content += `\n\n📋 **${this.t.chatInterface.toolOutput}**:\n\`\`\`\n${preview}${truncated}\n\`\`\``;
+                                }
+
+                                toolStatus.delete(event.toolCall.id);
+                            }
+                            this.shouldScrollToBottom = true;
+                            break;
+
+                        case 'tool_error':
+                            // 工具执行失败
+                            if (event.toolCall) {
+                                const name = toolStatus.get(event.toolCall.id)?.name || event.toolCall.name || 'unknown';
+                                aiMessage.content = aiMessage.content.replace(
+                                    new RegExp(`🔧 ${this.t.chatInterface.executingTool} ${name}\\.\\.\\.`),
+                                    `❌ ${name} ${this.t.chatInterface.toolFailed}: ${event.toolResult?.content || 'Unknown error'}`
+                                );
+                                toolStatus.delete(event.toolCall.id);
+                            }
+                            this.shouldScrollToBottom = true;
+                            break;
+
+                        case 'round_start':
+                            // 新一轮开始
+                            if (event.round && event.round > 1) {
+                                aiMessage.content += '\n\n---\n\n';
+                            }
+                            break;
+
+                        case 'round_end':
+                            // 一轮结束
+                            break;
+
+                        case 'agent_complete':
+                            // Agent 循环完成
+                            this.logger.info('Agent completed', {
+                                reason: event.reason,
+                                totalRounds: event.totalRounds
+                            });
+                            break;
+
+                        case 'error':
+                            // 错误
+                            aiMessage.content += `\n\n❌ ${this.t.chatInterface.errorPrefix}: ${event.error}`;
+                            this.shouldScrollToBottom = true;
+                            break;
+                    }
+                },
+                error: (error) => {
+                    this.logger.error('Agent stream error', error);
+                    aiMessage.content += `\n\n❌ ${this.t.chatInterface.errorPrefix}: ${error instanceof Error ? error.message : 'Unknown error'}`;
+                    this.isLoading = false;
+                    this.shouldScrollToBottom = true;
+                    this.saveChatHistory();
+                },
+                complete: () => {
+                    this.isLoading = false;
+                    this.saveChatHistory();
+                    this.shouldScrollToBottom = true;
+                }
+            });
+
+        } catch (error) {
+            this.logger.error('Failed to send message with agent', error);
+            aiMessage.content = `${this.t.chatInterface.errorPrefix}: ${error instanceof Error ? error.message : 'Unknown error'}\n\n${this.t.chatInterface.tipShortcut}`;
+            this.isLoading = false;
+            setTimeout(() => this.scrollToBottom(), 0);
+        }
+    }
+
+    /**
+     * 处理发送消息（原有方法，保留兼容性）
      */
     async onSendMessage(content: string): Promise<void> {
         if (!content.trim() || this.isLoading) {
@@ -225,6 +386,10 @@ export class ChatInterfaceComponent implements OnInit, OnDestroy, AfterViewCheck
         };
         this.messages.push(aiMessage);
 
+        // 工具调用状态跟踪
+        let pendingToolCalls: Map<string, { name: string; startTime: number }> = new Map();
+        let toolResultsToAppend: string[] = [];
+
         try {
             // 使用流式 API
             this.aiService.chatStream({
@@ -242,18 +407,73 @@ export class ChatInterfaceComponent implements OnInit, OnDestroy, AfterViewCheck
                     }
                     // 工具调用开始 - 显示提示
                     else if (event.type === 'tool_use_start') {
-                        aiMessage.content += `\n\n🔧 ${this.t.chatInterface.executingTool}`;
+                        const toolName = event.toolCall?.name ? ` (${event.toolCall.name})` : '';
+                        aiMessage.content += `\n\n🔧 ${this.t.chatInterface.executingTool}${toolName}...`;
+
+                        // 记录待执行的工具
+                        if (event.toolCall?.id) {
+                            pendingToolCalls.set(event.toolCall.id, {
+                                name: event.toolCall.name || 'unknown',
+                                startTime: Date.now()
+                            });
+                        }
                         this.shouldScrollToBottom = true;
                     }
                     // 工具调用完成 - 更新状态
                     else if (event.type === 'tool_use_end') {
-                        aiMessage.content = aiMessage.content.replace(`🔧 ${this.t.chatInterface.executingTool}`, `✅ ${this.t.chatInterface.toolComplete}`);
+                        if (event.toolCall) {
+                            const toolInfo = pendingToolCalls.get(event.toolCall.id);
+                            const duration = toolInfo ? Date.now() - toolInfo.startTime : 0;
+                            const toolName = toolInfo?.name || event.toolCall.name || 'unknown';
+
+                            // 替换等待提示为完成状态
+                            aiMessage.content = aiMessage.content.replace(
+                                /🔧 正在执行工具.*?\.\.\./g,
+                                `✅ ${toolName} 完成`
+                            );
+
+                            pendingToolCalls.delete(event.toolCall.id);
+                        }
+                        this.shouldScrollToBottom = true;
+                    }
+                    // 工具结果 - 追加到消息
+                    else if (event.type === 'tool_result' && event.result) {
+                        const isError = event.result.is_error;
+                        const icon = isError ? '❌' : '📋';
+                        const header = isError ? '**工具执行失败**' : '**工具输出**';
+
+                        // 截断过长的结果
+                        const maxPreviewLength = 800;
+                        let resultPreview = event.result.content;
+                        const isTruncated = resultPreview.length > maxPreviewLength;
+                        if (isTruncated) {
+                            resultPreview = resultPreview.substring(0, maxPreviewLength) + '\n...(已截断)';
+                        }
+
+                        // 格式化工具结果
+                        const formattedResult = `\n\n${icon} ${header}:\n\`\`\`\n${resultPreview}\n\`\`\``;
+                        toolResultsToAppend.push(formattedResult);
+                        this.shouldScrollToBottom = true;
+                    }
+                    // 工具错误
+                    else if (event.type === 'tool_error' && event.error) {
+                        aiMessage.content = aiMessage.content.replace(
+                            /🔧 正在执行工具.*?\.\.\./g,
+                            `❌ 工具执行失败: ${event.error}`
+                        );
                         this.shouldScrollToBottom = true;
                     }
-                    // 消息结束
+                    // 消息结束 - 附加所有工具结果
                     else if (event.type === 'message_end') {
                         this.logger.info('Stream completed');
+
+                        // 附加所有工具结果
+                        if (toolResultsToAppend.length > 0) {
+                            aiMessage.content += toolResultsToAppend.join('');
+                        }
+
                         this.playNotificationSound();
+                        this.shouldScrollToBottom = true;
                     }
                 },
                 error: (error) => {

package/src/components/chat/chat-message.component.ts

@@ -1,5 +1,6 @@
 import { Component, Input, Output, EventEmitter, ViewEncapsulation } from '@angular/core';
 import { ChatMessage } from '../../types/ai.types';
+import { ToastService } from '../../services/core/toast.service';
 
 @Component({
     selector: 'app-chat-message',
@@ -15,6 +16,8 @@ export class ChatMessageComponent {
     @Output() messageClick = new EventEmitter<ChatMessage>();
     @Output() messageAction = new EventEmitter<{ action: string; message: ChatMessage }>();
 
+    constructor(private toastService: ToastService) {}
+
     /**
      * 处理消息点击
      */
@@ -34,7 +37,9 @@ export class ChatMessageComponent {
      */
     copyMessage(): void {
         navigator.clipboard.writeText(this.message.content).then(() => {
-            // TODO: 显示复制成功提示
+            this.toastService.success('已复制到剪贴板', 2000);
+        }).catch(error => {
+            this.toastService.error('复制失败，请重试');
         });
     }
 

package/src/components/settings/context-settings.component.ts

@@ -1,91 +1,91 @@
-import { Component, OnInit, OnDestroy, ViewEncapsulation } from '@angular/core';
-import { Subject } from 'rxjs';
-import { takeUntil } from 'rxjs/operators';
-import { ConfigProviderService } from '../../services/core/config-provider.service';
-import { ContextManager } from '../../services/context/manager';
-import { ToastService } from '../../services/core/toast.service';
-import { TranslateService } from '../../i18n';
-import { ContextConfig, DEFAULT_CONTEXT_CONFIG } from '../../types/ai.types';
-
-@Component({
-    selector: 'app-context-settings',
-    templateUrl: './context-settings.component.html',
-    styleUrls: ['./context-settings.component.scss'],
-    encapsulation: ViewEncapsulation.None
-})
-export class ContextSettingsComponent implements OnInit, OnDestroy {
-    // 配置项
-    config: ContextConfig = { ...DEFAULT_CONTEXT_CONFIG };
-    autoCompactEnabled = true;
-
-    // 当前供应商的上下文限制
-    activeProviderContextWindow: number = 200000;
-
-    // 翻译对象
-    t: any;
-
-    private destroy$ = new Subject<void>();
-
-    constructor(
-        private configService: ConfigProviderService,
-        private contextManager: ContextManager,
-        private toast: ToastService,
-        private translate: TranslateService
-    ) {
-        this.t = this.translate.t;
-    }
-
-    ngOnInit(): void {
-        this.translate.translation$.pipe(
-            takeUntil(this.destroy$)
-        ).subscribe(translation => {
-            this.t = translation;
-        });
-
-        this.loadConfig();
-    }
-
-    ngOnDestroy(): void {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-
-    loadConfig(): void {
-        const savedConfig = this.configService.getContextConfig();
-        if (savedConfig) {
-            this.config = { ...DEFAULT_CONTEXT_CONFIG, ...savedConfig };
-        }
-        this.autoCompactEnabled = this.configService.isAutoCompactEnabled();
-
-        // 获取当前供应商的上下文限制
-        this.activeProviderContextWindow = this.configService.getActiveProviderContextWindow();
-
-        // 确保配置的 maxContextTokens 不超过供应商限制
-        if (this.config.maxContextTokens > this.activeProviderContextWindow) {
-            this.config.maxContextTokens = this.activeProviderContextWindow;
-        }
-    }
-
-    saveConfig(): void {
-        this.configService.setContextConfig(this.config);
-        this.contextManager.updateConfig(this.config);
-        this.toast.success(this.t?.contextSettings?.configSaved || '上下文配置已保存');
-    }
-
-    toggleAutoCompact(): void {
-        this.autoCompactEnabled = !this.autoCompactEnabled;
-        this.configService.setAutoCompactEnabled(this.autoCompactEnabled);
-        this.toast.info(
-            this.autoCompactEnabled
-                ? (this.t?.contextSettings?.autoCompactEnabled || '自动压缩已启用')
-                : (this.t?.contextSettings?.autoCompactDisabled || '自动压缩已禁用')
-        );
-    }
-
-    resetToDefaults(): void {
-        this.config = { ...DEFAULT_CONTEXT_CONFIG };
-        this.autoCompactEnabled = true;
-        this.saveConfig();
-        this.toast.info(this.t?.common?.resetToDefault || '已重置为默认配置');
-    }
-}
+import { Component, OnInit, OnDestroy, ViewEncapsulation } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ConfigProviderService } from '../../services/core/config-provider.service';
+import { ContextManager } from '../../services/context/manager';
+import { ToastService } from '../../services/core/toast.service';
+import { TranslateService } from '../../i18n';
+import { ContextConfig, DEFAULT_CONTEXT_CONFIG } from '../../types/ai.types';
+
+@Component({
+    selector: 'app-context-settings',
+    templateUrl: './context-settings.component.html',
+    styleUrls: ['./context-settings.component.scss'],
+    encapsulation: ViewEncapsulation.None
+})
+export class ContextSettingsComponent implements OnInit, OnDestroy {
+    // 配置项
+    config: ContextConfig = { ...DEFAULT_CONTEXT_CONFIG };
+    autoCompactEnabled = true;
+
+    // 当前供应商的上下文限制
+    activeProviderContextWindow: number = 200000;
+
+    // 翻译对象
+    t: any;
+
+    private destroy$ = new Subject<void>();
+
+    constructor(
+        private configService: ConfigProviderService,
+        private contextManager: ContextManager,
+        private toast: ToastService,
+        private translate: TranslateService
+    ) {
+        this.t = this.translate.t;
+    }
+
+    ngOnInit(): void {
+        this.translate.translation$.pipe(
+            takeUntil(this.destroy$)
+        ).subscribe(translation => {
+            this.t = translation;
+        });
+
+        this.loadConfig();
+    }
+
+    ngOnDestroy(): void {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+
+    loadConfig(): void {
+        const savedConfig = this.configService.getContextConfig();
+        if (savedConfig) {
+            this.config = { ...DEFAULT_CONTEXT_CONFIG, ...savedConfig };
+        }
+        this.autoCompactEnabled = this.configService.isAutoCompactEnabled();
+
+        // 获取当前供应商的上下文限制
+        this.activeProviderContextWindow = this.configService.getActiveProviderContextWindow();
+
+        // 确保配置的 maxContextTokens 不超过供应商限制
+        if (this.config.maxContextTokens > this.activeProviderContextWindow) {
+            this.config.maxContextTokens = this.activeProviderContextWindow;
+        }
+    }
+
+    saveConfig(): void {
+        this.configService.setContextConfig(this.config);
+        this.contextManager.updateConfig(this.config);
+        this.toast.success(this.t?.contextSettings?.configSaved || '上下文配置已保存');
+    }
+
+    toggleAutoCompact(): void {
+        this.autoCompactEnabled = !this.autoCompactEnabled;
+        this.configService.setAutoCompactEnabled(this.autoCompactEnabled);
+        this.toast.info(
+            this.autoCompactEnabled
+                ? (this.t?.contextSettings?.autoCompactEnabled || '自动压缩已启用')
+                : (this.t?.contextSettings?.autoCompactDisabled || '自动压缩已禁用')
+        );
+    }
+
+    resetToDefaults(): void {
+        this.config = { ...DEFAULT_CONTEXT_CONFIG };
+        this.autoCompactEnabled = true;
+        this.saveConfig();
+        this.toast.info(this.t?.common?.resetToDefault || '已重置为默认配置');
+    }
+}

package/src/components/terminal/ai-toolbar-button.component.ts

@@ -1,4 +1,5 @@
 import { Component, Input } from '@angular/core';
+import { AiSidebarService } from '../../services/chat/ai-sidebar.service';
 
 /**
  * AI工具栏按钮组件
@@ -14,8 +15,9 @@ export class AiToolbarButtonComponent {
     @Input() tooltip: string = 'Open AI Assistant';
     @Input() showLabel: boolean = true;
 
+    constructor(private sidebarService: AiSidebarService) {}
+
     onClick(): void {
-        // TODO: 触发打开AI助手
-        console.log('AI Assistant button clicked');
+        this.sidebarService.toggle();
     }
 }

package/src/components/terminal/command-suggestion.component.ts

@@ -1,7 +1,10 @@
 import { Component, Input, Output, EventEmitter, OnInit, OnDestroy } from '@angular/core';
 import { Subject } from 'rxjs';
 import { debounceTime, takeUntil } from 'rxjs/operators';
-import { CommandResponse } from '../../types/ai.types';
+import { CommandResponse, CommandRequest } from '../../types/ai.types';
+import { AiAssistantService } from '../../services/core/ai-assistant.service';
+import { TerminalContextService } from '../../services/terminal/terminal-context.service';
+import { LoggerService } from '../../services/core/logger.service';
 
 @Component({
     selector: 'app-command-suggestion',
@@ -14,12 +17,19 @@ export class CommandSuggestionComponent implements OnInit, OnDestroy {
     @Output() closed = new EventEmitter<void>();
 
     suggestions: CommandResponse[] = [];
+    isLoading = false;
     private inputSubject = new Subject<string>();
     private destroy$ = new Subject<void>();
 
+    constructor(
+        private aiService: AiAssistantService,
+        private terminalContext: TerminalContextService,
+        private logger: LoggerService
+    ) {}
+
     ngOnInit(): void {
         this.inputSubject.pipe(
-            debounceTime(500),
+            debounceTime(300),
             takeUntil(this.destroy$)
         ).subscribe(text => {
             this.generateSuggestions(text);
@@ -35,10 +45,142 @@ export class CommandSuggestionComponent implements OnInit, OnDestroy {
         this.inputSubject.next(text);
     }
 
-    private generateSuggestions(text: string): void {
-        // TODO: 调用AI生成建议
-        // 这里应该调用CommandGeneratorService
-        this.suggestions = [];
+    private async generateSuggestions(text: string): Promise<void> {
+        // 如果输入太短，不生成建议
+        if (text.length < 2) {
+            this.suggestions = [];
+            return;
+        }
+
+        this.isLoading = true;
+
+        try {
+            // 1. 获取基于上下文的智能建议
+            const suggestedCommands = await this.aiService.getSuggestedCommands(text);
+
+            // 2. 如果有AI建议，转换为CommandResponse格式
+            const aiSuggestions: CommandResponse[] = [];
+
+            // 添加前5个最相关的建议
+            for (const cmd of suggestedCommands.slice(0, 5)) {
+                // 如果命令模板中包含占位符，用当前输入填充
+                const filledCmd = cmd.replace('""', text).replace('${input}', text);
+
+                aiSuggestions.push({
+                    command: filledCmd,
+                    explanation: this.getExplanationForCommand(filledCmd),
+                    confidence: this.calculateConfidence(filledCmd, text)
+                });
+            }
+
+            // 3. 如果输入看起来像自然语言，调用AI生成命令
+            if (this.looksLikeNaturalLanguage(text)) {
+                const aiCommand = await this.generateAICommand(text);
+                if (aiCommand && !aiSuggestions.find(s => s.command === aiCommand.command)) {
+                    aiSuggestions.unshift(aiCommand);
+                }
+            }
+
+            this.suggestions = aiSuggestions.slice(0, 6);
+
+        } catch (error) {
+            this.logger.error('Failed to generate suggestions', error);
+            this.suggestions = [];
+        } finally {
+            this.isLoading = false;
+        }
+    }
+
+    /**
+     * 检查输入是否像自然语言
+     */
+    private looksLikeNaturalLanguage(text: string): boolean {
+        const naturalLanguagePatterns = [
+            /^[a-zA-Z]+/,
+            /^(帮我|请|我想|需要|要)/,
+            /how to|what is|what's/
+        ];
+
+        return naturalLanguagePatterns.some(pattern => pattern.test(text.toLowerCase()));
+    }
+
+    /**
+     * 调用AI生成命令
+     */
+    private async generateAICommand(naturalLanguage: string): Promise<CommandResponse | null> {
+        try {
+            const context = this.terminalContext.getCurrentContext();
+
+            const request: CommandRequest = {
+                naturalLanguage,
+                context: {
+                    currentDirectory: context?.session.cwd,
+                    operatingSystem: context?.systemInfo.platform,
+                    shell: context?.session.shell,
+                    environment: context?.session.environment
+                }
+            };
+
+            const response = await this.aiService.generateCommand(request);
+            return response;
+
+        } catch (error) {
+            this.logger.warn('AI command generation failed', error);
+            return null;
+        }
+    }
+
+    /**
+     * 为命令生成解释
+     */
+    private getExplanationForCommand(command: string): string {
+        const explanations: { [key: string]: string } = {
+            'git status': '查看当前Git仓库状态',
+            'git pull': '拉取远程最新代码',
+            'git add .': '添加所有文件到暂存区',
+            'git commit -m ""': '提交暂存区文件',
+            'git checkout -b ': '创建并切换到新分支',
+            'git log --oneline': '查看简化的提交历史',
+            'npm install': '安装项目依赖',
+            'npm run dev': '启动开发服务器',
+            'npm run build': '构建生产版本',
+            'npm test': '运行测试',
+            'docker build -t .': '构建Docker镜像',
+            'docker-compose up': '启动Docker容器',
+            'docker ps': '查看运行中的容器',
+            'kubectl get pods': '查看Kubernetes Pods',
+            'ls -la': '列出所有文件详细信息',
+            'grep -r "" .': '递归搜索文件内容'
+        };
+
+        return explanations[command] || '执行命令';
+    }
+
+    /**
+     * 计算命令匹配度
+     */
+    private calculateConfidence(command: string, input: string): number {
+        const lowerInput = input.toLowerCase();
+        const lowerCmd = command.toLowerCase();
+
+        // 完全匹配开头
+        if (lowerCmd.startsWith(lowerInput)) {
+            return 0.95;
+        }
+
+        // 包含输入关键词
+        if (lowerCmd.includes(lowerInput)) {
+            return 0.8;
+        }
+
+        // 相同的命令前缀
+        const inputParts = lowerInput.split(' ');
+        const cmdParts = lowerCmd.split(' ');
+        if (inputParts[0] === cmdParts[0]) {
+            return 0.7;
+        }
+
+        return 0.5;
     }
 
     selectSuggestion(suggestion: CommandResponse): void {