@opensumi/ide-ai-native 3.9.1-next-1749007675.0 → 3.9.1-next-1749008258.0

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);
+  }
+}

package/src/browser/rules/rules.view.tsx

@@ -0,0 +1,127 @@
+import React, { useCallback, useEffect, useState } from 'react';
+
+import { Icon } from '@opensumi/ide-components';
+import { useInjectable } from '@opensumi/ide-core-browser';
+import { RulesServiceToken, localize } from '@opensumi/ide-core-common';
+
+import { ProjectRule } from '../../common/types';
+
+import styles from './rules.module.less';
+import { RulesService } from './rules.service';
+
+export const RulesView: React.FC = () => {
+  const rulesService = useInjectable<RulesService>(RulesServiceToken);
+  const [globalRules, setGlobalRules] = useState<string>(rulesService.globalRules as string);
+  const [projectRules, setProjectRules] = useState<ProjectRule[]>([]);
+
+  useEffect(() => {
+    setProjectRules(rulesService.projectRules);
+  }, [rulesService]);
+
+  const handleGlobalRulesChange = useCallback(
+    (e) => {
+      setGlobalRules(e.target.value);
+      rulesService.updateGlobalRules(e.target.value);
+    },
+    [rulesService, globalRules],
+  );
+
+  const handleCreateNewRule = useCallback(() => {
+    rulesService.createNewRule();
+  }, [rulesService]);
+
+  const handleOpenRule = useCallback(
+    (rule: ProjectRule) => {
+      rulesService.openRule(rule);
+    },
+    [rulesService],
+  );
+
+  const getFileNameFromPath = (path: string) => decodeURIComponent(path.split('/').pop() || path);
+
+  const hasWarning = (rule: ProjectRule) => !rule.description && !rule.alwaysApply && !rule.globs;
+
+  const getAppliesToText = (rule: ProjectRule) => {
+    if (rule.globs) {
+      if (Array.isArray(rule.globs)) {
+        return `Applies to: ${rule.globs.join(', ')}`;
+      } else {
+        return `Applies to: ${rule.globs}`;
+      }
+    }
+    return '';
+  };
+
+  useEffect(() => {
+    const disposable = rulesService.onRulesChange(() => {
+      setProjectRules(rulesService.projectRules);
+    });
+    return () => {
+      disposable.dispose();
+    };
+  }, []);
+
+  return (
+    <div className={styles.container}>
+      <div className={styles.header}>
+        <div>
+          <h2 className={styles.title}>{localize('ai.native.rules.title')}</h2>
+          <p className={styles.description}>{localize('ai.native.rules.description')}</p>
+        </div>
+      </div>
+      <div className={styles.user_rules}>
+        <div className={styles.user_rules_header}>
+          <h3 className={styles.title}>{localize('ai.native.rules.userRules.title')}</h3>
+          <p className={styles.description}>{localize('ai.native.rules.userRules.description')}</p>
+        </div>
+        <div className={styles.user_rules_content}>
+          <textarea
+            rows={6}
+            placeholder={localize('ai.native.rules.userRules.placeholder')}
+            value={globalRules}
+            onChange={handleGlobalRulesChange}
+            style={{ resize: 'none' }}
+          />
+        </div>
+      </div>
+      <div className={styles.project_rules}>
+        <div className={styles.project_rules_header}>
+          <div className={styles.project_rules_header_left}>
+            <h3 className={styles.title}>
+              {localize('ai.native.rules.projectRules.title')}
+              <button className={styles.actionButton} onClick={handleCreateNewRule}>
+                <Icon icon='plus' className={styles.actionButtonIcon} />
+                {localize('ai.native.rules.projectRules.newRule')}
+              </button>
+            </h3>
+            <p className={styles.description}>{localize('ai.native.rules.projectRules.description')}</p>
+          </div>
+        </div>
+        <div className={styles.project_rules_content}>
+          {projectRules.length > 0 ? (
+            <div className={styles.project_rules_list}>
+              {projectRules.map((rule, index) => (
+                <div key={index} className={styles.rule_item} onClick={() => handleOpenRule(rule)}>
+                  <div className={styles.rule_item_left}>
+                    <div className={styles.rule_filename}>{getFileNameFromPath(rule.path)}</div>
+                    {rule.description && <div className={styles.rule_description}>{rule.description}</div>}
+                    {hasWarning(rule) && (
+                      <div className={styles.rule_warning}>
+                        This rule may never be used since it has no description or auto attachments
+                      </div>
+                    )}
+                  </div>
+                  <div className={styles.rule_item_right}>
+                    {getAppliesToText(rule) && <div className={styles.rule_applies_to}>{getAppliesToText(rule)}</div>}
+                  </div>
+                </div>
+              ))}
+            </div>
+          ) : (
+            <div className={styles.empty_state}>{localize('ai.native.rules.projectRules.empty')}</div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+};

package/src/browser/types.ts

@@ -5,7 +5,6 @@ import { ZodSchema } from 'zod';
 import { AIActionItem } from '@opensumi/ide-core-browser/lib/components/ai-native/index';
 import {
   CancellationToken,
-  ChatMessageRole,
   ChatResponse,
   Deferred,
   IAICompletionOption,
@@ -135,8 +134,6 @@ export interface IChatFeatureRegistry {
   registerImageUploadProvider(provider: IImageUploadProvider): void;
   registerWelcome(content: IChatWelcomeMessageContent | React.ReactNode, sampleQuestions?: ISampleQuestions[]): void;
   registerSlashCommand(command: IChatSlashCommandItem, handler: IChatSlashCommandHandler): void;
-
-  registerMessageSummaryProvider(provider: IMessageSummaryProvider): void;
 }
 
 export type ChatWelcomeRender = (props: {
@@ -301,15 +298,6 @@ export interface IImageUploadProvider {
   imageUpload(file: File): Promise<DataContent | URL>;
 }
 
-export interface IMessageSummaryProvider {
-  getMessageSummary(
-    messages: Array<{
-      role: ChatMessageRole;
-      content: string;
-    }>,
-  ): Promise<string | undefined>;
-}
-
 export const AINativeCoreContribution = Symbol('AINativeCoreContribution');
 
 export interface AINativeCoreContribution {

package/src/browser/widget/inline-stream-diff/live-preview.component.tsx

@@ -13,7 +13,6 @@ import {
   Position,
 } from '@opensumi/ide-monaco';
 import { ReactInlineContentWidget } from '@opensumi/ide-monaco/lib/browser/ai-native/BaseInlineContentWidget';
-import { URI } from '@opensumi/ide-monaco/lib/browser/monaco-api';
 import { ContentWidgetPositionPreference } from '@opensumi/ide-monaco/lib/browser/monaco-exports/editor';
 import { EditorOption } from '@opensumi/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
 import { IScrollEvent } from '@opensumi/monaco-editor-core/esm/vs/editor/common/editorCommon';

package/src/common/MDC_PARSER_README.md

@@ -0,0 +1,171 @@
+# MDC 文件解析器
+
+MDC (Markdown with YAML Frontmatter) 解析器用于解析和序列化带有 YAML frontmatter 的 Markdown 文件。
+
+## 文件格式
+
+MDC 文件格式如下：
+
+```
+---
+description:
+globs:
+alwaysApply: false
+---
+icejs is a react-like framework
+```
+
+其中：
+
+- `---` 分隔符之间的部分是 YAML frontmatter
+- 分隔符之后的部分是 Markdown 内容
+
+## API 接口
+
+### 类型定义
+
+```typescript
+interface IMDCFrontmatter {
+  description?: string;
+  globs?: string | string[];
+  alwaysApply?: boolean;
+  [key: string]: any;
+}
+
+interface IMDCParseResult {
+  frontmatter: IMDCFrontmatter;
+  content: string;
+}
+
+interface IMDCContent {
+  frontmatter: IMDCFrontmatter;
+  content: string;
+}
+```
+
+### 主要函数
+
+#### `parseMDC(rawContent: string): IMDCParseResult`
+
+解析 MDC 文件内容，返回解析后的 frontmatter 和内容。
+
+**示例：**
+
+```typescript
+const content = `---
+description: "React规则"
+globs: ["*.tsx", "*.jsx"]
+alwaysApply: true
+---
+使用React hooks和函数组件`;
+
+const result = parseMDC(content);
+// result.frontmatter = { description: "React规则", globs: ["*.tsx", "*.jsx"], alwaysApply: true }
+// result.content = "使用React hooks和函数组件"
+```
+
+#### `serializeMDC(mdcContent: IMDCContent): string`
+
+将 MDC 内容对象序列化为字符串格式。
+
+**示例：**
+
+```typescript
+const mdcContent = {
+  frontmatter: {
+    description: 'TypeScript规则',
+    globs: ['*.ts'],
+    alwaysApply: false,
+  },
+  content: '使用严格的类型检查',
+};
+
+const serialized = serializeMDC(mdcContent);
+// 输出:
+// ---
+// description: TypeScript规则
+// globs:
+//   - "*.ts"
+// alwaysApply: false
+// ---
+// 使用严格的类型检查
+```
+
+#### `updateMDCFrontmatter(rawContent: string, newFrontmatter: Partial<IMDCFrontmatter>): string`
+
+更新现有 MDC 内容的 frontmatter。
+
+**示例：**
+
+```typescript
+const original = `---
+description: 
+alwaysApply: false
+---
+原始内容`;
+
+const updated = updateMDCFrontmatter(original, {
+  description: '更新后的描述',
+  globs: ['*.js'],
+});
+// 更新 frontmatter，保持原始内容不变
+```
+
+#### `extractMDCContent(rawContent: string): string`
+
+从 MDC 内容中提取纯文本内容（不包含 frontmatter）。
+
+**示例：**
+
+```typescript
+const content = extractMDCContent(mdcContent);
+// 只返回 Markdown 内容部分
+```
+
+#### `validateMDCFrontmatter(frontmatter: any): boolean`
+
+验证 frontmatter 对象是否符合规范。
+
+#### `createDefaultMDCFrontmatter(): IMDCFrontmatter`
+
+创建默认的 frontmatter 对象。
+
+## 在 RulesService 中的使用
+
+`RulesService` 类已经集成了 MDC 解析功能：
+
+```typescript
+// 解析全局规则
+const mdcRules = rulesService.parseGlobalRulesAsMDC();
+if (mdcRules) {
+  console.log('规则描述:', mdcRules.frontmatter.description);
+  console.log('适用文件:', mdcRules.frontmatter.globs);
+  console.log('规则内容:', mdcRules.content);
+}
+
+// 更新全局规则
+const newMDCContent = {
+  frontmatter: {
+    description: '新的编码规范',
+    globs: ['src/**/*.ts'],
+    alwaysApply: true,
+  },
+  content: '遵循 TypeScript 最佳实践',
+};
+rulesService.updateGlobalRulesWithMDC(newMDCContent);
+```
+
+## 错误处理
+
+解析器对错误具有良好的容错性：
+
+- 如果 YAML frontmatter 格式错误，将返回空的 frontmatter 对象
+- 如果没有 frontmatter，整个内容将作为 content 返回
+- 序列化失败时，只返回内容部分
+
+## 注意事项
+
+1. frontmatter 中的 `globs` 字段可以是字符串或字符串数组
+2. 所有 frontmatter 字段都是可选的
+3. frontmatter 支持扩展，可以包含任意额外字段
+4. 内容部分会自动去除首尾空白字符

package/src/common/index.ts

@@ -333,3 +333,6 @@ export interface IInlineDiffService {
 }
 
 export const InlineDiffServiceToken = Symbol('InlineDiffService');
+
+export * from './tool-invocation-registry';
+export * from './mdc-parser';

package/src/common/llm-context.ts

@@ -1,5 +1,7 @@
 import { Event, URI } from '@opensumi/ide-core-common/lib/utils';
 
+import { ProjectRule } from './types';
+
 export interface LLMContextService {
   /**
    * 开始自动收集
@@ -21,6 +23,11 @@ export interface LLMContextService {
    */
   addFolderToContext(uri: URI, isManual?: boolean): void;
 
+  /**
+   * 添加规则到 context 中
+   */
+  addRuleToContext(uri: URI, isManual?: boolean): void;
+
   /**
    * 清除上下文
    */
@@ -33,6 +40,7 @@ export interface LLMContextService {
     viewed: FileContext[];
     attached: FileContext[];
     attachedFolders: FileContext[];
+    attachedRules: ProjectRule[];
     version: number;
   }>;
 
@@ -42,6 +50,18 @@ export interface LLMContextService {
    */
   removeFileFromContext(uri: URI, isManual?: boolean): void;
 
+  /**
+   * 从 context 中移除文件夹
+   * @param uri URI
+   */
+  removeFolderFromContext(uri: URI): void;
+
+  /**
+   * 从 context 中移除规则
+   * @param uri URI
+   */
+  removeRuleFromContext(uri: URI): void;
+
   /** 导出为可序列化格式 */
   serialize(): Promise<SerializedContext>;
 }
@@ -58,12 +78,15 @@ export interface AttachFileContext {
   lineErrors: string[];
   path: string;
   language: string;
+  selection?: [number, number];
 }
 
 export interface SerializedContext {
   recentlyViewFiles: string[];
   attachedFiles: Array<AttachFileContext>;
   attachedFolders: string[];
+  attachedRules: string[];
+  globalRules: string[];
 }
 
 export enum LLM_CONTEXT_KEY {