@starlink-awaken/agentmesh 1.0.2 → 1.0.3

package/dist/core/config.js

@@ -0,0 +1,101 @@
+import { readFileSync, existsSync } from 'fs';
+import { parse } from 'yaml';
+import { join } from 'path';
+const DEFAULT_CONFIG = {
+    port: 3000,
+    wsPort: 3001,
+    host: '0.0.0.0',
+    dataDir: './data',
+    logDir: './logs',
+    logLevel: 'info',
+    routing: {
+        defaultAgent: 'claude-code',
+        rules: []
+    },
+    agents: []
+};
+let cachedConfig = null;
+/**
+ * 加载配置文件
+ */
+export function loadConfig(configPath) {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const paths = configPath
+        ? [configPath]
+        : [
+            './config/gateway.yaml',
+            './config/gateway.yml',
+            join(process.cwd(), 'config/gateway.yaml'),
+            join(process.cwd(), 'config/gateway.yml')
+        ];
+    for (const path of paths) {
+        try {
+            if (existsSync(path)) {
+                console.log(`[Config] Loading from: ${path}`);
+                const content = readFileSync(path, 'utf-8');
+                const parsed = parse(content);
+                // 合并配置
+                cachedConfig = {
+                    ...DEFAULT_CONFIG,
+                    ...parsed,
+                    routing: {
+                        ...DEFAULT_CONFIG.routing,
+                        ...parsed.routing,
+                        rules: parsed.routing?.rules || DEFAULT_CONFIG.routing.rules
+                    }
+                };
+                console.log(`[Config] Loaded successfully`);
+                return cachedConfig;
+            }
+        }
+        catch (error) {
+            console.warn(`[Config] Failed to load ${path}:`, error);
+        }
+    }
+    console.log('[Config] Using default configuration');
+    cachedConfig = { ...DEFAULT_CONFIG };
+    return cachedConfig;
+}
+/**
+ * 重新加载配置
+ */
+export function reloadConfig(configPath) {
+    cachedConfig = null;
+    return loadConfig(configPath);
+}
+/**
+ * 获取配置
+ */
+export function getConfig() {
+    if (!cachedConfig) {
+        return loadConfig();
+    }
+    return cachedConfig;
+}
+/**
+ * 获取 Agent 配置
+ */
+export function getAgentConfig(agentId) {
+    const config = getConfig();
+    return config.agents.find(a => a.id === agentId);
+}
+/**
+ * 获取所有 Agent 配置
+ */
+export function getAllAgentConfigs() {
+    return getConfig().agents;
+}
+/**
+ * 获取路由规则
+ */
+export function getRoutingRules() {
+    return getConfig().routing.rules;
+}
+/**
+ * 获取默认 Agent
+ */
+export function getDefaultAgent() {
+    return getConfig().routing.defaultAgent;
+}

package/dist/core/context-manager.d.ts

