wraptc 1.0.3 → 1.0.4

package/src/core/__tests__/unit/providers/configurable.test.ts

@@ -0,0 +1,429 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { defineProvider } from "../../../define-provider";
+import { ConfigurableProvider, createConfigurableProvider } from "../../../providers/configurable";
+import type { CodingRequest, ProviderDefinition } from "../../../types";
+
+// Mock Bun.spawn for provider tests
+const createMockProcess = (stdout: string, stderr = "", exitCode = 0) => {
+  const encoder = new TextEncoder();
+  const stdoutData = encoder.encode(stdout);
+  const stderrData = encoder.encode(stderr);
+
+  return {
+    stdin: {
+      write: mock(() => {}),
+      end: mock(() => {}),
+    },
+    stdout: {
+      getReader: () => {
+        let read = false;
+        return {
+          read: async () => {
+            if (!read) {
+              read = true;
+              return { done: false, value: stdoutData };
+            }
+            return { done: true, value: undefined };
+          },
+          releaseLock: () => {},
+        };
+      },
+    },
+    stderr: {
+      getReader: () => {
+        let read = false;
+        return {
+          read: async () => {
+            if (!read && stderr) {
+              read = true;
+              return { done: false, value: stderrData };
+            }
+            return { done: true, value: undefined };
+          },
+          releaseLock: () => {},
+        };
+      },
+    },
+    exited: Promise.resolve(exitCode),
+    kill: mock(() => {}),
+  };
+};
+
+let mockSpawn: ReturnType<typeof mock>;
+let originalSpawn: typeof Bun.spawn;
+
+describe("ConfigurableProvider - Phase 2 Features", () => {
+  beforeEach(() => {
+    originalSpawn = Bun.spawn;
+    mockSpawn = mock(() => createMockProcess("test output"));
+    (globalThis as any).Bun.spawn = mockSpawn;
+  });
+
+  afterEach(() => {
+    (globalThis as any).Bun.spawn = originalSpawn;
+  });
+
+  describe("buildArgs with subcommand", () => {
+    test("should prepend subcommand to arguments", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        subcommand: "exec",
+        input: { method: "positional" },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello world", stream: false };
+
+      await provider.runOnce(req, {});
+
+      expect(mockSpawn).toHaveBeenCalled();
+      const spawnArgs = mockSpawn.mock.calls[0][0];
+      expect(spawnArgs[0]).toBe("test-cli");
+      expect(spawnArgs[1]).toBe("exec"); // subcommand should be first
+      expect(spawnArgs).toContain("Hello world");
+    });
+  });
+
+  describe("buildArgs with system prompt", () => {
+    test("should add system prompt flag when configured", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        args: {
+          systemPromptFlag: "--system",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = {
+        prompt: "Hello world",
+        systemPrompt: "You are a helpful assistant",
+        stream: false,
+      };
+
+      await provider.runOnce(req, {});
+
+      const spawnArgs = mockSpawn.mock.calls[0][0];
+      expect(spawnArgs).toContain("--system");
+      expect(spawnArgs).toContain("You are a helpful assistant");
+    });
+
+    test("should combine system prompt with main prompt when method is combined", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        args: {
+          systemPromptMethod: "combined",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = {
+        prompt: "Hello world",
+        systemPrompt: "You are a helpful assistant",
+        stream: false,
+      };
+
+      await provider.runOnce(req, {});
+
+      const spawnArgs = mockSpawn.mock.calls[0][0];
+      // Should contain combined prompt
+      expect(
+        spawnArgs.some(
+          (arg: string) =>
+            arg.includes("You are a helpful assistant") && arg.includes("Hello world"),
+        ),
+      ).toBe(true);
+    });
+  });
+
+  describe("buildArgs with request parameters", () => {
+    test("should add maxTokens flag when configured", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        args: {
+          maxTokensFlag: "--max-tokens",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = {
+        prompt: "Hello",
+        maxTokens: 1000,
+        stream: false,
+      };
+
+      await provider.runOnce(req, {});
+
+      const spawnArgs = mockSpawn.mock.calls[0][0];
+      expect(spawnArgs).toContain("--max-tokens");
+      expect(spawnArgs).toContain("1000");
+    });
+
+    test("should add temperature flag when configured", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        args: {
+          temperatureFlag: "--temperature",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = {
+        prompt: "Hello",
+        temperature: 0.7,
+        stream: false,
+      };
+
+      await provider.runOnce(req, {});
+
+      const spawnArgs = mockSpawn.mock.calls[0][0];
+      expect(spawnArgs).toContain("--temperature");
+      expect(spawnArgs).toContain("0.7");
+    });
+
+    test("should add language flag when configured", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        args: {
+          languageFlag: "--language",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = {
+        prompt: "Hello",
+        language: "python",
+        stream: false,
+      };
+
+      await provider.runOnce(req, {});
+
+      const spawnArgs = mockSpawn.mock.calls[0][0];
+      expect(spawnArgs).toContain("--language");
+      expect(spawnArgs).toContain("python");
+    });
+  });
+
+  describe("environment variables", () => {
+    test("should pass environment variables to process", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        env: {
+          API_KEY: "test-key",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      await provider.runOnce(req, {});
+
+      const spawnOpts = mockSpawn.mock.calls[0][1];
+      expect(spawnOpts.env).toBeDefined();
+      expect(spawnOpts.env.API_KEY).toBe("test-key");
+    });
+
+    test("should interpolate ${VAR} syntax from process.env", async () => {
+      // Set up test environment variable
+      process.env.TEST_API_KEY = "interpolated-value";
+
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        env: {
+          API_KEY: "${TEST_API_KEY}",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      await provider.runOnce(req, {});
+
+      const spawnOpts = mockSpawn.mock.calls[0][1];
+      expect(spawnOpts.env.API_KEY).toBe("interpolated-value");
+
+      // Clean up
+      process.env.TEST_API_KEY = undefined;
+    });
+
+    test("should allow opts.env to override definition env", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        env: {
+          API_KEY: "default-key",
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      await provider.runOnce(req, { env: { API_KEY: "override-key" } });
+
+      const spawnOpts = mockSpawn.mock.calls[0][1];
+      expect(spawnOpts.env.API_KEY).toBe("override-key");
+    });
+  });
+
+  describe("defaultCwd", () => {
+    test("should use defaultCwd when no opts.cwd provided", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        defaultCwd: "/tmp/test",
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      await provider.runOnce(req, {});
+
+      const spawnOpts = mockSpawn.mock.calls[0][1];
+      expect(spawnOpts.cwd).toBe("/tmp/test");
+    });
+
+    test("should allow opts.cwd to override defaultCwd", async () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        defaultCwd: "/tmp/test",
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      await provider.runOnce(req, { cwd: "/tmp/override" });
+
+      const spawnOpts = mockSpawn.mock.calls[0][1];
+      expect(spawnOpts.cwd).toBe("/tmp/override");
+    });
+  });
+
+  describe("allowedExitCodes", () => {
+    test("should treat exit code 0 as success by default", async () => {
+      mockSpawn = mock(() => createMockProcess("success output", "", 0));
+      (globalThis as any).Bun.spawn = mockSpawn;
+
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      const result = await provider.runOnce(req, {});
+      expect(result.text).toBe("success output");
+    });
+
+    test("should treat exit code 1 as failure by default", async () => {
+      mockSpawn = mock(() => createMockProcess("", "error", 1));
+      (globalThis as any).Bun.spawn = mockSpawn;
+
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      await expect(provider.runOnce(req, {})).rejects.toThrow(/failed with code 1/);
+    });
+
+    test("should allow custom exit codes", async () => {
+      mockSpawn = mock(() => createMockProcess("warning output", "", 1));
+      (globalThis as any).Bun.spawn = mockSpawn;
+
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        allowedExitCodes: [0, 1], // Allow warnings
+      });
+
+      const provider = new ConfigurableProvider(definition);
+      const req: CodingRequest = { prompt: "Hello", stream: false };
+
+      const result = await provider.runOnce(req, {});
+      expect(result.text).toBe("warning output");
+    });
+  });
+
+  describe("error classification", () => {
+    test("should classify rate limit errors", () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+
+      expect(provider.classifyError({ stderr: "rate limit exceeded" })).toBe("RATE_LIMIT");
+      expect(provider.classifyError({ stderr: "429 Too Many Requests" })).toBe("RATE_LIMIT");
+    });
+
+    test("should classify auth errors", () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+
+      expect(provider.classifyError({ stderr: "401 unauthorized" })).toBe("UNAUTHORIZED");
+      expect(provider.classifyError({ stderr: "invalid api key" })).toBe("UNAUTHORIZED");
+    });
+
+    test("should use provider-specific error patterns first", () => {
+      const definition = defineProvider({
+        id: "test-cli",
+        binary: "test-cli",
+        input: { method: "positional" },
+        errors: {
+          OUT_OF_CREDITS: ["custom quota message"],
+        },
+      });
+
+      const provider = new ConfigurableProvider(definition);
+
+      expect(provider.classifyError({ stderr: "custom quota message" })).toBe("OUT_OF_CREDITS");
+    });
+  });
+
+  describe("createConfigurableProvider helper", () => {
+    test("should create provider from definition", () => {
+      const definition = defineProvider({
+        id: "helper-test",
+        binary: "helper-cli",
+        input: { method: "stdin" },
+      });
+
+      const provider = createConfigurableProvider(definition);
+
+      expect(provider).toBeInstanceOf(ConfigurableProvider);
+      expect(provider.id).toBe("helper-test");
+    });
+  });
+});

