@starlink-awaken/agentmesh 1.0.2 → 1.2.0

package/dist/src/core/agent-registry.js

@@ -0,0 +1,295 @@
+import { ProcessAdapter } from '../adapters/process.js';
+import { ClaudeCodeAdapter } from '../adapters/claude-code.js';
+import { OpenClawAdapter } from '../adapters/openclaw.js';
+import { getAllAgentConfigs } from './config.js';
+// 默认 Agent 配置
+const DEFAULT_AGENT_CONFIGS = {
+    'claude-code': {
+        name: 'Claude Code',
+        capabilities: ['code-generation', 'code-review', 'debugging', 'refactoring', 'documentation', 'file-operations'],
+        command: 'claude',
+        args: ['-p']
+    },
+    'openclaw': {
+        name: 'OpenClaw',
+        capabilities: ['browser-automation', 'web-scraping', 'form-filling', 'ui-testing'],
+        command: 'openclaw',
+        args: ['--task']
+    },
+    'opencode': {
+        name: 'OpenCode',
+        capabilities: ['code-completion', 'code-generation', 'refactoring', 'debugging'],
+        command: 'opencode',
+        args: ['--task']
+    },
+    'gemini': {
+        name: 'Google Gemini CLI',
+        capabilities: ['code-generation', 'multimodal', 'reasoning', 'analysis'],
+        command: 'gemini',
+        args: ['--prompt']
+    },
+    'codex': {
+        name: 'OpenAI Codex',
+        capabilities: ['code-generation', 'code-explanation', 'refactoring'],
+        command: 'codex',
+        args: ['complete']
+    },
+    'github-copilot': {
+        name: 'GitHub Copilot',
+        capabilities: ['code-completion', 'code-suggestions', 'refactoring'],
+        command: 'copilot',
+        args: ['--ask']
+    },
+    'qwen-code': {
+        name: 'Qwen Code',
+        capabilities: ['code-generation', 'code-review', 'multilingual'],
+        command: 'qwen-code',
+        args: ['--task']
+    },
+    'crush': {
+        name: 'CRUSH AI',
+        capabilities: ['code-generation', 'debugging', 'security-analysis'],
+        command: 'crush',
+        args: ['run']
+    },
+    'droid': {
+        name: 'Droid Agent',
+        capabilities: ['android-development', 'mobile-debugging', 'device-control'],
+        command: 'droid',
+        args: ['--task']
+    },
+    'factory': {
+        name: 'Factory AI',
+        capabilities: ['code-generation', 'testing', 'documentation', 'refactoring'],
+        command: 'factory',
+        args: ['--task']
+    },
+    'cursor': {
+        name: 'Cursor',
+        capabilities: ['code-completion', 'code-generation', 'refactoring', 'chat'],
+        command: 'cursor',
+        args: ['--task']
+    },
+    'windsurf': {
+        name: 'Windsurf',
+        capabilities: ['code-generation', 'agentic-coding', 'flow-state'],
+        command: 'windsurf',
+        args: ['--task']
+    },
+    'zed': {
+        name: 'Zed AI',
+        capabilities: ['code-generation', 'collaboration', 'high-performance'],
+        command: 'zed',
+        args: ['--ai-task']
+    },
+    'aider': {
+        name: 'Aider',
+        capabilities: ['git-based-editing', 'code-refactoring', 'multi-file-changes'],
+        command: 'aider',
+        args: ['--message']
+    },
+    'cline': {
+        name: 'Cline',
+        capabilities: ['autonomous-coding', 'file-operations', 'command-execution'],
+        command: 'cline',
+        args: ['--task']
+    },
+    'roo-code': {
+        name: 'Roo Code',
+        capabilities: ['code-generation', 'agentic-mode', 'workspace-awareness'],
+        command: 'roo-code',
+        args: ['--task']
+    },
+    // 2026 新增 Agent
+    'perplexity': {
+        name: 'Perplexity',
+        capabilities: ['research', 'web-search', 'fact-checking', 'analysis'],
+        command: 'perplexity',
+        args: ['--query']
+    },
+    'grok': {
+        name: 'xAI Grok',
+        capabilities: ['reasoning', 'humor', 'code-generation', 'analysis'],
+        command: 'grok',
+        args: ['--prompt']
+    },
+    'phind': {
+        name: 'Phind',
+        capabilities: ['developer-search', 'code-search', 'documentation-search'],
+        command: 'phind',
+        args: ['--search']
+    },
+    'you': {
+        name: 'You.com AI',
+        capabilities: ['web-search', 'code-search', 'general-assistant'],
+        command: 'you',
+        args: ['--query']
+    },
+    'lepton': {
+        name: 'Lepton AI',
+        capabilities: ['code-generation', 'conversation', 'analysis'],
+        command: 'lepton',
+        args: ['--prompt']
+    },
+    'ollama': {
+        name: 'Ollama',
+        capabilities: ['local-llm', 'code-generation', 'privacy-focused'],
+        command: 'ollama',
+        args: ['run']
+    },
+    'llama': {
+        name: 'Meta Llama',
+        capabilities: ['code-generation', 'reasoning', 'open-source'],
+        command: 'llama',
+        args: ['--prompt']
+    },
+    'mistral': {
+        name: 'Mistral AI',
+        capabilities: ['code-generation', 'reasoning', 'multilingual'],
+        command: 'mistral',
+        args: ['--task']
+    },
+    'anthropic': {
+        name: 'Anthropic CLI',
+        capabilities: ['conversation', 'reasoning', 'code-generation'],
+        command: 'anthropic',
+        args: ['--prompt']
+    }
+};
+export class AgentRegistry {
+    adapters = new Map();
+    initialized = false;
+    constructor() {
+        // 延迟初始化
+    }
+    /**
+     * 初始化注册表
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        // 注册内置适配器
+        this.register(new ClaudeCodeAdapter());
+        this.register(new OpenClawAdapter());
+        // 从配置加载所有 Agent
+        this.registerAllFromConfig();
+        this.initialized = true;
+    }
+    /**
+     * 从配置注册所有 Agent
+     */
+    registerAllFromConfig() {
+        const configAgents = getAllAgentConfigs();
+        // 1. 先注册配置文件中的 Agent
+        for (const config of configAgents) {
+            if (this.adapters.has(config.id))
+                continue;
+            if (config.type === 'claude-code' || config.type === 'openclaw') {
+                // 跳过，内置适配器已注册
+                continue;
+            }
+            if (config.type === 'process' && config.command) {
+                const adapter = new ProcessAdapter(config.id, config.name, config.capabilities, {
+                    command: config.command,
+                    args: config.args,
+                    env: config.env
+                });
+                this.adapters.set(config.id, adapter);
+                console.log(`[AgentRegistry] Registered from config: ${config.id}`);
+            }
+        }
+        // 2. 再注册默认 Agent（未被配置覆盖的）
+        for (const [id, defaultConfig] of Object.entries(DEFAULT_AGENT_CONFIGS)) {
+            if (this.adapters.has(id))
+                continue;
+            const adapter = new ProcessAdapter(id, defaultConfig.name, defaultConfig.capabilities, {
+                command: defaultConfig.command,
+                args: defaultConfig.args,
+                env: defaultConfig.env
+            });
+            this.adapters.set(id, adapter);
+            console.log(`[AgentRegistry] Registered default: ${id}`);
+        }
+    }
+    /**
+     * 注册自定义适配器
+     */
+    register(adapter) {
+        this.adapters.set(adapter.id, adapter);
+        console.log(`[AgentRegistry] Registered adapter: ${adapter.id}`);
+    }
+    /**
+     * 获取适配器
+     */
+    get(agentId) {
+        return this.adapters.get(agentId);
+    }
+    /**
+     * 获取所有适配器
+     */
+    getAll() {
+        return Array.from(this.adapters.values());
+    }
+    /**
+     * 获取所有 Agent 信息
+     */
+    getAgents() {
+        return this.getAll().map(adapter => ({
+            id: adapter.id,
+            name: adapter.name,
+            type: adapter.type,
+            capabilities: adapter.capabilities,
+            status: 'online',
+            lastSeen: Date.now()
+        }));
+    }
+    /**
+     * 根据能力查找 Agent
+     */
+    findByCapability(capability) {
+        return this.getAll()
+            .filter(adapter => adapter.capabilities.includes(capability))
+            .map(adapter => ({
+            id: adapter.id,
+            name: adapter.name,
+            type: adapter.type,
+            capabilities: adapter.capabilities,
+            status: 'online',
+            lastSeen: Date.now()
+        }));
+    }
+    /**
+     * 检查适配器是否存在
+     */
+    has(agentId) {
+        return this.adapters.has(agentId);
+    }
+    /**
+     * 检查适配器是否健康
+     */
+    async checkHealth(agentId) {
+        const adapter = this.adapters.get(agentId);
+        if (!adapter)
+            return false;
+        return adapter.health();
+    }
+    /**
+     * 获取可用 Agent 列表（健康检查）
+     */
+    async getAvailableAgents() {
+        const results = [];
+        for (const adapter of this.adapters.values()) {
+            const isHealthy = await adapter.health().catch(() => false);
+            results.push({
+                id: adapter.id,
+                name: adapter.name,
+                type: adapter.type,
+                capabilities: adapter.capabilities,
+                status: isHealthy ? 'online' : 'offline',
+                lastSeen: Date.now()
+            });
+        }
+        return results;
+    }
+}
+export const agentRegistry = new AgentRegistry();

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

