@catchmexz/fedin-vibe-mcp-server 0.1.0

package/dist/operations/git/git-repository.js

@@ -0,0 +1,334 @@
+import { simpleGit } from 'simple-git';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { z } from 'zod';
+// Git仓库操作的参数验证模式
+export const CloneRepositorySchema = z.object({
+    repositoryUrl: z.string().describe('Git仓库URL'),
+    localPath: z.string().describe('本地克隆路径'),
+    branch: z.string().optional().describe('指定分支，默认为主分支'),
+    depth: z.number().optional().describe('克隆深度，用于浅克隆'),
+    username: z.string().optional().describe('Git用户名'),
+    password: z.string().optional().describe('Git密码或访问令牌'),
+});
+export const PushRepositorySchema = z.object({
+    localPath: z.string().describe('本地仓库路径'),
+    branch: z.string().optional().describe('推送的分支，默认为当前分支'),
+    remote: z.string().optional().describe('远程仓库名，默认为origin'),
+    commitMessage: z.string().optional().describe('提交信息'),
+    addAll: z.boolean().optional().describe('是否添加所有更改，默认为true'),
+});
+export const PullRepositorySchema = z.object({
+    localPath: z.string().describe('本地仓库路径'),
+    branch: z.string().optional().describe('拉取的分支，默认为当前分支'),
+    remote: z.string().optional().describe('远程仓库名，默认为origin'),
+});
+export const CreateBranchSchema = z.object({
+    localPath: z.string().describe('本地仓库路径'),
+    branchName: z.string().describe('新分支名称'),
+    fromBranch: z.string().optional().describe('基于哪个分支创建，默认为当前分支'),
+    checkout: z.boolean().optional().describe('是否切换到新分支，默认为true'),
+});
+export const SwitchBranchSchema = z.object({
+    localPath: z.string().describe('本地仓库路径'),
+    branchName: z.string().describe('要切换到的分支名称'),
+});
+export const GetRepositoryStatusSchema = z.object({
+    localPath: z.string().describe('本地仓库路径'),
+});
+/**
+ * Git仓库操作类
+ */
+export class GitRepositoryOperations {
+    /**
+     * 克隆Git仓库
+     */
+    static async cloneRepository(params) {
+        const { repositoryUrl, localPath, branch, depth, username, password } = params;
+        try {
+            // 检查本地路径是否已存在
+            try {
+                await fs.access(localPath);
+                throw new Error(`目标路径 ${localPath} 已存在`);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+            // 创建父目录
+            await fs.mkdir(path.dirname(localPath), { recursive: true });
+            const git = simpleGit();
+            // 构建克隆选项
+            const cloneOptions = {};
+            if (branch) {
+                cloneOptions['--branch'] = branch;
+            }
+            if (depth) {
+                cloneOptions['--depth'] = depth;
+            }
+            // 如果提供了认证信息，修改URL
+            let authUrl = repositoryUrl;
+            if (username && password) {
+                const url = new URL(repositoryUrl);
+                url.username = username;
+                url.password = password;
+                authUrl = url.toString();
+            }
+            console.log(`开始克隆仓库: ${repositoryUrl} 到 ${localPath}`);
+            const result = await git.clone(authUrl, localPath, cloneOptions);
+            return {
+                success: true,
+                message: `成功克隆仓库到 ${localPath}`,
+                localPath,
+                repositoryUrl,
+                branch: branch || 'default',
+            };
+        }
+        catch (error) {
+            console.error('克隆仓库失败:', error);
+            return {
+                success: false,
+                error: `克隆仓库失败: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * 推送代码到远程仓库
+     */
+    static async pushRepository(params) {
+        const { localPath, branch, remote = 'origin', commitMessage, addAll = true } = params;
+        try {
+            // 检查本地路径是否存在
+            await fs.access(localPath);
+            const git = simpleGit(localPath);
+            // 检查是否是Git仓库
+            const isRepo = await git.checkIsRepo();
+            if (!isRepo) {
+                throw new Error(`${localPath} 不是一个Git仓库`);
+            }
+            // 如果需要添加所有更改
+            if (addAll) {
+                await git.add('.');
+                console.log('已添加所有更改到暂存区');
+            }
+            // 检查是否有更改需要提交
+            const status = await git.status();
+            if (status.staged.length === 0 && status.not_added.length === 0 && status.modified.length === 0) {
+                return {
+                    success: true,
+                    message: '没有更改需要推送',
+                    status,
+                };
+            }
+            // 提交更改
+            if (status.staged.length > 0 || (addAll && (status.not_added.length > 0 || status.modified.length > 0))) {
+                const message = commitMessage || `自动提交 - ${new Date().toISOString()}`;
+                const commitResult = await git.commit(message);
+                console.log(`已提交更改: ${message}`);
+            }
+            // 推送到远程仓库
+            const pushBranch = branch || await git.revparse(['--abbrev-ref', 'HEAD']);
+            const pushResult = await git.push(remote, pushBranch);
+            return {
+                success: true,
+                message: `成功推送到 ${remote}/${pushBranch}`,
+                pushResult,
+                branch: pushBranch,
+                remote,
+            };
+        }
+        catch (error) {
+            console.error('推送仓库失败:', error);
+            return {
+                success: false,
+                error: `推送仓库失败: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * 从远程仓库拉取更新
+     */
+    static async pullRepository(params) {
+        const { localPath, branch, remote = 'origin' } = params;
+        try {
+            // 检查本地路径是否存在
+            await fs.access(localPath);
+            const git = simpleGit(localPath);
+            // 检查是否是Git仓库
+            const isRepo = await git.checkIsRepo();
+            if (!isRepo) {
+                throw new Error(`${localPath} 不是一个Git仓库`);
+            }
+            // 拉取更新
+            const pullBranch = branch || await git.revparse(['--abbrev-ref', 'HEAD']);
+            const pullResult = await git.pull(remote, pullBranch);
+            return {
+                success: true,
+                message: `成功从 ${remote}/${pullBranch} 拉取更新`,
+                pullResult,
+                branch: pullBranch,
+                remote,
+                summary: pullResult.summary,
+            };
+        }
+        catch (error) {
+            console.error('拉取仓库失败:', error);
+            return {
+                success: false,
+                error: `拉取仓库失败: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * 创建新分支
+     */
+    static async createBranch(params) {
+        const { localPath, branchName, fromBranch, checkout = true } = params;
+        try {
+            // 检查本地路径是否存在
+            await fs.access(localPath);
+            const git = simpleGit(localPath);
+            // 检查是否是Git仓库
+            const isRepo = await git.checkIsRepo();
+            if (!isRepo) {
+                throw new Error(`${localPath} 不是一个Git仓库`);
+            }
+            // 检查分支是否已存在
+            const branches = await git.branchLocal();
+            if (branches.all.includes(branchName)) {
+                throw new Error(`分支 ${branchName} 已存在`);
+            }
+            // 创建分支
+            if (fromBranch) {
+                await git.checkoutBranch(branchName, fromBranch);
+            }
+            else {
+                await git.checkoutLocalBranch(branchName);
+            }
+            // 如果不需要切换到新分支，切换回原分支
+            if (!checkout && fromBranch) {
+                await git.checkout(fromBranch);
+            }
+            return {
+                success: true,
+                message: `成功创建分支 ${branchName}`,
+                branchName,
+                fromBranch: fromBranch || 'current',
+                checkedOut: checkout,
+            };
+        }
+        catch (error) {
+            console.error('创建分支失败:', error);
+            return {
+                success: false,
+                error: `创建分支失败: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * 切换分支
+     */
+    static async switchBranch(params) {
+        const { localPath, branchName } = params;
+        try {
+            // 检查本地路径是否存在
+            await fs.access(localPath);
+            const git = simpleGit(localPath);
+            // 检查是否是Git仓库
+            const isRepo = await git.checkIsRepo();
+            if (!isRepo) {
+                throw new Error(`${localPath} 不是一个Git仓库`);
+            }
+            // 检查分支是否存在
+            const branches = await git.branchLocal();
+            if (!branches.all.includes(branchName)) {
+                // 尝试从远程分支创建本地分支
+                const remoteBranches = await git.branch(['-r']);
+                const remoteBranchName = `origin/${branchName}`;
+                if (remoteBranches.all.includes(remoteBranchName)) {
+                    await git.checkoutBranch(branchName, remoteBranchName);
+                }
+                else {
+                    throw new Error(`分支 ${branchName} 不存在`);
+                }
+            }
+            else {
+                // 切换到现有分支
+                await git.checkout(branchName);
+            }
+            return {
+                success: true,
+                message: `成功切换到分支 ${branchName}`,
+                branchName,
+            };
+        }
+        catch (error) {
+            console.error('切换分支失败:', error);
+            return {
+                success: false,
+                error: `切换分支失败: ${error.message}`,
+            };
+        }
+    }
+    /**
+     * 获取仓库状态
+     */
+    static async getRepositoryStatus(params) {
+        const { localPath } = params;
+        try {
+            // 检查本地路径是否存在
+            await fs.access(localPath);
+            const git = simpleGit(localPath);
+            // 检查是否是Git仓库
+            const isRepo = await git.checkIsRepo();
+            if (!isRepo) {
+                throw new Error(`${localPath} 不是一个Git仓库`);
+            }
+            // 获取状态信息
+            const status = await git.status();
+            const branches = await git.branchLocal();
+            const remotes = await git.getRemotes(true);
+            const currentBranch = await git.revparse(['--abbrev-ref', 'HEAD']);
+            // 获取最近的提交信息
+            const latestCommit = await git.log({ maxCount: 1 });
+            return {
+                success: true,
+                status: {
+                    current: currentBranch,
+                    tracking: status.tracking,
+                    ahead: status.ahead,
+                    behind: status.behind,
+                    staged: status.staged,
+                    not_added: status.not_added,
+                    conflicted: status.conflicted,
+                    created: status.created,
+                    deleted: status.deleted,
+                    modified: status.modified,
+                    renamed: status.renamed,
+                },
+                branches: {
+                    current: branches.current,
+                    all: branches.all,
+                },
+                remotes: remotes.map(remote => ({
+                    name: remote.name,
+                    refs: remote.refs,
+                })),
+                latestCommit: latestCommit.latest ? {
+                    hash: latestCommit.latest.hash,
+                    date: latestCommit.latest.date,
+                    message: latestCommit.latest.message,
+                    author: latestCommit.latest.author_name,
+                } : null,
+            };
+        }
+        catch (error) {
+            console.error('获取仓库状态失败:', error);
+            return {
+                success: false,
+                error: `获取仓库状态失败: ${error.message}`,
+            };
+        }
+    }
+}

package/dist/operations/git/index.js

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+import { simpleGit } from 'simple-git';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { tmpdir } from 'os';
+export class GitOperations {
+    git;
+    workingDir;
+    constructor(workingDir) {
+        this.workingDir = workingDir || tmpdir();
+        this.git = simpleGit(this.workingDir);
+    }
+    /**
+     * 克隆整个代码库到本地
+     */
+    async cloneRepository(repo) {
+        const repoName = this.extractRepoName(repo.url);
+        const localPath = repo.localPath || path.join(this.workingDir, repoName);
+        // 确保目录存在
+        await fs.mkdir(path.dirname(localPath), { recursive: true });
+        const cloneOptions = {
+            '--depth': 1, // 浅克隆，只获取最新提交
+        };
+        if (repo.branch) {
+            cloneOptions['--branch'] = repo.branch;
+        }
+        // 构建带认证的URL
+        const cloneUrl = this.buildAuthenticatedUrl(repo.url, repo.credentials);
+        try {
+            await this.git.clone(cloneUrl, localPath, cloneOptions);
+            return localPath;
+        }
+        catch (error) {
+            throw new Error(`克隆代码库失败: ${error}`);
+        }
+    }
+    /**
+     * 推送整个代码库的更改
+     */
+    async pushRepository(localPath, repo, commitMessage, files) {
+        const git = simpleGit(localPath);
+        try {
+            // 配置用户信息（如果提供了凭据）
+            if (repo.credentials) {
+                await git.addConfig('user.name', repo.credentials.username);
+                await git.addConfig('user.email', `${repo.credentials.username}@example.com`);
+            }
+            // 添加文件
+            if (files && files.length > 0) {
+                await git.add(files);
+            }
+            else {
+                await git.add('.');
+            }
+            // 检查是否有更改
+            const status = await git.status();
+            if (status.files.length === 0) {
+                throw new Error('没有检测到文件更改');
+            }
+            // 提交更改
+            await git.commit(commitMessage);
+            // 推送到远程仓库
+            const pushOptions = {};
+            const branch = repo.branch || 'master';
+            const pushUrl = this.buildAuthenticatedUrl(repo.url, repo.credentials);
+            await git.addRemote('origin', pushUrl).catch(() => { }); // 忽略已存在的错误
+            await git.push('origin', branch, pushOptions);
+        }
+        catch (error) {
+            throw new Error(`推送代码库失败: ${error}`);
+        }
+    }
+    /**
+     * 拉取最新更改
+     */
+    async pullRepository(localPath, repo) {
+        const git = simpleGit(localPath);
+        try {
+            const branch = repo.branch || 'master';
+            await git.pull('origin', branch);
+        }
+        catch (error) {
+            throw new Error(`拉取代码库失败: ${error}`);
+        }
+    }
+    /**
+     * 获取代码库状态
+     */
+    async getRepositoryStatus(localPath) {
+        const git = simpleGit(localPath);
+        try {
+            const status = await git.status();
+            const log = await git.log({ maxCount: 10 });
+            return {
+                status,
+                recentCommits: log.all,
+                currentBranch: status.current,
+                ahead: status.ahead,
+                behind: status.behind,
+                modified: status.modified,
+                created: status.created,
+                deleted: status.deleted,
+            };
+        }
+        catch (error) {
+            throw new Error(`获取代码库状态失败: ${error}`);
+        }
+    }
+    /**
+     * 创建新分支
+     */
+    async createBranch(localPath, branchName, fromBranch) {
+        const git = simpleGit(localPath);
+        try {
+            if (fromBranch) {
+                await git.checkoutBranch(branchName, fromBranch);
+            }
+            else {
+                await git.checkoutLocalBranch(branchName);
+            }
+        }
+        catch (error) {
+            throw new Error(`创建分支失败: ${error}`);
+        }
+    }
+    /**
+     * 切换分支
+     */
+    async switchBranch(localPath, branchName) {
+        const git = simpleGit(localPath);
+        try {
+            await git.checkout(branchName);
+        }
+        catch (error) {
+            throw new Error(`切换分支失败: ${error}`);
+        }
+    }
+    /**
+     * 同步本地代码库与远程Codeup仓库
+     */
+    async syncWithCodeup(localPath, organizationId, repositoryId, branch = 'master') {
+        // 这里可以结合现有的Codeup API来实现双向同步
+        // 1. 从本地推送到Codeup
+        // 2. 从Codeup拉取到本地
+        // 3. 处理冲突
+        // 实现细节可以根据具体需求来完善
+    }
+    extractRepoName(url) {
+        const match = url.match(/\/([^\/]+)\.git$/);
+        return match ? match[1] : 'repository';
+    }
+    buildAuthenticatedUrl(url, credentials) {
+        if (!credentials)
+            return url;
+        // 处理不同格式的Git URL
+        if (url.startsWith('https://')) {
+            const urlObj = new URL(url);
+            urlObj.username = credentials.username;
+            urlObj.password = credentials.password;
+            return urlObj.toString();
+        }
+        else if (url.startsWith('git@')) {
+            // SSH格式暂时不处理认证，需要SSH密钥配置
+            return url;
+        }
+        return url;
+    }
+    /**
+     * 清理临时目录
+     */
+    async cleanup(localPath) {
+        try {
+            await fs.rm(localPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.warn(`清理目录失败: ${error}`);
+        }
+    }
+}
+// 导出操作函数
+export const gitOperations = new GitOperations();
+// Zod schemas for validation
+export const CloneRepositorySchema = z.object({
+    organizationId: z.string().describe('组织ID'),
+    repositoryUrl: z.string().describe('代码库URL'),
+    branch: z.string().optional().describe('分支名称，默认为master'),
+    localPath: z.string().optional().describe('本地路径，不指定则使用临时目录'),
+    username: z.string().optional().describe('用户名'),
+    password: z.string().optional().describe('密码或访问令牌'),
+});
+export const PushRepositorySchema = z.object({
+    organizationId: z.string().describe('组织ID'),
+    localPath: z.string().describe('本地代码库路径'),
+    repositoryUrl: z.string().describe('代码库URL'),
+    commitMessage: z.string().describe('提交信息'),
+    branch: z.string().optional().describe('分支名称，默认为master'),
+    files: z.array(z.string()).optional().describe('要提交的文件列表，不指定则提交所有更改'),
+    username: z.string().optional().describe('用户名'),
+    password: z.string().optional().describe('密码或访问令牌'),
+});
+export const RepositoryStatusSchema = z.object({
+    organizationId: z.string().describe('组织ID'),
+    localPath: z.string().describe('本地代码库路径'),
+});
+export const BranchOperationSchema = z.object({
+    organizationId: z.string().describe('组织ID'),
+    localPath: z.string().describe('本地代码库路径'),
+    branchName: z.string().describe('分支名称'),
+    fromBranch: z.string().optional().describe('源分支名称（仅创建分支时使用）'),
+});

package/dist/operations/organization/members.js

@@ -0,0 +1,94 @@
+import { OrganizationMembersSchema, MemberInfoSchema, SearchOrganizationMembersResultSchema, } from './types.js';
+import { buildUrl, yunxiaoRequest } from "../../common/utils.js";
+/**
+ * 查询组织成员列表
+ * @param organizationId 组织ID
+ * @param page 当前页，默认1
+ * @param perPage 每页数据条数，默认100
+ * @returns 组织成员列表
+ */
+export const getOrganizationMembersFunc = async (organizationId, page = 1, perPage = 100) => {
+    const url = `/oapi/v1/platform/organizations/${organizationId}/members`;
+    const params = {
+        page: page,
+        perPage: perPage
+    };
+    const urlWithParams = buildUrl(url, params);
+    const response = await yunxiaoRequest(urlWithParams, {
+        method: "GET",
+    });
+    // 验证响应数据结构
+    return OrganizationMembersSchema.parse(response);
+};
+/**
+ * 查询组织成员详细信息
+ * @param organizationId 组织ID
+ * @param memberId 成员ID
+ * @returns 组织成员详细信息
+ */
+export const getOrganizationMemberInfoFunc = async (organizationId, memberId) => {
+    const url = `/oapi/v1/platform/organizations/${organizationId}/members/${memberId}`;
+    console.log("aaa", url);
+    const response = await yunxiaoRequest(url, {
+        method: "GET",
+    });
+    return MemberInfoSchema.parse(response);
+};
+/**
+ * 搜索组织成员
+ * @param organizationId 组织ID
+ * @param includeChildren
+ * @param page 当前页，默认1
+ * @param perPage 每页数据条数，默认100
+ * @param deptIds
+ * @param nextToken
+ * @param query
+ * @param roleIds
+ * @param statuses
+ * @returns 搜索到的组织成员列表
+ */
+export const searchOrganizationMembersFunc = async (organizationId, includeChildren = false, page = 1, perPage = 100, deptIds, nextToken, query, roleIds, statuses) => {
+    const url = `/oapi/v1/platform/organizations/${organizationId}/members:search`;
+    const payload = {
+        page: page,
+        perPage: perPage
+    };
+    if (deptIds) {
+        payload.deptIds = deptIds;
+    }
+    if (nextToken) {
+        payload.nextToken = nextToken;
+    }
+    if (query) {
+        payload.query = query;
+    }
+    if (roleIds) {
+        payload.roleIds = roleIds;
+    }
+    if (statuses) {
+        payload.statuses = statuses;
+    }
+    const response = await yunxiaoRequest(url, {
+        method: "POST",
+        body: payload,
+    });
+    // 验证响应数据结构
+    return SearchOrganizationMembersResultSchema.parse(response);
+};
+/**
+ * 通过用户ID查询组织成员详细信息
+ * @param organizationId 组织ID
+ * @param userId 用户ID
+ * @returns 组织成员详细信息
+ */
+export const getOrganizationMemberByUserIdInfoFunc = async (organizationId, userId) => {
+    const url = `/oapi/v1/platform/organizations/${organizationId}/members:readByUser`;
+    const params = {
+        userId: userId
+    };
+    const urlWithParams = buildUrl(url, params);
+    const response = await yunxiaoRequest(urlWithParams, {
+        method: "GET",
+    });
+    return MemberInfoSchema.parse(response);
+};