@ty_krystal/sei-ai 0.1.8 → 0.1.13

package/dist/core/openapi.js

@@ -0,0 +1,261 @@
+import { SeiMcpError } from './errors.js';
+const OPENAPI_HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS', 'TRACE'];
+export function buildOpenApiDocSummary(openapiDoc, keyword) {
+    if (!isObject(openapiDoc)) {
+        throw new SeiMcpError('OpenAPI 文档不是 JSON 对象', 'INVALID_REQUEST');
+    }
+    throwIfOpenApiErrorPayload(openapiDoc);
+    const info = isObject(openapiDoc.info) ? openapiDoc.info : {};
+    const rawPaths = openapiDoc.paths;
+    if (!isObject(rawPaths)) {
+        throw new SeiMcpError('OpenAPI 文档缺少 paths 对象', 'INVALID_REQUEST');
+    }
+    const normalizedKeyword = normalizeText(keyword).toLowerCase();
+    const items = [];
+    for (const [path, rawPathItem] of Object.entries(rawPaths)) {
+        if (!isObject(rawPathItem)) {
+            continue;
+        }
+        for (const [method, rawOperation] of Object.entries(rawPathItem)) {
+            const methodUpper = method.toUpperCase();
+            if (!OPENAPI_HTTP_METHODS.includes(methodUpper) || !isObject(rawOperation)) {
+                continue;
+            }
+            const tags = Array.isArray(rawOperation.tags)
+                ? rawOperation.tags.map((item) => normalizeText(item)).filter(Boolean)
+                : [];
+            const item = {
+                method: methodUpper,
+                path: normalizeText(path),
+                tags,
+                summary: normalizeText(rawOperation.summary),
+                description: normalizeText(rawOperation.description),
+                operationId: normalizeText(rawOperation.operationId),
+                parameters: extractOpenApiParameters(rawOperation),
+                requestBody: extractOpenApiRequestBody(rawOperation),
+                responses: extractOpenApiResponses(rawOperation),
+            };
+            if (normalizedKeyword) {
+                const searchable = JSON.stringify(item).toLowerCase();
+                if (!searchable.includes(normalizedKeyword)) {
+                    continue;
+                }
+            }
+            items.push(item);
+        }
+    }
+    items.sort((a, b) => {
+        const tagA = normalizeText((Array.isArray(a.tags) ? a.tags[0] : '') || '未分组');
+        const tagB = normalizeText((Array.isArray(b.tags) ? b.tags[0] : '') || '未分组');
+        if (tagA !== tagB) {
+            return tagA.localeCompare(tagB, 'zh-CN');
+        }
+        const pathCompare = normalizeText(a.path).localeCompare(normalizeText(b.path), 'en');
+        if (pathCompare !== 0) {
+            return pathCompare;
+        }
+        return OPENAPI_HTTP_METHODS.indexOf(normalizeText(a.method)) -
+            OPENAPI_HTTP_METHODS.indexOf(normalizeText(b.method));
+    });
+    return {
+        title: normalizeText(info.title) || 'SEI API',
+        version: normalizeText(info.version),
+        openapi: normalizeText(openapiDoc.openapi ?? openapiDoc.swagger),
+        count: items.length,
+        items,
+    };
+}
+export function renderOpenApiMarkdown(summary) {
+    const lines = [`# ${normalizeText(summary.title) || 'SEI API'}`, ''];
+    const version = normalizeText(summary.version);
+    const openapiVersion = normalizeText(summary.openapi);
+    if (version) {
+        lines.push(`- 版本：${version}`);
+    }
+    if (openapiVersion) {
+        lines.push(`- OpenAPI：${openapiVersion}`);
+    }
+    lines.push(`- 接口数：${Number(summary.count ?? 0)}`);
+    let currentTag = '';
+    const items = Array.isArray(summary.items) ? summary.items : [];
+    for (const rawItem of items) {
+        if (!isObject(rawItem)) {
+            continue;
+        }
+        const tags = Array.isArray(rawItem.tags) ? rawItem.tags : [];
+        const tag = normalizeText(tags[0] ?? '未分组') || '未分组';
+        if (tag !== currentTag) {
+            lines.push('', `## ${tag}`);
+            currentTag = tag;
+        }
+        const method = normalizeText(rawItem.method);
+        const path = normalizeText(rawItem.path);
+        lines.push('', `### ${method} ${path}`);
+        const summaryText = normalizeText(rawItem.summary);
+        const description = normalizeText(rawItem.description);
+        const operationId = normalizeText(rawItem.operationId);
+        if (summaryText) {
+            lines.push(`- 摘要：${summaryText}`);
+        }
+        if (description && description !== summaryText) {
+            lines.push(`- 说明：${description}`);
+        }
+        if (operationId) {
+            lines.push(`- operationId：\`${operationId}\``);
+        }
+        const parameters = Array.isArray(rawItem.parameters) ? rawItem.parameters : [];
+        if (parameters.length > 0) {
+            lines.push('- 参数：');
+            for (const rawParameter of parameters) {
+                if (!isObject(rawParameter)) {
+                    continue;
+                }
+                const name = normalizeText(rawParameter.name);
+                const location = normalizeText(rawParameter.in);
+                const schema = normalizeText(rawParameter.schema);
+                const required = rawParameter.required ? '必填' : '可选';
+                const descriptionText = normalizeText(rawParameter.description);
+                const detail = [schema, required, descriptionText].filter(Boolean).join('，');
+                lines.push(`  - \`${location} ${name}\`${detail ? `：${detail}` : ''}`);
+            }
+        }
+        const requestBody = Array.isArray(rawItem.requestBody) ? rawItem.requestBody : [];
+        if (requestBody.length > 0) {
+            const parts = requestBody
+                .filter(isObject)
+                .map((body) => {
+                const contentType = normalizeText(body.contentType);
+                const schema = normalizeText(body.schema);
+                return schema ? `${contentType}(${schema})` : contentType;
+            })
+                .filter(Boolean);
+            if (parts.length > 0) {
+                lines.push(`- 请求体：${parts.join(', ')}`);
+            }
+        }
+        const responses = Array.isArray(rawItem.responses) ? rawItem.responses : [];
+        if (responses.length > 0) {
+            const parts = responses
+                .filter(isObject)
+                .map((response) => `${normalizeText(response.status)} ${normalizeText(response.description)}`.trim())
+                .filter(Boolean);
+            if (parts.length > 0) {
+                lines.push(`- 响应：${parts.join(', ')}`);
+            }
+        }
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+function extractOpenApiParameters(operation) {
+    const rawParameters = operation.parameters;
+    if (!Array.isArray(rawParameters)) {
+        return [];
+    }
+    return rawParameters
+        .filter(isObject)
+        .map((parameter) => ({
+        name: normalizeText(parameter.name),
+        in: normalizeText(parameter.in),
+        required: Boolean(parameter.required),
+        schema: summarizeSchema(parameter.schema),
+        description: normalizeText(parameter.description),
+    }))
+        .filter((item) => item.name || item.in);
+}
+function extractOpenApiRequestBody(operation) {
+    const requestBody = operation.requestBody;
+    if (!isObject(requestBody) || !isObject(requestBody.content)) {
+        return [];
+    }
+    return Object.entries(requestBody.content)
+        .map(([contentType, contentInfo]) => ({
+        contentType: normalizeText(contentType),
+        schema: summarizeSchema(isObject(contentInfo) ? contentInfo.schema : undefined),
+    }))
+        .filter((item) => item.contentType);
+}
+function extractOpenApiResponses(operation) {
+    const rawResponses = operation.responses;
+    if (!isObject(rawResponses)) {
+        return [];
+    }
+    return Object.entries(rawResponses)
+        .map(([status, response]) => ({
+        status: normalizeText(status),
+        description: normalizeText(isObject(response) ? response.description : ''),
+    }))
+        .filter((item) => item.status);
+}
+function summarizeSchema(schema) {
+    if (!isObject(schema)) {
+        return '';
+    }
+    const ref = normalizeText(schema.$ref);
+    if (ref) {
+        return ref.split('/').pop() ?? ref;
+    }
+    const schemaType = normalizeText(schema.type);
+    const schemaFormat = normalizeText(schema.format);
+    if (schemaType === 'array') {
+        const itemText = summarizeSchema(schema.items);
+        return `array<${itemText || 'item'}>`;
+    }
+    if (schemaType && schemaFormat) {
+        return `${schemaType}/${schemaFormat}`;
+    }
+    if (schemaType) {
+        return schemaType;
+    }
+    return Array.isArray(schema.enum) && schema.enum.length > 0 ? 'enum' : '';
+}
+function throwIfOpenApiErrorPayload(openapiDoc) {
+    const rootCause = isObject(openapiDoc.rootCause) ? openapiDoc.rootCause : null;
+    const stackTrace = Array.isArray(rootCause?.stackTrace) ? rootCause.stackTrace : [];
+    const topFrame = stackTrace.find(isObject);
+    const rootMessage = normalizeText(rootCause?.message);
+    const rootException = normalizeText(rootCause?.exception);
+    const message = normalizeText(openapiDoc.message);
+    const error = normalizeText(openapiDoc.error);
+    const path = normalizeText(openapiDoc.path);
+    if (!rootCause && !message && !error) {
+        return;
+    }
+    const parts = [
+        message || error,
+        rootException,
+        rootMessage,
+        formatStackFrame(topFrame),
+        path ? `path=${path}` : '',
+    ].filter(Boolean);
+    throw new SeiMcpError(parts.length > 0
+        ? `OpenAPI 文档生成失败：${parts.join(' | ')}`
+        : 'OpenAPI 文档生成失败，服务端返回异常对象', 'INVALID_REQUEST', {
+        error,
+        message,
+        path,
+        rootCause: rootCause ?? undefined,
+    });
+}
+function formatStackFrame(frame) {
+    if (!isObject(frame)) {
+        return '';
+    }
+    const className = normalizeText(frame.className);
+    const methodName = normalizeText(frame.methodName);
+    const fileName = normalizeText(frame.fileName);
+    const lineNumber = Number(frame.lineNumber);
+    const locationParts = [className, methodName].filter(Boolean);
+    const sourceParts = [fileName, Number.isFinite(lineNumber) && lineNumber > 0 ? String(lineNumber) : ''].filter(Boolean);
+    const location = locationParts.join('#');
+    const source = sourceParts.join(':');
+    if (location && source) {
+        return `${location} (${source})`;
+    }
+    return location || source;
+}
+function normalizeText(value) {
+    return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/core/sei-client.d.ts

@@ -0,0 +1,25 @@
+import type { Logger, SeiAuthSettings, SeiClient, SeiCommandOptions, SeiMcpConfig, SeiRequestOptions } from './types.js';
+interface JsonRequestOptions extends SeiRequestOptions {
+    allowEmpty?: boolean;
+    allowFailure?: boolean;
+    skipAuth?: boolean;
+}
+export interface CliSeiClient {
+    call(method: string, path: string, payload?: unknown, options?: JsonRequestOptions): Promise<unknown>;
+    query(payload: unknown, options?: JsonRequestOptions): Promise<unknown>;
+    save(payload: unknown, options?: JsonRequestOptions): Promise<unknown>;
+    querySql(sql: string, page?: number, size?: number, options?: JsonRequestOptions): Promise<unknown>;
+    readApiDocs(): Promise<unknown>;
+    relogin(): Promise<string>;
+    executeDdlStatements(statements: string[], options?: JsonRequestOptions): Promise<unknown>;
+}
+export declare function createSeiClient(config: SeiMcpConfig, logger: Logger, fetchImpl?: typeof fetch): SeiClient;
+export declare function createSeiAuthSettings(config: SeiMcpConfig, options?: SeiCommandOptions): SeiAuthSettings;
+export declare function createCliSeiClient(settings: SeiAuthSettings, logger: Logger, fetchImpl?: typeof fetch): CliSeiClient;
+export declare function buildQuerySqlPayload(sql: string, page?: number, size?: number): {
+    sql: string;
+    page: number;
+    size: number;
+};
+export declare function stripTrailingQuerySqlLimit(sql: string): string;
+export {};