@starlink-awaken/agentmesh 1.0.0

package/src/core/agent-registry.ts

@@ -0,0 +1,334 @@
+import { ProcessAdapter } from '../adapters/process.js';
+import { ClaudeCodeAdapter } from '../adapters/claude-code.js';
+import { OpenClawAdapter } from '../adapters/openclaw.js';
+import type { AgentAdapter } from '../adapters/base.js';
+import type { Agent } from '../types/index.js';
+import { getAllAgentConfigs } from './config.js';
+
+// 默认 Agent 配置
+const DEFAULT_AGENT_CONFIGS: Record<string, {
+  name: string;
+  capabilities: string[];
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}> = {
+  '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 {
+  private adapters: Map<string, AgentAdapter> = new Map();
+  private initialized = false;
+
+  constructor() {
+    // 延迟初始化
+  }
+
+  /**
+   * 初始化注册表
+   */
+  initialize(): void {
+    if (this.initialized) return;
+
+    // 注册内置适配器
+    this.register(new ClaudeCodeAdapter());
+    this.register(new OpenClawAdapter());
+
+    // 从配置加载所有 Agent
+    this.registerAllFromConfig();
+
+    this.initialized = true;
+  }
+
+  /**
+   * 从配置注册所有 Agent
+   */
+  private registerAllFromConfig(): void {
+    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: AgentAdapter): void {
+    this.adapters.set(adapter.id, adapter);
+    console.log(`[AgentRegistry] Registered adapter: ${adapter.id}`);
+  }
+
+  /**
+   * 获取适配器
+   */
+  get(agentId: string): AgentAdapter | undefined {
+    return this.adapters.get(agentId);
+  }
+
+  /**
+   * 获取所有适配器
+   */
+  getAll(): AgentAdapter[] {
+    return Array.from(this.adapters.values());
+  }
+
+  /**
+   * 获取所有 Agent 信息
+   */
+  getAgents(): Agent[] {
+    return this.getAll().map(adapter => ({
+      id: adapter.id,
+      name: adapter.name,
+      type: adapter.type as Agent['type'],
+      capabilities: adapter.capabilities,
+      status: 'online' as const,
+      lastSeen: Date.now()
+    }));
+  }
+
+  /**
+   * 根据能力查找 Agent
+   */
+  findByCapability(capability: string): Agent[] {
+    return this.getAll()
+      .filter(adapter => adapter.capabilities.includes(capability))
+      .map(adapter => ({
+        id: adapter.id,
+        name: adapter.name,
+        type: adapter.type as Agent['type'],
+        capabilities: adapter.capabilities,
+        status: 'online' as const,
+        lastSeen: Date.now()
+      }));
+  }
+
+  /**
+   * 检查适配器是否存在
+   */
+  has(agentId: string): boolean {
+    return this.adapters.has(agentId);
+  }
+
+  /**
+   * 检查适配器是否健康
+   */
+  async checkHealth(agentId: string): Promise<boolean> {
+    const adapter = this.adapters.get(agentId);
+    if (!adapter) return false;
+    return adapter.health();
+  }
+
+  /**
+   * 获取可用 Agent 列表（健康检查）
+   */
+  async getAvailableAgents(): Promise<Agent[]> {
+    const results: Agent[] = [];
+
+    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 as Agent['type'],
+        capabilities: adapter.capabilities,
+        status: isHealthy ? 'online' as const : 'offline' as const,
+        lastSeen: Date.now()
+      });
+    }
+
+    return results;
+  }
+}
+
+export const agentRegistry = new AgentRegistry();

package/src/core/config.ts

@@ -0,0 +1,148 @@
+import { readFileSync, existsSync } from 'fs';
+import { parse } from 'yaml';
+import { join } from 'path';
+
+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[];
+}
+
+const DEFAULT_CONFIG: GatewayConfig = {
+  port: 3000,
+  wsPort: 3001,
+  host: '0.0.0.0',
+  dataDir: './data',
+  logDir: './logs',
+  logLevel: 'info',
+  routing: {
+    defaultAgent: 'claude-code',
+    rules: []
+  },
+  agents: []
+};
+
+let cachedConfig: GatewayConfig | null = null;
+
+/**
+ * 加载配置文件
+ */
+export function loadConfig(configPath?: string): GatewayConfig {
+  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) as Partial<GatewayConfig>;
+
+        // 合并配置
+        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?: string): GatewayConfig {
+  cachedConfig = null;
+  return loadConfig(configPath);
+}
+
+/**
+ * 获取配置
+ */
+export function getConfig(): GatewayConfig {
+  if (!cachedConfig) {
+    return loadConfig();
+  }
+  return cachedConfig;
+}
+
+/**
+ * 获取 Agent 配置
+ */
+export function getAgentConfig(agentId: string): AgentConfig | undefined {
+  const config = getConfig();
+  return config.agents.find(a => a.id === agentId);
+}
+
+/**
+ * 获取所有 Agent 配置
+ */
+export function getAllAgentConfigs(): AgentConfig[] {
+  return getConfig().agents;
+}
+
+/**
+ * 获取路由规则
+ */
+export function getRoutingRules(): RoutingRule[] {
+  return getConfig().routing.rules;
+}
+
+/**
+ * 获取默认 Agent
+ */
+export function getDefaultAgent(): string | undefined {
+  return getConfig().routing.defaultAgent;
+}

package/src/core/context-manager.ts

@@ -0,0 +1,210 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import type { AgentMessage, ContextRef } from '../types/index.js';
+import { vectorStore } from './vector-store.js';
+
+interface ContextData {
+  shared_space_id: string;
+  messages: AgentMessage[];
+  artifacts: Map<string, string>;
+  metadata: Record<string, unknown>;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export class ContextManager {
+  private memoryCache: Map<string, ContextData> = new Map();
+  private baseDir: string;
+
+  constructor(baseDir: string = './data/tasks') {
+    this.baseDir = baseDir;
+  }
+
+  /**
+   * 创建共享空间
+   */
+  async createSharedSpace(metadata: Record<string, unknown> = {}): Promise<string> {
+    const spaceId = uuidv4();
+    const context: ContextData = {
+      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: string): Promise<ContextData | null> {
+    // 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: string, message: AgentMessage): Promise<void> {
+    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: string, limit?: number): Promise<AgentMessage[]> {
+    const context = await this.getSharedSpace(spaceId);
+    if (!context) {
+      return [];
+    }
+
+    const messages = context.messages;
+    return limit ? messages.slice(-limit) : messages;
+  }
+
+  /**
+   * 添加产物文件
+   */
+  async addArtifact(spaceId: string, filename: string, content: string): Promise<string> {
+    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: string, filename: string): Promise<string | null> {
+    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;
+    }
+  }
+
+  /**
+   * 持久化到文件系统
+   */
+  private async persistToFile(spaceId: string, context: ContextData): Promise<void> {
+    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'
+    );
+  }
+
+  /**
+   * 从文件系统加载
+   */
+  private async loadFromFile(spaceId: string): Promise<ContextData | null> {
+    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: string): Promise<ContextRef> {
+    return {
+      shared_space_id: spaceId
+    };
+  }
+}
+
+export const contextManager = new ContextManager();