@auto-docs-test-code/test-code-mcp 0.1.0

package/README.md

@@ -0,0 +1,78 @@
+# @auto-docs/test-code-mcp
+
+Auto Docs 백엔드의 `POST /api/ai/api-tests/generate`를 MCP tool로 노출하는 패키지입니다.
+
+## Install
+
+```bash
+npm install @auto-docs/test-code-mcp
+# or
+yarn add @auto-docs/test-code-mcp
+```
+
+개발 중 로컬 테스트:
+
+```bash
+npm install ./tools/auto-docs-test-code-mcp
+# or
+yarn add file:./tools/auto-docs-test-code-mcp
+```
+
+## Environment
+
+```bash
+export AUTO_DOCS_API_BASE_URL=http://localhost:8080/api
+export AUTO_DOCS_ACCESS_TOKEN=<your-jwt>
+```
+
+## MCP Server command
+
+```bash
+auto-docs-test-code-mcp
+```
+
+## Tool
+
+### `generate_api_tests_and_qa`
+
+입력 파라미터:
+- `projectId` (required, number)
+- `request` (required, string)
+- `baseUrl` (optional)
+- `token` (optional)
+- `apiSpec` (optional)
+- `implementationContext` (optional)
+- `framework` (optional)
+- `targetFilePathHint` (optional)
+- `maxQaItems` (optional)
+- `createQaTickets` (optional, default: `false`)
+- `qaLabels` (optional, string[])
+- `assignees` (optional, string[])
+
+반환:
+- Auto Docs API `data` payload(JSON text)
+
+## Example MCP config
+
+```json
+{
+  "mcpServers": {
+    "auto-docs-test-code": {
+      "command": "auto-docs-test-code-mcp",
+      "env": {
+        "AUTO_DOCS_API_BASE_URL": "http://localhost:8080/api",
+        "AUTO_DOCS_ACCESS_TOKEN": "<JWT>"
+      }
+    }
+  }
+}
+```
+
+## Publish
+
+패키지 퍼블리시는 이 디렉터리에서 실행:
+
+```bash
+cd tools/auto-docs-test-code-mcp
+npm publish --access public
+```

