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

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

@@ -1,189 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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/common/image-compression.ts

@@ -1,174 +0,0 @@
-import { isObject } from '@opensumi/ide-utils';
-
-import { IMCPToolResult, IMCPToolResultContent } from './types';
-
-export interface ImageCompressionOptions {
-  maxSizeKB?: number;
-  quality?: number;
-  maxWidth?: number;
-  maxHeight?: number;
-  mimeType?: string;
-}
-
-const DEFAULT_OPTIONS: Required<ImageCompressionOptions> = {
-  maxSizeKB: 500, // 500KB
-  quality: 0.8,
-  maxWidth: 1920,
-  maxHeight: 1080,
-  mimeType: 'image/jpeg',
-};
-
-/**
- * 获取 base64 图像的大小（KB）
- */
-export function getBase64ImageSize(base64String: string): number {
-  if (!base64String) {
-    return 0;
-  }
-
-  // 移除 data URL 前缀
-  const base64Data = base64String.split(',')[1] || base64String;
-
-  // Base64 编码后的大小约为原始大小的 4/3
-  const sizeInBytes = (base64Data.length * 3) / 4;
-  return sizeInBytes / 1024; // 转换为 KB
-}
-
-/**
- * 使用 Canvas API 进行真正的图像压缩
- */
-export function compressBase64Image(base64String: string, options: ImageCompressionOptions = {}): Promise<string> {
-  return new Promise((resolve) => {
-    try {
-      // 输入验证
-      if (!base64String || typeof base64String !== 'string') {
-        resolve(base64String || '');
-        return;
-      }
-      if (!base64String.startsWith('data:') && options.mimeType) {
-        base64String = `data:${options.mimeType};base64,${base64String}`;
-      }
-      const opts = { ...DEFAULT_OPTIONS, ...options };
-      const currentSize = getBase64ImageSize(base64String);
-      // 如果图像已经小于目标大小，直接返回
-      if (currentSize <= opts.maxSizeKB) {
-        resolve(base64String);
-        return;
-      }
-      // 创建图像对象
-      const img = new Image();
-      img.onload = () => {
-        try {
-          // 计算新的尺寸，保持宽高比
-          let { width, height } = img;
-          // 处理极小图片
-          if (width <= 1 || height <= 1) {
-            resolve(base64String);
-            return;
-          }
-          const aspectRatio = width / height;
-          if (width > opts.maxWidth) {
-            width = opts.maxWidth;
-            height = width / aspectRatio;
-          }
-          if (height > opts.maxHeight) {
-            height = opts.maxHeight;
-            width = height * aspectRatio;
-          }
-          const canvas = document.createElement('canvas');
-          const ctx = canvas.getContext('2d');
-          if (!ctx) {
-            resolve(base64String);
-            return;
-          }
-          canvas.width = Math.round(width);
-          canvas.height = Math.round(height);
-          ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
-          let compressedBase64 = canvas.toDataURL(opts.mimeType, opts.quality);
-          let compressedSize = getBase64ImageSize(compressedBase64);
-          let currentQuality = opts.quality;
-          let attempts = 0;
-          const maxAttempts = 5;
-          while (compressedSize > opts.maxSizeKB && attempts < maxAttempts) {
-            currentQuality *= 0.6;
-            compressedBase64 = canvas.toDataURL(opts.mimeType, currentQuality);
-            compressedSize = getBase64ImageSize(compressedBase64);
-            attempts++;
-          }
-          const [, base64] = compressedBase64.split(',');
-          resolve(base64);
-        } catch (error) {
-          // 压缩失败，返回原始图像
-          resolve(base64String);
-        }
-      };
-      img.onerror = () => {
-        // 图像加载失败，返回原始字符串
-        resolve(base64String);
-      };
-      img.src = base64String;
-    } catch (error) {
-      resolve(base64String);
-    }
-  });
-}
-
-/**
- * 压缩内容数组格式的工具结果
- */
-export async function compressContentArrayResult(
-  result: IMCPToolResult,
-  options: ImageCompressionOptions = {},
-): Promise<IMCPToolResult> {
-  if (!result || !result.content || !Array.isArray(result.content)) {
-    return result;
-  }
-
-  const compressedContent = await Promise.all(
-    result.content.map(async (item) => {
-      if (item.type === 'image') {
-        let compressedData: string;
-        // 检测环境
-        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
-          compressedData = await compressBase64Image(item.data, {
-            ...options,
-            mimeType: item.mimeType,
-          });
-        } else {
-          compressedData = item.data;
-        }
-
-        return {
-          ...item,
-          data: compressedData,
-        };
-      }
-      return item;
-    }),
-  );
-
-  return {
-    ...result,
-    content: compressedContent,
-  };
-}
-
-/**
- * 智能压缩工具结果，支持多种格式
- */
-export async function compressToolResultSmart(
-  result: IMCPToolResult,
-  options: ImageCompressionOptions = {},
-): Promise<any> {
-  if (
-    result &&
-    isObject(result) &&
-    result.content &&
-    Array.isArray(result.content) &&
-    result.content.some((item: IMCPToolResultContent) => item.type === 'image')
-  ) {
-    return await compressContentArrayResult(result, options);
-  }
-
-  return result;
-}