@bolloon/bolloon-agent 0.1.0

package/src/workflows/collaboration.ts

@@ -0,0 +1,455 @@
+/**
+ * Multi-Agent Collaboration Workflow
+ *
+ * 工作流设计：
+ * 1. 命令解析 - 理解用户意图
+ * 2. DID查询 - 从IPNS/IPFS查找已注册智能体
+ * 3. 协作判断 - 分析是否需要多智能体协作
+ * 4. 任务分发 - 发送文档给其他智能体
+ * 5. 结果汇总 - 收集并整合协作结果
+ */
+
+import { AgentProtocol, AgentMessage, Task, TaskResult, ImproveResult } from '../agents/protocol.js';
+import { p2pNetwork } from '../network/p2p.js';
+import { documentReader } from '../documents/reader.js';
+import { getMinimax } from '../constraints/index.js';
+import { IpfsClient } from '@diap/sdk';
+
+export interface AgentInfo {
+  did: string;
+  name: string;
+  ipnsName?: string;
+  peerId?: string;
+  lastSeen?: number;
+}
+
+export interface CollaborationResult {
+  success: boolean;
+  collaborated: boolean;
+  agents: AgentInfo[];
+  taskId?: string;
+  result?: string;
+  qualityScore?: number;
+  error?: string;
+}
+
+export interface CommandIntent {
+  action: 'read' | 'summarize' | 'improve' | 'collaborate' | 'report' | 'query';
+  target?: string;
+  requirements?: string;
+  context?: string;
+  needCollaboration: boolean;
+  suggestedAgents?: string[];
+}
+
+/**
+ * 命令解析器 - 将用户输入解析为结构化意图
+ */
+export class CommandParser {
+  private collaborationKeywords = ['协作', '合作', '其他', '帮忙', '请教', '团队', '分享', '交给'];
+  private improvementKeywords = ['改进', '优化', '修改', '完善', '润色', '修正'];
+  private queryKeywords = ['查看', '列表', '查询', '有哪些', '谁在线'];
+
+  parse(input: string, context?: string): CommandIntent {
+    const lowerInput = input.toLowerCase();
+
+    // 检测是否需要协作
+    const needCollaboration = this.collaborationKeywords.some(k => lowerInput.includes(k));
+
+    // 解析动作
+    let action: CommandIntent['action'] = 'query';
+
+    if (lowerInput.includes('改进') || lowerInput.includes('优化') || lowerInput.includes('修改')) {
+      action = 'improve';
+    } else if (lowerInput.includes('总结') || lowerInput.includes('摘要')) {
+      action = 'summarize';
+    } else if (lowerInput.includes('读取') || lowerInput.includes('阅读')) {
+      action = 'read';
+    } else if (lowerInput.includes('汇报') || lowerInput.includes('报告')) {
+      action = 'report';
+    } else if (this.queryKeywords.some(k => lowerInput.includes(k))) {
+      action = 'query';
+    }
+
+    // 提取目标文件/主题
+    const targetMatch = input.match(/[\w\.\/]+\.(md|txt|pdf|docx)/i);
+    const target = targetMatch ? targetMatch[0] : undefined;
+
+    // 提取需求描述
+    const requirements = this.extractRequirements(input);
+
+    // 识别建议的智能体（如果有）
+    const suggestedAgents = this.extractAgentNames(input);
+
+    return {
+      action,
+      target,
+      requirements,
+      context: context || input,
+      needCollaboration,
+      suggestedAgents
+    };
+  }
+
+  private extractRequirements(input: string): string | undefined {
+    // 查找引号内的内容或特定模式
+    const quotes = input.match(/["'""]([^""']+)[""'"]/);
+    if (quotes) return quotes[1];
+
+    const afterKeywords = input.match(/(?:改进|优化|修改|要求|需要)[:：]\s*(.+)/i);
+    if (afterKeywords) return afterKeywords[1];
+
+    return undefined;
+  }
+
+  private extractAgentNames(input: string): string[] | undefined {
+    const names = input.match(/[@@]\w+/g);
+    return names ? names.map(n => n.substring(1)) : undefined;
+  }
+}
+
+/**
+ * DID注册表 - 管理已知智能体的DID信息
+ */
+export class DIDRegistry {
+  private agents: Map<string, AgentInfo> = new Map();
+  private ipfsClient: IpfsClient;
+
+  constructor(ipfsApiUrl: string = 'http://127.0.0.1:5001') {
+    this.ipfsClient = new IpfsClient(ipfsApiUrl, null);
+  }
+
+  async registerAgent(agent: AgentInfo): Promise<void> {
+    this.agents.set(agent.did, {
+      ...agent,
+      lastSeen: Date.now()
+    });
+  }
+
+  async unregisterAgent(did: string): Promise<void> {
+    this.agents.delete(did);
+  }
+
+  getAgent(did: string): AgentInfo | undefined {
+    return this.agents.get(did);
+  }
+
+  getAllAgents(): AgentInfo[] {
+    return Array.from(this.agents.values());
+  }
+
+  getOnlineAgents(): AgentInfo[] {
+    const now = Date.now();
+    const timeout = 5 * 60 * 1000; // 5分钟超时
+    return this.getAllAgents().filter(a => a.lastSeen && (now - a.lastSeen) < timeout);
+  }
+
+  async resolveDIDFromIPNS(ipnsName: string): Promise<AgentInfo | null> {
+    try {
+      const cid = await this.ipfsClient.resolveIpns(ipnsName);
+      const content = await this.ipfsClient.get(cid);
+      const doc = JSON.parse(content);
+      return {
+        did: doc.id,
+        name: doc.name || doc.id,
+        ipnsName
+      };
+    } catch (error) {
+      console.error(`Failed to resolve DID from IPNS ${ipnsName}:`, error);
+      return null;
+    }
+  }
+
+  async discoverAgents(): Promise<AgentInfo[]> {
+    const discovered: AgentInfo[] = [];
+    const peers = p2pNetwork.getPeers();
+
+    for (const peerId of peers) {
+      // 尝试从已知IPNS名称列表中解析
+      // 实际实现中应该通过某种服务发现机制
+      const agent = this.getAgentByPeerId(peerId);
+      if (agent) {
+        discovered.push(agent);
+      }
+    }
+
+    return discovered;
+  }
+
+  private getAgentByPeerId(peerId: string): AgentInfo | undefined {
+    for (const agent of this.agents.values()) {
+      if (agent.peerId === peerId) {
+        return agent;
+      }
+    }
+    return undefined;
+  }
+}
+
+/**
+ * 协作决策器 - 判断是否需要多智能体协作
+ */
+export class CollaborationDecider {
+  private threshold = 0.7;
+
+  async shouldCollaborate(intent: CommandIntent, qualityScore?: number): Promise<boolean> {
+    // 明确要求协作
+    if (intent.needCollaboration) return true;
+
+    // 质量问题，建议协作改进
+    if (qualityScore && qualityScore < this.threshold) return true;
+
+    // 复杂任务建议协作
+    if (intent.action === 'improve' && intent.requirements) {
+      if (intent.requirements.length > 200) return true; // 复杂需求
+    }
+
+    return false;
+  }
+
+  selectAgentsForTask(intent: CommandIntent, availableAgents: AgentInfo[]): AgentInfo[] {
+    if (!availableAgents.length) return [];
+
+    // 如果用户指定了智能体
+    if (intent.suggestedAgents?.length) {
+      return availableAgents.filter(a =>
+        intent.suggestedAgents!.some(name =>
+          a.name.includes(name) || a.did.includes(name)
+        )
+      );
+    }
+
+    // 根据任务类型选择
+    switch (intent.action) {
+      case 'improve':
+        // 改进任务可以选多个智能体并行处理
+        return availableAgents.slice(0, 3);
+      case 'summarize':
+        // 摘要任务选一个即可
+        return [availableAgents[0]];
+      default:
+        return availableAgents.slice(0, 2);
+    }
+  }
+}
+
+/**
+ * 任务分发器 - 管理多智能体任务分发和结果收集
+ */
+export class TaskDispatcher {
+  private protocol: AgentProtocol;
+  private pendingTasks: Map<string, { intent: CommandIntent; agents: AgentInfo[] }> = new Map();
+
+  constructor(protocol: AgentProtocol) {
+    this.protocol = protocol;
+  }
+
+  async dispatchSummarize(intent: CommandIntent, target: string, agents: AgentInfo[]): Promise<string> {
+    const taskId = `summarize-${Date.now()}`;
+
+    this.pendingTasks.set(taskId, { intent, agents });
+
+    // 广播任务给选定的智能体
+    for (const agent of agents) {
+      const task: Task = {
+        taskId,
+        action: 'summarize',
+        target,
+        context: intent.context
+      };
+      await this.protocol.sendTask(task, agent.peerId || agent.did);
+    }
+
+    return taskId;
+  }
+
+  async dispatchImprove(intent: CommandIntent, target: string, agents: AgentInfo[]): Promise<string> {
+    const taskId = `improve-${Date.now()}`;
+
+    this.pendingTasks.set(taskId, { intent, agents });
+
+    // 向每个智能体发送改进请求
+    for (const agent of agents) {
+      await this.protocol.requestImprove(target, intent.requirements || '', agent.peerId);
+    }
+
+    return taskId;
+  }
+
+  cancelTask(taskId: string): void {
+    this.pendingTasks.delete(taskId);
+  }
+
+  getPendingTasks(): string[] {
+    return Array.from(this.pendingTasks.keys());
+  }
+}
+
+/**
+ * 多智能体协作工作流 - 主协调器
+ */
+export class MultiAgentWorkflow {
+  private parser: CommandParser;
+  private registry: DIDRegistry;
+  private decider: CollaborationDecider;
+  private dispatcher: TaskDispatcher;
+  private protocol: AgentProtocol;
+
+  constructor() {
+    this.parser = new CommandParser();
+    this.registry = new DIDRegistry();
+    this.decider = new CollaborationDecider();
+    this.protocol = new AgentProtocol('local', 'coordinator');
+    this.dispatcher = new TaskDispatcher(this.protocol);
+
+    this.setupResultHandlers();
+  }
+
+  private setupResultHandlers(): void {
+    // 处理返回结果
+    p2pNetwork.onMessage('result', async (data, from) => {
+      const msg = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
+      const result = JSON.parse(msg.payload) as TaskResult;
+      console.log(`\n📥 收到来自 ${from} 的结果:`);
+      console.log(`   质量: ${(result.qualityScore! * 10).toFixed(1)}/10`);
+      console.log(`   摘要: ${result.result?.substring(0, 100)}...`);
+    });
+
+    // 处理改进结果
+    p2pNetwork.onMessage('improved', async (data, from) => {
+      const msg = JSON.parse(new TextDecoder().decode(data)) as AgentMessage;
+      const result = JSON.parse(msg.payload) as ImproveResult;
+      console.log(`\n✨ 收到来自 ${from} 的改进结果:`);
+      console.log(`   质量: ${(result.qualityScore! * 10).toFixed(1)}/10`);
+      console.log(`   自动发送: ${result.shouldAutoSend ? '是' : '否'}`);
+    });
+  }
+
+  /**
+   * 处理用户输入的完整流程
+   */
+  async process(input: string, context?: string): Promise<CollaborationResult> {
+    // 1. 命令解析
+    const intent = this.parser.parse(input, context);
+    console.log(`\n🔍 解析命令:`, intent);
+
+    // 2. 发现可用的智能体
+    const agents = await this.registry.discoverAgents();
+    console.log(`\n👥 发现 ${agents.length} 个在线智能体`);
+
+    // 3. 协作决策
+    const shouldCollaborate = await this.decider.shouldCollaborate(intent);
+    console.log(`\n🤔 协作决策: ${shouldCollaborate ? '需要协作' : '独立完成'}`);
+
+    if (!shouldCollaborate) {
+      // 独立执行
+      return this.executeIndependently(intent);
+    }
+
+    // 4. 选择执行智能体
+    const selectedAgents = this.decider.selectAgentsForTask(intent, agents);
+    console.log(`\n🎯 选中 ${selectedAgents.length} 个智能体执行`);
+
+    if (selectedAgents.length === 0) {
+      // 没有可用智能体，降级为独立执行
+      console.log(`\n⚠️ 没有可用智能体，降级为独立执行`);
+      return this.executeIndependently(intent);
+    }
+
+    // 5. 分发任务
+    return this.dispatchToAgents(intent, selectedAgents);
+  }
+
+  /**
+   * 独立执行（无需协作）
+   */
+  private async executeIndependently(intent: CommandIntent): Promise<CollaborationResult> {
+    try {
+      let result: string;
+      let qualityScore = 0.5;
+
+      if (intent.action === 'read' || intent.action === 'summarize') {
+        if (!intent.target) {
+          return { success: false, collaborated: false, agents: [], error: '缺少目标文件' };
+        }
+        const content = await documentReader.read(intent.target);
+        const llm = getMinimax();
+        const summarizeResult = await llm.summarize(content.text, intent.context);
+        result = summarizeResult.summary;
+        qualityScore = summarizeResult.qualityScore;
+      } else if (intent.action === 'improve' && intent.target) {
+        const content = await documentReader.read(intent.target);
+        const llm = getMinimax();
+        result = await llm.improveContent(content.text, intent.requirements || '', intent.context);
+        qualityScore = llm.estimateQuality(content.text, result);
+      } else {
+        return { success: false, collaborated: false, agents: [], error: '未知动作' };
+      }
+
+      return {
+        success: true,
+        collaborated: false,
+        agents: [],
+        result,
+        qualityScore
+      };
+    } catch (error) {
+      return {
+        success: false,
+        collaborated: false,
+        agents: [],
+        error: String(error)
+      };
+    }
+  }
+
+  /**
+   * 分发给多个智能体协作执行
+   */
+  private async dispatchToAgents(intent: CommandIntent, agents: AgentInfo[]): Promise<CollaborationResult> {
+    try {
+      if (!intent.target) {
+        return { success: false, collaborated: true, agents, error: '缺少目标文件' };
+      }
+
+      let taskId: string;
+
+      if (intent.action === 'summarize' || intent.action === 'read') {
+        taskId = await this.dispatcher.dispatchSummarize(intent, intent.target, agents);
+      } else if (intent.action === 'improve') {
+        taskId = await this.dispatcher.dispatchImprove(intent, intent.target, agents);
+      } else {
+        return { success: false, collaborated: true, agents, error: '不支持的协作动作' };
+      }
+
+      return {
+        success: true,
+        collaborated: true,
+        agents,
+        taskId,
+        result: `任务已分发，等待结果...`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        collaborated: true,
+        agents,
+        error: String(error)
+      };
+    }
+  }
+
+  /**
+   * 查询当前在线的智能体
+   */
+  async listAgents(): Promise<AgentInfo[]> {
+    return this.registry.discoverAgents();
+  }
+
+  /**
+   * 注册一个新智能体
+   */
+  async registerAgent(agent: AgentInfo): Promise<void> {
+    await this.registry.registerAgent(agent);
+  }
+}

