@catchmexz/fedin-vibe-mcp-server 0.1.0

package/dist/operations/codeup/files.js

@@ -0,0 +1,483 @@
+import { yunxiaoRequest, buildUrl, pathEscape } from "../../common/utils.js";
+import { FileContentSchema, CreateFileResponseSchema, DeleteFileResponseSchema, FileInfoSchema } from "./types.js";
+import * as fs from 'fs';
+import pkg from 'fs-extra';
+import * as path from 'path';
+import minimatch from "minimatch";
+const { removeSync } = pkg;
+function readGitignore(projectPath) {
+    const gitignorePath = path.join(projectPath, ".gitignore");
+    try {
+        const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+        const originIgnorePatterns = gitignoreContent
+            .split("\n")
+            .filter((line) => line.trim() !== "" && !line.startsWith("#"))
+            .map((pattern) => pattern.trim());
+        originIgnorePatterns.push(".git");
+        return originIgnorePatterns;
+    }
+    catch (error) {
+        console.warn("No .gitignore file found or error reading it");
+        return [];
+    }
+}
+function shouldIgnoreFile(filePath, ignorePatterns) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    return ignorePatterns.some((pattern) => minimatch(relativePath, pattern) ||
+        minimatch(path.basename(filePath), pattern));
+}
+// 检测文件是否为二进制文件
+function isBinaryFile(filePath) {
+    const binaryExtensions = [
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".bmp",
+        ".webp",
+        ".svg",
+        ".ico",
+        ".pdf",
+        ".doc",
+        ".docx",
+        ".xls",
+        ".xlsx",
+        ".ppt",
+        ".pptx",
+        ".zip",
+        ".rar",
+        ".7z",
+        ".tar",
+        ".gz",
+        ".mp3",
+        ".mp4",
+        ".avi",
+        ".mov",
+        ".wmv",
+        ".exe",
+        ".dll",
+        ".so",
+        ".dylib",
+        ".woff",
+        ".woff2",
+        ".ttf",
+        ".eot"
+    ];
+    const ext = path.extname(filePath).toLowerCase();
+    return binaryExtensions.includes(ext);
+}
+function getAllFiles(dir, ignorePatterns) {
+    const files = [];
+    function traverseDirectory(currentPath) {
+        const entries = fs.readdirSync(currentPath);
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                // 递归遍历子目录
+                if (!shouldIgnoreFile(fullPath, ignorePatterns)) {
+                    traverseDirectory(fullPath);
+                }
+            }
+            else {
+                // 检查是否应该忽略文件
+                if (!shouldIgnoreFile(fullPath, ignorePatterns)) {
+                    try {
+                        const relativePath = path.relative(dir, fullPath);
+                        let content;
+                        let encoding = "text";
+                        if (isBinaryFile(fullPath)) {
+                            // 二进制文件使用base64编码
+                            content = fs.readFileSync(fullPath).toString("base64");
+                            encoding = "base64";
+                        }
+                        else {
+                            // 文本文件使用utf-8编码
+                            content = fs.readFileSync(fullPath, "utf-8");
+                            encoding = "text";
+                        }
+                        files.push({
+                            path: relativePath,
+                            content: content,
+                            encoding: encoding
+                        });
+                    }
+                    catch (error) {
+                        // 对于无法读取的文件，跳过
+                        console.warn(`Could not read file: ${fullPath}`, error);
+                    }
+                }
+            }
+        }
+    }
+    traverseDirectory(dir);
+    return files;
+}
+// Common helper function to handle repositoryId and filePath encoding
+function handlePathEncoding(repositoryId, filePath) {
+    let encodedRepoId = repositoryId;
+    let encodedFilePath = filePath;
+    // 自动处理repositoryId中未编码的斜杠
+    if (repositoryId.includes("/")) {
+        // 发现未编码的斜杠，自动进行URL编码
+        const parts = repositoryId.split("/", 2);
+        if (parts.length === 2) {
+            const encodedRepoName = encodeURIComponent(parts[1]);
+            // 移除编码中的+号（空格被编码为+，但我们需要%20）
+            const formattedEncodedName = encodedRepoName.replace(/\+/g, "%20");
+            encodedRepoId = `${parts[0]}%2F${formattedEncodedName}`;
+        }
+    }
+    // 确保filePath已被URL编码
+    if (filePath.includes("/")) {
+        const startsWithSlash = filePath.startsWith("/");
+        if (startsWithSlash) {
+            encodedFilePath = encodedFilePath.substring(1);
+        }
+        encodedFilePath = encodeURIComponent(filePath);
+    }
+    return { encodedRepoId, encodedFilePath };
+}
+export async function clearProjectPath(projectPath) {
+    try {
+        // 检查路径是否存在
+        if (!fs.existsSync(projectPath)) {
+            console.warn(`目录不存在: ${projectPath}`);
+            return;
+        }
+        // 确保是一个目录
+        const stats = fs.statSync(projectPath);
+        if (!stats.isDirectory()) {
+            throw new Error(`提供的路径不是一个目录: ${projectPath}`);
+        }
+        // 读取目录内容
+        const files = fs.readdirSync(projectPath);
+        // 遍历并删除所有文件和子目录
+        for (const file of files) {
+            const currentPath = path.join(projectPath, file);
+            removeSync(currentPath);
+        }
+        console.log(`已成功清空目录: ${projectPath}`);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`清空目录时发生错误: ${error.message}`);
+        }
+        else {
+            console.error(`清空目录时发生未知错误: ${String(error)}`);
+        }
+        throw error;
+    }
+}
+/**
+ * 查询文件内容
+ * @param organizationId
+ * @param repositoryId
+ * @param filePath
+ * @param ref
+ */
+export async function getFileBlobsFunc(organizationId, repositoryId, filePath, ref) {
+    // const { encodedRepoId, encodedFilePath } = handlePathEncoding(repositoryId, filePath);
+    let encodedRepoId = repositoryId;
+    let encodedFilePath = filePath;
+    // 自动处理repositoryId中未编码的斜杠
+    if (repositoryId.includes("/")) {
+        // 发现未编码的斜杠，自动进行URL编码
+        const parts = repositoryId.split("/", 2);
+        if (parts.length === 2) {
+            const encodedRepoName = encodeURIComponent(parts[1]);
+            // 移除编码中的+号（空格被编码为+，但我们需要%20）
+            const formattedEncodedName = encodedRepoName.replace(/\+/g, "%20");
+            encodedRepoId = `${parts[0]}%2F${formattedEncodedName}`;
+        }
+    }
+    // 确保filePath已被URL编码
+    if (filePath.includes("/")) {
+        encodedFilePath = encodeURIComponent(filePath);
+    }
+    const baseUrl = `/oapi/v1/codeup/organizations/${organizationId}/repositories/${encodedRepoId}/files/${encodedFilePath}`;
+    // 构建查询参数
+    const queryParams = {
+        ref: ref
+    };
+    // 使用buildUrl函数构建包含查询参数的URL
+    const url = buildUrl(baseUrl, queryParams);
+    const response = await yunxiaoRequest(url, {
+        method: "GET"
+    });
+    return FileContentSchema.parse(response);
+}
+/**
+ * 创建文件
+ * @param organizationId
+ * @param repositoryId
+ * @param filePath
+ * @param content
+ * @param commitMessage
+ * @param branch
+ * @param encoding
+ */
+export async function createFileFunc(organizationId, repositoryId, filePath, content, commitMessage, branch, encoding) {
+    let encodedRepoId = repositoryId;
+    let encodedFilePath = filePath;
+    if (repositoryId.includes("/")) {
+        // 发现未编码的斜杠，自动进行URL编码
+        const parts = repositoryId.split("/", 2);
+        if (parts.length === 2) {
+            const encodedRepoName = encodeURIComponent(parts[1]);
+            // 移除编码中的+号（空格被编码为+，但我们需要%20）
+            const formattedEncodedName = encodedRepoName.replace(/\+/g, "%20");
+            encodedRepoId = `${parts[0]}%2F${formattedEncodedName}`;
+        }
+    }
+    // 确保filePath已被URL编码
+    if (filePath.includes("/")) {
+        encodedFilePath = pathEscape(filePath);
+    }
+    const url = `/oapi/v1/codeup/organizations/${organizationId}/repositories/${encodedRepoId}/files`;
+    const body = {
+        branch: branch,
+        filePath: encodedFilePath,
+        content: content,
+        commitMessage: commitMessage,
+        encoding: encoding || "text" // 默认使用text编码
+    };
+    const response = await yunxiaoRequest(url, {
+        method: "POST",
+        body: body
+    });
+    return CreateFileResponseSchema.parse(response);
+}
+export async function pushFilesFunc(organizationId, repositoryId, commitMessage, projectPath) {
+    // 读取 .gitignore 模式
+    // const ignorePatterns = readGitignore(projectPath);
+    const ignorePatterns = [
+        'dist',
+        '.next',
+        'node_modules',
+        '.git',
+        '.vercel',
+        '.cache',
+        'build',
+        'out',
+        '.nuxt',
+        '.svelte-kit',
+        'package-lock.json',
+        '.DS_Store'
+    ];
+    // 获取所有文件
+    const files = getAllFiles(projectPath, ignorePatterns);
+    const remoteFileList = await listFilesFunc(organizationId, repositoryId, undefined, "master", "RECURSIVE");
+    const remoteFilePathArr = remoteFileList.map((i) => i.path);
+    const shouldCreateFiles = files.filter((file) => !remoteFilePathArr.includes(file.path));
+    const shouldUpdateFiles = files.filter((file) => remoteFilePathArr.includes(file.path));
+    const shouldDeleteFiles = remoteFileList.filter((remoteFile) => !files.some((file) => file.path === remoteFile.path));
+    const createFilesSuccess = [];
+    const createFileErrors = [];
+    const updateFilesSuccess = [];
+    const updateFileErrors = [];
+    const deleteFilesSuccess = [];
+    const deleteFileErrors = [];
+    for (let i of shouldCreateFiles) {
+        console.error("[创建文件]:", i.path);
+        try {
+            const result = await createFileFunc(organizationId, repositoryId, i.path, i.content, commitMessage, "master", i.encoding);
+            createFilesSuccess.push(result.filePath);
+        }
+        catch (error) {
+            createFileErrors.push(error.message);
+        }
+    }
+    for (let i of shouldUpdateFiles) {
+        console.error("[更新文件]:", i.path);
+        try {
+            const result = await updateFileFunc(organizationId, repositoryId, i.path, i.content, commitMessage, "master", i.encoding);
+            updateFilesSuccess.push(result.filePath);
+        }
+        catch (error) {
+            updateFileErrors.push(error.message);
+        }
+    }
+    for (let i of shouldDeleteFiles) {
+        console.error("[删除文件]:", i.path);
+        try {
+            const result = await deleteFileFunc(organizationId, repositoryId, i.path, commitMessage, "master");
+            deleteFilesSuccess.push(result.filePath);
+        }
+        catch (error) {
+            deleteFileErrors.push(error.message);
+        }
+    }
+    return {
+        createFilesSuccess,
+        createFileErrors,
+        updateFilesSuccess,
+        updateFileErrors,
+        deleteFilesSuccess,
+        deleteFileErrors
+    };
+}
+/**
+ * 拉取整个代码库文件
+ * @param organizationId
+ * @param repositoryId
+ * @param projectPath
+ */
+export async function pullFilesFunc(organizationId, repositoryId, currntProjectPath) {
+    // 拉取之前 需要将当前projectPath路径下的所有代码文件清空
+    await clearProjectPath(currntProjectPath);
+    const allRemoteFilesPath = await listFilesFunc(organizationId, repositoryId, undefined, "master", "RECURSIVE");
+    const allFiles = [];
+    for (let i of allRemoteFilesPath) {
+        try {
+            const fileBlob = await getFileBlobsFunc(organizationId, repositoryId, i.path, "master");
+            allFiles.push(fileBlob);
+            // 写入文件到本地目录
+            const fullPath = path.join(currntProjectPath, i.path);
+            // 确保目录存在
+            const fileDir = path.dirname(fullPath);
+            fs.mkdirSync(fileDir, { recursive: true });
+            // 根据编码写入文件
+            if (fileBlob.encoding === 'base64') {
+                const buffer = Buffer.from(fileBlob.content || '', 'base64');
+                fs.writeFileSync(fullPath, buffer);
+            }
+            else {
+                fs.writeFileSync(fullPath, fileBlob.content || '', 'utf-8');
+            }
+        }
+        catch (error) {
+            console.error('[获取文件内容失败]:', error);
+        }
+    }
+    return allRemoteFilesPath;
+}
+/**
+ * 更新文件内容
+ * @param organizationId
+ * @param repositoryId
+ * @param filePath
+ * @param content
+ * @param commitMessage
+ * @param branch
+ * @param encoding
+ */
+export async function updateFileFunc(organizationId, repositoryId, filePath, content, commitMessage, branch, encoding) {
+    //const { encodedRepoId, encodedFilePath } = handlePathEncoding(repositoryId, filePath);
+    let encodedRepoId = repositoryId;
+    let encodedFilePath = filePath;
+    // 自动处理repositoryId中未编码的斜杠
+    if (repositoryId.includes("/")) {
+        // 发现未编码的斜杠，自动进行URL编码
+        const parts = repositoryId.split("/", 2);
+        if (parts.length === 2) {
+            const encodedRepoName = encodeURIComponent(parts[1]);
+            // 移除编码中的+号（空格被编码为+，但我们需要%20）
+            const formattedEncodedName = encodedRepoName.replace(/\+/g, "%20");
+            encodedRepoId = `${parts[0]}%2F${formattedEncodedName}`;
+        }
+    }
+    // 确保filePath已被URL编码
+    if (filePath.includes("/")) {
+        const pathToEncode = filePath.startsWith("/")
+            ? filePath.substring(1)
+            : filePath;
+        encodedFilePath = encodeURIComponent(pathToEncode);
+    }
+    const url = `/oapi/v1/codeup/organizations/${organizationId}/repositories/${encodedRepoId}/files/${encodedFilePath}`;
+    const body = {
+        branch: branch,
+        commitMessage: commitMessage,
+        content: content,
+        encoding: encoding || "text" // 默认使用text编码
+    };
+    const response = await yunxiaoRequest(url, {
+        method: "PUT",
+        body: body
+    });
+    return CreateFileResponseSchema.parse(response);
+}
+/**
+ * 删除文件
+ * @param organizationId
+ * @param repositoryId
+ * @param filePath
+ * @param commitMessage
+ * @param branch
+ */
+export async function deleteFileFunc(organizationId, repositoryId, filePath, commitMessage, branch) {
+    let encodedRepoId = repositoryId;
+    let encodedFilePath = filePath;
+    if (repositoryId.includes("/")) {
+        // 发现未编码的斜杠，自动进行URL编码
+        const parts = repositoryId.split("/", 2);
+        if (parts.length === 2) {
+            const encodedRepoName = encodeURIComponent(parts[1]);
+            // 移除编码中的+号（空格被编码为+，但我们需要%20）
+            const formattedEncodedName = encodedRepoName.replace(/\+/g, "%20");
+            encodedRepoId = `${parts[0]}%2F${formattedEncodedName}`;
+        }
+    }
+    // 确保filePath已被URL编码
+    if (filePath.includes("/")) {
+        encodedFilePath = encodeURIComponent(filePath);
+    }
+    const baseUrl = `/oapi/v1/codeup/organizations/${organizationId}/repositories/${encodedRepoId}/files/${encodedFilePath}`;
+    // 构建查询参数
+    const queryParams = {
+        branch: branch,
+        commitMessage: commitMessage
+    };
+    // 使用buildUrl函数构建包含查询参数的URL
+    const url = buildUrl(baseUrl, queryParams);
+    const response = await yunxiaoRequest(url, {
+        method: "DELETE"
+    });
+    return DeleteFileResponseSchema.parse(response);
+}
+/**
+ * 查询文件树
+ * @param organizationId
+ * @param repositoryId
+ * @param path
+ * @param ref
+ * @param type
+ */
+export async function listFilesFunc(organizationId, repositoryId, path, ref, type // Possible values: DIRECT, RECURSIVE, FLATTEN
+) {
+    // 自动处理repositoryId中未编码的斜杠
+    let encodedRepoId = repositoryId;
+    if (repositoryId.includes("/")) {
+        // 发现未编码的斜杠，自动进行URL编码
+        const parts = repositoryId.split("/", 2);
+        if (parts.length === 2) {
+            const encodedRepoName = encodeURIComponent(parts[1]);
+            // 移除编码中的+号（空格被编码为+，但我们需要%20）
+            const formattedEncodedName = encodedRepoName.replace(/\+/g, "%20");
+            encodedRepoId = `${parts[0]}%2F${formattedEncodedName}`;
+        }
+    }
+    const baseUrl = `/oapi/v1/codeup/organizations/${organizationId}/repositories/${encodedRepoId}/files/tree`;
+    // 构建查询参数
+    const queryParams = {};
+    if (path) {
+        queryParams.path = path;
+    }
+    if (ref) {
+        queryParams.ref = ref;
+    }
+    if (type) {
+        queryParams.type = type;
+    }
+    // 使用buildUrl函数构建包含查询参数的URL
+    const url = buildUrl(baseUrl, queryParams);
+    const response = await yunxiaoRequest(url, {
+        method: "GET"
+    });
+    // 确保响应是数组
+    if (!Array.isArray(response)) {
+        return [];
+    }
+    // 解析每个文件信息对象
+    return response.map((fileInfo) => FileInfoSchema.parse(fileInfo));
+}