package/index.mjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  McpError,
+  ErrorCode,
+} from '@modelcontextprotocol/sdk/types.js';
+
+const TOOL_NAME = 'generate_api_tests_and_qa';
+const DEFAULT_BASE_URL = 'http://localhost:8080/api';
+
+function normalizeBaseUrl(raw) {
+  const value = `${raw || DEFAULT_BASE_URL}`.trim();
+  if (!value) {
+    return DEFAULT_BASE_URL;
+  }
+  return value.replace(/\/+$/, '');
+}
+
+function assertString(value, name, required = false) {
+  if (value === undefined || value === null) {
+    if (required) {
+      throw new McpError(ErrorCode.InvalidParams, `${name} is required.`);
+    }
+    return undefined;
+  }
+
+  if (typeof value !== 'string') {
+    throw new McpError(ErrorCode.InvalidParams, `${name} must be a string.`);
+  }
+
+  const normalized = value.trim();
+  if (!normalized && required) {
+    throw new McpError(ErrorCode.InvalidParams, `${name} cannot be empty.`);
+  }
+
+  return normalized || undefined;
+}
+
+function assertNumber(value, name, required = false) {
+  if (value === undefined || value === null) {
+    if (required) {
+      throw new McpError(ErrorCode.InvalidParams, `${name} is required.`);
+    }
+    return undefined;
+  }
+
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new McpError(ErrorCode.InvalidParams, `${name} must be a number.`);
+  }
+
+  return parsed;
+}
+
+function assertBoolean(value, name, defaultValue) {
+  if (value === undefined || value === null) {
+    return defaultValue;
+  }
+
+  if (typeof value !== 'boolean') {
+    throw new McpError(ErrorCode.InvalidParams, `${name} must be a boolean.`);
+  }
+
+  return value;
+}
+
+function assertStringArray(value, name) {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `${name} must be an array of strings.`,
+    );
+  }
+
+  return value.map((item) => item.trim()).filter(Boolean);
+}
+
+async function callGenerateApiTests(payload) {
+  const baseUrl = normalizeBaseUrl(payload.baseUrl || process.env.AUTO_DOCS_API_BASE_URL);
+  const token = assertString(
+    payload.token || process.env.AUTO_DOCS_ACCESS_TOKEN,
+    'token',
+    true,
+  );
+
+  const response = await fetch(`${baseUrl}/ai/api-tests/generate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({
+      projectId: payload.projectId,
+      request: payload.request,
+      apiSpec: payload.apiSpec,
+      implementationContext: payload.implementationContext,
+      framework: payload.framework,
+      targetFilePathHint: payload.targetFilePathHint,
+      maxQaItems: payload.maxQaItems,
+      createQaTickets: payload.createQaTickets,
+      qaLabels: payload.qaLabels,
+      assignees: payload.assignees,
+    }),
+  });
+
+  const json = await response.json().catch(() => null);
+
+  if (!response.ok) {
+    const reason =
+      json?.message ||
+      json?.error?.message ||
+      `Request failed with status ${response.status}`;
+
+    throw new McpError(ErrorCode.InternalError, `Auto Docs API error: ${reason}`);
+  }
+
+  return json;
+}
+
+function createServer() {
+  const server = new Server(
+    {
+      name: '@auto-docs/test-code-mcp',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    },
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: TOOL_NAME,
+        description:
+          'Generate API test draft and optional QA tickets via Auto Docs backend.',
+        inputSchema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            baseUrl: {
+              type: 'string',
+              description:
+                'Auto Docs API base URL. Default: AUTO_DOCS_API_BASE_URL or http://localhost:8080/api',
+            },
+            token: {
+              type: 'string',
+              description:
+                'Access token. Default: AUTO_DOCS_ACCESS_TOKEN environment variable.',
+            },
+            projectId: {
+              type: 'number',
+              description: 'Project ID',
+            },
+            request: {
+              type: 'string',
+              description: 'Natural-language request for API test generation',
+            },
+            apiSpec: {
+              type: 'string',
+              description: 'API specification summary',
+            },
+            implementationContext: {
+              type: 'string',
+              description: 'Implementation context summary',
+            },
+            framework: {
+              type: 'string',
+              description: 'Testing framework hint (e.g., jest + supertest)',
+            },
+            targetFilePathHint: {
+              type: 'string',
+              description: 'Target test file path hint',
+            },
+            maxQaItems: {
+              type: 'number',
+              description: 'Maximum number of QA tickets to generate',
+            },
+            createQaTickets: {
+              type: 'boolean',
+              description: 'Whether to create QA tickets in backend (default: false)',
+            },
+            qaLabels: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Labels for generated QA tickets',
+            },
+            assignees: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Assignees for generated QA tickets',
+            },
+          },
+          required: ['projectId', 'request'],
+        },
+      },
+    ],
+  }));
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+
+    if (name !== TOOL_NAME) {
+      throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+    }
+
+    const projectId = assertNumber(args.projectId, 'projectId', true);
+    if (!Number.isInteger(projectId) || projectId <= 0) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        'projectId must be a positive integer.',
+      );
+    }
+
+    const payload = {
+      baseUrl: assertString(args.baseUrl, 'baseUrl'),
+      token: assertString(args.token, 'token'),
+      projectId,
+      request: assertString(args.request, 'request', true),
+      apiSpec: assertString(args.apiSpec, 'apiSpec'),
+      implementationContext: assertString(
+        args.implementationContext,
+        'implementationContext',
+      ),
+      framework: assertString(args.framework, 'framework'),
+      targetFilePathHint: assertString(args.targetFilePathHint, 'targetFilePathHint'),
+      maxQaItems: assertNumber(args.maxQaItems, 'maxQaItems'),
+      createQaTickets: assertBoolean(args.createQaTickets, 'createQaTickets', false),
+      qaLabels: assertStringArray(args.qaLabels, 'qaLabels'),
+      assignees: assertStringArray(args.assignees, 'assignees'),
+    };
+
+    const result = await callGenerateApiTests(payload);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result?.data ?? result, null, 2),
+        },
+      ],
+    };
+  });
+
+  return server;
+}
+
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  console.error('[auto-docs-test-code-mcp] fatal error:', error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@auto-docs-test-code/test-code-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Auto Docs AI API test generation",
+  "type": "module",
+  "main": "index.mjs",
+  "bin": {
+    "auto-docs-test-code-mcp": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "auto-docs",
+    "api-test",
+    "qa"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.1"
+  }
+}