package/src/workflows/index.ts

@@ -0,0 +1,64 @@
+/**
+ * Multi-Agent Collaboration Workflows
+ *
+ * 工作流设计文档：
+ *
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                      用户输入                              │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *                            ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                   命令解析器 (CommandParser)                │
+ * │  - 识别动作: read/summarize/improve/query/collaborate      │
+ * │  - 提取目标文件、需求描述                                  │
+ * │  - 检测协作关键词                                         │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *                            ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                  DID注册表 (DIDRegistry)                    │
+ * │  - 管理已知智能体的DID信息                                │
+ * │  - 从IPNS解析其他智能体DID文档                            │
+ * │  - 追踪在线状态                                           │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *                            ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                 协作决策器 (CollaborationDecider)           │
+ * │  - 基于任务复杂度、关键词、质量评分决策                     │
+ * │  - 选择合适的执行智能体                                   │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *              ┌─────────────┴─────────────┐
+ *              │                           │
+ *              ▼                           ▼
+ *    ┌─────────────────┐       ┌─────────────────┐
+ *    │    独立执行      │       │   多智能体协作   │
+ *    │  - 直接处理      │       │                 │
+ *    │  - 返回结果      │       │  - 分发任务     │
+ *    └─────────────────┘       │  - 收集结果     │
+ *                              │  - 汇总汇报     │
+ *                              └─────────────────┘
+ *                                       │
+ *                                       ▼
+ *                              ┌─────────────────┐
+ *                              │   任务分发器     │
+ *                              │ (TaskDispatcher) │
+ *                              │                 │
+ *                              │ - Protocol发送  │
+ *                              │ - 任务追踪      │
+ *                              │ - 结果收集      │
+ *                              └─────────────────┘
+ */
+
+export {
+  CommandParser,
+  DIDRegistry,
+  CollaborationDecider,
+  TaskDispatcher,
+  MultiAgentWorkflow,
+  type AgentInfo,
+  type CollaborationResult,
+  type CommandIntent
+} from './collaboration.js';

