feat: add real-time deployment streaming and comparison tools (#7)

* feat: add real-time deployment streaming and comparison tools

- Add 3 new MCP tools: watch_deployment, compare_deployments, get_deployment_logs
- Implement deployment streaming with dynamic polling intervals
- Add deployment comparison with risk assessment and performance metrics
- Create log analysis with error detection and suggested fixes
- Refactor API layer with native fetch and per-token rate limiting
- Add Markdown response formatting for consistent output across AI tools
- Extract constants and remove magic numbers
- Update documentation with tool examples and troubleshooting section
- Clean up landing page design and remove excessive emojis
- Add test coverage (87 tests passing)

* chore: remove redundant placeholder tests and TODO comments

- Remove empty test placeholders in mcp-handler.test.ts
- Remove TODO comment for rate limiting (intentionally simple for now)
- Clean up codebase from unnecessary comments

* fix: resolve TypeScript errors for CI build

- Add missing required parameters to test function calls
- Replace hardcoded values with constants
- Fix return type mismatches in deployment methods
- Add deployments field to comparison result structure
- Handle undefined analysis parameter in formatter
- Fix type indexing in event formatter
- Update test assertions for filtered log output

* fix: resolve unhandled promise rejections and clean up codebase

- Fix unhandled promise rejections in request deduplication logic
- Update test assertions to use expect().rejects.toThrow() pattern
- Add test coverage for deduplicated error handling
- Remove redundant and obvious comments throughout codebase
- Clean up promise handling in api-client to prevent warnings

Author: alexpota

README.md

@@ -1,54 +1,66 @@
-import js from '@eslint/js';
-import tseslint from '@typescript-eslint/eslint-plugin';
-import tsparser from '@typescript-eslint/parser';
-import prettier from 'eslint-plugin-prettier';
-import prettierConfig from 'eslint-config-prettier';
+import js from "@eslint/js";
+import tseslint from "@typescript-eslint/eslint-plugin";
+import tsparser from "@typescript-eslint/parser";
+import prettier from "eslint-plugin-prettier";
+import prettierConfig from "eslint-config-prettier";
 
 export default [
   js.configs.recommended,
   {
-    files: ['**/*.ts', '**/*.tsx'],
+    files: ["**/*.ts", "**/*.tsx"],
     languageOptions: {
       parser: tsparser,
       parserOptions: {
         ecmaVersion: 2022,
-        sourceType: 'module',
-        project: './tsconfig.json',
+        sourceType: "module",
+        project: "./tsconfig.json",
       },
       globals: {
-        console: 'readonly',
-        process: 'readonly',
-        global: 'readonly',
-        fetch: 'readonly',
-        setTimeout: 'readonly',
-        clearTimeout: 'readonly',
-        crypto: 'readonly',
-        KVNamespace: 'readonly',
+        console: "readonly",
+        process: "readonly",
+        global: "readonly",
+        fetch: "readonly",
+        setTimeout: "readonly",
+        clearTimeout: "readonly",
+        setInterval: "readonly",
+        clearInterval: "readonly",
+        crypto: "readonly",
+        KVNamespace: "readonly",
       },
     },
     plugins: {
-      '@typescript-eslint': tseslint,
+      "@typescript-eslint": tseslint,
       prettier: prettier,
     },
     rules: {
       ...tseslint.configs.recommended.rules,
       ...prettierConfig.rules,
-      'prettier/prettier': 'error',
-      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
-      '@typescript-eslint/no-explicit-any': 'warn',
-      '@typescript-eslint/explicit-function-return-type': 'off',
-      '@typescript-eslint/explicit-module-boundary-types': 'off',
-      '@typescript-eslint/no-non-null-assertion': 'warn',
+      "prettier/prettier": "error",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_" },
+      ],
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-non-null-assertion": "warn",
+      "no-console": ["error", { allow: ["warn", "error"] }],
+      "no-debugger": "error",
+      "no-var": "error",
+      "prefer-const": "error",
+      eqeqeq: ["error", "always"],
+      "no-eval": "error",
+      "no-implied-eval": "error",
+      "no-throw-literal": "error",
+      "no-duplicate-imports": "error",
     },
   },
   {
-    files: ['**/*.js'],
+    files: ["**/*.js"],
     languageOptions: {
       ecmaVersion: 2022,
-      sourceType: 'module',
+      sourceType: "module",
     },
   },
   {
-    ignores: ['dist/**', 'node_modules/**', '*.config.js'],
+    ignores: ["dist/**", "node_modules/**", "*.config.js"],
   },
-];
+];

eslint.config.js