@@ -0,0 +1,52 @@
+import type { AgentMessage, ContextRef } from '../types/index.js';
+interface ContextData {
+    shared_space_id: string;
+    messages: AgentMessage[];
+    artifacts: Map<string, string>;
+    metadata: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class ContextManager {
+    private memoryCache;
+    private baseDir;
+    constructor(baseDir?: string);
+    /**
+     * 创建共享空间
+     */
+    createSharedSpace(metadata?: Record<string, unknown>): Promise<string>;
+    /**
+     * 获取共享空间
+     */
+    getSharedSpace(spaceId: string): Promise<ContextData | null>;
+    /**
+     * 添加消息到共享空间
+     */
+    addMessage(spaceId: string, message: AgentMessage): Promise<void>;
+    /**
+     * 获取消息历史
+     */
+    getMessages(spaceId: string, limit?: number): Promise<AgentMessage[]>;
+    /**
+     * 添加产物文件
+     */
+    addArtifact(spaceId: string, filename: string, content: string): Promise<string>;
+    /**
+     * 获取产物文件
+     */
+    getArtifact(spaceId: string, filename: string): Promise<string | null>;
+    /**
+     * 持久化到文件系统
+     */
+    private persistToFile;
+    /**
+     * 从文件系统加载
+     */
+    private loadFromFile;
+    /**
+     * 创建 ContextRef
+     */
+    createContextRef(spaceId: string): Promise<ContextRef>;
+}
+export declare const contextManager: ContextManager;
+export {};

package/dist/core/context-manager.js

@@ -0,0 +1,165 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { vectorStore } from './vector-store.js';
+export class ContextManager {
+    memoryCache = new Map();
+    baseDir;
+    constructor(baseDir = './data/tasks') {
+        this.baseDir = baseDir;
+    }
+    /**
+     * 创建共享空间
+     */
+    async createSharedSpace(metadata = {}) {
+        const spaceId = uuidv4();
+        const context = {
+            shared_space_id: spaceId,
+            messages: [],
+            artifacts: new Map(),
+            metadata,
+            createdAt: Date.now(),
+            updatedAt: Date.now()
+        };
+        // L1: 内存缓存
+        this.memoryCache.set(spaceId, context);
+        // L2: 文件系统持久化
+        await this.persistToFile(spaceId, context);
+        return spaceId;
+    }
+    /**
+     * 获取共享空间
+     */
+    async getSharedSpace(spaceId) {
+        // L1: 先从内存获取
+        if (this.memoryCache.has(spaceId)) {
+            return this.memoryCache.get(spaceId);
+        }
+        // L2: 从文件系统加载
+        try {
+            const context = await this.loadFromFile(spaceId);
+            if (context) {
+                this.memoryCache.set(spaceId, context);
+                return context;
+            }
+        }
+        catch (error) {
+            console.error(`[ContextManager] Failed to load context: ${spaceId}`, error);
+        }
+        return null;
+    }
+    /**
+     * 添加消息到共享空间
+     */
+    async addMessage(spaceId, message) {
+        const context = await this.getSharedSpace(spaceId);
+        if (!context) {
+            throw new Error(`Shared space not found: ${spaceId}`);
+        }
+        context.messages.push(message);
+        context.updatedAt = Date.now();
+        // 更新内存缓存
+        this.memoryCache.set(spaceId, context);
+        // 持久化到文件系统
+        await this.persistToFile(spaceId, context);
+        // L3: 添加到向量数据库（异步，不阻塞）
+        if (vectorStore.isAvailable()) {
+            vectorStore.addMessage(spaceId, message).catch(err => {
+                console.error('[ContextManager] Vector store add failed:', err);
+            });
+        }
+    }
+    /**
+     * 获取消息历史
+     */
+    async getMessages(spaceId, limit) {
+        const context = await this.getSharedSpace(spaceId);
+        if (!context) {
+            return [];
+        }
+        const messages = context.messages;
+        return limit ? messages.slice(-limit) : messages;
+    }
+    /**
+     * 添加产物文件
+     */
+    async addArtifact(spaceId, filename, content) {
+        const context = await this.getSharedSpace(spaceId);
+        if (!context) {
+            throw new Error(`Shared space not found: ${spaceId}`);
+        }
+        const artifactsDir = join(this.baseDir, spaceId, 'artifacts');
+        await fs.mkdir(artifactsDir, { recursive: true });
+        const filePath = join(artifactsDir, filename);
+        await fs.writeFile(filePath, content, 'utf-8');
+        context.artifacts.set(filename, filePath);
+        context.updatedAt = Date.now();
+        // 更新内存缓存
+        this.memoryCache.set(spaceId, context);
+        // 持久化
+        await this.persistToFile(spaceId, context);
+        return filePath;
+    }
+    /**
+     * 获取产物文件
+     */
+    async getArtifact(spaceId, filename) {
+        const context = await this.getSharedSpace(spaceId);
+        if (!context) {
+            return null;
+        }
+        const filePath = context.artifacts.get(filename);
+        if (!filePath) {
+            return null;
+        }
+        try {
+            return await fs.readFile(filePath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 持久化到文件系统
+     */
+    async persistToFile(spaceId, context) {
+        const dir = join(this.baseDir, spaceId);
+        await fs.mkdir(dir, { recursive: true });
+        // 序列化 context（Map 需要转换）
+        const serialized = {
+            shared_space_id: context.shared_space_id,
+            messages: context.messages,
+            artifacts: Object.fromEntries(context.artifacts),
+            metadata: context.metadata,
+            createdAt: context.createdAt,
+            updatedAt: context.updatedAt
+        };
+        await fs.writeFile(join(dir, 'context.json'), JSON.stringify(serialized, null, 2), 'utf-8');
+    }
+    /**
+     * 从文件系统加载
+     */
+    async loadFromFile(spaceId) {
+        const filePath = join(this.baseDir, spaceId, 'context.json');
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            return {
+                ...parsed,
+                artifacts: new Map(Object.entries(parsed.artifacts || {}))
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 创建 ContextRef
+     */
+    async createContextRef(spaceId) {
+        return {
+            shared_space_id: spaceId
+        };
+    }
+}
+export const contextManager = new ContextManager();

package/dist/core/event-bus.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter } from 'events';
+import type { AgentMessage, EventType } from '../types/index.js';
+interface EventBusOptions {
+    logger?: Console;
+}
+export declare class EventBus extends EventEmitter {
+    private logger;
+    constructor(options?: EventBusOptions);
+    /**
+     * 发布事件
+     */
+    publish(eventType: EventType, data: AgentMessage): void;
+    /**
+     * 订阅事件
+     */
+    subscribe(eventType: EventType, handler: (event: {
+        type: EventType;
+        data: AgentMessage;
+        timestamp: number;
+    }) => void): () => void;
+    /**
+     * 发布任务事件
+     */
+    publishTaskEvent(eventType: Exclude<EventType, 'agent.registered' | 'agent.unregistered'>, message: AgentMessage): void;
+    /**
+     * 发布 Agent 事件
+     */
+    publishAgentEvent(eventType: 'agent.registered' | 'agent.unregistered', message: AgentMessage): void;
+    /**
+     * 获取所有事件类型
+     */
+    getEventTypes(): EventType[];
+}
+export declare const eventBus: EventBus;
+export {};

package/dist/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/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/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)
+};