@cliangdev/flux-plugin 0.3.0 → 0.3.1-dev.bdbaeae

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

@@ -0,0 +1,509 @@
+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 {
+    constructor(_opts: { auth: string }) {}
+
+    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 },
+              },
+            };
+          }
+          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 () => {
+      await expect(
+        configureGithubTool.handler({
+          owner: "testowner",
+          repo: "flux-tracking",
+        }),
+      ).rejects.toThrow();
+    });
+
+    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-init-project.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const TEST_DIR = `/tmp/flux-init-test-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const FLUX_DIR = join(TEST_DIR, ".flux");
+process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+import { config } from "../../config.js";
+import { closeDb } from "../../db/index.js";
+import { initProjectTool } from "../init-project.js";
+
+describe("init_project", () => {
+  beforeEach(() => {
+    closeDb();
+    config.clearCache();
+    if (existsSync(FLUX_DIR)) {
+      rmSync(FLUX_DIR, { recursive: true, force: true });
+    }
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    closeDb();
+    config.clearCache();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("local adapter", () => {
+    test("creates .flux directory and project.json", async () => {
+      await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "local",
+      });
+
+      expect(existsSync(FLUX_DIR)).toBe(true);
+      expect(existsSync(join(FLUX_DIR, "project.json"))).toBe(true);
+    });
+
+    test("initializes SQLite database for local adapter", async () => {
+      await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "local",
+      });
+
+      expect(existsSync(join(FLUX_DIR, "flux.db"))).toBe(true);
+    });
+
+    test("returns planning message for local adapter", async () => {
+      const result = (await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain("/flux:prd");
+    });
+  });
+
+  describe("github adapter", () => {
+    test("creates .flux directory and project.json", async () => {
+      await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "github",
+      });
+
+      expect(existsSync(FLUX_DIR)).toBe(true);
+      expect(existsSync(join(FLUX_DIR, "project.json"))).toBe(true);
+    });
+
+    test("does not create SQLite database for github adapter", async () => {
+      await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "github",
+      });
+
+      expect(existsSync(join(FLUX_DIR, "flux.db"))).toBe(false);
+    });
+
+    test("project.json records adapter type as github", async () => {
+      const result = (await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "github",
+      })) as any;
+
+      expect(result.project.adapter.type).toBe("github");
+    });
+
+    test("returns configure_github next-step message", async () => {
+      const result = (await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "github",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.message).toContain("configure_github");
+    });
+
+    test("fails if project already initialized", async () => {
+      await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "github",
+      });
+
+      await expect(
+        initProjectTool.handler({
+          name: "Test Project",
+          vision: "Test vision",
+          adapter: "github",
+        }),
+      ).rejects.toThrow(/already initialized/i);
+    });
+  });
+
+  describe("linear adapter", () => {
+    test("does not create SQLite database for linear adapter", async () => {
+      await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "linear",
+      });
+
+      expect(existsSync(join(FLUX_DIR, "flux.db"))).toBe(false);
+    });
+
+    test("returns configure_linear next-step message", async () => {
+      const result = (await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+        adapter: "linear",
+      })) as any;
+
+      expect(result.message).toContain("configure_linear");
+    });
+  });
+
+  describe("input validation", () => {
+    test("rejects missing name", async () => {
+      await expect(
+        initProjectTool.handler({ vision: "Test vision" }),
+      ).rejects.toThrow();
+    });
+
+    test("rejects missing vision", async () => {
+      await expect(
+        initProjectTool.handler({ name: "Test Project" }),
+      ).rejects.toThrow();
+    });
+
+    test("defaults to local adapter when not specified", async () => {
+      const result = (await initProjectTool.handler({
+        name: "Test Project",
+        vision: "Test vision",
+      })) as any;
+
+      expect(result.project.adapter.type).toBe("local");
+    });
+  });
+});