@@ -0,0 +1,219 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { BaseAPIClient } from "../api-client.js";
+
+class TestAPIClient extends BaseAPIClient {
+  protected endpoints = {
+    test: {
+      path: "test",
+      method: "GET" as const,
+      docsUrl: "https://example.com/docs",
+      description: "Test endpoint",
+    },
+    post: {
+      path: "test/post",
+      method: "POST" as const,
+      docsUrl: "https://example.com/docs/post",
+      description: "POST endpoint",
+    },
+  };
+
+  async testRequest() {
+    return this.request(this.endpoints.test);
+  }
+
+  async testRequestWithOptions(options: any) {
+    return this.request(this.endpoints.test, options);
+  }
+
+  async testPostRequest(body: any) {
+    return this.request(this.endpoints.post, { body });
+  }
+}
+
+describe("BaseAPIClient", () => {
+  let client: TestAPIClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    global.fetch = vi.fn();
+    client = new TestAPIClient({
+      baseUrl: "https://api.example.com",
+      timeout: 5000,
+      retry: 2,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should make successful API request", async () => {
+    const mockResponse = { data: "test" };
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      text: async () => JSON.stringify(mockResponse),
+    });
+
+    const result = await client.testRequest();
+
+    expect(result).toEqual(mockResponse);
+    expect(fetch).toHaveBeenCalled();
+  });
+
+  it("should pass headers and options", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      text: async () => JSON.stringify({ success: true }),
+    });
+
+    await client.testRequestWithOptions({
+      headers: {
+        Authorization: "Bearer token123",
+      },
+      searchParams: {
+        limit: 10,
+      },
+    });
+
+    expect(fetch).toHaveBeenCalled();
+    const [url, options] = (fetch as any).mock.calls[0];
+    expect(url.toString()).toContain("limit=10");
+    expect(options.headers.get("Authorization")).toBe("Bearer token123");
+  });
+
+  it("should handle HTTP errors properly", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+      text: async () => "",
+    });
+
+    await expect(client.testRequest()).rejects.toThrow(
+      "API request failed for test"
+    );
+  });
+
+  it("should retry on network errors", async () => {
+    let callCount = 0;
+    (global.fetch as any).mockImplementation(() => {
+      callCount++;
+      if (callCount <= 2) {
+        throw new Error("Network error");
+      }
+      return Promise.resolve({
+        ok: true,
+        text: async () => JSON.stringify({ retried: true }),
+      });
+    });
+
+    const result = await client.testRequest();
+    expect(result).toEqual({ retried: true });
+    expect(callCount).toBe(3);
+  });
+
+  it("should not retry on 4xx errors", async () => {
+    let callCount = 0;
+    (global.fetch as any).mockImplementation(() => {
+      callCount++;
+      return Promise.resolve({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+        text: async () => "",
+      });
+    });
+
+    await expect(client.testRequest()).rejects.toThrow("API request failed");
+    expect(callCount).toBe(1);
+  });
+
+  it("should handle request deduplication for GET requests", async () => {
+    let fetchCallCount = 0;
+    (global.fetch as any).mockImplementation(() => {
+      fetchCallCount++;
+      return new Promise(resolve => {
+        setTimeout(() => {
+          resolve({
+            ok: true,
+            text: async () => JSON.stringify({ count: fetchCallCount }),
+          });
+        }, 10);
+      });
+    });
+
+    const [result1, result2] = await Promise.all([
+      client.testRequest(),
+      client.testRequest(),
+    ]);
+
+    expect(result1).toEqual(result2);
+    expect(fetchCallCount).toBe(1);
+  });
+
+  it("should handle deduplicated request errors properly", async () => {
+    let fetchCallCount = 0;
+    (global.fetch as any).mockImplementation(() => {
+      fetchCallCount++;
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        statusText: "Not Found",
+        text: async () => "",
+      });
+    });
+
+    const promise1 = client
+      .testRequest()
+      .catch(err => ({ error: err.message }));
+    const promise2 = client
+      .testRequest()
+      .catch(err => ({ error: err.message }));
+
+    const [result1, result2] = await Promise.all([promise1, promise2]);
+
+    expect(result1).toHaveProperty("error");
+    expect(result2).toHaveProperty("error");
+    expect(result1).toEqual(result2);
+    expect(fetchCallCount).toBe(1);
+  });
+
+  it("should not deduplicate POST requests", async () => {
+    let fetchCallCount = 0;
+    (global.fetch as any).mockImplementation(() => {
+      fetchCallCount++;
+      return Promise.resolve({
+        ok: true,
+        text: async () => JSON.stringify({ count: fetchCallCount }),
+      });
+    });
+
+    await Promise.all([
+      client.testPostRequest({ data: 1 }),
+      client.testPostRequest({ data: 2 }),
+    ]);
+
+    expect(fetchCallCount).toBe(2);
+  });
+
+  it("should handle empty responses", async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      text: async () => "",
+    });
+
+    const result = await client.testRequest();
+    expect(result).toEqual({});
+  });
+
+  it("should handle invalid JSON responses", async () => {
+    (global.fetch as any).mockResolvedValue({
+      ok: true,
+      text: async () => "not json",
+    });
+
+    await expect(client.testRequest()).rejects.toThrow(
+      "API request failed for test"
+    );
+  });
+});

src/adapters/base/__tests__/api-client.test.ts

@@ -10,6 +10,19 @@ export abstract class BaseAdapter {
 
   abstract authenticate(token: string): Promise<boolean>;
 
+  abstract getDeploymentById(deploymentId: string, token: string): Promise<any>;
+
+  abstract getRecentDeployments(
+    project: string,
+    token: string,
+    limit?: number
+  ): Promise<any[]>;
+
+  abstract getDeploymentLogs(
+    deploymentId: string,
+    token: string
+  ): Promise<string>;
+
   protected formatTimestamp(date: Date | string | number): string {
     return new Date(date).toISOString();
   }