@cliangdev/flux-plugin 0.1.0 → 0.2.0-dev.2b9c207

package/src/__tests__/version.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+describe("version module", () => {
+  test("VERSION is exported from src/version.ts", async () => {
+    // Dynamic import to get the VERSION constant
+    const versionModule = await import("../version.js");
+
+    expect(versionModule.VERSION).toBeDefined();
+    expect(typeof versionModule.VERSION).toBe("string");
+  });
+
+  test("VERSION equals package.json version", async () => {
+    // Read package.json version
+    const packageJsonPath = join(process.cwd(), "package.json");
+    expect(existsSync(packageJsonPath)).toBe(true);
+
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const packageVersion = packageJson.version;
+
+    expect(packageVersion).toBeDefined();
+    expect(typeof packageVersion).toBe("string");
+
+    // Import VERSION and compare
+    const versionModule = await import("../version.js");
+    expect(versionModule.VERSION).toBe(packageVersion);
+  });
+
+  test("VERSION is a valid semver format", async () => {
+    const versionModule = await import("../version.js");
+
+    // Basic semver format check (e.g., "0.1.0", "1.2.3-beta.1")
+    const semverPattern = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+    expect(semverPattern.test(versionModule.VERSION)).toBe(true);
+  });
+});

package/src/server/__tests__/config.test.ts

