github-cicd-mcp 0.0.0-stage → 1.2.0

package/dist/tools/issues.js

@@ -0,0 +1,167 @@
+import { z } from "zod";
+import { owner, perPage, repo } from "../lib/fields.js";
+import { getOctokit } from "../lib/github.js";
+import { errorResult, jsonResult } from "../lib/response.js";
+export function registerIssueTools(server) {
+    server.tool("github_create_issue", "Create an issue in a repository.", {
+        owner,
+        repo,
+        title: z.string(),
+        body: z.string().optional(),
+        labels: z.string().optional().describe("JSON array of label names"),
+        assignees: z.string().optional().describe("JSON array of GitHub usernames"),
+    }, async ({ owner, repo, title, body, labels, assignees }) => {
+        try {
+            const { data } = await getOctokit().rest.issues.create({
+                owner,
+                repo,
+                title,
+                body: body ?? undefined,
+                labels: labels ? JSON.parse(labels) : undefined,
+                assignees: assignees ? JSON.parse(assignees) : undefined,
+            });
+            return jsonResult({
+                number: data.number,
+                title: data.title,
+                state: data.state,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_issues", "List issues (excludes pull requests unless filtered).", {
+        owner,
+        repo,
+        state: z.string().optional().describe("open | closed | all"),
+        labels: z.string().optional().describe("Comma-separated label names"),
+        per_page: perPage,
+    }, async ({ owner, repo, state, labels, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.issues.listForRepo({
+                owner,
+                repo,
+                state: state ?? "open",
+                labels: labels ?? undefined,
+                per_page: per_page ?? 30,
+            });
+            return jsonResult(data
+                .filter((i) => !i.pull_request)
+                .map((i) => ({
+                number: i.number,
+                title: i.title,
+                state: i.state,
+                user: i.user?.login,
+                labels: i.labels.map((l) => (typeof l === "string" ? l : l.name)),
+                html_url: i.html_url,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_get_issue", "Get issue details by number.", {
+        owner,
+        repo,
+        issue_number: z.number(),
+    }, async ({ owner, repo, issue_number }) => {
+        try {
+            const { data } = await getOctokit().rest.issues.get({
+                owner,
+                repo,
+                issue_number,
+            });
+            return jsonResult({
+                number: data.number,
+                title: data.title,
+                body: data.body,
+                state: data.state,
+                user: data.user?.login,
+                labels: data.labels.map((l) => (typeof l === "string" ? l : l.name)),
+                assignees: data.assignees?.map((a) => a.login),
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_update_issue", "Update issue title, body, state, or labels.", {
+        owner,
+        repo,
+        issue_number: z.number(),
+        title: z.string().optional(),
+        body: z.string().optional(),
+        state: z.string().optional().describe("open | closed"),
+        labels: z.string().optional().describe("JSON array of label names (replaces all labels)"),
+    }, async ({ owner, repo, issue_number, title, body, state, labels }) => {
+        try {
+            const { data } = await getOctokit().rest.issues.update({
+                owner,
+                repo,
+                issue_number,
+                title: title ?? undefined,
+                body: body ?? undefined,
+                state: state,
+                labels: labels ? JSON.parse(labels) : undefined,
+            });
+            return jsonResult({
+                number: data.number,
+                title: data.title,
+                state: data.state,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_add_issue_comment", "Add a comment to an issue or pull request.", {
+        owner,
+        repo,
+        issue_number: z.number(),
+        body: z.string(),
+    }, async ({ owner, repo, issue_number, body }) => {
+        try {
+            const { data } = await getOctokit().rest.issues.createComment({
+                owner,
+                repo,
+                issue_number,
+                body,
+            });
+            return jsonResult({
+                id: data.id,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_issue_comments", "List comments on an issue or PR.", {
+        owner,
+        repo,
+        issue_number: z.number(),
+        per_page: perPage,
+    }, async ({ owner, repo, issue_number, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.issues.listComments({
+                owner,
+                repo,
+                issue_number,
+                per_page: per_page ?? 30,
+            });
+            return jsonResult(data.map((c) => ({
+                id: c.id,
+                user: c.user?.login,
+                body: c.body,
+                created_at: c.created_at,
+                html_url: c.html_url,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}

package/dist/tools/local-git.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerLocalGitTools(server: McpServer): void;

package/dist/tools/local-git.js

@@ -0,0 +1,142 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { simpleGit } from "simple-git";
+import { z } from "zod";
+import { errorResult, jsonResult, textResult } from "../lib/response.js";
+const repoPath = z.string().describe("Path to git repository root");
+function gitAt(cwd) {
+    const dir = resolve(cwd);
+    if (!existsSync(resolve(dir, ".git"))) {
+        throw new Error(`Not a git repository: ${dir}`);
+    }
+    return simpleGit({ baseDir: dir });
+}
+export function registerLocalGitTools(server) {
+    server.tool("git_status", "Show working tree status in a local clone (branch, staged/unstaged files).", { path: repoPath }, async ({ path }) => {
+        try {
+            const git = gitAt(path);
+            const status = await git.status();
+            return jsonResult({
+                current: status.current,
+                tracking: status.tracking,
+                ahead: status.ahead,
+                behind: status.behind,
+                staged: status.staged,
+                modified: status.modified,
+                created: status.created,
+                deleted: status.deleted,
+                conflicted: status.conflicted,
+                isClean: status.isClean(),
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("git_commit", "Stage all changes and create a local commit.", {
+        path: repoPath,
+        message: z.string().describe("Commit message"),
+        all: z
+            .boolean()
+            .optional()
+            .describe("Stage all changes (default true). If false, only staged files"),
+    }, async ({ path, message, all }) => {
+        try {
+            const git = gitAt(path);
+            if (all !== false) {
+                await git.add("-A");
+            }
+            const result = await git.commit(message);
+            return jsonResult({
+                commit: result.commit,
+                summary: result.summary,
+                branch: result.branch,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("git_push", "Push commits to remote (set upstream on first push if needed).", {
+        path: repoPath,
+        remote: z.string().optional().describe("Remote name (default origin)"),
+        branch: z.string().optional().describe("Branch to push; default current branch"),
+        set_upstream: z
+            .boolean()
+            .optional()
+            .describe("Use -u on push (default true for new branches)"),
+    }, async ({ path, remote, branch, set_upstream }) => {
+        try {
+            const git = gitAt(path);
+            const rem = remote ?? "origin";
+            const status = await git.status();
+            const br = branch ?? status.current ?? "HEAD";
+            const args = set_upstream === false ? [rem, br] : ["-u", rem, br];
+            await git.push(args);
+            return jsonResult({
+                pushed: true,
+                remote: rem,
+                branch: br,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("git_pull", "Pull from remote with rebase (ff-only friendly for CI branches).", {
+        path: repoPath,
+        remote: z.string().optional().describe("Default origin"),
+        branch: z.string().optional(),
+        rebase: z.boolean().optional().describe("Use --rebase (default true)"),
+    }, async ({ path, remote, branch, rebase }) => {
+        try {
+            const git = gitAt(path);
+            const rem = remote ?? "origin";
+            const status = await git.status();
+            const br = branch ?? status.current ?? undefined;
+            if (rebase !== false) {
+                await git.pull(rem, br, { "--rebase": "true" });
+            }
+            else {
+                await git.pull(rem, br);
+            }
+            return textResult(`Pulled ${rem}/${br ?? "current branch"}`);
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("git_log", "Recent commit log on current branch.", {
+        path: repoPath,
+        max_count: z.number().optional().describe("Number of commits (default 10)"),
+    }, async ({ path, max_count }) => {
+        try {
+            const git = gitAt(path);
+            const log = await git.log({ maxCount: max_count ?? 10 });
+            return jsonResult(log.all.map((c) => ({
+                hash: c.hash,
+                date: c.date,
+                message: c.message,
+                author_name: c.author_name,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("git_clone", "Clone a repository into a directory (uses local git, not API).", {
+        url: z.string().describe("HTTPS or SSH clone URL"),
+        directory: z.string().describe("Target directory path"),
+        branch: z.string().optional().describe("Optional branch to checkout"),
+    }, async ({ url, directory, branch }) => {
+        try {
+            const dir = resolve(directory);
+            const git = simpleGit();
+            await git.clone(url, dir, branch ? ["--branch", branch] : []);
+            return jsonResult({ cloned: url, directory: dir, branch: branch ?? "default" });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}

package/dist/tools/pull-requests.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerPullRequestTools(server: McpServer): void;

package/dist/tools/pull-requests.js

@@ -0,0 +1,198 @@
+import { z } from "zod";
+import { owner, perPage, repo } from "../lib/fields.js";
+import { getOctokit } from "../lib/github.js";
+import { errorResult, jsonResult } from "../lib/response.js";
+export function registerPullRequestTools(server) {
+    server.tool("github_create_pull_request", "Open a pull request (base ← head).", {
+        owner,
+        repo,
+        title: z.string(),
+        head: z.string().describe("Head branch (or user:branch for forks)"),
+        base: z.string().describe("Base branch (e.g. main)"),
+        body: z.string().optional().describe("PR description (markdown)"),
+        draft: z.boolean().optional().describe("Create as draft PR"),
+    }, async ({ owner, repo, title, head, base, body, draft }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.create({
+                owner,
+                repo,
+                title,
+                head,
+                base,
+                body: body ?? undefined,
+                draft: draft ?? undefined,
+            });
+            return jsonResult({
+                number: data.number,
+                title: data.title,
+                state: data.state,
+                html_url: data.html_url,
+                mergeable: data.mergeable,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_pull_requests", "List pull requests for a repository.", {
+        owner,
+        repo,
+        state: z.string().optional().describe("open | closed | all (default open)"),
+        per_page: perPage,
+    }, async ({ owner, repo, state, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.list({
+                owner,
+                repo,
+                state: state ?? "open",
+                per_page: per_page ?? 30,
+            });
+            return jsonResult(data.map((pr) => ({
+                number: pr.number,
+                title: pr.title,
+                state: pr.state,
+                user: pr.user?.login,
+                head: pr.head.ref,
+                base: pr.base.ref,
+                html_url: pr.html_url,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_get_pull_request", "Get pull request details including merge status.", {
+        owner,
+        repo,
+        pull_number: z.number(),
+    }, async ({ owner, repo, pull_number }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.get({
+                owner,
+                repo,
+                pull_number,
+            });
+            return jsonResult({
+                number: data.number,
+                title: data.title,
+                body: data.body,
+                state: data.state,
+                merged: data.merged,
+                mergeable: data.mergeable,
+                mergeable_state: data.mergeable_state,
+                head: { ref: data.head.ref, sha: data.head.sha },
+                base: { ref: data.base.ref, sha: data.base.sha },
+                html_url: data.html_url,
+                changed_files: data.changed_files,
+                additions: data.additions,
+                deletions: data.deletions,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_merge_pull_request", "Merge a pull request when checks pass (squash, merge, or rebase).", {
+        owner,
+        repo,
+        pull_number: z.number(),
+        merge_method: z
+            .string()
+            .optional()
+            .describe("merge | squash | rebase (default squash)"),
+        commit_title: z.string().optional(),
+        commit_message: z.string().optional(),
+    }, async ({ owner, repo, pull_number, merge_method, commit_title, commit_message }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.merge({
+                owner,
+                repo,
+                pull_number,
+                merge_method: merge_method ?? "squash",
+                commit_title: commit_title ?? undefined,
+                commit_message: commit_message ?? undefined,
+            });
+            return jsonResult(data);
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_update_pull_request", "Update PR title, body, or state (open/closed).", {
+        owner,
+        repo,
+        pull_number: z.number(),
+        title: z.string().optional(),
+        body: z.string().optional(),
+        state: z.string().optional().describe("open | closed"),
+    }, async ({ owner, repo, pull_number, title, body, state }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.update({
+                owner,
+                repo,
+                pull_number,
+                title: title ?? undefined,
+                body: body ?? undefined,
+                state: state,
+            });
+            return jsonResult({
+                number: data.number,
+                title: data.title,
+                state: data.state,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_pull_request_files", "List files changed in a pull request.", {
+        owner,
+        repo,
+        pull_number: z.number(),
+    }, async ({ owner, repo, pull_number }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.listFiles({
+                owner,
+                repo,
+                pull_number,
+                per_page: 100,
+            });
+            return jsonResult(data.map((f) => ({
+                filename: f.filename,
+                status: f.status,
+                additions: f.additions,
+                deletions: f.deletions,
+                patch: f.patch?.slice(0, 2000),
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_create_pull_request_review", "Submit a PR review (comment, approve, or request changes).", {
+        owner,
+        repo,
+        pull_number: z.number(),
+        event: z.string().describe("COMMENT | APPROVE | REQUEST_CHANGES"),
+        body: z.string().optional().describe("Review comment"),
+    }, async ({ owner, repo, pull_number, event, body }) => {
+        try {
+            const { data } = await getOctokit().rest.pulls.createReview({
+                owner,
+                repo,
+                pull_number,
+                event: event,
+                body: body ?? undefined,
+            });
+            return jsonResult({
+                id: data.id,
+                state: data.state,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}

package/dist/tools/releases.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerReleaseTools(server: McpServer): void;

package/dist/tools/releases.js

@@ -0,0 +1,146 @@
+import { z } from "zod";
+import { owner, perPage, repo } from "../lib/fields.js";
+import { getOctokit } from "../lib/github.js";
+import { errorResult, jsonResult } from "../lib/response.js";
+export function registerReleaseTools(server) {
+    server.tool("github_list_releases", "List releases for a repository.", {
+        owner,
+        repo,
+        per_page: perPage,
+    }, async ({ owner, repo, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.listReleases({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+            });
+            return jsonResult(data.map((r) => ({
+                id: r.id,
+                tag_name: r.tag_name,
+                name: r.name,
+                draft: r.draft,
+                prerelease: r.prerelease,
+                published_at: r.published_at,
+                html_url: r.html_url,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_get_release_by_tag", "Get a release by tag name.", {
+        owner,
+        repo,
+        tag: z.string().describe("Tag name, e.g. v1.0.0"),
+    }, async ({ owner, repo, tag }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.getReleaseByTag({
+                owner,
+                repo,
+                tag,
+            });
+            return jsonResult({
+                id: data.id,
+                tag_name: data.tag_name,
+                name: data.name,
+                body: data.body,
+                draft: data.draft,
+                prerelease: data.prerelease,
+                html_url: data.html_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_create_release", "Create a GitHub release (optionally from an existing tag).", {
+        owner,
+        repo,
+        tag_name: z.string().describe("Tag for the release, e.g. v1.0.0"),
+        name: z.string().optional().describe("Release title"),
+        body: z.string().optional().describe("Release notes (markdown)"),
+        draft: z.boolean().optional(),
+        prerelease: z.boolean().optional(),
+        target_commitish: z.string().optional().describe("Branch or commit if tag is new"),
+    }, async ({ owner, repo, tag_name, name, body, draft, prerelease, target_commitish }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.createRelease({
+                owner,
+                repo,
+                tag_name,
+                name: name ?? undefined,
+                body: body ?? undefined,
+                draft: draft ?? false,
+                prerelease: prerelease ?? false,
+                target_commitish: target_commitish ?? undefined,
+            });
+            return jsonResult({
+                id: data.id,
+                tag_name: data.tag_name,
+                html_url: data.html_url,
+                upload_url: data.upload_url,
+            });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_list_tags", "List git tags in a repository.", {
+        owner,
+        repo,
+        per_page: perPage,
+    }, async ({ owner, repo, per_page }) => {
+        try {
+            const { data } = await getOctokit().rest.repos.listTags({
+                owner,
+                repo,
+                per_page: per_page ?? 30,
+            });
+            return jsonResult(data.map((t) => ({
+                name: t.name,
+                sha: t.commit.sha,
+            })));
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+    server.tool("github_create_tag", "Create a lightweight or annotated tag ref via the Git API.", {
+        owner,
+        repo,
+        tag: z.string().describe("Tag name, e.g. v1.0.0"),
+        sha: z.string().describe("Commit SHA to tag"),
+        message: z.string().optional().describe("If set, creates an annotated tag object"),
+    }, async ({ owner, repo, tag, sha, message }) => {
+        try {
+            const octokit = getOctokit();
+            if (message) {
+                const { data: tagObj } = await octokit.rest.git.createTag({
+                    owner,
+                    repo,
+                    tag,
+                    message,
+                    object: sha,
+                    type: "commit",
+                });
+                await octokit.rest.git.createRef({
+                    owner,
+                    repo,
+                    ref: `refs/tags/${tag}`,
+                    sha: tagObj.sha,
+                });
+                return jsonResult({ tag, sha: tagObj.sha, annotated: true });
+            }
+            const { data } = await octokit.rest.git.createRef({
+                owner,
+                repo,
+                ref: `refs/tags/${tag}`,
+                sha,
+            });
+            return jsonResult({ ref: data.ref, sha, annotated: false });
+        }
+        catch (e) {
+            return errorResult(e);
+        }
+    });
+}

package/dist/tools/repos.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRepoTools(server: McpServer): void;