package/src/core/__tests__/unit/providers/gemini.test.ts

@@ -0,0 +1,251 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { GeminiProvider } from "../../../providers/gemini";
+import type { CodingRequest, ProviderConfig } from "../../../types";
+
+describe("GeminiProvider", () => {
+  let provider: GeminiProvider;
+  let config: ProviderConfig;
+  let originalSpawn: typeof Bun.spawn;
+
+  beforeEach(() => {
+    config = {
+      binary: "gemini",
+      args: [],
+      jsonMode: "flag",
+      jsonFlag: "--output-format",
+      streamingMode: "jsonl",
+      capabilities: ["generate", "edit", "explain", "test"],
+    };
+    provider = new GeminiProvider(config);
+    originalSpawn = Bun.spawn;
+  });
+
+  afterEach(() => {
+    Bun.spawn = originalSpawn;
+  });
+
+  describe("constructor", () => {
+    test("should initialize with correct id and display name", () => {
+      expect(provider.id).toBe("gemini");
+      expect(provider.displayName).toBe("Gemini CLI");
+    });
+
+    test("should set binary path from config", () => {
+      const customBinaryConfig = { ...config, binary: "/custom/gemini" };
+      const customProvider = new GeminiProvider(customBinaryConfig);
+      expect(customProvider.binaryPath).toBe("/custom/gemini");
+    });
+
+    test("should set default binary if not provided", () => {
+      const defaultConfig = { ...config, binary: "" };
+      const defaultProvider = new GeminiProvider(defaultConfig);
+      expect(defaultProvider.binaryPath).toBe("gemini");
+    });
+
+    test("should set streaming support based on config", () => {
+      expect(provider.supportsStreaming).toBe(true);
+
+      const noStreamConfig = { ...config, streamingMode: "none" as const };
+      const noStreamProvider = new GeminiProvider(noStreamConfig);
+      expect(noStreamProvider.supportsStreaming).toBe(false);
+    });
+
+    test("should set JSON preference based on config", () => {
+      expect(provider.prefersJson).toBe(true);
+
+      const noJsonConfig = { ...config, jsonMode: "none" as const };
+      const noJsonProvider = new GeminiProvider(noJsonConfig);
+      expect(noJsonProvider.prefersJson).toBe(false);
+    });
+  });
+
+  describe("buildArgs", () => {
+    test("should build args with JSON flag", () => {
+      const req: CodingRequest = { prompt: "test prompt" };
+      const args = provider.buildArgs(req, {});
+
+      expect(args).toContain("-o");
+      expect(args).toContain("json");
+      expect(args).toContain("test prompt");
+    });
+
+    test("should include config args", () => {
+      const configWithArgs = { ...config, args: ["--verbose", "--model=gpt4"] };
+      const providerWithArgs = new GeminiProvider(configWithArgs);
+      const req: CodingRequest = { prompt: "test" };
+      const args = providerWithArgs.buildArgs(req, {});
+
+      expect(args).toContain("--verbose");
+      expect(args).toContain("--model=gpt4");
+    });
+
+    test("should skip JSON flag when jsonMode is none", () => {
+      const noJsonConfig = { ...config, jsonMode: "none" as const };
+      const noJsonProvider = new GeminiProvider(noJsonConfig);
+      const req: CodingRequest = { prompt: "test" };
+      const args = noJsonProvider.buildArgs(req, {});
+
+      expect(args).not.toContain("-o");
+      expect(args).not.toContain("json");
+    });
+  });
+
+  describe("getStdinInput", () => {
+    test("should return undefined for Gemini (uses positional args)", () => {
+      const result = provider.getStdinInput();
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("classifyError", () => {
+    test("should classify OUT_OF_CREDITS errors", () => {
+      const errors = [
+        "quota exceeded",
+        "out of quota",
+        "QUOTA EXCEEDED",
+        "out of credits",
+        "insufficient quota",
+      ];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("OUT_OF_CREDITS");
+      }
+    });
+
+    test("should classify RATE_LIMIT errors", () => {
+      const errors = ["rate limit exceeded", "Rate limit exceeded", "429", "too many requests"];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("RATE_LIMIT");
+      }
+    });
+
+    test("should classify BAD_REQUEST errors", () => {
+      const errors = ["400", "Bad request", "bad request", "invalid request"];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("BAD_REQUEST");
+      }
+    });
+
+    test("should classify UNAUTHORIZED errors", () => {
+      const errors = ["401", "unauthorized", "invalid api key", "authentication failed"];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("UNAUTHORIZED");
+      }
+    });
+
+    test("should classify TIMEOUT errors", () => {
+      const errors = ["timeout", "timed out", "deadline exceeded"];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("TIMEOUT");
+      }
+    });
+
+    test("should classify INTERNAL errors", () => {
+      const errors = ["500", "Internal server error", "internal error", "server error"];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("INTERNAL");
+      }
+    });
+
+    test("should classify TRANSIENT for unmatched errors", () => {
+      const errors = [
+        "connection refused",
+        "econnrefused",
+        "network error",
+        "some unknown error xyz",
+      ];
+
+      for (const error of errors) {
+        const result = provider.classifyError({ stderr: error });
+        expect(result).toBe("TRANSIENT");
+      }
+    });
+
+    test("should combine stdout and stderr for classification", () => {
+      const result = provider.classifyError({
+        stderr: "some stderr",
+        stdout: "rate limit exceeded",
+      });
+
+      expect(result).toBe("RATE_LIMIT");
+    });
+
+    test("should handle empty error context", () => {
+      const result = provider.classifyError({});
+      expect(result).toBe("TRANSIENT");
+    });
+  });
+
+  describe("getInfo", () => {
+    test("should return provider information", () => {
+      const info = provider.getInfo();
+
+      expect(info).toEqual({
+        id: "gemini",
+        displayName: "Gemini CLI",
+        supportsStreaming: true,
+        prefersJson: true,
+        capabilities: ["generate", "edit", "explain", "test"],
+      });
+    });
+
+    test("should handle different streaming modes", () => {
+      const noStreamConfig = { ...config, streamingMode: "none" as const };
+      const noStreamProvider = new GeminiProvider(noStreamConfig);
+
+      const info = noStreamProvider.getInfo();
+      expect(info.supportsStreaming).toBe(false);
+    });
+
+    test("should handle different JSON modes", () => {
+      const noJsonConfig = { ...config, jsonMode: "none" as const };
+      const noJsonProvider = new GeminiProvider(noJsonConfig);
+
+      const info = noJsonProvider.getInfo();
+      expect(info.prefersJson).toBe(false);
+    });
+  });
+
+  describe("runOnce (integration)", () => {
+    test("should throw when binary not found", async () => {
+      // Use a non-existent binary path
+      const nonExistentConfig = { ...config, binary: "/nonexistent/path/to/gemini-xyz-999" };
+      const nonExistentProvider = new GeminiProvider(nonExistentConfig);
+      const req: CodingRequest = { prompt: "test" };
+
+      await expect(nonExistentProvider.runOnce(req, {})).rejects.toThrow(/Binary not found/);
+    });
+  });
+
+  describe("runStream (integration)", () => {
+    test("should throw when binary not found", async () => {
+      // Use a non-existent binary path
+      const nonExistentConfig = { ...config, binary: "/nonexistent/path/to/gemini-xyz-999" };
+      const nonExistentProvider = new GeminiProvider(nonExistentConfig);
+      const req: CodingRequest = { prompt: "test" };
+
+      try {
+        for await (const _event of nonExistentProvider.runStream(req, {})) {
+          // Should not get here
+        }
+        // If we get here without error, fail the test
+        expect(true).toBe(false);
+      } catch (error) {
+        // Expected - binary not found
+        expect(error).toBeDefined();
+        expect((error as Error).message).toMatch(/Binary not found/);
+      }
+    });
+  });
+});