@@ -0,0 +1,163 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+
+describe("config", () => {
+  const originalEnv = process.env.FLUX_PROJECT_ROOT;
+  const originalCwd = process.cwd();
+  // Use os.tmpdir() to get the real temp path (handles /tmp -> /private/tmp on macOS)
+  const TEST_DIR = `${realpathSync(tmpdir())}/flux-config-test-${Date.now()}`;
+  const NESTED_DIR = `${TEST_DIR}/subdir/nested`;
+
+  beforeEach(async () => {
+    // Clean up any previous test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+
+    // Create test directory structure
+    mkdirSync(NESTED_DIR, { recursive: true });
+
+    // Clear the config cache before each test
+    const { config } = await import("../config.js");
+    config.clearCache();
+  });
+
+  afterEach(async () => {
+    // Restore original env
+    if (originalEnv !== undefined) {
+      process.env.FLUX_PROJECT_ROOT = originalEnv;
+    } else {
+      delete process.env.FLUX_PROJECT_ROOT;
+    }
+
+    // Restore original cwd
+    process.chdir(originalCwd);
+
+    // Clear the config cache
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test("uses env var when properly set", async () => {
+    process.env.FLUX_PROJECT_ROOT = "/some/valid/path";
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    expect(config.projectRoot).toBe("/some/valid/path");
+  });
+
+  test("ignores unresolved template variable and walks up directories", async () => {
+    // Create a .flux folder at TEST_DIR
+    mkdirSync(`${TEST_DIR}/.flux`, { recursive: true });
+    writeFileSync(
+      `${TEST_DIR}/.flux/project.json`,
+      JSON.stringify({ name: "test" }),
+    );
+
+    // Simulate Claude Code passing unresolved template variable
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: intentionally testing literal template string
+    process.env.FLUX_PROJECT_ROOT = "${CLAUDE_PROJECT_DIR}";
+
+    // Change to nested directory
+    process.chdir(NESTED_DIR);
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    // Should walk up and find TEST_DIR, not use the literal "${CLAUDE_PROJECT_DIR}"
+    expect(config.projectRoot).not.toContain("${");
+    expect(config.projectRoot).toBe(TEST_DIR);
+  });
+
+  test("walks up directories to find .flux folder", async () => {
+    // Create a .flux folder at TEST_DIR (parent of NESTED_DIR)
+    mkdirSync(`${TEST_DIR}/.flux`, { recursive: true });
+    writeFileSync(
+      `${TEST_DIR}/.flux/project.json`,
+      JSON.stringify({ name: "test" }),
+    );
+
+    // No env var set
+    delete process.env.FLUX_PROJECT_ROOT;
+
+    // Change to nested directory
+    process.chdir(NESTED_DIR);
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    // Should walk up and find TEST_DIR
+    expect(config.projectRoot).toBe(TEST_DIR);
+  });
+
+  test("falls back to cwd when no .flux folder found", async () => {
+    // No .flux folder anywhere in TEST_DIR hierarchy
+    // No env var set
+    delete process.env.FLUX_PROJECT_ROOT;
+
+    // Change to test directory (which has no .flux)
+    process.chdir(TEST_DIR);
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    // Should fall back to cwd
+    expect(config.projectRoot).toBe(TEST_DIR);
+  });
+
+  test("projectExists returns true when project.json exists", async () => {
+    mkdirSync(`${TEST_DIR}/.flux`, { recursive: true });
+    writeFileSync(
+      `${TEST_DIR}/.flux/project.json`,
+      JSON.stringify({ name: "test" }),
+    );
+
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    expect(config.projectExists).toBe(true);
+  });
+
+  test("projectExists returns false when project.json does not exist", async () => {
+    // No .flux folder
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    expect(config.projectExists).toBe(false);
+  });
+
+  test("caches project root for performance", async () => {
+    process.env.FLUX_PROJECT_ROOT = "/first/path";
+
+    const { config } = await import("../config.js");
+    config.clearCache();
+
+    // First call caches the value
+    expect(config.projectRoot).toBe("/first/path");
+
+    // Changing env var should not affect cached value
+    process.env.FLUX_PROJECT_ROOT = "/second/path";
+    expect(config.projectRoot).toBe("/first/path");
+
+    // After clearing cache, should use new env var
+    config.clearCache();
+    expect(config.projectRoot).toBe("/second/path");
+  });
+});

package/src/server/adapters/__tests__/a-client-linear.test.ts

@@ -0,0 +1,197 @@
+import { describe, expect, test } from "bun:test";
+import { LinearApiError, LinearClient } from "../linear/client.js";
+
+const config = {
+  apiKey: "lin_api_test123",
+  teamId: "TEAM-123",
+  projectId: "proj_container",
+  defaultLabels: { prd: "prd", epic: "epic", task: "task" },
+};
+
+describe("LinearClient", () => {
+  describe("constructor", () => {
+    test("creates client with valid config", () => {
+      const client = new LinearClient(config);
+
+      expect(client).toBeDefined();
+      expect(client.client).toBeDefined();
+    });
+
+    test("accepts custom retry options", () => {
+      const client = new LinearClient(config, {
+        maxRetries: 5,
+        baseDelay: 500,
+      });
+
+      expect(client).toBeDefined();
+    });
+  });
+
+  describe("execute - retry logic", () => {
+    test("returns result on successful operation", async () => {
+      const client = new LinearClient(config);
+      let callCount = 0;
+      const operation = () => {
+        callCount++;
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      expect(result).toEqual({ data: "success" });
+      expect(callCount).toBe(1);
+    });
+
+    test("retries on network error and succeeds", async () => {
+      const client = new LinearClient(config, { maxRetries: 3, baseDelay: 10 });
+      let attempts = 0;
+      const operation = () => {
+        attempts++;
+        if (attempts < 3) {
+          const error: any = new Error("Network error");
+          error.code = "ECONNRESET";
+          return Promise.reject(error);
+        }
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      expect(result).toEqual({ data: "success" });
+      expect(attempts).toBe(3);
+    });
+
+    test("retries on rate limit error (429) and succeeds", async () => {
+      const client = new LinearClient(config, { maxRetries: 3, baseDelay: 10 });
+      let attempts = 0;
+      const operation = () => {
+        attempts++;
+        if (attempts < 2) {
+          const error: any = new Error("Rate limited");
+          error.status = 429;
+          return Promise.reject(error);
+        }
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      expect(result).toEqual({ data: "success" });
+      expect(attempts).toBe(2);
+    });
+
+    test("throws LinearApiError after max retries exhausted (rate limit)", async () => {
+      const client = new LinearClient(config, { maxRetries: 2, baseDelay: 10 });
+      const operation = () => {
+        const error: any = new Error("Rate limited");
+        error.status = 429;
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      await expect(client.execute(operation)).rejects.toThrow(
+        "Rate limited after 2 retries",
+      );
+    });
+
+    test("throws LinearApiError after max retries exhausted (network error)", async () => {
+      const client = new LinearClient(config, { maxRetries: 2, baseDelay: 10 });
+      const operation = () => {
+        const error: any = new Error("Connection failed");
+        error.code = "ECONNREFUSED";
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      await expect(client.execute(operation)).rejects.toThrow(
+        "Network error after 2 retries",
+      );
+    });
+
+    test("throws immediately on unauthorized error (401)", async () => {
+      const client = new LinearClient(config);
+      const operation = () => {
+        const error: any = new Error("Unauthorized");
+        error.status = 401;
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      await expect(client.execute(operation)).rejects.toThrow(
+        "Unauthorized: Invalid API key",
+      );
+    });
+
+    test("throws immediately on other API errors", async () => {
+      const client = new LinearClient(config);
+      let callCount = 0;
+      const operation = () => {
+        callCount++;
+        const error: any = new Error("Bad request");
+        error.status = 400;
+        return Promise.reject(error);
+      };
+
+      await expect(client.execute(operation)).rejects.toThrow(LinearApiError);
+      expect(callCount).toBe(1); // No retries for non-retryable errors
+    });
+  });
+
+  describe("LinearApiError", () => {
+    test("creates error with all properties", () => {
+      const originalError = new Error("Original error");
+      const error = new LinearApiError(
+        "Test error message",
+        "TEST_CODE",
+        500,
+        originalError,
+      );
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error.name).toBe("LinearApiError");
+      expect(error.message).toBe("Test error message");
+      expect(error.code).toBe("TEST_CODE");
+      expect(error.statusCode).toBe(500);
+      expect(error.originalError).toBe(originalError);
+    });
+
+    test("creates error without optional fields", () => {
+      const error = new LinearApiError("Test error", "TEST_CODE");
+
+      expect(error.message).toBe("Test error");
+      expect(error.code).toBe("TEST_CODE");
+      expect(error.statusCode).toBeUndefined();
+      expect(error.originalError).toBeUndefined();
+    });
+  });
+
+  describe("exponential backoff", () => {
+    test("applies exponential backoff with jitter", async () => {
+      const client = new LinearClient(config, {
+        maxRetries: 3,
+        baseDelay: 100,
+      });
+      const startTime = Date.now();
+      let attempts = 0;
+
+      const operation = () => {
+        attempts++;
+        if (attempts <= 3) {
+          const error: any = new Error("Rate limited");
+          error.status = 429;
+          return Promise.reject(error);
+        }
+        return Promise.resolve({ data: "success" });
+      };
+
+      const result = await client.execute(operation);
+
+      const elapsed = Date.now() - startTime;
+
+      // Expected delays: ~100ms, ~200ms, ~400ms (with jitter ±10%)
+      // Total: ~700ms minimum
+      expect(elapsed).toBeGreaterThanOrEqual(630); // 700ms - 10% jitter
+      expect(result).toEqual({ data: "success" });
+    });
+  });
+});

package/src/server/adapters/__tests__/adapter-factory.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+
+describe("Adapter Factory", () => {
+  const originalEnv = process.env.FLUX_PROJECT_ROOT;
+  const TEST_DIR = `${realpathSync(tmpdir())}/flux-factory-test-${Date.now()}`;
+  const FLUX_DIR = `${TEST_DIR}/.flux`;
+  const PROJECT_JSON_PATH = `${FLUX_DIR}/project.json`;
+  const LINEAR_CONFIG_PATH = `${FLUX_DIR}/linear-config.json`;
+
+  beforeEach(async () => {
+    // Clean up any previous test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+
+    // Create test directory structure
+    mkdirSync(FLUX_DIR, { recursive: true });
+
+    // Set project root to test directory
+    process.env.FLUX_PROJECT_ROOT = TEST_DIR;
+
+    // Clear caches
+    const { config } = await import("../../config.js");
+    config.clearCache();
+
+    const { clearAdapterCache } = await import("../factory.js");
+    clearAdapterCache();
+  });
+
+  afterEach(async () => {
+    // Restore original env
+    if (originalEnv !== undefined) {
+      process.env.FLUX_PROJECT_ROOT = originalEnv;
+    } else {
+      delete process.env.FLUX_PROJECT_ROOT;
+    }
+
+    // Clear caches
+    const { config } = await import("../../config.js");
+    config.clearCache();
+
+    const { clearAdapterCache } = await import("../factory.js");
+    clearAdapterCache();
+
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe("getAdapter with default configuration", () => {
+    test("returns LocalAdapter when no project.json exists", async () => {
+      const { getAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = getAdapter();
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+
+    test("returns LocalAdapter when project.json has no adapter config", async () => {
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          // No adapter config - should default to local
+        }),
+      );
+
+      const { getAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = getAdapter(true); // Force new adapter to pick up config
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+
+    test("returns LocalAdapter when project.json explicitly sets adapter.type='local'", async () => {
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          adapter: { type: "local" },
+        }),
+      );
+
+      const { getAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = getAdapter(true);
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+  });
+
+  describe("getAdapter with Linear configuration", () => {
+    test("returns LinearAdapter when project.json has adapter.type='linear' and config exists", async () => {
+      // Create project.json with Linear adapter
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          adapter: { type: "linear" },
+        }),
+      );
+
+      // Create Linear config file
+      writeFileSync(
+        LINEAR_CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test_key",
+          teamId: "TEAM-123",
+          projectId: "proj_container",
+          defaultLabels: {
+            prd: "prd",
+            epic: "epic",
+            task: "task",
+          },
+        }),
+      );
+
+      const { getAdapter } = await import("../factory.js");
+      const { LinearAdapter } = await import("../linear/adapter.js");
+
+      const adapter = getAdapter(true);
+
+      expect(adapter).toBeInstanceOf(LinearAdapter);
+    });
+
+    test("throws error when adapter.type='linear' but no config file exists", async () => {
+      // Create project.json with Linear adapter
+      writeFileSync(
+        PROJECT_JSON_PATH,
+        JSON.stringify({
+          name: "test-project",
+          adapter: { type: "linear" },
+        }),
+      );
+
+      // Don't create Linear config file
+
+      const { getAdapter } = await import("../factory.js");
+
+      expect(() => getAdapter(true)).toThrow(
+        "Linear adapter configured but no configuration found. Run configure_linear tool first.",
+      );
+    });
+  });
+
+  describe("adapter caching", () => {
+    test("returns same instance when called multiple times without forceNew", async () => {
+      const { getAdapter } = await import("../factory.js");
+
+      const adapter1 = getAdapter();
+      const adapter2 = getAdapter();
+
+      expect(adapter1).toBe(adapter2);
+    });
+
+    test("returns new instance when forceNew=true", async () => {
+      const { getAdapter } = await import("../factory.js");
+
+      const adapter1 = getAdapter();
+      const adapter2 = getAdapter(true);
+
+      expect(adapter1).not.toBe(adapter2);
+    });
+
+    test("clearAdapterCache forces new instance on next getAdapter call", async () => {
+      const { getAdapter, clearAdapterCache } = await import("../factory.js");
+
+      const adapter1 = getAdapter();
+      clearAdapterCache();
+      const adapter2 = getAdapter();
+
+      expect(adapter1).not.toBe(adapter2);
+    });
+  });
+
+  describe("createAdapter with explicit config", () => {
+    test("creates LocalAdapter when type='local'", async () => {
+      const { createAdapter } = await import("../factory.js");
+      const { LocalAdapter } = await import("../local-adapter.js");
+
+      const adapter = createAdapter({ type: "local" });
+
+      expect(adapter).toBeInstanceOf(LocalAdapter);
+    });
+
+    test("creates LinearAdapter when type='linear' and config exists", async () => {
+      // Create Linear config file
+      writeFileSync(
+        LINEAR_CONFIG_PATH,
+        JSON.stringify({
+          apiKey: "lin_api_test_key",
+          teamId: "TEAM-123",
+          projectId: "proj_container",
+          defaultLabels: {
+            prd: "prd",
+            epic: "epic",
+            task: "task",
+          },
+        }),
+      );
+
+      const { createAdapter } = await import("../factory.js");
+      const { LinearAdapter } = await import("../linear/adapter.js");
+
+      const adapter = createAdapter({ type: "linear" });
+
+      expect(adapter).toBeInstanceOf(LinearAdapter);
+    });
+
+    test("throws error when type='linear' but no config exists", async () => {
+      const { createAdapter } = await import("../factory.js");
+
+      expect(() => createAdapter({ type: "linear" })).toThrow(
+        "Linear adapter configured but no configuration found. Run configure_linear tool first.",
+      );
+    });
+  });
+});