@aflueza/log-analysis 0.0.0-stage → 0.2.1-rc.2

package/lib/index.js

@@ -0,0 +1,540 @@
+import { LogAnalyzer } from './analyzer.js';
+import { ParserRulesDatabase, ParserRulesDatabaseError } from './database/parser-rules-database.js';
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import z from '@deepseek-ai/schemastery';
+const CHANNEL = '/log-analysis';
+const analyzer = new LogAnalyzer();
+let parserRules;
+const parserSuggestionControllers = new Map();
+export const name = 'log-analysis';
+export const Config = z.object({
+    analysisProvider: z.string().default('').volatile(),
+    analysisModel: z.string().default('').volatile(),
+    analysisReasoningEffort: z.string().default('').volatile(),
+});
+export const inject = ['connection', 'webServer', 'tools', 'llm', 'settings'];
+export function apply(ctx, config) {
+    parserRules = new ParserRulesDatabase(dshHomePath('plugins', 'log-analysis', 'dsh-log-analysis.sqlite'));
+    ctx.effect(() => () => {
+        parserRules?.close();
+        parserRules = undefined;
+    }, 'log-analysis: close parser rules database');
+    // The web profile does not mount a console logger exporter by default. Keep
+    // this plugin's operational records visible to the process log without
+    // routing unrelated DSH messages to stdout.
+    ctx.effect(() => ctx.logger.exporter({
+        export: (message) => {
+            const first = message.args[0];
+            if (typeof first !== 'string' || !first.startsWith('log-analysis:'))
+                return;
+            // eslint-disable-next-line no-console
+            console.log(`[${message.type.toUpperCase()}]`, ...message.args);
+        },
+    }), 'log-analysis: console exporter');
+    ctx.inject(['connection', 'webServer', 'llm', 'settings'], (rpcCtx) => {
+        const webServer = rpcCtx.webServer;
+        const runtime = rpcCtx;
+        rpcCtx.effect(() => {
+            const unconfigure = runtime.settings.configure({ auto: false }, rpcCtx.fiber);
+            const unregister = webServer.register({
+                kind: 'prefix',
+                path: CHANNEL,
+                handler: (request, response) => handleRpcRequest(rpcCtx.connection, runtime, request, response),
+            });
+            return () => {
+                unregister();
+                unconfigure();
+            };
+        }, 'log-analysis: RPC route');
+    });
+    ctx.inject(['tools'], (toolCtx) => {
+        const tools = toolCtx.tools;
+        const dispose = tools.register(rawTool('log_analysis_summary', '查询当前日志分析会话的概览统计、Top 错误、趋势和最近异常。', {}, async () => ({ summary: analyzer.summary() })));
+        return dispose;
+    });
+}
+function rawTool(name, description, parameters, execute) {
+    return {
+        name,
+        description,
+        parameters: { type: 'object', properties: parameters },
+        output: {
+            schema: { type: 'json' },
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
+        },
+        execute,
+    };
+}
+async function handleRpcRequest(connection, runtime, request, response) {
+    const rejection = connection.requestRejection(request);
+    if (rejection !== undefined) {
+        response.writeHead(rejection);
+        response.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+    }
+    const endpoint = endpointFromRequest(request);
+    if (request.method !== 'POST' || endpoint === null) {
+        response.writeHead(404);
+        response.end('not found');
+        return;
+    }
+    const mediaType = request.headers['content-type']?.split(';', 1)[0]?.trim().toLowerCase();
+    if (mediaType !== 'application/json') {
+        response.writeHead(415);
+        response.end('content type must be application/json');
+        return;
+    }
+    let message;
+    try {
+        message = parseClientRequest(await readJsonBody(request));
+    }
+    catch {
+        response.writeHead(400);
+        response.end('invalid rpc request');
+        return;
+    }
+    if (message.method !== endpoint) {
+        writeRpcResult(response, message.rpcId, fail('invalid-payload', `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`));
+        return;
+    }
+    writeRpcResult(response, message.rpcId, await dispatch(endpoint, message.payload, runtime));
+}
+function parseClientRequest(value) {
+    if (!isRecord(value) ||
+        value.type !== 'client-request' ||
+        typeof value.rpcId !== 'string' ||
+        typeof value.method !== 'string' ||
+        !('payload' in value)) {
+        throw new TypeError('invalid client request envelope');
+    }
+    return {
+        type: 'client-request',
+        rpcId: value.rpcId,
+        method: value.method,
+        payload: value.payload,
+    };
+}
+function endpointFromRequest(request) {
+    const pathname = new URL(request.url ?? '/', 'http://x').pathname;
+    const prefix = `${CHANNEL}/`;
+    if (!pathname.startsWith(prefix))
+        return null;
+    return pathname.slice(prefix.length) || null;
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > 16 * 1024 * 1024)
+            throw new RangeError('request body exceeds 16 MiB');
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+function writeRpcResult(response, rpcId, result) {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ type: 'server-response', rpcId, result }));
+}
+async function dispatch(endpoint, payload, runtime) {
+    try {
+        return ok(await dispatchEndpoint(endpoint, payload, runtime));
+    }
+    catch (error) {
+        const failure = error instanceof AnalysisRpcError
+            ? error
+            : error instanceof ParserRulesDatabaseError
+                ? new AnalysisRpcError(error.code, error.message)
+                : new AnalysisRpcError('analysis-failed', error instanceof Error ? error.message : String(error));
+        return fail(failure.code, failure.message);
+    }
+}
+async function dispatchEndpoint(endpoint, payload, runtime) {
+    switch (endpoint) {
+        case 'parser-rules/list':
+            return parserRules?.list() ?? [];
+        case 'parser-rules/get':
+            return parserRules?.get(String(payload?.id));
+        case 'parser-rules/create': {
+            const input = payload;
+            if (typeof input.name !== 'string' ||
+                !input.rule ||
+                (input.sampleRaw !== undefined && typeof input.sampleRaw !== 'string'))
+                throw new AnalysisRpcError('invalid-payload', '解析规则参数无效');
+            return await parserRules.create(input.name, input.rule, String(input.sampleRaw ?? ''));
+        }
+        case 'parser-rules/update': {
+            const input = payload;
+            if (typeof input.id !== 'string' ||
+                typeof input.name !== 'string' ||
+                !input.rule ||
+                (input.sampleRaw !== undefined && typeof input.sampleRaw !== 'string'))
+                throw new AnalysisRpcError('invalid-payload', '解析规则参数无效');
+            return await parserRules.update(input.id, input.name, input.rule, String(input.sampleRaw ?? ''));
+        }
+        case 'parser-rules/delete': {
+            const input = payload;
+            if (typeof input?.id !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '解析规则参数无效');
+            await parserRules.delete(input.id);
+            return { id: input.id, deleted: true };
+        }
+        case 'parser-rules/validate': {
+            const input = payload;
+            if (!input?.rule || typeof input.sampleRaw !== 'string' || typeof input.fileName !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '规则验证参数无效');
+            return analyzer.previewRuleOnSample(input.rule, input.sampleRaw, input.fileName);
+        }
+        case 'analysis/models':
+            return modelCatalog(runtime);
+        case 'analysis/model-info': {
+            const input = payload;
+            if (typeof input?.provider !== 'string' || typeof input.model !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '模型信息请求无效');
+            const info = await runtime.llm.resolveModelInfo(input.provider, input.model);
+            return info.reasoning ? { reasoning: info.reasoning } : {};
+        }
+        case 'analysis/parser/suggest/cancel': {
+            const input = payload;
+            if (!input || (input.sessionId !== undefined && input.sessionId !== analyzer.sessionId))
+                throw new AnalysisRpcError('analysis-session-expired', '分析会话已失效，请重新开始分析');
+            if (typeof input.requestId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '识别取消请求无效');
+            const controller = parserSuggestionControllers.get(input.requestId);
+            controller?.abort(new Error('日志格式识别已取消'));
+            return { requestId: input.requestId, cancelled: Boolean(controller) };
+        }
+        case 'analysis/start': {
+            const input = payload;
+            const files = input?.files;
+            if (!Array.isArray(files) || files.some((file) => !isFileInput(file))) {
+                throw new Error('analysis/start requires file IDs, names, and sizes');
+            }
+            const samples = input?.samples;
+            if (samples !== undefined &&
+                (!Array.isArray(samples) || samples.some((sample) => !isParserSample(sample))))
+                throw new Error('analysis/start requires bounded log samples');
+            const query = input?.query;
+            if (query !== undefined &&
+                (query === null || typeof query !== 'object' || Array.isArray(query))) {
+                throw new Error('analysis/start query must be an object');
+            }
+            return analyzer.start(files, (samples ?? []), (query ?? {}));
+        }
+        case 'analysis/sample/open': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId || typeof input.fileId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '样例分块打开请求无效');
+            const level = input.level === undefined || input.level === 'ALL'
+                ? undefined
+                : String(input.level);
+            return analyzer.openSampleChunk(input.fileId, level);
+        }
+        case 'analysis/sample/chunk': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId ||
+                typeof input.fileId !== 'string' ||
+                typeof input.offset !== 'number' ||
+                typeof input.content !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '样例分块请求无效');
+            if (Buffer.byteLength(input.content, 'utf8') > 512 * 1024)
+                throw new AnalysisRpcError('chunk-too-large', '单个文件分块不能超过 512 KiB');
+            const byteLength = input.byteLength === undefined ? undefined : Number(input.byteLength);
+            if (byteLength !== undefined &&
+                (!Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > 512 * 1024))
+                throw new AnalysisRpcError('invalid-payload', '样例分块字节长度无效');
+            return analyzer.appendSampleChunk(input.fileId, input.offset, input.content, input.eof === true, byteLength);
+        }
+        case 'analysis/sample/finish': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId || typeof input.fileId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '样例分块完成请求无效');
+            return analyzer.finishSampleChunk(input.fileId);
+        }
+        case 'analysis/sample/cancel': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId || typeof input.fileId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '样例分块取消请求无效');
+            analyzer.cancelSampleChunk(input.fileId);
+            return { fileId: input.fileId, cancelled: true };
+        }
+        case 'analysis/parser/suggest': {
+            const input = payload;
+            const hasExternalSample = typeof input?.sampleRaw === 'string';
+            if (!hasExternalSample && input?.sessionId !== analyzer.sessionId)
+                throw new AnalysisRpcError('analysis-session-expired', '分析会话已失效，请重新开始分析');
+            if (typeof input?.requestId !== 'string' ||
+                (hasExternalSample
+                    ? !String(input.sampleRaw).trim() ||
+                        String(input.sampleRaw).length > 120_000 ||
+                        typeof input.fileName !== 'string'
+                    : typeof input.fileId !== 'string' || typeof input.sampleVersion !== 'number')) {
+                throw new AnalysisRpcError('invalid-payload', '智能识别请求缺少样例信息');
+            }
+            if (parserSuggestionControllers.has(input.requestId))
+                throw new AnalysisRpcError('invalid-payload', '识别请求 ID 已在使用');
+            const controller = new AbortController();
+            parserSuggestionControllers.set(input.requestId, controller);
+            try {
+                const config = activeConfig(runtime);
+                if (!config.analysisProvider || !config.analysisModel)
+                    throw new AnalysisRpcError('analysis-model-not-configured', '请先在设置中选择分析模型');
+                const provider = runtime.llm
+                    .listProviders()
+                    .find((item) => item.id === config.analysisProvider);
+                if (!provider) {
+                    await runtime.settings.update('log-analysis', {
+                        analysisProvider: '',
+                        analysisModel: '',
+                        analysisReasoningEffort: '',
+                    });
+                    throw new AnalysisRpcError('analysis-model-unavailable', '分析模型不可用，请重新选择');
+                }
+                const models = await runtime.llm.listModels(config.analysisProvider);
+                const selectedModelInfo = models.find((item) => item.id === config.analysisModel);
+                if (!selectedModelInfo) {
+                    await runtime.settings.update('log-analysis', {
+                        analysisProvider: '',
+                        analysisModel: '',
+                        analysisReasoningEffort: '',
+                    });
+                    throw new AnalysisRpcError('analysis-model-unavailable', '分析模型不可用，请重新选择');
+                }
+                const resolvedModelInfo = await runtime.llm.resolveModelInfo(config.analysisProvider, config.analysisModel);
+                const efforts = resolvedModelInfo.reasoning?.efforts ?? [];
+                const reasoningEffort = config.analysisReasoningEffort &&
+                    efforts.some((effort) => effort.id === config.analysisReasoningEffort)
+                    ? config.analysisReasoningEffort
+                    : (resolvedModelInfo.reasoning?.defaultEffort ?? efforts[0]?.id);
+                const fileId = hasExternalSample
+                    ? `rule-management:${input.requestId}`
+                    : String(input.fileId);
+                const requestedSampleVersion = hasExternalSample ? -1 : Number(input.sampleVersion);
+                runtime.logger.info(`log-analysis: parser suggestion started provider=${config.analysisProvider} model=${config.analysisModel} fileId=${fileId} sampleVersion=${requestedSampleVersion}`);
+                try {
+                    const result = await analyzer.suggestParser(config.analysisProvider, config.analysisModel, async function* (selectedProvider, selectedModel, prompt) {
+                        yield* runtime.llm.stream({
+                            provider: selectedProvider,
+                            model: selectedModel,
+                            ...(reasoningEffort ? { reasoningEffort } : {}),
+                            signal: controller.signal,
+                            messages: [{ role: 'user', content: [{ type: 'text', text: prompt }] }],
+                        });
+                    }, fileId, requestedSampleVersion, controller.signal, (phase, content) => {
+                        runtime.logger.info(`log-analysis: parser suggestion model ${phase} requestId=${input.requestId}\n${content}`);
+                    }, hasExternalSample
+                        ? { content: String(input.sampleRaw), fileName: String(input.fileName) }
+                        : undefined);
+                    runtime.logger.info(`log-analysis: parser suggestion completed format=${result.format} records=${result.records.length} validationErrors=${result.validationErrors.length} executionErrors=${result.executionErrors.length}`);
+                    return result;
+                }
+                catch (error) {
+                    if (controller.signal.aborted)
+                        throw new AnalysisRpcError('analysis-parser-suggestion-cancelled', '日志格式识别已取消');
+                    const message = error instanceof Error ? error.message : String(error);
+                    runtime.logger.error(`log-analysis: parser suggestion failed provider=${config.analysisProvider} model=${config.analysisModel} fileId=${input.fileId} sampleVersion=${input.sampleVersion} error=${message}`);
+                    throw new AnalysisRpcError('analysis-parser-suggestion-failed', message);
+                }
+            }
+            finally {
+                if (parserSuggestionControllers.get(input.requestId) === controller)
+                    parserSuggestionControllers.delete(input.requestId);
+            }
+        }
+        case 'analysis/parser/sample': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId ||
+                typeof input.fileId !== 'string' ||
+                typeof input.content !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '样例更新请求无效或会话已失效');
+            if (input.source !== 'default' && input.source !== 'level' && input.source !== 'manual')
+                throw new AnalysisRpcError('invalid-payload', '样例来源无效');
+            const level = input.level === undefined ? undefined : String(input.level);
+            if (level !== undefined &&
+                !['ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE', 'UNKNOWN'].includes(level)) {
+                throw new AnalysisRpcError('invalid-payload', '样例级别无效');
+            }
+            if (input.rule !== undefined)
+                return analyzer.previewParserRule(input.rule, input.fileId);
+            return analyzer.setSample(input.fileId, input.content, input.source, level);
+        }
+        case 'analysis/file': {
+            const input = payload;
+            if (!input ||
+                typeof input.fileId !== 'string' ||
+                typeof input.ruleId !== 'string' ||
+                typeof input.content !== 'string') {
+                throw new Error('analysis/file requires a file ID, rule ID, and complete text content');
+            }
+            const record = parserRules.get(input.ruleId);
+            return analyzer.analyzeFile(input.fileId, input.content, record.id, record.rule);
+        }
+        case 'analysis/file/open': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId ||
+                typeof input.fileId !== 'string' ||
+                typeof input.ruleId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '文件分块打开请求无效');
+            if (input.query !== undefined &&
+                (input.query === null || typeof input.query !== 'object' || Array.isArray(input.query)))
+                throw new AnalysisRpcError('invalid-payload', '分析条件无效');
+            if (input.query !== undefined)
+                analyzer.setQuery(input.query);
+            const record = parserRules.get(input.ruleId);
+            return analyzer.openFileChunk(input.fileId, record.id, record.rule);
+        }
+        case 'analysis/file/chunk': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId ||
+                typeof input.fileId !== 'string' ||
+                typeof input.offset !== 'number' ||
+                typeof input.content !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '文件分块请求无效');
+            if (Buffer.byteLength(input.content, 'utf8') > 512 * 1024)
+                throw new AnalysisRpcError('chunk-too-large', '单个文件分块不能超过 512 KiB');
+            const byteLength = input.byteLength === undefined ? undefined : Number(input.byteLength);
+            if (byteLength !== undefined &&
+                (!Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > 512 * 1024))
+                throw new AnalysisRpcError('invalid-payload', '文件分块字节长度无效');
+            return analyzer.appendFileChunk(input.fileId, input.offset, input.content, input.eof === true, byteLength);
+        }
+        case 'analysis/file/finish': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId || typeof input.fileId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '文件分块完成请求无效');
+            return analyzer.finishFileChunk(input.fileId);
+        }
+        case 'analysis/file/cancel': {
+            const input = payload;
+            if (input?.sessionId !== analyzer.sessionId || typeof input.fileId !== 'string')
+                throw new AnalysisRpcError('invalid-payload', '文件分块取消请求无效');
+            return analyzer.cancelFileChunk(input.fileId);
+        }
+        case 'analysis/file-failed': {
+            const input = payload;
+            if (!input || typeof input.fileId !== 'string' || typeof input.message !== 'string') {
+                throw new Error('analysis/file-failed requires a file ID and error message');
+            }
+            return analyzer.failFile(input.fileId, input.message);
+        }
+        case 'analysis/remove-file': {
+            const input = payload;
+            if (!input || typeof input.fileId !== 'string') {
+                throw new Error('analysis/remove-file requires a file ID');
+            }
+            return analyzer.removeFile(input.fileId);
+        }
+        case 'analysis/summary': {
+            const input = payload;
+            if (typeof input?.ruleId !== 'string' || !input.ruleId.trim())
+                throw new AnalysisRpcError('invalid-payload', '查询分析摘要必须提供解析规则 ID');
+            const rule = parserRules.get(input.ruleId);
+            return analyzer.summary(rule);
+        }
+        case 'analysis/entry':
+            return analyzer.entry(String(payload.id));
+        case 'analysis/clear':
+            analyzer.clear();
+            return analyzer.summary();
+        case 'analysis/cancel':
+            analyzer.cancel();
+            return analyzer.summary();
+    }
+}
+class AnalysisRpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function activeConfig(runtime) {
+    const value = runtime.settings.describe().find((row) => row.ns === 'log-analysis')?.value;
+    if (!isRecord(value))
+        return { analysisProvider: '', analysisModel: '', analysisReasoningEffort: '' };
+    return {
+        analysisProvider: typeof value.analysisProvider === 'string' ? value.analysisProvider : '',
+        analysisModel: typeof value.analysisModel === 'string' ? value.analysisModel : '',
+        analysisReasoningEffort: typeof value.analysisReasoningEffort === 'string' ? value.analysisReasoningEffort : '',
+    };
+}
+async function modelCatalog(runtime) {
+    const config = activeConfig(runtime);
+    const providers = await Promise.all(runtime.llm.listProviders().map(async (provider) => {
+        try {
+            const models = await runtime.llm.listModels(provider.id);
+            return { ...provider, models: models.map(({ id, name }) => ({ id, name })) };
+        }
+        catch {
+            return { ...provider, models: [] };
+        }
+    }));
+    const selected = providers.find((provider) => provider.id === config.analysisProvider);
+    const wasConfigured = Boolean(config.analysisProvider || config.analysisModel);
+    const selectedModel = selected?.models.find((model) => model.id === config.analysisModel);
+    const configured = Boolean(selectedModel);
+    if ((config.analysisProvider || config.analysisModel) && !configured) {
+        await runtime.settings.update('log-analysis', {
+            analysisProvider: '',
+            analysisModel: '',
+            analysisReasoningEffort: '',
+        });
+    }
+    else if (configured) {
+        let reasoning;
+        try {
+            reasoning = (await runtime.llm.resolveModelInfo(config.analysisProvider, config.analysisModel)).reasoning;
+        }
+        catch {
+            reasoning = undefined;
+        }
+        const efforts = reasoning?.efforts ?? [];
+        if ((!config.analysisReasoningEffort ||
+            !efforts.some((effort) => effort.id === config.analysisReasoningEffort)) &&
+            (reasoning || config.analysisReasoningEffort)) {
+            await runtime.settings.update('log-analysis', {
+                analysisReasoningEffort: reasoning?.defaultEffort ?? efforts[0]?.id ?? '',
+            });
+        }
+        if (reasoning && selected) {
+            selected.models = selected.models.map((model) => model.id === config.analysisModel ? { ...model, reasoning } : model);
+        }
+    }
+    return {
+        providers,
+        configured,
+        invalidated: wasConfigured && !configured,
+        ...(configured
+            ? { selectedProvider: config.analysisProvider, selectedModel: config.analysisModel }
+            : {}),
+        ...(configured && config.analysisReasoningEffort
+            ? { selectedReasoningEffort: config.analysisReasoningEffort }
+            : {}),
+    };
+}
+function isFileInput(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const file = value;
+    return (typeof file.id === 'string' &&
+        typeof file.name === 'string' &&
+        typeof file.size === 'number' &&
+        Number.isFinite(file.size) &&
+        file.size >= 0);
+}
+function isParserSample(value) {
+    return (isRecord(value) &&
+        typeof value.fileId === 'string' &&
+        typeof value.content === 'string' &&
+        value.content.length <= 512_000);
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function fail(code, message) {
+    return { ok: false, error: { code, message, details: {} } };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/lib/shared/types.js

@@ -0,0 +1 @@
+export {};