feat: add gh_auth_status, actions_runs_filter, labels_sync, check_run_create tools

Author: AlbinoGeek

src/server/actions-runs-filter-tool.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test";
+
+import { registerActionsRunsFilterTool } from "./actions-runs-filter-tool.js";
+import { captureTool } from "./test-harness.js";
+
+describe("actions_runs_filter tool", () => {
+  const run = captureTool(registerActionsRunsFilterTool);
+
+  test("returns error for missing authentication", async () => {
+    const text = await run({
+      owner: "nonexistent",
+      repo: "nonexistent",
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; runs?: unknown[] };
+
+    // May return AUTH_MISSING or runs list depending on environment
+    if (parsed.error) {
+      expect(parsed.error.code).toBeDefined();
+    }
+  });
+
+  test("returns runs list structure when successful", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      limit: 5,
+    });
+    const parsed = JSON.parse(text) as {
+      error?: { code: string };
+      runs?: Array<{
+        id: number;
+        name: string;
+        status: string;
+        conclusion: string | null;
+        branch: string;
+        createdAt: string;
+        url: string;
+      }>;
+    };
+
+    // If no auth error
+    if (!parsed.error || parsed.error.code !== "AUTH_MISSING") {
+      if (parsed.runs !== undefined) {
+        expect(Array.isArray(parsed.runs)).toBe(true);
+        if (parsed.runs.length > 0) {
+          const run = parsed.runs[0];
+          expect(typeof run.id).toBe("number");
+          expect(typeof run.name).toBe("string");
+          expect(typeof run.status).toBe("string");
+          expect(typeof run.createdAt).toBe("string");
+          expect(typeof run.url).toBe("string");
+        }
+      }
+    }
+  });
+
+  test("respects limit parameter", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      limit: 3,
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; runs?: unknown[] };
+
+    if (!parsed.error && parsed.runs) {
+      expect(parsed.runs.length).toBeLessThanOrEqual(3);
+    }
+  });
+
+  test("accepts optional filters", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      status: "completed",
+      limit: 10,
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; runs?: unknown[] };
+
+    if (!parsed.error && parsed.runs) {
+      // Should not throw
+      expect(Array.isArray(parsed.runs)).toBe(true);
+    }
+  });
+
+  test("handles workflow filter", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      workflow: "CI",
+      limit: 5,
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; runs?: unknown[] };
+
+    if (!parsed.error && parsed.runs) {
+      // Workflow filter applied
+      expect(Array.isArray(parsed.runs)).toBe(true);
+    }
+  });
+});

src/server/actions-runs-filter-tool.ts

@@ -0,0 +1,105 @@
+import type { FastMCP } from "fastmcp";
+import { z } from "zod";
+import { classifyError, getOctokit } from "./github-client.js";
+import { errorRespond, jsonRespond } from "./json.js";
+
+export interface WorkflowRun {
+  id: number;
+  name: string;
+  status: string;
+  conclusion: string | null;
+  branch: string;
+  createdAt: string;
+  url: string;
+}
+
+export interface ActionsRunsFilterResult {
+  runs: WorkflowRun[];
+}
+
+export function registerActionsRunsFilterTool(server: FastMCP): void {
+  server.addTool({
+    name: "actions_runs_filter",
+    description:
+      "List and filter GitHub Actions workflow runs for a repository. Filter by workflow name, status, conclusion, and branch.",
+    annotations: { readOnlyHint: true },
+    parameters: z.object({
+      owner: z.string().describe("GitHub owner or organization."),
+      repo: z.string().describe("GitHub repository name."),
+      workflow: z.string().optional().describe("Workflow name or ID to filter by."),
+      status: z
+        .enum(["queued", "in_progress", "completed"])
+        .optional()
+        .describe("Filter by status: queued, in_progress, or completed."),
+      conclusion: z
+        .enum(["success", "failure", "cancelled"])
+        .optional()
+        .describe("Filter by conclusion: success, failure, or cancelled."),
+      branch: z.string().optional().describe("Filter by branch name."),
+      limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .default(20)
+        .describe("Maximum number of runs to return (default 20)."),
+    }),
+    execute: async (args) => {
+      try {
+        const octokit = getOctokit();
+        const { owner, repo, workflow, status, conclusion, branch, limit } = args;
+
+        // Prepare API call parameters with proper types
+        const apiParams: Parameters<typeof octokit.actions.listWorkflowRunsForRepo>[0] = {
+          owner,
+          repo,
+          per_page: Math.min(limit, 100),
+        };
+
+        // Add optional parameters with proper type casting
+        if (status === "queued" || status === "in_progress" || status === "completed") {
+          apiParams.status = status;
+        }
+        if (conclusion === "success" || conclusion === "failure" || conclusion === "cancelled") {
+          apiParams.conclusion = conclusion;
+        }
+        if (branch) {
+          apiParams.head_branch = branch;
+        }
+
+        // List workflow runs
+        const response = await octokit.actions.listWorkflowRunsForRepo(apiParams);
+
+        // Filter by workflow name if provided
+        let runs = response.data.workflow_runs || [];
+        if (workflow) {
+          runs = runs.filter((run) =>
+            (run.name ?? "").toLowerCase().includes(workflow.toLowerCase()),
+          );
+        }
+
+        // Map to output format and limit results
+        const result: ActionsRunsFilterResult = {
+          runs: runs.slice(0, limit).map((run) => ({
+            id: run.id,
+            name: run.name ?? "",
+            status: run.status ?? "",
+            conclusion: run.conclusion,
+            branch: run.head_branch ?? "",
+            createdAt: run.created_at ?? "",
+            url: run.html_url ?? "",
+          })),
+        };
+
+        return jsonRespond(result);
+      } catch (err) {
+        console.error(
+          `[actions_runs_filter] Failed to list workflow runs for ${args.owner}/${args.repo}:`,
+          err instanceof Error ? err.message : String(err),
+        );
+        return errorRespond(classifyError(err));
+      }
+    },
+  });
+}

