cogmem 3.6.2

package/dist/utils/ConversationMarkdownNormalization.js

@@ -0,0 +1,567 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const NORMALIZED_SOURCE_FAMILY = 'normalized_conversation_markdown';
+const NORMALIZATION_CONTRACT_VERSION = 'v1';
+const DEFAULT_ONBOARDING_PATH = 'export/preprocess -> normalize -> batch:preflight -> batch:consolidate --strict -> recall';
+export function parseNormalizerArgs(argv, usage) {
+    const args = argv[0] === '--' ? argv.slice(1) : argv;
+    const result = {
+        title: 'Normalized Conversation Export',
+        format: undefined
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === '--input')
+            result.input = args[index + 1];
+        if (token === '--output')
+            result.output = args[index + 1];
+        if (token === '--title')
+            result.title = args[index + 1];
+        if (token === '--format') {
+            const format = args[index + 1];
+            if (format === 'csv' || format === 'tsv')
+                result.format = format;
+        }
+        if (token.startsWith('--'))
+            index += 1;
+    }
+    if (!result.input || !result.output) {
+        throw new Error(usage);
+    }
+    return result;
+}
+export function normalizeRole(input) {
+    const lowered = (input || '').trim().toLowerCase();
+    if (['assistant', 'agent', 'ai', 'bot', 'model'].includes(lowered))
+        return 'agent';
+    if (['system', 'sys'].includes(lowered))
+        return 'system';
+    if (['narrator', 'note', 'notes', 'memo'].includes(lowered))
+        return 'narrator';
+    return 'user';
+}
+export function pickMessageText(item) {
+    const direct = coerceText(item.content) || coerceText(item.text) || coerceText(item.message);
+    return direct.trim();
+}
+export function pickTimestamp(item, fallback) {
+    const raw = coerceText(item.occurredAt)
+        || coerceText(item.occurred_at)
+        || coerceText(item.timestamp)
+        || coerceText(item.created_at)
+        || coerceText(item.createdAt)
+        || coerceText(item.sentAt)
+        || coerceText(item.sent_at)
+        || coerceText(item.time)
+        || coerceText(item.InsertTime)
+        || coerceText(item.insertTime)
+        || coerceText(item.insert_time);
+    const date = raw ? parseTimestampDate(raw, fallback) : new Date(fallback);
+    const usable = Number.isNaN(date.getTime()) ? new Date(fallback) : date;
+    return usable.toISOString();
+}
+export function writeNormalizedConversationMarkdown(outputPath, title, family, messages, markers = []) {
+    assertNormalizedMessages(messages, family);
+    const uniqueMarkers = dedupeMarkers(markers);
+    const content = [
+        `# ${title}`,
+        '',
+        '<!-- cogmem-normalized: true -->',
+        `<!-- cogmem-normalization-contract: ${NORMALIZATION_CONTRACT_VERSION} -->`,
+        `<!-- cogmem-normalized-source-family: ${NORMALIZED_SOURCE_FAMILY} -->`,
+        `<!-- cogmem-original-input-family: ${family} -->`,
+        `<!-- cogmem-normalized-from: ${family} -->`,
+        `<!-- cogmem-normalized-title: ${escapeMarkerValue(title)} -->`,
+        `<!-- cogmem-onboarding-path: ${DEFAULT_ONBOARDING_PATH} -->`,
+        ...uniqueMarkers.map((marker) => `<!-- ${marker.key}: ${escapeMarkerValue(marker.value)} -->`),
+        '',
+        ...messages.flatMap((message) => [
+            message.source ? `<!-- cogmem-source-ref: ${escapeMarkerValue(JSON.stringify(message.source))} -->` : undefined,
+            `- [${message.timestamp}] ${message.role}: ${message.text}`,
+        ].filter((line) => Boolean(line)))
+    ].join('\n');
+    mkdirSync(dirname(outputPath), { recursive: true });
+    writeFileSync(outputPath, content);
+}
+export function normalizeJsonlRecords(inputPath) {
+    const input = readFileSync(inputPath, 'utf8').replace(/\r\n/g, '\n');
+    let sourceOffset = 0;
+    return input.split('\n').flatMap((line, lineIndex) => {
+        if (!line.trim())
+            return [];
+        const parsed = asLooseRecord(JSON.parse(line));
+        const messages = Array.isArray(parsed.messages)
+            ? parsed.messages.map((item) => asLooseRecord(item))
+            : [];
+        if (messages.length > 0) {
+            return messages.flatMap((message, messageIndex) => {
+                sourceOffset += 1;
+                return normalizeLooseRecordWithParent(message, parsed, sourceOffset - 1, {
+                    sourceOffset,
+                    lineStart: lineIndex + 1,
+                    lineEnd: lineIndex + 1,
+                    orderingConfidence: 'high',
+                }, messageIndex);
+            });
+        }
+        sourceOffset += 1;
+        return normalizeLooseRecord(parsed, sourceOffset - 1, {
+            sourceOffset,
+            lineStart: lineIndex + 1,
+            lineEnd: lineIndex + 1,
+            orderingConfidence: 'high',
+        });
+    });
+}
+export function normalizeJsonArrayRecords(inputPath) {
+    const parsed = JSON.parse(readFileSync(inputPath, 'utf8'));
+    if (!Array.isArray(parsed)) {
+        throw new Error('Expected a top-level JSON array.');
+    }
+    return parsed.flatMap((item, index) => normalizeLooseRecord(asLooseRecord(item), index, {
+        sourceOffset: index + 1,
+        orderingConfidence: 'high',
+    }));
+}
+export function normalizeDelimitedRecords(inputPath, format) {
+    const input = readFileSync(inputPath, 'utf8').replace(/\r\n/g, '\n');
+    const delimiter = resolveDelimiter(inputPath, input, format);
+    const family = delimiter === '\t' ? 'tsv_transcript_export' : 'csv_transcript_export';
+    const rows = parseDelimited(input, delimiter);
+    if (rows.length === 0) {
+        throw new Error('Expected a header row plus at least one transcript row.');
+    }
+    const headers = rows[0].cells.map((cell) => normalizeHeader(cell));
+    const messages = rows.slice(1).flatMap((row, index) => {
+        const record = {};
+        headers.forEach((header, columnIndex) => {
+            if (!header)
+                return;
+            record[header] = row.cells[columnIndex] ?? '';
+        });
+        return normalizeLooseRecord(record, index, {
+            sourceOffset: index + 1,
+            lineStart: row.lineStart,
+            lineEnd: row.lineEnd,
+            orderingConfidence: 'high',
+        });
+    });
+    return { family, messages };
+}
+export function detectNormalizationFamily(markdown) {
+    return parseNormalizationMetadata(markdown).originalInputFamily;
+}
+export function parseNormalizationMetadata(markdown) {
+    const legacyFamily = readAnyMarker(markdown, 'cogmem-normalized-from', 'agent-brain-normalized-from');
+    const originalInputFamily = readAnyMarker(markdown, 'cogmem-original-input-family', 'agent-brain-original-input-family') || legacyFamily;
+    const normalizedSourceFamily = readAnyMarker(markdown, 'cogmem-normalized-source-family', 'agent-brain-normalized-source-family');
+    const contractVersion = readAnyMarker(markdown, 'cogmem-normalization-contract', 'agent-brain-normalization-contract');
+    const normalizedValue = readAnyMarker(markdown, 'cogmem-normalized', 'agent-brain-normalized');
+    const title = readAnyMarker(markdown, 'cogmem-normalized-title', 'agent-brain-normalized-title');
+    const onboardingPath = readAnyMarker(markdown, 'cogmem-onboarding-path', 'agent-brain-onboarding-path');
+    const family = originalInputFamily;
+    if (family !== 'jsonl_transcript_export'
+        && family !== 'json_array_transcript_export'
+        && family !== 'csv_transcript_export'
+        && family !== 'tsv_transcript_export'
+        && family !== 'app_private_mixed_event_export'
+        && family !== 'jsonl_mixed_event_log_export') {
+        return {
+            isNormalized: normalizedValue === 'true' || Boolean(legacyFamily)
+        };
+    }
+    return {
+        isNormalized: normalizedValue === 'true' || Boolean(legacyFamily),
+        contractVersion: contractVersion === NORMALIZATION_CONTRACT_VERSION ? NORMALIZATION_CONTRACT_VERSION : undefined,
+        normalizedSourceFamily: normalizedSourceFamily === NORMALIZED_SOURCE_FAMILY ? NORMALIZED_SOURCE_FAMILY : undefined,
+        originalInputFamily: family,
+        title,
+        onboardingPath
+    };
+}
+export function createConversationMarkdownNormalizer(options) {
+    return (records) => records.flatMap((record, index) => {
+        const mapped = options.mapRecord(record, index);
+        if (!mapped)
+            return [];
+        const entries = Array.isArray(mapped) ? mapped : [mapped];
+        return entries.filter((entry) => entry.text.trim());
+    });
+}
+export function normalizeAppPrivateMixedEventRecords(inputPath) {
+    return normalizeAppPrivateMixedEventExport(inputPath).messages;
+}
+export function normalizeAppPrivateMixedEventExport(inputPath) {
+    const parsed = JSON.parse(readFileSync(inputPath, 'utf8'));
+    return normalizeEventExportToConversationMarkdown(parsed, createExportBridge({
+        inputFamily: 'app_private_mixed_event_export',
+        selectRecords: (root) => {
+            const events = root.events;
+            return Array.isArray(events) ? events.map((item) => asLooseRecord(item)) : [];
+        },
+        isMessageCandidate: (event) => {
+            const eventKind = coerceText(event.kind) || coerceText(event.type) || coerceText(event.eventType);
+            return eventKind.toLowerCase() === 'message';
+        },
+        mapRole: (event) => {
+            const actor = asLooseRecord(event.actor);
+            return coerceText(actor.role) || coerceText(actor.type) || coerceText(event.role);
+        },
+        extractText: (event) => {
+            const body = asLooseRecord(event.body);
+            return (coerceText(body.text)
+                || coerceText(body.content)
+                || coerceText(body.message)
+                || coerceText(event.text)
+                || coerceText(event.message)).trim();
+        },
+        resolveTimestamp: (event, context) => pickTimestamp({
+            timestamp: coerceText(event.occurred_at) || coerceText(event.timestamp),
+            created_at: coerceText(event.created_at),
+            createdAt: coerceText(event.createdAt),
+            time: coerceText(event.time)
+        }, Date.now() + context.index * 1000),
+        emitMarkers: (event) => {
+            const actor = asLooseRecord(event.actor);
+            const kind = coerceText(event.kind) || coerceText(event.type) || coerceText(event.eventType);
+            return [
+                { key: 'cogmem-bridge-input-family', value: 'app_private_mixed_event_export' },
+                { key: 'cogmem-bridge-event-selector', value: 'kind/type/eventType == message' },
+                { key: 'cogmem-bridge-role-source', value: coerceText(actor.role) ? 'actor.role' : coerceText(actor.type) ? 'actor.type' : 'event.role' },
+                { key: 'cogmem-bridge-text-source', value: pickFirstMarkerValue([
+                        [coerceText(asLooseRecord(event.body).text), 'body.text'],
+                        [coerceText(asLooseRecord(event.body).content), 'body.content'],
+                        [coerceText(asLooseRecord(event.body).message), 'body.message'],
+                        [coerceText(event.text), 'event.text'],
+                        [coerceText(event.message), 'event.message']
+                    ]) || 'unknown' },
+                { key: 'cogmem-bridge-timestamp-source', value: pickFirstMarkerValue([
+                        [coerceText(event.occurred_at), 'occurred_at'],
+                        [coerceText(event.timestamp), 'timestamp'],
+                        [coerceText(event.created_at), 'created_at'],
+                        [coerceText(event.createdAt), 'createdAt'],
+                        [coerceText(event.time), 'time']
+                    ]) || 'normalization_fallback' }
+            ];
+        }
+    }));
+}
+export function normalizeJsonlMixedEventLogRecords(inputPath) {
+    return normalizeJsonlMixedEventLogExport(inputPath).messages;
+}
+export function normalizeJsonlMixedEventLogExport(inputPath) {
+    const input = readFileSync(inputPath, 'utf8').replace(/\r\n/g, '\n');
+    const events = input
+        .split('\n')
+        .filter((line) => line.trim())
+        .map((line) => asLooseRecord(JSON.parse(line)));
+    return normalizeEventExportToConversationMarkdown(events, createExportBridge({
+        inputFamily: 'jsonl_mixed_event_log_export',
+        selectRecords: (root) => root,
+        isMessageCandidate: (event) => {
+            const eventType = (coerceText(event.type) || coerceText(event.kind)).toLowerCase();
+            return (eventType === 'message'
+                || eventType === 'message.created'
+                || eventType === 'message.appended');
+        },
+        mapRole: (event) => {
+            const payload = asLooseRecord(event.payload);
+            const actor = asLooseRecord(event.actor);
+            return coerceText(payload.role) || coerceText(actor.role) || coerceText(actor.type) || coerceText(event.role);
+        },
+        extractText: (event) => {
+            const payload = asLooseRecord(event.payload);
+            return (coerceText(payload.text)
+                || coerceText(payload.content)
+                || coerceText(payload.message)
+                || coerceText(event.message)
+                || coerceText(event.text)).trim();
+        },
+        resolveTimestamp: (event, context) => {
+            const payload = asLooseRecord(event.payload);
+            return pickTimestamp({
+                timestamp: coerceText(payload.timestamp) || coerceText(event.timestamp),
+                created_at: coerceText(event.created_at) || coerceText(payload.created_at),
+                createdAt: coerceText(event.createdAt) || coerceText(payload.createdAt),
+                time: coerceText(event.time)
+            }, Date.now() + context.index * 1000);
+        },
+        emitMarkers: (event) => {
+            const payload = asLooseRecord(event.payload);
+            return [
+                { key: 'cogmem-bridge-input-family', value: 'jsonl_mixed_event_log_export' },
+                { key: 'cogmem-bridge-event-selector', value: 'type/kind in message-like events with text payload' },
+                { key: 'cogmem-bridge-role-source', value: pickFirstMarkerValue([
+                        [coerceText(payload.role), 'payload.role'],
+                        [coerceText(asLooseRecord(event.actor).role), 'actor.role'],
+                        [coerceText(asLooseRecord(event.actor).type), 'actor.type'],
+                        [coerceText(event.role), 'event.role']
+                    ]) || 'user_fallback' },
+                { key: 'cogmem-bridge-text-source', value: pickFirstMarkerValue([
+                        [coerceText(payload.text), 'payload.text'],
+                        [coerceText(payload.content), 'payload.content'],
+                        [coerceText(payload.message), 'payload.message'],
+                        [coerceText(event.message), 'event.message'],
+                        [coerceText(event.text), 'event.text']
+                    ]) || 'unknown' },
+                { key: 'cogmem-bridge-timestamp-source', value: pickFirstMarkerValue([
+                        [coerceText(payload.timestamp), 'payload.timestamp'],
+                        [coerceText(event.timestamp), 'event.timestamp'],
+                        [coerceText(event.created_at), 'event.created_at'],
+                        [coerceText(payload.created_at), 'payload.created_at'],
+                        [coerceText(event.createdAt), 'event.createdAt'],
+                        [coerceText(payload.createdAt), 'payload.createdAt'],
+                        [coerceText(event.time), 'event.time']
+                    ]) || 'normalization_fallback' }
+            ];
+        }
+    }));
+}
+export function createExportBridge(recipe) {
+    const createContext = (record, index, root, records) => ({
+        index,
+        record,
+        root,
+        inputFamily: recipe.inputFamily
+    });
+    const normalizeRecords = (records, root) => records.flatMap((record, index) => {
+        const resolvedRoot = (root ?? records);
+        const context = createContext(record, index, resolvedRoot, records);
+        if (recipe.isMessageCandidate && !recipe.isMessageCandidate(record, context)) {
+            return [];
+        }
+        const text = (recipe.extractText(record, context) || '').trim();
+        if (!text)
+            return [];
+        return [{
+                role: normalizeRole(recipe.mapRole(record, context)),
+                text,
+                timestamp: recipe.resolveTimestamp(record, context),
+                source: {
+                    sourceOffset: context.index + 1,
+                    orderingConfidence: 'high',
+                },
+            }];
+    });
+    const normalizeRoot = (input) => {
+        const records = recipe.selectRecords ? recipe.selectRecords(input) : input;
+        return normalizeRecords(records, input);
+    };
+    const collectMarkers = (records, root) => {
+        if (!recipe.emitMarkers)
+            return [];
+        const resolvedRoot = (root ?? records);
+        return dedupeMarkers(records.flatMap((record, index) => {
+            const context = createContext(record, index, resolvedRoot, records);
+            if (recipe.isMessageCandidate && !recipe.isMessageCandidate(record, context)) {
+                return [];
+            }
+            return recipe.emitMarkers?.(record, context) || [];
+        }));
+    };
+    const collectRootMarkers = (input) => {
+        const records = recipe.selectRecords ? recipe.selectRecords(input) : input;
+        return collectMarkers(records, input);
+    };
+    return {
+        inputFamily: recipe.inputFamily,
+        normalizeRoot,
+        normalizeRecords,
+        collectMarkers,
+        collectRootMarkers
+    };
+}
+export function normalizeEventExportToConversationMarkdown(input, bridge) {
+    const messages = bridge.normalizeRoot(input);
+    assertBridgeMessages(messages, bridge.inputFamily);
+    return {
+        family: bridge.inputFamily,
+        messages,
+        markers: bridge.collectRootMarkers(input)
+    };
+}
+function assertBridgeMessages(messages, family) {
+    if (messages.length > 0)
+        return;
+    throw new Error(`Bridge normalization failed for ${family}: no message records were produced. Check selectRecords, isMessageCandidate, extractText, resolveTimestamp, and confirm the export exposes stable text/timestamp fields.`);
+}
+function assertNormalizedMessages(messages, family) {
+    if (messages.length === 0) {
+        throw new Error(`Normalization failed for ${family}: no conversation messages were produced.`);
+    }
+    for (const [index, message] of messages.entries()) {
+        if (!message.text.trim()) {
+            throw new Error(`Normalization failed for ${family}: message ${index} is missing text.`);
+        }
+        const timestamp = new Date(message.timestamp);
+        if (Number.isNaN(timestamp.getTime())) {
+            throw new Error(`Normalization failed for ${family}: message ${index} has an invalid timestamp.`);
+        }
+    }
+}
+function readAnyMarker(markdown, ...markers) {
+    for (const marker of markers) {
+        const value = readMarker(markdown, marker);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function readMarker(markdown, marker) {
+    const pattern = new RegExp(`<!--\\s*${marker}:\\s*([^]+?)\\s*-->`, 'i');
+    const match = markdown.match(pattern);
+    return match?.[1]?.trim();
+}
+function escapeMarkerValue(value) {
+    return value.replace(/-->/g, '--&gt;').trim();
+}
+function dedupeMarkers(markers) {
+    const seen = new Set();
+    const output = [];
+    for (const marker of markers) {
+        const key = marker.key.trim();
+        const value = marker.value.trim();
+        if (!key || !value)
+            continue;
+        const identity = `${key}::${value}`;
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        output.push({ key, value });
+    }
+    return output;
+}
+function normalizeLooseRecord(item, index, source) {
+    const text = pickMessageText(item);
+    if (!text)
+        return [];
+    return [{
+            role: normalizeRole(coerceText(item.role)),
+            text,
+            timestamp: pickTimestamp(item, Date.now() + index * 1000),
+            source: source ?? {
+                sourceOffset: index + 1,
+                orderingConfidence: 'high',
+            },
+        }];
+}
+function normalizeLooseRecordWithParent(item, parent, index, source, messageIndex) {
+    const text = pickMessageText(item);
+    if (!text)
+        return [];
+    const parentTimestamp = pickTimestamp(parent, Date.now() + index * 1000 + messageIndex);
+    const parentFallback = Date.parse(parentTimestamp);
+    const timestamp = pickTimestamp(item, Number.isNaN(parentFallback) ? Date.now() + index * 1000 : parentFallback);
+    return [{
+            role: normalizeRole(coerceText(item.role) || coerceText(item.sender) || coerceText(item.author)),
+            text,
+            timestamp,
+            source,
+        }];
+}
+function coerceText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => {
+            if (typeof entry === 'string')
+                return entry;
+            if (entry && typeof entry === 'object' && typeof entry.text === 'string') {
+                return entry.text;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (value && typeof value === 'object' && typeof value.text === 'string') {
+        return value.text;
+    }
+    return '';
+}
+function parseTimestampDate(raw, fallback) {
+    const trimmed = raw.trim();
+    if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        const numeric = Number(trimmed);
+        if (Number.isFinite(numeric)) {
+            return new Date(numeric < 10_000_000_000 ? numeric * 1000 : numeric);
+        }
+    }
+    const parsed = new Date(trimmed);
+    return Number.isNaN(parsed.getTime()) ? new Date(fallback) : parsed;
+}
+function pickFirstMarkerValue(candidates) {
+    for (const [value, label] of candidates) {
+        if (value.trim())
+            return label;
+    }
+    return undefined;
+}
+function asLooseRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function resolveDelimiter(inputPath, input, format) {
+    if (format === 'csv')
+        return ',';
+    if (format === 'tsv')
+        return '\t';
+    if (inputPath.toLowerCase().endsWith('.tsv'))
+        return '\t';
+    const firstLine = input.split('\n').find((line) => line.trim()) || '';
+    return firstLine.includes('\t') ? '\t' : ',';
+}
+function normalizeHeader(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, '_');
+}
+function parseDelimited(input, delimiter) {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let inQuotes = false;
+    let lineNumber = 1;
+    let rowStartLine = 1;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        const next = input[index + 1];
+        if (char === '"') {
+            if (inQuotes && next === '"') {
+                cell += '"';
+                index += 1;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+            continue;
+        }
+        if (!inQuotes && char === delimiter) {
+            row.push(cell);
+            cell = '';
+            continue;
+        }
+        if (!inQuotes && char === '\n') {
+            row.push(cell);
+            if (row.some((value) => value.trim())) {
+                rows.push({ cells: row, lineStart: rowStartLine, lineEnd: lineNumber });
+            }
+            row = [];
+            cell = '';
+            lineNumber += 1;
+            rowStartLine = lineNumber;
+            continue;
+        }
+        if (char === '\n')
+            lineNumber += 1;
+        cell += char;
+    }
+    row.push(cell);
+    if (row.some((value) => value.trim())) {
+        rows.push({ cells: row, lineStart: rowStartLine, lineEnd: lineNumber });
+    }
+    return rows;
+}

package/dist/utils/Logger.d.ts

@@ -0,0 +1,22 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LoggerOptions {
+    level: LogLevel;
+    prefix?: string;
+}
+export declare class Logger {
+    private level;
+    private prefix;
+    constructor(options: LoggerOptions);
+    private shouldLog;
+    private formatMessage;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+}
+export declare function getLogger(prefix?: string, level?: LogLevel): Logger;
+export declare function setGlobalLogLevel(level: LogLevel): void;
+export declare const logger: Logger;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/Logger.js

@@ -0,0 +1,77 @@
+// ============================================
+// 日志系统 - 统一的日志管理
+// ============================================
+const LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+};
+export class Logger {
+    level;
+    prefix;
+    constructor(options) {
+        this.level = options.level;
+        this.prefix = options.prefix || '';
+    }
+    shouldLog(level) {
+        return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.level];
+    }
+    formatMessage(level, message, ...args) {
+        const timestamp = new Date().toISOString();
+        const prefix = this.prefix ? `[${this.prefix}] ` : '';
+        const levelStr = `[${level.toUpperCase()}]`;
+        const formattedMessage = args.length > 0
+            ? `${message} ${args.map(a => JSON.stringify(a)).join(' ')}`
+            : message;
+        return `${timestamp} ${levelStr} ${prefix}${formattedMessage}`;
+    }
+    debug(message, ...args) {
+        if (this.shouldLog('debug')) {
+            console.debug(this.formatMessage('debug', message, ...args));
+        }
+    }
+    info(message, ...args) {
+        if (this.shouldLog('info')) {
+            console.info(this.formatMessage('info', message, ...args));
+        }
+    }
+    warn(message, ...args) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.formatMessage('warn', message, ...args));
+        }
+    }
+    error(message, ...args) {
+        if (this.shouldLog('error')) {
+            console.error(this.formatMessage('error', message, ...args));
+        }
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    getLevel() {
+        return this.level;
+    }
+}
+// 全局日志器实例
+let globalLogger = null;
+export function getLogger(prefix, level) {
+    if (!globalLogger) {
+        globalLogger = new Logger({
+            level: level || 'info',
+            prefix: 'AgentBrain'
+        });
+    }
+    if (prefix) {
+        return new Logger({ level: globalLogger.getLevel(), prefix });
+    }
+    return globalLogger;
+}
+export function setGlobalLogLevel(level) {
+    if (!globalLogger) {
+        getLogger();
+    }
+    globalLogger?.setLevel(level);
+}
+// 便捷函数
+export const logger = getLogger();