@starlink-awaken/agentmesh 1.0.2 → 1.2.0

package/dist/src/core/event-bus.js

@@ -0,0 +1,62 @@
+import { EventEmitter } from 'events';
+export class EventBus extends EventEmitter {
+    logger;
+    constructor(options = {}) {
+        super();
+        this.logger = options.logger || console;
+        this.setMaxListeners(100);
+    }
+    /**
+     * 发布事件
+     */
+    publish(eventType, data) {
+        const event = {
+            type: eventType,
+            data,
+            timestamp: Date.now()
+        };
+        this.emit(eventType, event);
+        this.logger.info(`[EventBus] Published: ${eventType}`, { id: data.id });
+    }
+    /**
+     * 订阅事件
+     */
+    subscribe(eventType, handler) {
+        this.on(eventType, handler);
+        this.logger.info(`[EventBus] Subscribed to: ${eventType}`);
+        // 返回取消订阅函数
+        return () => {
+            this.off(eventType, handler);
+            this.logger.info(`[EventBus] Unsubscribed from: ${eventType}`);
+        };
+    }
+    /**
+     * 发布任务事件
+     */
+    publishTaskEvent(eventType, message) {
+        this.publish(eventType, message);
+    }
+    /**
+     * 发布 Agent 事件
+     */
+    publishAgentEvent(eventType, message) {
+        this.publish(eventType, message);
+    }
+    /**
+     * 获取所有事件类型
+     */
+    getEventTypes() {
+        return [
+            'agent.registered',
+            'agent.unregistered',
+            'task.submitted',
+            'task.assigned',
+            'task.started',
+            'task.progress',
+            'task.completed',
+            'task.failed',
+            'context.updated'
+        ];
+    }
+}
+export const eventBus = new EventBus();

package/dist/src/core/logger.d.ts

@@ -0,0 +1,14 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface Logger {
+    debug(msg: string, data?: Record<string, any>): void;
+    info(msg: string, data?: Record<string, any>): void;
+    warn(msg: string, data?: Record<string, any>): void;
+    error(msg: string, data?: Record<string, any>): void;
+}
+export declare function initLogger(opts?: {
+    level?: LogLevel;
+    dir?: string;
+    pino?: any;
+}): void;
+export declare const logger: Logger;
+export declare function createLogger(bindings?: Record<string, any>): Logger;

package/dist/src/core/logger.js

@@ -0,0 +1,57 @@
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+const LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+let currentLevel = 'info';
+let logDir = null;
+let logFile = null;
+let pinoInstance = null;
+export function initLogger(opts = {}) {
+    currentLevel = opts.level || 'info';
+    if (opts.pino && typeof opts.pino.child === 'function') {
+        pinoInstance = opts.pino;
+    }
+    if (opts.dir) {
+        logDir = opts.dir;
+        if (!existsSync(logDir))
+            mkdirSync(logDir, { recursive: true });
+        const date = new Date().toISOString().slice(0, 10);
+        logFile = join(logDir, `agentmesh-${date}.log`);
+    }
+}
+function shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+}
+function writeLine(level, msg, data) {
+    const ts = new Date().toISOString();
+    const extra = data ? ' ' + JSON.stringify(data) : '';
+    const line = `[${ts}] [${level.toUpperCase()}] ${msg}${extra}`;
+    if (pinoInstance) {
+        // 委托给 Pino: 将 data 序列化到消息中
+        pinoInstance[level](line);
+    }
+    else {
+        process.stderr.write(line + '\n');
+    }
+    if (logFile) {
+        try {
+            Bun.write(logFile, line + '\n').catch(() => { });
+        }
+        catch { }
+    }
+}
+export const logger = {
+    debug(msg, data) { if (shouldLog('debug'))
+        writeLine('debug', msg, data); },
+    info(msg, data) { if (shouldLog('info'))
+        writeLine('info', msg, data); },
+    warn(msg, data) { if (shouldLog('warn'))
+        writeLine('warn', msg, data); },
+    error(msg, data) { if (shouldLog('error'))
+        writeLine('error', msg, data); },
+};
+export function createLogger(bindings) {
+    if (!pinoInstance)
+        return logger;
+    // 直接从全局 pino 实例获取 child，当前版本用 context 前缀
+    return logger;
+}

