bmall-mcp 1.0.0

package/src/tools/utils.ts

@@ -0,0 +1,370 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+
+export const HOME = process.env.HOME || process.env.USERPROFILE || "";
+export const CWD = process.cwd();
+
+// Git 仓库配置
+export const GIT_REPO = "git@coding.jd.com:IBKFXHJDBM/RulesManager.git";
+export const GIT_BRANCH = "develop";
+export const RULES_CACHE_DIR = path.join(HOME, ".bmall-mcp/rules-cache");
+
+// 项目类型检测
+export type ProjectType = "ios" | "android" | "web" | "flutter" | "unknown";
+
+// IDE 的 Rules 目录映射（项目级别）
+export const IDE_PATHS: Record<string, string> = {
+  kiro: path.join(CWD, ".kiro/steering/bmall"),
+  cursor: path.join(CWD, ".cursor/rules/bmall"),
+  windsurf: path.join(CWD, ".windsurfrules"),
+};
+
+export function log(message: string) {
+  console.error(`[bmall-mcp] ${message}`);
+}
+
+export function detectProjectType(): ProjectType {
+  const checks: Array<[string, ProjectType]> = [
+    ["ios/Podfile", "ios"],
+    ["*.xcodeproj", "ios"],
+    ["Podfile", "ios"],
+    ["android/build.gradle", "android"],
+    ["build.gradle", "android"],
+    ["AndroidManifest.xml", "android"],
+    ["package.json", "web"],
+    ["webpack.config.js", "web"],
+    ["tsconfig.json", "web"],
+    ["vite.config.ts", "web"],
+    ["pubspec.yaml", "flutter"],
+    ["flutter.yaml", "flutter"],
+  ];
+
+  for (const [pattern, type] of checks) {
+    try {
+      if (pattern.includes("*")) {
+        const files = fs.readdirSync(CWD);
+        if (files.some(f => f.match(pattern.replace("*", ".*")))) {
+          log(`检测到 ${type} 项目特征: ${pattern}`);
+          return type;
+        }
+      } else {
+        const fullPath = path.join(CWD, pattern);
+        if (fs.existsSync(fullPath)) {
+          log(`检测到 ${type} 项目特征: ${pattern}`);
+          return type;
+        }
+      }
+    } catch (e) {
+      // 继续
+    }
+  }
+
+  log(`未检测到项目类型，使用默认值: iOS`);
+  return "ios";
+}
+
+export function detectProjectName(): string {
+  // 优先级：package.json > Podfile > pubspec.yaml > 目录名
+  
+  // 1. 检查 package.json
+  const packageJsonPath = path.join(CWD, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const content = fs.readFileSync(packageJsonPath, "utf-8");
+      const json = JSON.parse(content);
+      if (json.name) {
+        const name = sanitizeProjectName(json.name);
+        log(`从 package.json 检测到项目名: ${name}`);
+        return name;
+      }
+    } catch (e) {
+      // 继续
+    }
+  }
+
+  // 2. 检查 Podfile
+  const podfilePath = path.join(CWD, "Podfile");
+  if (fs.existsSync(podfilePath)) {
+    try {
+      const content = fs.readFileSync(podfilePath, "utf-8");
+      const match = content.match(/platform\s*:\s*:ios.*?target\s+['"](.*?)['"]/s);
+      if (match && match[1]) {
+        const name = sanitizeProjectName(match[1]);
+        log(`从 Podfile 检测到项目名: ${name}`);
+        return name;
+      }
+    } catch (e) {
+      // 继续
+    }
+  }
+
+  // 3. 检查 pubspec.yaml
+  const pubspecPath = path.join(CWD, "pubspec.yaml");
+  if (fs.existsSync(pubspecPath)) {
+    try {
+      const content = fs.readFileSync(pubspecPath, "utf-8");
+      const match = content.match(/^name:\s*(.+?)$/m);
+      if (match && match[1]) {
+        const name = sanitizeProjectName(match[1]);
+        log(`从 pubspec.yaml 检测到项目名: ${name}`);
+        return name;
+      }
+    } catch (e) {
+      // 继续
+    }
+  }
+
+  // 4. 使用目录名
+  const dirName = path.basename(CWD);
+  const name = sanitizeProjectName(dirName);
+  log(`使用目录名作为项目名: ${name}`);
+  return name;
+}
+
+// 清理项目名，确保可以用作分支名
+export function sanitizeProjectName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-_]/g, "-")  // 非法字符替换为 -
+    .replace(/-+/g, "-")           // 多个 - 合并
+    .replace(/^-|-$/g, "");        // 去掉首尾 -
+}
+
+export function normalizeRulesType(input: string): ProjectType {
+  const normalized = input.toLowerCase().trim();
+  
+  if (["ios", "i", "iphone", "objective-c", "objc", "oc"].includes(normalized)) {
+    return "ios";
+  }
+  if (["android", "a", "kotlin", "java"].includes(normalized)) {
+    return "android";
+  }
+  if (["web", "w", "javascript", "js", "typescript", "ts", "react", "vue", "angular"].includes(normalized)) {
+    return "web";
+  }
+  if (["flutter", "f", "dart"].includes(normalized)) {
+    return "flutter";
+  }
+  
+  return "unknown";
+}
+
+export function validateAndGetRulesType(rulesType?: string): { type: ProjectType; error?: string } {
+  if (rulesType) {
+    const normalized = normalizeRulesType(rulesType);
+    if (normalized === "unknown") {
+      return {
+        type: "ios",
+        error: `❌ 不支持的 Rules 类型: ${rulesType}\n支持的类型: iOS/Android/Web/Flutter (或其他别名)`,
+      };
+    }
+    log(`使用用户指定的 Rules 类型: ${normalized}`);
+    return { type: normalized };
+  }
+  
+  const projectType = detectProjectType();
+  return { type: projectType };
+}
+
+export function validateAndGetIDE(ide?: string): { ide: string; path: string; error?: string } {
+  const targetIDE = ide || detectCurrentIDE();
+  
+  const idePath = IDE_PATHS[targetIDE];
+  if (!idePath) {
+    return {
+      ide: targetIDE,
+      path: "",
+      error: `❌ 不支持的 IDE: ${targetIDE}\n支持的 IDE: kiro, cursor, windsurf`,
+    };
+  }
+  
+  return { ide: targetIDE, path: idePath };
+}
+
+export function getGitRulesDir(projectType: ProjectType): string {
+  const dirMap: Record<ProjectType, string> = {
+    ios: "iOS",
+    android: "Android",
+    web: "Web",
+    flutter: "Flutter",
+    unknown: "iOS",
+  };
+  return dirMap[projectType];
+}
+
+export function detectCurrentIDE(): string {
+  if (process.env.KIRO_HOME) return "kiro";
+  if (process.env.CURSOR_HOME) return "cursor";
+  if (process.env.WINDSURF_HOME) return "windsurf";
+
+  if (fs.existsSync(path.join(HOME, ".kiro"))) return "kiro";
+  if (fs.existsSync(path.join(HOME, ".cursor"))) return "cursor";
+  if (fs.existsSync(path.join(HOME, ".codeium/windsurf"))) return "windsurf";
+
+  return "kiro";
+}
+
+// Git 操作公共函数
+export function initializeGitCache(): void {
+  const gitDir = path.join(RULES_CACHE_DIR, ".git");
+  
+  // 检查 .git 目录是否存在且有效
+  if (fs.existsSync(gitDir)) {
+    try {
+      execSync(`git -C ${RULES_CACHE_DIR} status`, { stdio: "pipe" });
+      return; // Git 仓库有效
+    } catch (e) {
+      log(`Git 仓库损坏，重新初始化...`);
+      fs.rmSync(RULES_CACHE_DIR, { recursive: true, force: true });
+    }
+  }
+
+  log(`创建缓存目录: ${RULES_CACHE_DIR}`);
+  fs.mkdirSync(RULES_CACHE_DIR, { recursive: true });
+  
+  log(`初始化 Git 仓库...`);
+  execSync(`git init ${RULES_CACHE_DIR}`, { stdio: "inherit" });
+  
+  log(`添加远程: ${GIT_REPO}`);
+  execSync(
+    `git -C ${RULES_CACHE_DIR} remote add origin ${GIT_REPO}`,
+    { stdio: "inherit" }
+  );
+}
+
+export function setupSparseCheckout(rulesDir: string): void {
+  log(`配置 sparse-checkout...`);
+  execSync(`git -C ${RULES_CACHE_DIR} config core.sparseCheckout true`, {
+    stdio: "inherit",
+  });
+  
+  const sparseCheckoutFile = path.join(
+    RULES_CACHE_DIR,
+    ".git/info/sparse-checkout"
+  );
+  fs.writeFileSync(sparseCheckoutFile, `${rulesDir}/\n`);
+  log(`设置只克隆 ${rulesDir} 目录...`);
+}
+
+export function checkoutOrCreateBranch(branchName: string, baseBranch: string = GIT_BRANCH): void {
+  log(`检出或创建分支 ${branchName}...`);
+  
+  // 先尝试检出远程分支（如果存在）
+  try {
+    execSync(`git -C ${RULES_CACHE_DIR} fetch origin ${branchName}`, {
+      stdio: "pipe",
+    });
+    // 远程分支存在，检出并跟踪
+    execSync(`git -C ${RULES_CACHE_DIR} checkout -B ${branchName} origin/${branchName}`, {
+      stdio: "inherit",
+    });
+    log(`检出远程分支: ${branchName}`);
+    return;
+  } catch (e) {
+    // 远程分支不存在，继续创建新分支
+  }
+  
+  // 基于主分支创建新分支
+  log(`远程分支不存在，基于 ${baseBranch} 创建...`);
+  try {
+    execSync(`git -C ${RULES_CACHE_DIR} checkout -B ${baseBranch} origin/${baseBranch}`, {
+      stdio: "inherit",
+    });
+    execSync(`git -C ${RULES_CACHE_DIR} checkout -b ${branchName}`, {
+      stdio: "inherit",
+    });
+    log(`创建新分支: ${branchName}`);
+  } catch (e2) {
+    log(`主分支不存在，创建孤立分支...`);
+    execSync(`git -C ${RULES_CACHE_DIR} checkout --orphan ${branchName}`, {
+      stdio: "inherit",
+    });
+    log(`创建孤立分支: ${branchName}`);
+  }
+}
+
+export async function fetchRulesFromGit(projectType: ProjectType): Promise<string> {
+  const rulesDir = getGitRulesDir(projectType);
+  
+  log(`Git 仓库: ${GIT_REPO}`);
+  log(`分支: ${GIT_BRANCH}`);
+  log(`Rules 目录: ${rulesDir}`);
+  
+  // 初始化缓存仓库
+  initializeGitCache();
+  
+  // 设置 sparse-checkout
+  setupSparseCheckout(rulesDir);
+  
+  // 拉取远程分支
+  log(`拉取分支 ${GIT_BRANCH}...`);
+  execSync(`git -C ${RULES_CACHE_DIR} fetch origin ${GIT_BRANCH}`, {
+    stdio: "inherit",
+  });
+  
+  // 检出到 origin/develop（避免本地分支不存在的问题）
+  log(`检出 origin/${GIT_BRANCH}...`);
+  try {
+    execSync(`git -C ${RULES_CACHE_DIR} checkout -B ${GIT_BRANCH} origin/${GIT_BRANCH}`, {
+      stdio: "inherit",
+    });
+  } catch (e) {
+    // 如果失败，尝试直接检出 FETCH_HEAD
+    execSync(`git -C ${RULES_CACHE_DIR} checkout FETCH_HEAD`, {
+      stdio: "inherit",
+    });
+  }
+  
+  const projectRulesDir = path.join(RULES_CACHE_DIR, rulesDir);
+  if (!fs.existsSync(projectRulesDir)) {
+    throw new Error(`${rulesDir} 目录不存在: ${projectRulesDir}`);
+  }
+  
+  log(`${rulesDir} 目录: ${projectRulesDir}`);
+  return projectRulesDir;
+}
+
+export function copyMarkdownFiles(
+  src: string, 
+  dest: string, 
+  options: { backup?: boolean } = { backup: true }
+): { count: number; backups: string[] } {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  let count = 0;
+  const backups: string[] = [];
+  const files = fs.readdirSync(src);
+
+  for (const file of files) {
+    if (file.startsWith(".") || file === "node_modules") {
+      continue;
+    }
+
+    const srcPath = path.join(src, file);
+    const destPath = path.join(dest, file);
+    const stat = fs.statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      const result = copyMarkdownFiles(srcPath, destPath, options);
+      count += result.count;
+      backups.push(...result.backups);
+    } else if (file.endsWith(".md")) {
+      // 如果目标文件已存在且需要备份
+      if (options.backup && fs.existsSync(destPath)) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const backupPath = `${destPath}.backup.${timestamp}`;
+        fs.copyFileSync(destPath, backupPath);
+        backups.push(backupPath);
+        log(`备份文件: ${destPath} → ${backupPath}`);
+      }
+      
+      fs.copyFileSync(srcPath, destPath);
+      count++;
+    }
+  }
+
+  return { count, backups };
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "node",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}