@@ -0,0 +1,59 @@
+export interface AgentConfig {
+    id: string;
+    name: string;
+    type: 'claude-code' | 'openclaw' | 'process' | 'http';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    endpoint?: string;
+    capabilities: string[];
+}
+export interface RoutingRule {
+    name: string;
+    keywords: string[];
+    agent?: string;
+    strategy?: 'direct' | 'broadcast';
+    agents?: string[];
+    priority: number;
+}
+export interface GatewayConfig {
+    port: number;
+    wsPort: number;
+    host: string;
+    dataDir: string;
+    logDir: string;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    routing: {
+        defaultAgent?: string;
+        rules: RoutingRule[];
+    };
+    agents: AgentConfig[];
+}
+/**
+ * 加载配置文件
+ */
+export declare function loadConfig(configPath?: string): GatewayConfig;
+/**
+ * 重新加载配置
+ */
+export declare function reloadConfig(configPath?: string): GatewayConfig;
+/**
+ * 获取配置
+ */
+export declare function getConfig(): GatewayConfig;
+/**
+ * 获取 Agent 配置
+ */
+export declare function getAgentConfig(agentId: string): AgentConfig | undefined;
+/**
+ * 获取所有 Agent 配置
+ */
+export declare function getAllAgentConfigs(): AgentConfig[];
+/**
+ * 获取路由规则
+ */
+export declare function getRoutingRules(): RoutingRule[];
+/**
+ * 获取默认 Agent
+ */
+export declare function getDefaultAgent(): string | undefined;

package/dist/src/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/src/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/src/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/src/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 {};