@opensumi/ide-ai-native 3.9.1-next-1749540423.0 → 3.9.1-next-1749547010.0

package/src/browser/model/msg-history-manager.ts

@@ -1,11 +1,61 @@
 import { Disposable, Emitter, Event, uuid } from '@opensumi/ide-core-common';
 import { ChatMessageRole, IHistoryChatMessage } from '@opensumi/ide-core-common/lib/types/ai-native';
 
+import { ChatFeatureRegistry } from '../chat/chat.feature.registry';
+
 type IExcludeMessage = Omit<IHistoryChatMessage, 'id' | 'order'>;
 
+interface IMemoryConfig {
+  shortTermSize: number; // 最近消息窗口大小（10条）
+  bufferSize: number; // 缓冲区大小（5条）
+}
+
+interface IMemorySummary {
+  content: string;
+  timestamp: number;
+  messageIds: string[];
+}
+
+interface IToolCallInfo {
+  id: string;
+  name: string;
+  args: Record<string, any>;
+  result: any;
+}
+
+export interface MessageBufferManager {
+  messages: IHistoryChatMessage[];
+  add(message: IHistoryChatMessage): void;
+  clear(): void;
+  size(): number;
+}
+
+class SimpleMessageBuffer implements MessageBufferManager {
+  private _messages: IHistoryChatMessage[] = [];
+
+  get messages(): IHistoryChatMessage[] {
+    return this._messages;
+  }
+
+  add(message: IHistoryChatMessage): void {
+    this._messages.push(message);
+  }
+
+  clear(): void {
+    this._messages = [];
+  }
+
+  size(): number {
+    return this._messages.length;
+  }
+}
+
 export class MsgHistoryManager extends Disposable {
   private messageMap: Map<string, IHistoryChatMessage> = new Map();
   private messageAdditionalMap: Map<string, Record<string, any>> = new Map();
+  private memorySummaries: IMemorySummary[] = [];
+  private toolCallMap: Map<string, IToolCallInfo> = new Map();
+  private isCompressing = false; // 添加压缩锁，防止重复压缩
 
   private readonly _onMessageChange = new Emitter<IHistoryChatMessage[]>();
   public readonly onMessageChange: Event<IHistoryChatMessage[]> = this._onMessageChange.event;
@@ -13,11 +63,33 @@ export class MsgHistoryManager extends Disposable {
   private readonly _onMessageAdditionalChange = new Emitter<Record<string, any>>();
   public readonly onMessageAdditionalChange: Event<Record<string, any>> = this._onMessageAdditionalChange.event;
 
-  constructor(data?: { additional: Record<string, any>; messages: IHistoryChatMessage[] }) {
+  private messageBuffer: MessageBufferManager;
+
+  memoryConfig: IMemoryConfig = {
+    shortTermSize: 10,
+    bufferSize: 5,
+  };
+
+  constructor(
+    private chatFeatureRegistry: ChatFeatureRegistry,
+    data?: {
+      additional: Record<string, any>;
+      messages: IHistoryChatMessage[];
+      toolCalls?: Record<string, IToolCallInfo>;
+      memorySummaries?: IMemorySummary[];
+    },
+  ) {
     super();
+    this.messageBuffer = new SimpleMessageBuffer();
     if (data) {
       this.messageMap = new Map(data.messages.map((item) => [item.id, item]));
       this.messageAdditionalMap = new Map(Object.entries(data.additional));
+      if (data.toolCalls) {
+        this.toolCallMap = new Map(Object.entries(data.toolCalls));
+      }
+      if (data.memorySummaries) {
+        this.memorySummaries = data.memorySummaries;
+      }
     }
   }
 
@@ -33,6 +105,91 @@ export class MsgHistoryManager extends Disposable {
   public clearMessages() {
     this.messageMap.clear();
     this.messageAdditionalMap.clear();
+    this.memorySummaries = [];
+    this.toolCallMap.clear();
+  }
+
+  /**
+   * 压缩历史消息的方法：
+   * 1. 保持最新的10条消息不变
+   * 2. 当累积了5条超出限制的消息时，对这5条（最早的消息）进行总结
+   * 3. 总结完成后删除这5条消息
+   * 4. 重复这个过程，确保消息数量始终在可控范围内
+   */
+  private async compressMemory() {
+    // 如果正在压缩中，直接返回
+    if (this.isCompressing) {
+      return;
+    }
+
+    const messages = this.messageList;
+    // 只有当消息总数超过短期记忆限制时才进行压缩
+    if (messages.length <= this.memoryConfig.shortTermSize) {
+      return;
+    }
+
+    try {
+      this.isCompressing = true;
+
+      // 1. 获取超出短期记忆限制的最新一条消息
+      const latestExcessMessage = messages[messages.length - this.memoryConfig.shortTermSize - 1];
+
+      // 如果这条消息已经被总结过，就不需要再处理
+      if (latestExcessMessage.isSummarized) {
+        return;
+      }
+
+      // 2. 将这条消息添加到缓冲区
+      this.messageBuffer.add(latestExcessMessage);
+
+      // 3. 当缓冲区达到指定大小时，进行总结
+      if (this.messageBuffer.size() >= this.memoryConfig.bufferSize) {
+        const messagesToSummarize = this.messageBuffer.messages;
+
+        const summaryProvider = this.chatFeatureRegistry.getMessageSummaryProvider?.();
+        if (summaryProvider) {
+          const messageContents = messagesToSummarize.map((msg) => ({
+            role: msg.role,
+            content: msg.content,
+          }));
+
+          const memorize = await summaryProvider.generateMemorizedMessage(messageContents);
+          if (memorize) {
+            // 添加新的记忆总结
+            this.memorySummaries.push({
+              content: memorize,
+              timestamp: Date.now(),
+              messageIds: messagesToSummarize.map((msg) => msg.id),
+            });
+
+            // 标记消息为已总结
+            for (const msg of messagesToSummarize) {
+              const existingMsg = this.messageMap.get(msg.id);
+              if (existingMsg) {
+                this.messageMap.set(msg.id, {
+                  ...existingMsg,
+                  isSummarized: true,
+                });
+              }
+            }
+
+            // 清空缓冲区
+            this.messageBuffer.clear();
+          }
+        }
+      }
+    } finally {
+      this.isCompressing = false;
+    }
+  }
+
+  public addToolCall(toolCall: IToolCallInfo): void {
+    this.toolCallMap.set(toolCall.id, toolCall);
+  }
+
+  public getToolCall(id: string): IToolCallInfo | undefined {
+    const toolCall = this.toolCallMap.get(id);
+    return toolCall;
   }
 
   private doAddMessage(message: IExcludeMessage): string {
@@ -48,11 +205,19 @@ export class MsgHistoryManager extends Disposable {
 
     this.messageMap.set(id, msg);
 
+    // 在添加新消息后尝试压缩记忆
+    this.compressMemory().catch((error) => {
+      // eslint-disable-next-line no-console
+      console.error('[MsgHistoryManager] Error compressing memory', error);
+    });
+
+    // 无论压缩是否完成，都触发消息变更事件
     this._onMessageChange.fire(this.getMessages());
     return id;
   }
 
   private get messageList(): IHistoryChatMessage[] {
+    // 按 order 升序排序，保持消息的原始顺序
     return Array.from(this.messageMap.values()).sort((a, b) => a.order - b.order);
   }
 
@@ -65,6 +230,17 @@ export class MsgHistoryManager extends Disposable {
     return this.messageList;
   }
 
+  public getMemorySummaries(): IMemorySummary[] {
+    return this.memorySummaries;
+  }
+
+  public setMemoryConfig(config: Partial<IMemoryConfig>) {
+    this.memoryConfig = {
+      ...this.memoryConfig,
+      ...config,
+    };
+  }
+
   public addUserMessage(
     message: Required<Pick<IExcludeMessage, 'agentId' | 'agentCommand' | 'content' | 'relationId' | 'images'>>,
   ): string {
@@ -118,9 +294,12 @@ export class MsgHistoryManager extends Disposable {
   }
 
   toJSON() {
-    return {
+    const data = {
       messages: this.getMessages(),
       additional: Object.fromEntries(this.messageAdditionalMap.entries()),
+      memorySummaries: this.memorySummaries,
+      toolCalls: Object.fromEntries(this.toolCallMap.entries()),
     };
+    return data;
   }
 }

package/src/browser/preferences/schema.ts

@@ -177,5 +177,10 @@ export const aiNativePreferenceSchema: PreferenceSchema = {
       type: 'string',
       description: '%preference.ai.native.chat.system.prompt.description%',
     },
+    [AINativeSettingSectionsId.GlobalRules]: {
+      type: 'string',
+      default: '',
+      description: '%preference.ai.native.globalRules.description%',
+    },
   },
 };

package/src/browser/rules/rules.contribution.ts

@@ -0,0 +1,105 @@
+import { Autowired } from '@opensumi/di';
+import { getIcon } from '@opensumi/ide-components';
+import { ClientAppContribution } from '@opensumi/ide-core-browser';
+import { LabelService } from '@opensumi/ide-core-browser/lib/services';
+import {
+  CommandContribution,
+  CommandRegistry,
+  Domain,
+  RulesServiceToken,
+  URI,
+  localize,
+} from '@opensumi/ide-core-common';
+import {
+  BrowserEditorContribution,
+  EditorComponentRegistry,
+  EditorComponentRenderMode,
+  IResource,
+  ResourceService,
+  WorkbenchEditorService,
+} from '@opensumi/ide-editor/lib/browser/types';
+import { IconService } from '@opensumi/ide-theme/lib/browser';
+import { IWorkspaceService } from '@opensumi/ide-workspace/lib/common';
+
+import { RulesService } from './rules.service';
+import { RulesView } from './rules.view';
+
+export namespace RulesCommands {
+  export const OPEN_RULES_FILE = {
+    id: 'rules.openRulesConfig',
+    label: 'Open Rules Configuration',
+  };
+}
+
+const COMPONENTS_ID = 'opensumi-rules-viewer';
+export const RULES_COMPONENTS_SCHEME_ID = 'rules';
+
+export type IRulesResource = IResource<{ configType: string }>;
+
+@Domain(BrowserEditorContribution, CommandContribution, ClientAppContribution)
+export class RulesContribution implements BrowserEditorContribution, CommandContribution, ClientAppContribution {
+  @Autowired(IWorkspaceService)
+  protected readonly workspaceService: IWorkspaceService;
+
+  @Autowired(IconService)
+  protected readonly iconService: IconService;
+
+  @Autowired(WorkbenchEditorService)
+  protected readonly editorService: WorkbenchEditorService;
+
+  @Autowired()
+  labelService: LabelService;
+
+  @Autowired(RulesServiceToken)
+  protected readonly rulesService: RulesService;
+
+  onStart() {
+    this.rulesService.initProjectRules();
+  }
+
+  registerEditorComponent(registry: EditorComponentRegistry) {
+    registry.registerEditorComponent({
+      uid: COMPONENTS_ID,
+      scheme: RULES_COMPONENTS_SCHEME_ID,
+      component: RulesView,
+      renderMode: EditorComponentRenderMode.ONE_PER_WORKBENCH,
+    });
+
+    registry.registerEditorComponentResolver(RULES_COMPONENTS_SCHEME_ID, (resource, results) => {
+      results.push({
+        type: 'component',
+        componentId: COMPONENTS_ID,
+      });
+    });
+  }
+
+  registerResource(service: ResourceService) {
+    service.registerResourceProvider({
+      scheme: RULES_COMPONENTS_SCHEME_ID,
+      provideResource: async (uri: URI): Promise<IRulesResource> => {
+        const { configType } = uri.getParsedQuery();
+
+        return {
+          uri,
+          name: localize('ai.native.rules.title'),
+          icon: getIcon('rules'),
+          metadata: {
+            configType,
+          },
+        };
+      },
+    });
+  }
+
+  registerCommands(registry: CommandRegistry) {
+    registry.registerCommand(RulesCommands.OPEN_RULES_FILE, {
+      execute: () => {
+        const uri = new URI().withScheme(RULES_COMPONENTS_SCHEME_ID);
+        this.editorService.open(uri, {
+          preview: false,
+          focus: true,
+        });
+      },
+    });
+  }
+}

package/src/browser/rules/rules.module.less

@@ -0,0 +1,175 @@
+.container {
+  padding: 20px;
+  color: var(--foreground);
+  textarea {
+    resize: vertical;
+    min-height: 60px;
+  }
+  input,
+  textarea {
+    width: 100%;
+    padding: 8px;
+    border: 1px solid var(--input-border);
+    border-radius: 4px;
+    background-color: var(--input-background);
+    color: var(--input-foreground);
+    font-size: 13px;
+    font-family: var(--monaco-monospace-font);
+
+    &:focus {
+      border-color: var(--focusBorder);
+      outline: none;
+    }
+
+    &::placeholder {
+      color: var(--descriptionForeground);
+      opacity: 0.6;
+    }
+  }
+}
+
+.header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  margin-bottom: 24px;
+}
+
+.title {
+  margin: 0 0 8px 0;
+  font-size: 24px;
+  font-weight: 600;
+}
+
+.description {
+  margin: 0;
+  color: var(--descriptionForeground);
+  font-size: 14px;
+  line-height: 1.5;
+}
+
+.user_rules {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  .user_rules_header {
+    display: flex;
+    flex-direction: column;
+  }
+}
+
+.project_rules {
+  margin-top: 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  h3 {
+    position: relative;
+  }
+  .actionButton {
+    position: absolute;
+    right: 0;
+    top: 0;
+  }
+}
+
+.project_rules_header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.project_rules_header_left {
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.actionButton {
+  padding: 8px 16px;
+  border-radius: 4px;
+  background-color: var(--button-primary-background);
+  color: var(--button-primary-foreground);
+  border: none;
+  cursor: pointer;
+  font-size: 13px;
+  .actionButtonIcon {
+    margin-right: 5px;
+  }
+
+  &:hover {
+    background-color: var(--button-primary-hover-background);
+  }
+}
+
+.project_rules_list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.rule_item {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px;
+  border: 1px solid var(--input-border);
+  border-radius: 4px;
+  background-color: var(--input-background);
+  opacity: 0.6;
+
+  &:hover {
+    opacity: 1;
+  }
+}
+
+.rule_item_left {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  flex: 1;
+}
+
+.rule_item_right {
+  display: flex;
+  align-items: center;
+  flex-shrink: 0;
+  margin-left: 16px;
+}
+
+.rule_filename {
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--foreground);
+}
+
+.rule_description {
+  font-size: 12px;
+  color: var(--descriptionForeground);
+}
+
+.rule_warning {
+  font-size: 12px;
+  color: var(--editorWarning-foreground);
+  display: flex;
+  align-items: center;
+  gap: 4px;
+
+  &::before {
+    content: '⚠';
+    color: var(--editorWarning-foreground);
+  }
+}
+
+.rule_applies_to {
+  font-size: 12px;
+  color: var(--descriptionForeground);
+  font-family: var(--monaco-monospace-font);
+}
+
+.empty_state {
+  text-align: center;
+  padding: 32px;
+  color: var(--descriptionForeground);
+  font-style: italic;
+}

package/src/browser/rules/rules.service.ts

@@ -0,0 +1,189 @@
+import { Autowired, Injectable } from '@opensumi/di';
+import { VALIDATE_TYPE } from '@opensumi/ide-components';
+import { AppConfig, PreferenceService } from '@opensumi/ide-core-browser';
+import {
+  AINativeSettingSectionsId,
+  Disposable,
+  Emitter,
+  URI,
+  formatLocalize,
+  localize,
+} from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+import { QuickInputService } from '@opensumi/ide-quick-open/lib/browser/quick-input-service';
+import { WorkspaceService } from '@opensumi/ide-workspace/lib/browser/workspace-service';
+import { IWorkspaceService } from '@opensumi/ide-workspace/lib/common';
+
+import { IMDCContent, IMDCParseResult, parseMDC, serializeMDC } from '../../common';
+import { ProjectRule } from '../../common/types';
+
+@Injectable()
+export class RulesService extends Disposable {
+  @Autowired(PreferenceService)
+  private readonly preferenceService: PreferenceService;
+
+  @Autowired(AppConfig)
+  private readonly appConfig: AppConfig;
+
+  @Autowired(IWorkspaceService)
+  private readonly workspaceService: WorkspaceService;
+
+  @Autowired(IFileServiceClient)
+  private readonly fileServiceClient: IFileServiceClient;
+
+  @Autowired(QuickInputService)
+  private readonly quickInputService: QuickInputService;
+
+  @Autowired(WorkbenchEditorService)
+  private readonly workbenchEditorService: WorkbenchEditorService;
+
+  private readonly rulesChangeEventEmitter = new Emitter<void>();
+
+  private _globalRules: string;
+  private _projectRules: ProjectRule[];
+
+  private _projectRulesPath: string;
+
+  get onRulesChange() {
+    return this.rulesChangeEventEmitter.event;
+  }
+
+  get globalRules() {
+    if (!this._globalRules) {
+      this._globalRules = this.preferenceService.get<string>(AINativeSettingSectionsId.GlobalRules) || '';
+    }
+    return this._globalRules;
+  }
+
+  get projectRules() {
+    return this._projectRules || [];
+  }
+
+  public async initProjectRules() {
+    this.dispose();
+    await this.workspaceService.whenReady;
+    const workspace = this.workspaceService.workspace;
+    // 如果存在 .sumi, 默认从 .sumi 中获取
+    const sumiConfigPath = new URI(workspace?.uri)
+      .resolve(this.appConfig.preferenceDirName || '.sumi')
+      .resolve('rules');
+    const cursorConfigPath = new URI(workspace?.uri).resolve('.cursor').resolve('rules');
+    if (await this.fileServiceClient.access(sumiConfigPath.codeUri.fsPath)) {
+      this._projectRulesPath = sumiConfigPath.codeUri.fsPath;
+    } else if (await this.fileServiceClient.access(cursorConfigPath.codeUri.fsPath)) {
+      this._projectRulesPath = cursorConfigPath.codeUri.fsPath;
+    } else {
+      this._projectRulesPath = sumiConfigPath.codeUri.fsPath;
+    }
+    const watcher = await this.fileServiceClient.watchFileChanges(new URI(this._projectRulesPath));
+    this.addDispose(
+      watcher.onFilesChanged((changes) => {
+        if (
+          changes.length > 0 &&
+          changes.some((change) => change.uri.endsWith('.mdc') && change.uri.includes('rules'))
+        ) {
+          this.initProjectRules();
+        }
+      }),
+    );
+    const dir = await this.fileServiceClient.getFileStat(this._projectRulesPath);
+    if (dir && dir.isDirectory) {
+      const files = dir.children?.filter((file) => !file.isDirectory && file.uri.endsWith('.mdc'));
+      if (files) {
+        const rules = await Promise.all(
+          files.map(async (file) => {
+            const item = await this.fileServiceClient.readFile(file.uri);
+            const data = this.parseMDCContent(item.content.toString());
+            return {
+              path: file.uri,
+              ...data.frontmatter,
+              content: data.content,
+            };
+          }),
+        );
+        if (rules.length > 0) {
+          this._projectRules = rules;
+          this.rulesChangeEventEmitter.fire();
+          return;
+        }
+      }
+    }
+    this._projectRules = [];
+    this.rulesChangeEventEmitter.fire();
+  }
+
+  async openRule(rule: ProjectRule) {
+    this.workbenchEditorService.open(new URI(rule.path));
+  }
+
+  async createNewRule() {
+    let value = await this.quickInputService.open({
+      title: localize('ai.native.rules.projectRules.newRule'),
+      value: '',
+      placeHolder: localize('ai.native.rules.projectRules.newRule.placeholder'),
+      validateInput: async (value) => {
+        const invalidCharsRegex = /[<>:"/\\|?*\x00-\x1F]/;
+        value = value.trim();
+        if (value === '') {
+          return {
+            message: localize('ai.native.rules.projectRules.newRule.error.notEmpty'),
+            type: VALIDATE_TYPE.ERROR,
+          };
+        } else if (invalidCharsRegex.test(value)) {
+          return {
+            message: localize('ai.native.rules.error.invalidFileName'),
+            type: VALIDATE_TYPE.ERROR,
+          };
+        } else {
+          const newRulePath = new URI(this._projectRulesPath).resolve(value + '.mdc');
+          const fileExists = this.projectRules.find(
+            (rule) => new URI(rule.path).codeUri.fsPath === newRulePath.codeUri.fsPath,
+          );
+          if (fileExists) {
+            return {
+              message: formatLocalize('ai.native.rules.error.fileExists', value + '.mdc'),
+              type: VALIDATE_TYPE.ERROR,
+            };
+          }
+        }
+      },
+    });
+    value = value?.trim();
+    if (value) {
+      const newRulePath = new URI(this._projectRulesPath).resolve(value + '.mdc');
+      await this.fileServiceClient.createFile(newRulePath.toString(), {
+        content: this.serializeMDCContent({
+          frontmatter: {
+            description: '',
+            globs: '',
+            alwaysApply: false,
+          },
+          content: '',
+        }),
+      });
+      this.workbenchEditorService.open(new URI(newRulePath.toString()));
+      this.initProjectRules();
+    }
+  }
+
+  updateGlobalRules(rules: string) {
+    this._globalRules = rules;
+    this.preferenceService.set(AINativeSettingSectionsId.GlobalRules, rules);
+  }
+
+  parseMDCContent(content: string): IMDCParseResult {
+    try {
+      return parseMDC(content);
+    } catch (error) {
+      return {
+        frontmatter: {},
+        content,
+      };
+    }
+  }
+
+  serializeMDCContent(mdcContent: IMDCContent): string {
+    return serializeMDC(mdcContent);
+  }
+}