@cliangdev/flux-plugin 0.3.1 → 0.4.0-dev.38b2bd1

package/src/server/tools/__tests__/z-configure-github.test.ts

@@ -0,0 +1,560 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+const TEST_DIR = `/tmp/flux-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const FLUX_DIR = join(TEST_DIR, ".flux");
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+let mockTokenValid = true;
+let mockRepoExists = false;
+let mockRemoteConfigExists = false;
+let mockRemoteConfig: Record<string, unknown> | null = null;
+let mockExistingLabels: string[] = [];
+let mockProjectId = "PVT_kwDOtest123";
+let mockProjectUrl = "https://github.com/orgs/testowner/projects/1";
+let mockOwnerId = "U_kgDOtest123";
+let createdLabels: string[] = [];
+let repoCreated = false;
+let configCommitted = false;
+
+mock.module("@octokit/rest", () => ({
+  Octokit: class MockOctokit {
+    users = {
+      getAuthenticated: async () => {
+        if (!mockTokenValid) {
+          const err: any = new Error("Bad credentials");
+          err.status = 401;
+          throw err;
+        }
+        return { data: { login: "testowner", id: 123456 } };
+      },
+    };
+
+    repos = {
+      get: async (_opts: { owner: string; repo: string }) => {
+        if (!mockRepoExists) {
+          const err: any = new Error("Not Found");
+          err.status = 404;
+          throw err;
+        }
+        return {
+          data: { html_url: `https://github.com/${_opts.owner}/${_opts.repo}` },
+        };
+      },
+      createForAuthenticatedUser: async (opts: {
+        name: string;
+        private: boolean;
+        auto_init: boolean;
+      }) => {
+        repoCreated = true;
+        return {
+          data: { html_url: `https://github.com/testowner/${opts.name}` },
+        };
+      },
+    };
+
+    issues = {
+      listLabelsForRepo: async (_opts: { owner: string; repo: string }) => {
+        return {
+          data: mockExistingLabels.map((name) => ({ name, color: "000000" })),
+        };
+      },
+      createLabel: async (opts: {
+        owner: string;
+        repo: string;
+        name: string;
+        color: string;
+      }) => {
+        createdLabels.push(opts.name);
+        return { data: { name: opts.name, color: opts.color } };
+      },
+    };
+
+    repos_getContent = {};
+
+    request = async (route: string, _opts: any) => {
+      if (route === "GET /repos/{owner}/{repo}/contents/{path}") {
+        if (!mockRemoteConfigExists) {
+          const err: any = new Error("Not Found");
+          err.status = 404;
+          throw err;
+        }
+        const content = Buffer.from(JSON.stringify(mockRemoteConfig)).toString(
+          "base64",
+        );
+        return { data: { content, encoding: "base64" } };
+      }
+      if (route === "PUT /repos/{owner}/{repo}/contents/{path}") {
+        configCommitted = true;
+        return { data: { content: { sha: "abc123" } } };
+      }
+      throw new Error(`Unhandled route: ${route}`);
+    };
+  },
+}));
+
+mock.module("@octokit/graphql", () => ({
+  graphql: Object.assign(
+    async (_query: string, _vars: any) => {
+      throw new Error("Use graphql.defaults instead");
+    },
+    {
+      defaults: (_opts: any) => {
+        return async (query: string, _vars: any) => {
+          if (query.includes("GetOwnerId")) {
+            return { user: { id: mockOwnerId } };
+          }
+          if (query.includes("CreateProject")) {
+            return {
+              createProjectV2: {
+                projectV2: { id: mockProjectId, url: mockProjectUrl },
+              },
+            };
+          }
+          if (query.includes("GetRepoId")) {
+            return { repository: { id: "REPO_NODE_ID" } };
+          }
+          if (query.includes("LinkProject")) {
+            return {
+              linkProjectV2ToRepository: { repository: { id: "REPO_NODE_ID" } },
+            };
+          }
+          if (query.includes("GetProjectFields")) {
+            return {
+              node: {
+                fields: {
+                  nodes: [
+                    {
+                      id: "PVTSSF_STATUS",
+                      name: "Status",
+                      options: [
+                        { id: "OPT_TODO", name: "Todo" },
+                        { id: "OPT_INPROGRESS", name: "In Progress" },
+                        { id: "OPT_DONE", name: "Done" },
+                      ],
+                    },
+                  ],
+                },
+              },
+            };
+          }
+          if (
+            query.includes("UpdateStatusOptions") ||
+            query.includes("updateProjectV2Field")
+          ) {
+            return {
+              updateProjectV2Field: {
+                projectV2Field: {
+                  options: [
+                    { id: "OPT_DRAFT", name: "Draft" },
+                    { id: "OPT_PENDING_REVIEW", name: "Pending Review" },
+                    { id: "OPT_REVIEWED", name: "Reviewed" },
+                    { id: "OPT_APPROVED", name: "Approved" },
+                    { id: "OPT_BREAKDOWN_READY", name: "Breakdown Ready" },
+                    { id: "OPT_IN_PROGRESS", name: "In Progress" },
+                    { id: "OPT_COMPLETED", name: "Completed" },
+                  ],
+                },
+              },
+            };
+          }
+          throw new Error(`Unhandled GraphQL query: ${query}`);
+        };
+      },
+    },
+  ),
+}));
+
+import { clearAdapterCache } from "../../adapters/index.js";
+import { config } from "../../config.js";
+import { configureGithubTool } from "../configure-github.js";
+
+describe("configure_github MCP Tool", () => {
+  beforeEach(() => {
+    config.clearCache();
+    clearAdapterCache();
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    mockTokenValid = true;
+    mockRepoExists = false;
+    mockRemoteConfigExists = false;
+    mockRemoteConfig = null;
+    mockExistingLabels = [];
+    mockProjectId = "PVT_kwDOtest123";
+    mockProjectUrl = "https://github.com/orgs/testowner/projects/1";
+    mockOwnerId = "U_kgDOtest123";
+    createdLabels = [];
+    repoCreated = false;
+    configCommitted = false;
+
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    const projectJsonPath = join(FLUX_DIR, "project.json");
+    const initialProject = {
+      name: "test-project",
+      ref_prefix: "TEST",
+      adapter: { type: "local" },
+    };
+    writeFileSync(projectJsonPath, JSON.stringify(initialProject, null, 2));
+  });
+
+  afterEach(() => {
+    clearAdapterCache();
+    config.clearCache();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("input validation", () => {
+    test("rejects missing token", async () => {
+      const saved = process.env.FLUX_GITHUB_TOKEN;
+      delete process.env.FLUX_GITHUB_TOKEN;
+      try {
+        await expect(
+          configureGithubTool.handler({
+            owner: "testowner",
+            repo: "flux-tracking",
+          }),
+        ).rejects.toThrow();
+      } finally {
+        if (saved !== undefined) process.env.FLUX_GITHUB_TOKEN = saved;
+      }
+    });
+
+    test("rejects missing owner", async () => {
+      await expect(
+        configureGithubTool.handler({
+          token: "ghp_test123",
+          repo: "flux-tracking",
+        }),
+      ).rejects.toThrow();
+    });
+
+    test("rejects missing repo", async () => {
+      await expect(
+        configureGithubTool.handler({
+          token: "ghp_test123",
+          owner: "testowner",
+        }),
+      ).rejects.toThrow();
+    });
+
+    test("visibility defaults to private when omitted", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBeDefined();
+    });
+  });
+
+  describe("token validation", () => {
+    test("returns descriptive error when PAT validation fails", async () => {
+      mockTokenValid = false;
+
+      await expect(
+        configureGithubTool.handler({
+          token: "ghp_invalid",
+          owner: "testowner",
+          repo: "flux-tracking",
+        }),
+      ).rejects.toThrow(/token|credentials|auth/i);
+    });
+  });
+
+  describe("mode detection", () => {
+    test("returns mode: setup when neither local config nor remote config exists", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("setup");
+    });
+
+    test("returns mode: join when remote .flux/github-config.json is readable", async () => {
+      mockRemoteConfigExists = true;
+      mockRemoteConfig = {
+        owner: "testowner",
+        repo: "flux-tracking",
+        projectId: "PVT_kwDOremote123",
+        refPrefix: "FLUX",
+      };
+
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("join");
+    });
+
+    test("returns mode: update when local project.json already has github adapter config", async () => {
+      const projectJsonPath = join(FLUX_DIR, "project.json");
+      const existingProject = {
+        name: "test-project",
+        ref_prefix: "FLUX",
+        adapter: {
+          type: "github",
+          config: {
+            token: "ghp_old_token",
+            owner: "testowner",
+            repo: "flux-tracking",
+            projectId: "PVT_kwDOtest123",
+            refPrefix: "FLUX",
+          },
+        },
+      };
+      writeFileSync(projectJsonPath, JSON.stringify(existingProject, null, 2));
+
+      const result = (await configureGithubTool.handler({
+        token: "ghp_new_token",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("update");
+    });
+
+    test("returns mode: setup when project.json has adapter type github but no config (partial init)", async () => {
+      const projectJsonPath = join(FLUX_DIR, "project.json");
+      const partialProject = {
+        name: "test-project",
+        ref_prefix: "FLUX",
+        adapter: { type: "github" },
+      };
+      writeFileSync(projectJsonPath, JSON.stringify(partialProject, null, 2));
+
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("setup");
+    });
+  });
+
+  describe("setup mode", () => {
+    test("skips repo creation if repo already exists", async () => {
+      mockRepoExists = true;
+
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("setup");
+      expect(repoCreated).toBe(false);
+    });
+
+    test("creates repo when it does not exist", async () => {
+      mockRepoExists = false;
+
+      await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      });
+
+      expect(repoCreated).toBe(true);
+    });
+
+    test("skips label creation for labels that already exist", async () => {
+      mockExistingLabels = ["flux:prd", "flux:epic", "flux:task"];
+
+      await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      });
+
+      expect(createdLabels).not.toContain("flux:prd");
+      expect(createdLabels).not.toContain("flux:epic");
+      expect(createdLabels).not.toContain("flux:task");
+    });
+
+    test("creates only missing labels", async () => {
+      mockExistingLabels = ["flux:prd"];
+      mockRepoExists = true;
+
+      await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      });
+
+      expect(createdLabels).not.toContain("flux:prd");
+      expect(createdLabels).toContain("flux:epic");
+      expect(createdLabels).toContain("flux:task");
+    });
+
+    test("commits .flux/github-config.json with required fields", async () => {
+      await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      });
+
+      expect(configCommitted).toBe(true);
+    });
+
+    test("returns board_url, repo_url, labels_created, mode: setup", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("setup");
+      expect(result.board_url).toBeDefined();
+      expect(result.repo_url).toBeDefined();
+      expect(typeof result.labels_created).toBe("number");
+    });
+  });
+
+  describe("join mode", () => {
+    beforeEach(() => {
+      mockRemoteConfigExists = true;
+      mockRemoteConfig = {
+        owner: "testowner",
+        repo: "flux-tracking",
+        projectId: "PVT_kwDOremote123",
+        refPrefix: "FLUX",
+      };
+    });
+
+    test("reads remote config and writes correct local project.json", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("join");
+
+      const projectJsonPath = join(FLUX_DIR, "project.json");
+      const saved = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+      expect(saved.adapter.type).toBe("github");
+      expect(saved.adapter.config.token).toBe("ghp_test123");
+      expect(saved.adapter.config.projectId).toBe("PVT_kwDOremote123");
+      expect(saved.adapter.config.refPrefix).toBe("FLUX");
+    });
+
+    test("does not trigger label or board creation in join mode", async () => {
+      await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      });
+
+      expect(createdLabels).toHaveLength(0);
+      expect(configCommitted).toBe(false);
+    });
+
+    test("returns mode: join with labels_created: 0", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("join");
+      expect(result.labels_created).toBe(0);
+      expect(result.repo_url).toBeDefined();
+    });
+
+    test("returns error with collaborator instructions when remote config is 404", async () => {
+      mockRemoteConfigExists = false;
+      mockRemoteConfig = null;
+
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("setup");
+    });
+  });
+
+  describe("update mode (token rotation)", () => {
+    beforeEach(() => {
+      const projectJsonPath = join(FLUX_DIR, "project.json");
+      const existingProject = {
+        name: "test-project",
+        ref_prefix: "FLUX",
+        adapter: {
+          type: "github",
+          config: {
+            token: "ghp_old_token",
+            owner: "testowner",
+            repo: "flux-tracking",
+            projectId: "PVT_kwDOtest123",
+            refPrefix: "FLUX",
+          },
+        },
+      };
+      writeFileSync(projectJsonPath, JSON.stringify(existingProject, null, 2));
+    });
+
+    test("updates only the token field, leaves other fields unchanged", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_new_token",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("update");
+
+      const projectJsonPath = join(FLUX_DIR, "project.json");
+      const saved = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+      expect(saved.adapter.config.token).toBe("ghp_new_token");
+      expect(saved.adapter.config.projectId).toBe("PVT_kwDOtest123");
+      expect(saved.adapter.config.refPrefix).toBe("FLUX");
+    });
+
+    test("returns mode: update with labels_created: 0", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_new_token",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result.mode).toBe("update");
+      expect(result.labels_created).toBe(0);
+    });
+  });
+
+  describe("response shape", () => {
+    test("contains board_url, repo_url, labels_created, mode in setup", async () => {
+      const result = (await configureGithubTool.handler({
+        token: "ghp_test123",
+        owner: "testowner",
+        repo: "flux-tracking",
+      })) as any;
+
+      expect(result).toHaveProperty("board_url");
+      expect(result).toHaveProperty("repo_url");
+      expect(result).toHaveProperty("labels_created");
+      expect(result).toHaveProperty("mode");
+    });
+
+    test("tool appears with correct name", () => {
+      expect(configureGithubTool.name).toBe("configure_github");
+    });
+  });
+});

package/src/server/tools/__tests__/z-get-linear-url.test.ts

@@ -49,7 +49,7 @@ describe("get_linear_url MCP Tool", () => {
   test("returns URL for project ref", async () => {
     // Get the adapter and mock its getLinearUrl method
     const adapter = getAdapter() as any;
-    adapter.getLinearUrl = mock(async (ref: string) => ({
+    adapter.getLinearUrl = mock(async (_ref: string) => ({
       url: "https://linear.app/myteam/project/my-project-abc123",
       type: "project",
       name: "My Project",
@@ -69,7 +69,7 @@ describe("get_linear_url MCP Tool", () => {
   test("returns URL for issue identifier", async () => {
     // Get the adapter and mock its getLinearUrl method
     const adapter = getAdapter() as any;
-    adapter.getLinearUrl = mock(async (ref: string) => ({
+    adapter.getLinearUrl = mock(async (_ref: string) => ({
       url: "https://linear.app/myteam/issue/ENG-42",
       type: "issue",
       identifier: "ENG-42",