package/tsconfig.electron.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "ignoreDeprecations": "6.0",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": false,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "types": ["node"]
+  },
+  "include": ["src/electron.ts", "src/electron-preload.ts"],
+  "exclude": ["node_modules", "dist", "src/constraint-runtime", "src/agents", "src/web"]
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "ignoreDeprecations": "6.0",
+    "jsx": "react-jsx",
+    "jsxImportSource": "react"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    exclude: [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/.kilo/worktrees/**',
+      '**/constraint-runtime/**'
+    ]
+  }
+});

package//346/203/263/346/263/225.md

@@ -0,0 +1,79 @@
+# AI智能体自主阅读与交流工具 - 设计文档
+
+## 一、项目概述
+
+设计一个AI智能体自主阅读文档、总结内容并自主交流的工具智能体。智能体具备自主决策能力，可根据人类指令或预设规则自动执行文档处理、信息汇报等任务。
+
+## 二、核心功能
+
+### 2.1 文档处理能力
+- **自主阅读**：智能体自动读取指定路径的文档（支持TXT、Markdown、PDF等格式）
+- **智能总结**：对文档内容进行语义理解和结构化总结，提取关键信息
+- **内容改写**：根据人类提出的要求，对文档进行优化、补充或重构
+
+### 2.2 工作流引擎
+- 支持可视化或配置化的工作流定义
+- 工作流节点包括：文档读取 → 内容分析 → 总结生成 → 审核判断 → 发送汇报
+- 支持条件分支：人类要求改写时进入修改流程，否则直接发送
+
+### 2.3 自主汇报与发送
+- 智能体根据汇报对象配置，自动发送总结内容到指定目标
+- 支持发送给自己的人类（自主汇报）或团队其他成员
+- 发送前支持预览确认，或完全自主决定（根据配置）
+
+### 2.4 去中心化P2P通信
+- 智能体之间通过DIaoP协议建立点对点通信
+- 支持跨设备、跨网络环境下的智能体互联
+- 使用TS SDK实现，配备专属身份文档（身份标识、密钥对）
+
+### 2.5 多智能体协作
+- 不同人类可拥有各自的智能体实例
+- 智能体间可互相发送任务、信息、文档
+- 支持群组广播或定向发送
+
+## 三、运行模式
+
+### 3.1 终端运行（MVP阶段）
+- 通过命令行启动智能体实例
+- 配置文件指定文档路径、汇报对象、身份信息
+- 日志输出运行状态和交互信息
+
+### 3.2 前端运行（后续阶段）
+- Web界面管理智能体配置
+- 可视化工作流设计器
+- 文档预览和编辑界面
+
+## 四、技术选型
+
+| 组件 | 技术方案 |
+|------|----------|
+| SDK | Pi SDK（MVP核心） |
+| 协议 | DIaoP（去中心化身份与通信协议） |
+| 语言 | TypeScript |
+| 身份系统 | DIaoP身份文档（公私钥、标识） |
+| 运行平台 | 终端（初期）、Web（后期） |
+
+## 五、实现效果
+
+### 5.1 人类视角
+- 告诉智能体："帮我看看这个文档，给出总结"
+- 智能体自动完成阅读、分析、总结，并推送给相关人员
+- 可以提出修改要求："第三部分太简单，帮我补充"
+- 智能体完成修改后，自主决定是否发送给另一个用户的智能体
+
+### 5.2 智能体视角
+- 接收任务 → 解析指令 → 执行工作流 → 反馈结果
+- 具备一定自主判断能力，减少人工干预
+- 可与其他智能体协商、分配任务
+
+### 5.3 系统视角
+- 多个智能体实例通过P2P网络互联
+- 无需中心化服务器，节点间直接通信
+- 身份由DIAP协议保障，可验证可追溯，有npm包可以下载调用。https://www.npmjs.com/package/@diap/sdk/v/0.1.2
+
+## 六、关键特性
+
+- **自主性**：智能体根据上下文和规则自主决策
+- **去中心化**：无单点依赖，节点平等互联
+- **安全可信**：DIAP协议提供身份验证和加密通信
+- **可扩展**：支持插件式功能扩展和工作流定制