♻️ refactor(utils): 优化工具类的错误处理和性能

- 【DiffSimplifier】添加配置缓存机制，优化配置读取性能
- 【LocalizationManager】增强消息格式化的错误处理和空值处理
- 【NotificationHandler】添加超时机制和统一的消息显示逻辑
- 【ProgressHandler】改进进度展示，支持取消操作
- 添加配置验证和日志记录功能

Author: littleCareless

src/utils/DiffSimplifier.ts

@@ -1,14 +1,31 @@
 import * as vscode from "vscode";
 
 export class DiffSimplifier {
+  private static configCache: {
+    enabled: boolean;
+    contextLines: number;
+    maxLineLength: number;
+  } | null = null;
+
   private static getConfig() {
+    if (this.configCache) {
+      return this.configCache;
+    }
+
     const config = vscode.workspace.getConfiguration("dish-ai-commit");
-    return {
-      enabled: config.get<boolean>("enableDiffSimplification") || false,
-      contextLines: config.get<number>("diffSimplification.contextLines") || 3,
+    this.configCache = {
+      enabled: config.get<boolean>("enableDiffSimplification") ?? false,
+      contextLines: config.get<number>("diffSimplification.contextLines") ?? 3,
       maxLineLength:
-        config.get<number>("diffSimplification.maxLineLength") || 120,
+        config.get<number>("diffSimplification.maxLineLength") ?? 120,
     };
+
+    return this.configCache;
+  }
+
+  // 添加配置更新方法
+  static clearConfigCache() {
+    this.configCache = null;
   }
 
   private static readonly CONTEXT_LINES = 3;
@@ -60,10 +77,12 @@ export class DiffSimplifier {
     return simplified.join("\n");
   }
 
+  // 优化 truncateLine 方法
   private static truncateLine(line: string, maxLength: number): string {
-    if (line.length <= maxLength) {
+    if (!line || line.length <= maxLength) {
       return line;
     }
-    return line.substring(0, maxLength - 3) + "...";
+    const ellipsis = "...";
+    return `${line.substring(0, maxLength - ellipsis.length)}${ellipsis}`;
   }
 }

src/utils/LocalizationManager.ts

@@ -55,10 +55,27 @@ export class LocalizationManager {
   }
 
   public format(key: string, ...args: any[]): string {
-    let message = this.getMessage(key);
-    args.forEach((arg, index) => {
-      message = message.replace(`{${index}}`, arg.toString());
-    });
-    return message;
+    try {
+      let message = this.getMessage(key);
+      if (!message) {
+        console.warn(`Missing localization key: ${key}`);
+        return key;
+      }
+
+      args.forEach((arg, index) => {
+        const value = arg?.toString() ?? "";
+        message = message.replace(`{${index}}`, value);
+      });
+      return message;
+    } catch (error) {
+      console.error(`Error formatting message for key ${key}:`, error);
+      return key;
+    }
+  }
+
+  // 添加新方法用于验证所有翻译键是否存在
+  public validateMessages(keys: string[]): string[] {
+    const missingKeys = keys.filter((key) => !this.messages[key]);
+    return missingKeys;
   }
 }

src/utils/NotificationHandler.ts

@@ -2,18 +2,45 @@ import * as vscode from "vscode";
 import { LocalizationManager } from "./LocalizationManager";
 
 export class NotificationHandler {
+  private static readonly TIMEOUT = 10000; // 10 seconds
+
+  private static async showMessage(
+    type: "info" | "warn" | "error",
+    key: string,
+    ...args: any[]
+  ): Promise<void> {
+    try {
+      const message = LocalizationManager.getInstance().format(key, ...args);
+      const promise =
+        type === "info"
+          ? vscode.window.showInformationMessage(message)
+          : type === "warn"
+          ? vscode.window.showWarningMessage(message)
+          : vscode.window.showErrorMessage(message);
+
+      await Promise.race([
+        promise,
+        new Promise((_, reject) =>
+          setTimeout(
+            () => reject(new Error("Notification timeout")),
+            this.TIMEOUT
+          )
+        ),
+      ]);
+    } catch (error) {
+      console.error(`Failed to show ${type} message:`, error);
+    }
+  }
+
   public static async info(key: string, ...args: any[]): Promise<void> {
-    const message = LocalizationManager.getInstance().format(key, ...args);
-    await vscode.window.showInformationMessage(message);
+    return this.showMessage("info", key, ...args);
   }
 
   public static async warn(key: string, ...args: any[]): Promise<void> {
-    const message = LocalizationManager.getInstance().format(key, ...args);
-    await vscode.window.showWarningMessage(message);
+    return this.showMessage("warn", key, ...args);
   }
 
   public static async error(key: string, ...args: any[]): Promise<void> {
-    const message = LocalizationManager.getInstance().format(key, ...args);
-    await vscode.window.showErrorMessage(message);
+    return this.showMessage("error", key, ...args);
   }
 }

src/utils/ProgressHandler.ts

@@ -8,18 +8,23 @@ export class ProgressHandler {
   static async withProgress<T>(
     title: string,
     task: (
-      progress: vscode.Progress<{ message?: string; increment?: number }>
+      progress: vscode.Progress<{ message?: string; increment?: number }>,
+      token: vscode.CancellationToken
     ) => Promise<T>
   ): Promise<T> {
     return vscode.window.withProgress(
       {
         location: vscode.ProgressLocation.Notification,
         title: `[${DISPLAY_NAME}]: ${title}`,
-        cancellable: false,
+        cancellable: true,
       },
-      async (progress) => {
-        // progress.report({ increment: 0 });
-        return await task(progress);
+      async (progress, token) => {
+        try {
+          return await task(progress, token);
+        } catch (error) {
+          console.error(`Progress task failed:`, error);
+          throw error;
+        }
       }
     );
   }