@ty_krystal/sei-ai 0.1.6 → 0.1.12

package/dist/core/env.js

@@ -0,0 +1,55 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const DEFAULT_ENV_FILES = ['.env.local', '.env'];
+export async function loadWorkingDirEnv(cwd = process.cwd(), env = process.env) {
+    for (const fileName of DEFAULT_ENV_FILES) {
+        await loadEnvFile(resolve(cwd, fileName), env);
+    }
+}
+async function loadEnvFile(path, env) {
+    try {
+        const text = await readFile(path, 'utf8');
+        const parsed = parseEnvText(text);
+        for (const [key, value] of Object.entries(parsed)) {
+            if (env[key] === undefined) {
+                env[key] = value;
+            }
+        }
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isMissingFile(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const withCode = error;
+    return withCode.code === 'ENOENT';
+}
+function parseEnvText(text) {
+    const result = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const equalsIndex = line.indexOf('=');
+        if (equalsIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, equalsIndex).trim();
+        if (!key) {
+            continue;
+        }
+        let value = line.slice(equalsIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,10 @@
+import type { JsonValue } from './utils.js';
+export declare class SeiMcpError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code?: string, details?: Record<string, unknown>);
+}
+export declare function isSeiMcpError(error: unknown): error is SeiMcpError;
+export declare function normalizeErrorMessage(error: unknown): string;
+export declare function formatCliError(error: unknown): string;
+export declare function toErrorLogMeta(error: unknown): JsonValue;

package/dist/core/errors.js

@@ -0,0 +1,55 @@
+export class SeiMcpError extends Error {
+    code;
+    details;
+    constructor(message, code = 'INTERNAL_ERROR', details) {
+        super(message);
+        this.name = 'SeiMcpError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export function isSeiMcpError(error) {
+    return error instanceof SeiMcpError;
+}
+export function normalizeErrorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
+export function formatCliError(error) {
+    if (error instanceof SeiMcpError) {
+        return `[${error.code}] ${error.message}`;
+    }
+    return `[INTERNAL_ERROR] ${normalizeErrorMessage(error)}`;
+}
+export function toErrorLogMeta(error) {
+    if (error instanceof SeiMcpError) {
+        return {
+            code: error.code,
+            message: error.message,
+            details: toJsonValue(error.details),
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack ?? '',
+        };
+    }
+    return {
+        message: normalizeErrorMessage(error),
+    };
+}
+function toJsonValue(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => toJsonValue(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toJsonValue(item)]));
+    }
+    return String(value);
+}

package/dist/core/index.d.ts

@@ -0,0 +1,14 @@
+export * from './cli-actions.js';
+export * from './cli-helpers.js';
+export * from './config.js';
+export * from './constants.js';
+export * from './env.js';
+export * from './errors.js';
+export * from './logger.js';
+export * from './openapi.js';
+export * from './sei-client.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './command-base/output.js';
+export * from './command-base/payload.js';
+export * from './command-base/sei-command.js';

package/dist/core/index.js

@@ -0,0 +1,14 @@
+export * from './cli-actions.js';
+export * from './cli-helpers.js';
+export * from './config.js';
+export * from './constants.js';
+export * from './env.js';
+export * from './errors.js';
+export * from './logger.js';
+export * from './openapi.js';
+export * from './sei-client.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './command-base/output.js';
+export * from './command-base/payload.js';
+export * from './command-base/sei-command.js';

package/dist/core/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from './types.js';
+export declare function createLogger(level?: string): Logger;

package/dist/core/logger.js

@@ -0,0 +1,71 @@
+import { DEFAULT_LOG_LEVEL, MAX_LOG_TEXT } from './constants.js';
+import { truncateText } from './utils.js';
+const LEVEL_PRIORITY = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+};
+const SENSITIVE_KEYS = new Set([
+    'authorization',
+    'cookie',
+    'password',
+    'token',
+    'aiKey',
+    'ai_key',
+    'secret',
+    'body',
+]);
+export function createLogger(level = DEFAULT_LOG_LEVEL) {
+    const threshold = LEVEL_PRIORITY[normalizeLevel(level)] ?? LEVEL_PRIORITY.info;
+    function write(targetLevel, message, meta) {
+        if (LEVEL_PRIORITY[targetLevel] > threshold) {
+            return;
+        }
+        const entry = {
+            level: targetLevel,
+            message: truncateText(message, MAX_LOG_TEXT),
+            meta: sanitizeMeta(meta),
+            time: new Date().toISOString(),
+        };
+        process.stderr.write(`${JSON.stringify(entry)}\n`);
+    }
+    return {
+        debug(message, meta) {
+            write('debug', message, meta);
+        },
+        info(message, meta) {
+            write('info', message, meta);
+        },
+        warn(message, meta) {
+            write('warn', message, meta);
+        },
+        error(message, meta) {
+            write('error', message, meta);
+        },
+    };
+}
+function normalizeLevel(level) {
+    const normalized = level.trim().toLowerCase();
+    if (normalized === 'debug' || normalized === 'info' || normalized === 'warn' || normalized === 'error') {
+        return normalized;
+    }
+    return 'info';
+}
+function sanitizeMeta(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeMeta(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (SENSITIVE_KEYS.has(key)) {
+            result[key] = '[REDACTED]';
+            continue;
+        }
+        result[key] = sanitizeMeta(item);
+    }
+    return result;
+}

package/dist/core/openapi.d.ts

@@ -0,0 +1,2 @@
+export declare function buildOpenApiDocSummary(openapiDoc: unknown, keyword?: string): Record<string, unknown>;
+export declare function renderOpenApiMarkdown(summary: Record<string, unknown>): string;

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 {};