package/dist/src/core/metrics.d.ts

@@ -0,0 +1,87 @@
+interface Metric {
+    name: string;
+    value: number;
+    timestamp: number;
+    tags?: Record<string, string>;
+}
+interface LogEntry {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+    data?: any;
+}
+export declare class Metrics {
+    private metrics;
+    private logs;
+    private logDir;
+    private maxMetricsHistory;
+    private maxLogsHistory;
+    constructor(logDir?: string);
+    private ensureLogDir;
+    /**
+     * 记录指标
+     */
+    record(name: string, value: number, tags?: Record<string, string>): void;
+    /**
+     * 递增计数器
+     */
+    increment(name: string, tags?: Record<string, string>): void;
+    /**
+     * 记录执行时间
+     */
+    timing(name: string, duration: number, tags?: Record<string, string>): void;
+    /**
+     * 获取指标值
+     */
+    get(name: string): number;
+    /**
+     * 获取指标历史
+     */
+    getHistory(name: string, limit?: number): Metric[];
+    /**
+     * 获取所有指标摘要
+     */
+    getSummary(): Record<string, {
+        count: number;
+        last: number;
+        avg: number;
+    }>;
+    /**
+     * 记录日志
+     */
+    log(level: LogEntry['level'], message: string, data?: any): void;
+    private writeLogToFile;
+    /**
+     * 获取日志
+     */
+    getLogs(level?: LogEntry['level'], limit?: number): LogEntry[];
+    /**
+     * 获取统计信息
+     */
+    getStats(): {
+        uptime: number;
+        totalTasks: number;
+        completedTasks: number;
+        failedTasks: number;
+        activeAgents: number;
+        metricsCount: number;
+        logsCount: number;
+    };
+    private startTime;
+    /**
+     * 启动计时
+     */
+    start(): void;
+    /**
+     * 重置指标
+     */
+    reset(): void;
+}
+export declare const metrics: Metrics;
+export declare const logger: {
+    debug: (message: string, data?: any) => void;
+    info: (message: string, data?: any) => void;
+    warn: (message: string, data?: any) => void;
+    error: (message: string, data?: any) => void;
+};
+export {};

package/dist/src/core/metrics.js