src/server/check-run-create-tool.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+
+import { registerCheckRunCreateTool } from "./check-run-create-tool.js";
+import { captureTool } from "./test-harness.js";
+
+describe("check_run_create tool", () => {
+  const run = captureTool(registerCheckRunCreateTool);
+
+  test("requires conclusion when status is completed", async () => {
+    const text = await run({
+      owner: "test",
+      repo: "test",
+      name: "Test Check",
+      headSha: "abc123",
+      status: "completed",
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string } };
+
+    // Should return validation error for missing conclusion
+    if (!parsed.error || parsed.error.code !== "AUTH_MISSING") {
+      if (parsed.error) {
+        expect(parsed.error.code).toBe("VALIDATION");
+      }
+    }
+  });
+
+  test("returns error for missing authentication", async () => {
+    const text = await run({
+      owner: "nonexistent",
+      repo: "nonexistent",
+      name: "Test Check",
+      headSha: "abc123",
+      status: "queued",
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string } };
+
+    // May return AUTH_MISSING depending on environment
+    if (parsed.error) {
+      expect(parsed.error.code).toBeDefined();
+    }
+  });
+
+  test("returns check run structure when successful", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      name: "Test Check",
+      headSha: "abc1234567890123456789012345678901234567",
+      status: "queued",
+    });
+    const parsed = JSON.parse(text) as {
+      error?: { code: string };
+      id?: number;
+      url?: string;
+    };
+
+    if (!parsed.error || parsed.error.code !== "AUTH_MISSING") {
+      if (!parsed.error && parsed.id !== undefined) {
+        expect(typeof parsed.id).toBe("number");
+        expect(typeof parsed.url).toBe("string");
+      }
+    }
+  });
+
+  test("accepts optional title and summary", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      name: "Check with Details",
+      headSha: "def1234567890123456789012345678901234567",
+      status: "in_progress",
+      title: "Test Title",
+      summary: "Test summary content",
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; id?: number };
+
+    if (!parsed.error && parsed.id !== undefined) {
+      expect(typeof parsed.id).toBe("number");
+    }
+  });
+
+  test("accepts completed status with conclusion", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      name: "Completed Check",
+      headSha: "ghi1234567890123456789012345678901234567",
+      status: "completed",
+      conclusion: "success",
+      title: "All good",
+      summary: "Check completed successfully",
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; id?: number };
+
+    if (!parsed.error && parsed.id !== undefined) {
+      expect(typeof parsed.id).toBe("number");
+    }
+  });
+
+  test("defaults to queued status", async () => {
+    const text = await run({
+      owner: "Rethunk-AI",
+      repo: "rethunk-github-mcp",
+      name: "Default Status Check",
+      headSha: "jkl1234567890123456789012345678901234567",
+    });
+    const parsed = JSON.parse(text) as { error?: { code: string }; id?: number };
+
+    if (!parsed.error && parsed.id !== undefined) {
+      expect(typeof parsed.id).toBe("number");
+    }
+  });
+});