package/dist/operations/codeup/repositories.js

@@ -0,0 +1,83 @@
+/**
+ * 代码库（Repository）相关操作
+ *
+ * 概念说明：
+ * - 代码库（Repository）是云效平台中的代码管理单元，属于CodeUp产品
+ * - 代码库与项目（Project）是不同的概念，项目属于项目管理领域
+ * - 代码库用于存储和管理源代码，而项目用于管理工作项、迭代等
+ * - 请勿混淆这两个概念，它们是不同的资源类型
+ */
+import { yunxiaoRequest, buildUrl, handleRepositoryIdEncoding } from "../../common/utils.js";
+import { RepositorySchema } from "./types.js";
+/**
+ * 创建仓库
+ * @param organizationId
+ * @param name
+ * @param description
+ */
+export async function createRepositoryFunc(organizationId, name, description) {
+    const url = `/oapi/v1/codeup/organizations/${organizationId}/repositories?createParentPath=true`;
+    const response = await yunxiaoRequest(url, {
+        method: "POST",
+        body: {
+            name,
+            description,
+            namespaceId: 1670786,
+            path: name
+        }
+    });
+    return RepositorySchema.parse(response);
+}
+/**
+ * 查询仓库详情
+ * @param organizationId
+ * @param repositoryId
+ */
+export async function getRepositoryFunc(organizationId, repositoryId) {
+    const encodedRepoId = handleRepositoryIdEncoding(repositoryId);
+    const url = `/oapi/v1/codeup/organizations/${organizationId}/repositories/${encodedRepoId}`;
+    const response = await yunxiaoRequest(url, {
+        method: "GET"
+    });
+    return RepositorySchema.parse(response);
+}
+/**
+ * 查询仓库列表
+ * @param organizationId
+ * @param page
+ * @param perPage
+ * @param orderBy
+ * @param sort
+ * @param search
+ * @param archived
+ */
+export async function listRepositoriesFunc(organizationId, page, perPage, orderBy, sort, search, archived) {
+    const baseUrl = `/oapi/v1/codeup/organizations/${organizationId}/repositories`;
+    const queryParams = {};
+    if (page !== undefined) {
+        queryParams.page = page;
+    }
+    if (perPage !== undefined) {
+        queryParams.perPage = perPage;
+    }
+    if (orderBy !== undefined) {
+        queryParams.orderBy = orderBy;
+    }
+    if (sort !== undefined) {
+        queryParams.sort = sort;
+    }
+    if (search !== undefined) {
+        queryParams.search = search;
+    }
+    if (archived !== undefined) {
+        queryParams.archived = String(archived); // Convert boolean to string
+    }
+    const url = buildUrl(baseUrl, queryParams);
+    const response = await yunxiaoRequest(url, {
+        method: "GET"
+    });
+    if (!Array.isArray(response)) {
+        return [];
+    }
+    return response.map((repo) => RepositorySchema.parse(repo));
+}