@@ -0,0 +1,167 @@
+import { writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+export class Metrics {
+    metrics = new Map();
+    logs = [];
+    logDir;
+    maxMetricsHistory = 1000;
+    maxLogsHistory = 1000;
+    constructor(logDir = './logs') {
+        this.logDir = logDir;
+        this.ensureLogDir();
+    }
+    ensureLogDir() {
+        if (!existsSync(this.logDir)) {
+            mkdirSync(this.logDir, { recursive: true });
+        }
+    }
+    /**
+     * 记录指标
+     */
+    record(name, value, tags) {
+        const metric = {
+            name,
+            value,
+            timestamp: Date.now(),
+            tags
+        };
+        if (!this.metrics.has(name)) {
+            this.metrics.set(name, []);
+        }
+        const history = this.metrics.get(name);
+        history.push(metric);
+        // 保持历史记录数量
+        if (history.length > this.maxMetricsHistory) {
+            history.shift();
+        }
+    }
+    /**
+     * 递增计数器
+     */
+    increment(name, tags) {
+        const current = this.get(name);
+        this.record(name, current + 1, tags);
+    }
+    /**
+     * 记录执行时间
+     */
+    timing(name, duration, tags) {
+        this.record(`${name}.duration`, duration, tags);
+    }
+    /**
+     * 获取指标值
+     */
+    get(name) {
+        const history = this.metrics.get(name);
+        if (!history || history.length === 0)
+            return 0;
+        const last = history[history.length - 1];
+        return last?.value ?? 0;
+    }
+    /**
+     * 获取指标历史
+     */
+    getHistory(name, limit) {
+        const history = this.metrics.get(name);
+        if (!history)
+            return [];
+        return limit ? history.slice(-limit) : history;
+    }
+    /**
+     * 获取所有指标摘要
+     */
+    getSummary() {
+        const summary = {};
+        for (const [name, history] of this.metrics) {
+            if (history.length === 0)
+                continue;
+            const values = history.map(m => m.value);
+            const sum = values.reduce((a, b) => a + b, 0);
+            summary[name] = {
+                count: history.length,
+                last: values[values.length - 1] ?? 0,
+                avg: sum / values.length
+            };
+        }
+        return summary;
+    }
+    /**
+     * 记录日志
+     */
+    log(level, message, data) {
+        const entry = {
+            level,
+            message,
+            timestamp: Date.now(),
+            data
+        };
+        this.logs.push(entry);
+        // 保持日志数量
+        if (this.logs.length > this.maxLogsHistory) {
+            this.logs.shift();
+        }
+        // 写入文件
+        this.writeLogToFile(entry);
+    }
+    writeLogToFile(entry) {
+        try {
+            const date = new Date(entry.timestamp).toISOString().split('T')[0];
+            const logFile = join(this.logDir, `gateway-${date}.log`);
+            const line = `[${new Date(entry.timestamp).toISOString()}] [${entry.level.toUpperCase()}] ${entry.message}${entry.data ? ' ' + JSON.stringify(entry.data) : ''}\n`;
+            appendFileSync(logFile, line);
+        }
+        catch (error) {
+            console.error('Failed to write log to file:', error);
+        }
+    }
+    /**
+     * 获取日志
+     */
+    getLogs(level, limit) {
+        let filtered = this.logs;
+        if (level) {
+            filtered = filtered.filter(l => l.level === level);
+        }
+        return limit ? filtered.slice(-limit) : filtered;
+    }
+    /**
+     * 获取统计信息
+     */
+    getStats() {
+        const taskHistory = this.metrics.get('tasks.submitted') || [];
+        const completedHistory = this.metrics.get('tasks.completed') || [];
+        const failedHistory = this.metrics.get('tasks.failed') || [];
+        return {
+            uptime: this.startTime ? Date.now() - this.startTime : 0,
+            totalTasks: taskHistory.length,
+            completedTasks: completedHistory.length,
+            failedTasks: failedHistory.length,
+            activeAgents: this.metrics.get('agents.active')?.[0]?.value || 0,
+            metricsCount: this.metrics.size,
+            logsCount: this.logs.length
+        };
+    }
+    startTime = Date.now();
+    /**
+     * 启动计时
+     */
+    start() {
+        this.startTime = Date.now();
+    }
+    /**
+     * 重置指标
+     */
+    reset() {
+        this.metrics.clear();
+        this.logs = [];
+        this.startTime = Date.now();
+    }
+}
+export const metrics = new Metrics();
+// 便捷方法
+export const logger = {
+    debug: (message, data) => metrics.log('debug', message, data),
+    info: (message, data) => metrics.log('info', message, data),
+    warn: (message, data) => metrics.log('warn', message, data),
+    error: (message, data) => metrics.log('error', message, data)
+};

package/dist/src/core/router.d.ts

@@ -0,0 +1,46 @@
+import type { Agent, RoutingRule, AgentMessage } from '../types/index.js';
+export declare class Router {
+    private rules;
+    private agents;
+    private defaultAgent?;
+    /**
+     * 配置路由规则
+     */
+    configure(rules: RoutingRule[], defaultAgent?: string): void;
+    /**
+     * 注册 Agent
+     */
+    registerAgent(agent: Agent): void;
+    /**
+     * 注销 Agent
+     */
+    unregisterAgent(agentId: string): void;
+    /**
+     * 获取所有在线 Agent
+     */
+    getOnlineAgents(): Agent[];
+    /**
+     * 路由任务到合适的 Agent
+     */
+    route(message: AgentMessage): {
+        agentIds: string[];
+        strategy: 'direct' | 'broadcast';
+    };
+    /**
+     * 检查任务是否匹配路由关键词
+     */
+    private matchesRule;
+    /**
+     * 检查 Agent 是否在线
+     */
+    private isAgentOnline;
+    /**
+     * 获取 Agent 信息
+     */
+    getAgent(agentId: string): Agent | undefined;
+    /**
+     * 获取所有 Agent
+     */
+    getAllAgents(): Agent[];
+}
+export declare const router: Router;

package/dist/src/core/router.js

@@ -0,0 +1,90 @@
+export class Router {
+    rules = [];
+    agents = new Map();
+    defaultAgent;
+    /**
+     * 配置路由规则
+     */
+    configure(rules, defaultAgent) {
+        // 按优先级排序
+        this.rules = [...rules].sort((a, b) => b.priority - a.priority);
+        this.defaultAgent = defaultAgent;
+    }
+    /**
+     * 注册 Agent
+     */
+    registerAgent(agent) {
+        this.agents.set(agent.id, agent);
+    }
+    /**
+     * 注销 Agent
+     */
+    unregisterAgent(agentId) {
+        this.agents.delete(agentId);
+    }
+    /**
+     * 获取所有在线 Agent
+     */
+    getOnlineAgents() {
+        return Array.from(this.agents.values()).filter(a => a.status === 'online');
+    }
+    /**
+     * 路由任务到合适的 Agent
+     */
+    route(message) {
+        const task = message.payload?.task || '';
+        // 匹配路由规则
+        for (const rule of this.rules) {
+            if (this.matchesRule(task, rule.keywords)) {
+                // 检查 Agent 是否在线
+                if (rule.strategy === 'broadcast' && rule.agents) {
+                    const availableAgents = rule.agents.filter(id => this.isAgentOnline(id));
+                    if (availableAgents.length > 0) {
+                        return { agentIds: availableAgents, strategy: 'broadcast' };
+                    }
+                }
+                else if (rule.agent && this.isAgentOnline(rule.agent)) {
+                    return { agentIds: [rule.agent], strategy: 'direct' };
+                }
+            }
+        }
+        // 使用默认 Agent
+        if (this.defaultAgent && this.isAgentOnline(this.defaultAgent)) {
+            return { agentIds: [this.defaultAgent], strategy: 'direct' };
+        }
+        // 返回所有在线 Agent 作为兜底
+        const onlineAgents = this.getOnlineAgents();
+        if (onlineAgents.length > 0) {
+            return { agentIds: onlineAgents.map(a => a.id), strategy: 'broadcast' };
+        }
+        // 没有可用的 Agent
+        return { agentIds: [], strategy: 'direct' };
+    }
+    /**
+     * 检查任务是否匹配路由关键词
+     */
+    matchesRule(task, keywords) {
+        const lowerTask = task.toLowerCase();
+        return keywords.some(keyword => lowerTask.includes(keyword.toLowerCase()));
+    }
+    /**
+     * 检查 Agent 是否在线
+     */
+    isAgentOnline(agentId) {
+        const agent = this.agents.get(agentId);
+        return agent?.status === 'online';
+    }
+    /**
+     * 获取 Agent 信息
+     */
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    /**
+     * 获取所有 Agent
+     */
+    getAllAgents() {
+        return Array.from(this.agents.values());
+    }
+}
+export const router = new Router();

package/dist/src/core/task-manager.d.ts

@@ -0,0 +1,41 @@
+import type { Task, AgentMessage, Error } from '../types/index.js';
+export declare class TaskManager {
+    private tasks;
+    /**
+     * 创建新任务
+     */
+    createTask(request: AgentMessage): Promise<Task>;
+    /**
+     * 分配任务到 Agent
+     */
+    assignTask(taskId: string, agentIds: string[]): Task | null;
+    /**
+     * 开始执行任务
+     */
+    startTask(taskId: string): Task | null;
+    /**
+     * 完成任务
+     */
+    completeTask(taskId: string, result: unknown): Task | null;
+    /**
+     * 任务失败
+     */
+    failTask(taskId: string, error: Error): Task | null;
+    /**
+     * 获取任务
+     */
+    getTask(taskId: string): Task | undefined;
+    /**
+     * 获取所有任务
+     */
+    getAllTasks(): Task[];
+    /**
+     * 处理任务
+     */
+    processTask(message: AgentMessage): Promise<Task>;
+    /**
+     * 执行任务
+     */
+    private executeTask;
+}
+export declare const taskManager: TaskManager;