@cliangdev/flux-plugin 0.2.0 → 0.3.0

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

@@ -0,0 +1,511 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync } 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;
+
+const mockViewer = {
+  id: "viewer-123",
+  name: "Test User",
+  email: "test@example.com",
+};
+const mockTeam = { id: "team-123", name: "Engineering", key: "ENG" };
+const mockTeams = [
+  { id: "team-123", name: "Engineering", key: "ENG" },
+  { id: "team-456", name: "Product", key: "PROD" },
+];
+const mockProject = { id: "proj-123", name: "Flux Project" };
+const mockProjects = [
+  {
+    id: "proj-123",
+    name: "Flux Project",
+    description: "Main project",
+    state: "started",
+    updatedAt: new Date("2024-01-15"),
+  },
+  {
+    id: "proj-456",
+    name: "Another Project",
+    description: null,
+    state: "planned",
+    updatedAt: new Date("2024-01-10"),
+  },
+];
+
+let lastApiKey = "";
+
+mock.module("@linear/sdk", () => ({
+  LinearClient: class MockLinearClient {
+    static ProjectOrderBy = { UpdatedAt: "updatedAt" };
+
+    constructor(config: { apiKey: string }) {
+      lastApiKey = config.apiKey;
+    }
+
+    get viewer() {
+      if (lastApiKey === "invalid-key") {
+        return Promise.reject(new Error("Invalid API key"));
+      }
+      return Promise.resolve(mockViewer);
+    }
+
+    async teams() {
+      return { nodes: mockTeams };
+    }
+
+    async team(teamId: string) {
+      if (teamId === "invalid-team") {
+        return null;
+      }
+      if (teamId === "team-view-fail") {
+        return { id: "team-view-fail", name: "View Fail Team", key: "VF" };
+      }
+      const found = mockTeams.find((t) => t.id === teamId);
+      return found ?? mockTeam;
+    }
+
+    async projects(_options?: any) {
+      return { nodes: mockProjects };
+    }
+
+    async project(projectId: string) {
+      if (projectId === "invalid-project") {
+        return null;
+      }
+      return mockProject;
+    }
+
+    async createProject(input: { name: string; teamIds: string[] }) {
+      return {
+        success: true,
+        project: { id: "new-proj-123", name: input.name },
+      };
+    }
+
+    async issueLabels(_filter: any) {
+      return { nodes: [] };
+    }
+
+    async createIssueLabel(input: { name: string; teamId: string }) {
+      return {
+        success: true,
+        issueLabel: { id: `label-${input.name}`, name: input.name },
+      };
+    }
+
+    async createCustomView(input: { name: string; teamId?: string }) {
+      if (input.teamId === "team-view-fail") {
+        throw new Error("View creation failed");
+      }
+      return {
+        success: true,
+        customView: { id: `view-${input.name}`, name: input.name },
+      };
+    }
+
+    async createViewPreferences(input: {
+      customViewId: string;
+      type: string;
+      viewType: string;
+      preferences: Record<string, unknown>;
+    }) {
+      if (input.customViewId === "view-pref-fail") {
+        throw new Error("View preferences creation failed");
+      }
+      return {
+        success: true,
+        viewPreferences: { id: `pref-${input.customViewId}` },
+      };
+    }
+  },
+}));
+
+import { clearAdapterCache } from "../../adapters/index.js";
+import { config } from "../../config.js";
+import { configureLinearTool } from "../configure-linear.js";
+
+describe("configure_linear MCP Tool", () => {
+  beforeEach(() => {
+    config.clearCache();
+    clearAdapterCache();
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+    delete process.env.LINEAR_API_KEY;
+
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    const projectJsonPath = join(FLUX_DIR, "project.json");
+    const initialProject = {
+      name: "test-project",
+      ref_prefix: "TEST",
+      adapter: { type: "local" },
+    };
+    require("node:fs").writeFileSync(
+      projectJsonPath,
+      JSON.stringify(initialProject, null, 2),
+    );
+  });
+
+  afterEach(() => {
+    clearAdapterCache();
+    config.clearCache();
+    delete process.env.LINEAR_API_KEY;
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("validation", () => {
+    test("throws when no API key source available", async () => {
+      await expect(
+        configureLinearTool.handler({
+          teamId: "team-123",
+          projectName: "Test Project",
+        }),
+      ).rejects.toThrow("Linear API key not found");
+    });
+
+    test("requires teamId in non-interactive mode", async () => {
+      await expect(
+        configureLinearTool.handler({
+          apiKey: "lin_api_test123",
+          projectName: "Test Project",
+        }),
+      ).rejects.toThrow();
+    });
+
+    test("requires projectName or existingProjectId in non-interactive mode", async () => {
+      await expect(
+        configureLinearTool.handler({
+          apiKey: "lin_api_test123",
+          teamId: "team-123",
+        }),
+      ).rejects.toThrow();
+    });
+
+    test("rejects invalid API key", async () => {
+      await expect(
+        configureLinearTool.handler({
+          apiKey: "invalid-key",
+          teamId: "team-123",
+          projectName: "Test Project",
+        }),
+      ).rejects.toThrow("Invalid Linear API key");
+    });
+
+    test("rejects invalid team ID", async () => {
+      await expect(
+        configureLinearTool.handler({
+          apiKey: "lin_api_test123",
+          teamId: "invalid-team",
+          projectName: "Test Project",
+        }),
+      ).rejects.toThrow("Team invalid-team not found");
+    });
+
+    test("rejects invalid existing project ID", async () => {
+      await expect(
+        configureLinearTool.handler({
+          apiKey: "lin_api_test123",
+          teamId: "team-123",
+          existingProjectId: "invalid-project",
+        }),
+      ).rejects.toThrow("Project invalid-project not found");
+    });
+  });
+
+  describe("API key resolution", () => {
+    test("uses API key from input parameter", async () => {
+      const result = (await configureLinearTool.handler({
+        apiKey: "lin_api_from_input",
+        teamId: "team-123",
+        projectName: "Test Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.api_key_source).toBe("input");
+    });
+
+    test("uses API key from environment variable", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_from_env";
+
+      const result = (await configureLinearTool.handler({
+        teamId: "team-123",
+        projectName: "Test Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.api_key_source).toBe("environment");
+    });
+
+    test("uses API key from existing config file", async () => {
+      const configPath = join(FLUX_DIR, "linear-config.json");
+      require("node:fs").writeFileSync(
+        configPath,
+        JSON.stringify({ apiKey: "lin_api_from_config" }),
+      );
+
+      const result = (await configureLinearTool.handler({
+        teamId: "team-123",
+        projectName: "Test Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.api_key_source).toBe("config");
+    });
+
+    test("input parameter takes priority over environment variable", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_from_env";
+
+      const result = (await configureLinearTool.handler({
+        apiKey: "lin_api_from_input",
+        teamId: "team-123",
+        projectName: "Test Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.api_key_source).toBe("input");
+    });
+
+    test("environment variable takes priority over config file", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_from_env";
+      const configPath = join(FLUX_DIR, "linear-config.json");
+      require("node:fs").writeFileSync(
+        configPath,
+        JSON.stringify({ apiKey: "lin_api_from_config" }),
+      );
+
+      const result = (await configureLinearTool.handler({
+        teamId: "team-123",
+        projectName: "Test Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.api_key_source).toBe("environment");
+    });
+  });
+
+  describe("config storage", () => {
+    test("saves config to .flux/linear-config.json with projectId", async () => {
+      await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        projectName: "Test Project",
+      });
+
+      const configPath = join(FLUX_DIR, "linear-config.json");
+      expect(existsSync(configPath)).toBe(true);
+
+      const savedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+      expect(savedConfig.apiKey).toBe("lin_api_test123");
+      expect(savedConfig.teamId).toBe("team-123");
+      expect(savedConfig.projectId).toBeDefined();
+      expect(savedConfig.defaultLabels.prd).toBe("prd");
+      expect(savedConfig.defaultLabels.epic).toBe("epic");
+      expect(savedConfig.defaultLabels.task).toBe("task");
+    });
+
+    test("saves custom labels", async () => {
+      await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        projectName: "Test Project",
+        prdLabel: "product-requirement",
+        epicLabel: "feature",
+        taskLabel: "sub-task",
+      });
+
+      const configPath = join(FLUX_DIR, "linear-config.json");
+      const savedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+      expect(savedConfig.defaultLabels.prd).toBe("product-requirement");
+      expect(savedConfig.defaultLabels.epic).toBe("feature");
+      expect(savedConfig.defaultLabels.task).toBe("sub-task");
+    });
+
+    test("uses existing project when existingProjectId provided", async () => {
+      await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        existingProjectId: "proj-123",
+      });
+
+      const configPath = join(FLUX_DIR, "linear-config.json");
+      const savedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+      expect(savedConfig.projectId).toBe("proj-123");
+    });
+  });
+
+  describe("project.json update", () => {
+    test("updates adapter.type to linear", async () => {
+      const projectJsonPath = join(FLUX_DIR, "project.json");
+
+      await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        projectName: "Test Project",
+      });
+
+      const updatedProject = JSON.parse(readFileSync(projectJsonPath, "utf-8"));
+      expect(updatedProject.adapter.type).toBe("linear");
+    });
+  });
+
+  describe("response", () => {
+    test("returns success with team and project info", async () => {
+      const result = (await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        projectName: "My Flux Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.message).toBe("Linear integration configured successfully");
+      expect(result.team).toBe("Engineering");
+      expect(result.project).toBeDefined();
+      expect(result.project.name).toBe("My Flux Project");
+      expect(result.labels).toBeDefined();
+      expect(result.labels.prd).toBeDefined();
+      expect(result.labels.epic).toBeDefined();
+      expect(result.labels.task).toBeDefined();
+    });
+  });
+
+  describe("adapter cache", () => {
+    test("clears adapter cache after config change", async () => {
+      await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        projectName: "Test Project",
+      });
+
+      const configPath = join(FLUX_DIR, "linear-config.json");
+      expect(existsSync(configPath)).toBe(true);
+    });
+  });
+
+  describe("view creation", () => {
+    test("creates Flux view for new project", async () => {
+      const result = (await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        projectName: "New Flux Project",
+      })) as any;
+
+      expect(result.view).toBeDefined();
+      expect(result.view.created).toBe("Flux: New Flux Project");
+      expect(result.view.setup_hint).toContain("Parent issue");
+      expect(result.view.skipped).toBeUndefined();
+    });
+
+    test("skips view creation for existing project", async () => {
+      const result = (await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-123",
+        existingProjectId: "proj-123",
+      })) as any;
+
+      expect(result.view).toBeDefined();
+      expect(result.view.created).toBeNull();
+      expect(result.view.skipped).toBe(true);
+    });
+
+    test("succeeds even if view creation fails", async () => {
+      const result = (await configureLinearTool.handler({
+        apiKey: "lin_api_test123",
+        teamId: "team-view-fail",
+        projectName: "Test Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.message).toBe("Linear integration configured successfully");
+      expect(result.view).toBeDefined();
+      expect(result.view.created).toBeNull();
+      expect(result.view.error).toBe("View creation failed");
+    });
+  });
+
+  describe("interactive mode", () => {
+    test("returns teams list when interactive with no teamId", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_test123";
+
+      const result = (await configureLinearTool.handler({
+        interactive: true,
+      })) as any;
+
+      expect(result.step).toBe("select_team");
+      expect(result.user).toBeDefined();
+      expect(result.user.name).toBe("Test User");
+      expect(result.user.email).toBe("test@example.com");
+      expect(result.api_key_source).toBe("environment");
+      expect(result.teams).toBeDefined();
+      expect(result.teams).toHaveLength(2);
+      expect(result.teams[0].id).toBe("team-123");
+      expect(result.teams[0].name).toBe("Engineering");
+      expect(result.teams[0].key).toBe("ENG");
+      expect(result.teams[1].id).toBe("team-456");
+      expect(result.teams[1].name).toBe("Product");
+    });
+
+    test("returns projects list when interactive with teamId but no project", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_test123";
+
+      const result = (await configureLinearTool.handler({
+        interactive: true,
+        teamId: "team-123",
+      })) as any;
+
+      expect(result.step).toBe("select_project");
+      expect(result.user).toBeDefined();
+      expect(result.user.name).toBe("Test User");
+      expect(result.team).toBeDefined();
+      expect(result.team.id).toBe("team-123");
+      expect(result.team.name).toBe("Engineering");
+      expect(result.team.key).toBe("ENG");
+      expect(result.projects).toBeDefined();
+      expect(result.projects).toHaveLength(2);
+      expect(result.projects[0].id).toBe("proj-123");
+      expect(result.projects[0].name).toBe("Flux Project");
+      expect(result.projects[0].description).toBe("Main project");
+      expect(result.projects[1].id).toBe("proj-456");
+    });
+
+    test("validates team exists in interactive project selection", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_test123";
+
+      await expect(
+        configureLinearTool.handler({
+          interactive: true,
+          teamId: "invalid-team",
+        }),
+      ).rejects.toThrow("Team invalid-team not found");
+    });
+
+    test("proceeds to configuration when interactive with full params", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_test123";
+
+      const result = (await configureLinearTool.handler({
+        interactive: true,
+        teamId: "team-123",
+        existingProjectId: "proj-123",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.message).toBe("Linear integration configured successfully");
+      expect(result.step).toBeUndefined();
+    });
+
+    test("allows new project creation in interactive mode", async () => {
+      process.env.LINEAR_API_KEY = "lin_api_test123";
+
+      const result = (await configureLinearTool.handler({
+        interactive: true,
+        teamId: "team-123",
+        projectName: "New Interactive Project",
+      })) as any;
+
+      expect(result.success).toBe(true);
+      expect(result.project.name).toBe("New Interactive Project");
+    });
+  });
+});

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

@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Set up test environment BEFORE any imports
+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;
+
+// Now import modules
+import { clearAdapterCache, getAdapter } from "../../adapters/index.js";
+import { config } from "../../config.js";
+import { getLinearUrlTool } from "../get-linear-url.js";
+
+describe("get_linear_url MCP Tool", () => {
+  beforeEach(() => {
+    config.clearCache();
+    clearAdapterCache();
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    // Create Linear config
+    const linearConfig = {
+      apiKey: "lin_api_test",
+      teamId: "team_123",
+      projectId: "proj_123",
+      defaultLabels: {
+        prd: "prd",
+        epic: "epic",
+        task: "task",
+      },
+    };
+
+    writeFileSync(
+      join(FLUX_DIR, "linear-config.json"),
+      JSON.stringify(linearConfig),
+    );
+  });
+
+  afterEach(() => {
+    clearAdapterCache();
+    config.clearCache();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  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) => ({
+      url: "https://linear.app/myteam/project/my-project-abc123",
+      type: "project",
+      name: "My Project",
+    }));
+
+    const result = (await getLinearUrlTool.handler({
+      ref: "proj_abc123",
+    })) as any;
+
+    expect(result.url).toBe(
+      "https://linear.app/myteam/project/my-project-abc123",
+    );
+    expect(result.type).toBe("project");
+    expect(result.name).toBe("My Project");
+  });
+
+  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) => ({
+      url: "https://linear.app/myteam/issue/ENG-42",
+      type: "issue",
+      identifier: "ENG-42",
+    }));
+
+    const result = (await getLinearUrlTool.handler({
+      ref: "ENG-42",
+    })) as any;
+
+    expect(result.url).toBe("https://linear.app/myteam/issue/ENG-42");
+    expect(result.type).toBe("issue");
+    expect(result.identifier).toBe("ENG-42");
+  });
+
+  test("throws error if Linear not configured", async () => {
+    // Remove Linear config
+    rmSync(join(FLUX_DIR, "linear-config.json"));
+    clearAdapterCache();
+
+    try {
+      await getLinearUrlTool.handler({ ref: "ENG-42" });
+      expect(true).toBe(false); // Should not reach here
+    } catch (err) {
+      expect((err as Error).message).toContain("Linear not configured");
+    }
+  });
+
+  test("throws error if ref is empty", async () => {
+    try {
+      await getLinearUrlTool.handler({ ref: "" });
+      expect(true).toBe(false); // Should not reach here
+    } catch (err) {
+      expect((err as Error).message).toContain("Entity ref is required");
+    }
+  });
+});