@bolloon/bolloon-agent 0.1.37 → 0.1.39

package/scripts/postinstall.js

@@ -0,0 +1,153 @@
+/**
+ * Postinstall 脚本
+ * npm 安装后自动执行
+ *
+ * 主要任务：
+ * 1. 确保 bin 目录存在且可执行
+ * 2. 初始化本地配置
+ * 3. 检查依赖完整性
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+const RESET = '\x1b[0m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+
+function log(msg, color = RESET) {
+  console.log(color + msg + RESET);
+}
+
+function initUserDirs() {
+  // 创建用户数据目录
+  const home = process.env.HOME || process.env.USERPROFILE || '/tmp';
+  const bolloonDir = path.join(home, '.bolloon');
+
+  const dirs = [
+    bolloonDir,
+    path.join(bolloonDir, 'sessions'),
+    path.join(bolloonDir, 'peer-store'),
+  ];
+
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+      log(`  ✓ 创建目录: ${dir}`, GREEN);
+    }
+  }
+
+  // 初始化配置文件
+  const configPath = path.join(bolloonDir, 'config.json');
+  if (!fs.existsSync(configPath)) {
+    const defaultConfig = {
+      version: '0.1.12',
+      initializedAt: new Date().toISOString(),
+      defaults: {
+        port: 54188,
+        theme: 'dark',
+        autoConnect: true,
+      },
+      providers: {
+        minimax: { enabled: false },
+        openai: { enabled: false },
+        anthropic: { enabled: false },
+      }
+    };
+    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+    log(`  ✓ 创建配置: ${configPath}`, GREEN);
+  }
+
+  return bolloonDir;
+}
+
+function checkNativeDeps() {
+  // 检查必要的原生依赖
+  const nativeDeps = [
+    'libp2p',
+    '@diap/sdk',
+  ];
+
+  let allOk = true;
+
+  for (const dep of nativeDeps) {
+    const depPath = path.join(rootDir, 'node_modules', dep);
+    if (!fs.existsSync(depPath)) {
+      log(`  ⚠ 缺少依赖: ${dep}`, YELLOW);
+      allOk = false;
+    }
+  }
+
+  return allOk;
+}
+
+function setupPlatform() {
+  const platform = process.platform;
+
+  log(`\n  平台: ${platform}`, CYAN);
+
+  if (platform === 'win32') {
+    // Windows: 确保 .cmd 文件存在
+    const binDir = path.join(rootDir, 'bin');
+    const cmdPath = path.join(binDir, 'bolloon.cmd');
+
+    if (fs.existsSync(binDir) && !fs.existsSync(cmdPath)) {
+      const cmdContent = `@echo off
+node "%~dp0..\\dist\\cli.js" %*
+`;
+      fs.writeFileSync(cmdPath, cmdContent);
+      log('  ✓ Windows 入口已创建', GREEN);
+    }
+  } else {
+    // Unix/Linux/Mac: 确保 bin 文件可执行
+    const binDir = path.join(rootDir, 'bin');
+    const binPath = path.join(binDir, 'bolloon.js');
+
+    if (fs.existsSync(binPath)) {
+      try {
+        fs.chmodSync(binPath, 0o755);
+        log('  ✓ bin/bolloon.js 已设为可执行', GREEN);
+      } catch (err) {
+        log(`  ⚠ 无法设置执行权限: ${err.message}`, YELLOW);
+      }
+    }
+  }
+}
+
+function main() {
+  console.log('\n📦 Bolloon 安装后处理...\n');
+
+  try {
+    // 1. 初始化用户目录
+    const bolloonDir = initUserDirs();
+    log(`  ✓ 用户数据目录: ${bolloonDir}`, GREEN);
+
+    // 2. 检查依赖
+    const depsOk = checkNativeDeps();
+    if (!depsOk) {
+      log('\n  ⚠ 部分依赖缺失，建议运行: npm install', YELLOW);
+    }
+
+    // 3. 平台特定设置
+    setupPlatform();
+
+    console.log('\n✅ 安装完成！\n');
+    console.log('  使用方式:');
+    console.log('    bolloon              # 启动 GUI');
+    console.log('    bolloon --web        # 启动 Web UI');
+    console.log('    bolloon --cli        # 命令行模式');
+    console.log('    bolloon --help       # 显示帮助\n');
+    console.log(`  配置文件: ${path.join(bolloonDir, 'config.json')}\n`);
+  } catch (err) {
+    console.error('\n❌ 安装后处理失败:', err.message);
+    console.error('  这通常不影响基本功能，继续安装...\n');
+  }
+}
+
+main();

package/dist/bollharness-integration/llm/pi-ai.js

@@ -1,397 +0,0 @@
-export class PiAIModel {
-    config;
-    provider;
-    constructor(config) {
-        this.config = config;
-        this.provider = config.provider;
-    }
-    async chat(message, context) {
-        const systemPrompt = this.buildSystemPrompt(context);
-        const messages = [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: message }
-        ];
-        try {
-            const response = await this.generateText({
-                messages,
-                temperature: 0.8
-            });
-            return { reply: response };
-        }
-        catch (error) {
-            console.error('PiAI chat error:', error);
-            return { reply: '抱歉，AI服务暂时不可用。' };
-        }
-    }
-    async summarize(text, context) {
-        const prompt = this.buildSummarizePrompt(text, context);
-        try {
-            const response = await this.generateText({
-                messages: [
-                    { role: 'system', content: 'You are a professional document summarizer.' },
-                    { role: 'user', content: prompt }
-                ],
-                temperature: 0.7
-            });
-            const qualityScore = this.estimateQuality(text, response);
-            return { summary: response, qualityScore };
-        }
-        catch (error) {
-            console.error('PiAI summarize error:', error);
-            return {
-                summary: text.substring(0, 500) + '...',
-                qualityScore: 0.5
-            };
-        }
-    }
-    async improveContent(content, requirements, context) {
-        const prompt = this.buildImprovePrompt(content, requirements, context);
-        try {
-            const response = await this.generateText({
-                messages: [
-                    { role: 'system', content: 'You are a professional document editor and improver.' },
-                    { role: 'user', content: prompt }
-                ],
-                temperature: 0.8
-            });
-            return response;
-        }
-        catch (error) {
-            console.error('PiAI improve error:', error);
-            return content;
-        }
-    }
-    async generateText(options) {
-        const { messages, temperature = 0.7, maxTokens = 4096 } = options;
-        switch (this.provider) {
-            case 'openai':
-            case 'minimax':
-                return this.callOpenAI(messages, temperature, maxTokens);
-            case 'anthropic':
-                return this.callAnthropic(messages, temperature, maxTokens);
-            case 'ollama':
-                return this.callOllama(messages, temperature);
-            case 'openrouter':
-                return this.callOpenRouter(messages, temperature, maxTokens);
-            case 'gemini':
-                return this.callGemini(messages, temperature, maxTokens);
-            case 'local':
-                return this.callLocal(messages, temperature);
-            default:
-                throw new Error(`Unsupported provider: ${this.provider}`);
-        }
-    }
-    getApiKey() {
-        return this.config.apiKey || this.getEnvApiKey();
-    }
-    getEnvApiKey() {
-        const envVars = {
-            openai: process.env.OPENAI_API_KEY || '',
-            anthropic: process.env.ANTHROPIC_API_KEY || '',
-            ollama: '',
-            openrouter: process.env.OPENROUTER_API_KEY || '',
-            gemini: process.env.GEMINI_API_KEY || '',
-            minimax: process.env.MINIMAX_API_KEY || '',
-            local: ''
-        };
-        return envVars[this.provider] || '';
-    }
-    getBaseUrl() {
-        if (this.config.baseUrl) {
-            return this.config.baseUrl;
-        }
-        const baseUrls = {
-            openai: 'https://api.openai.com/v1',
-            anthropic: 'https://api.anthropic.com/v1',
-            ollama: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-            openrouter: 'https://openrouter.ai/api/v1',
-            gemini: 'https://generativelanguage.googleapis.com/v1beta',
-            minimax: 'https://api.minimaxi.com/v1',
-            local: 'http://localhost:11434'
-        };
-        return baseUrls[this.provider];
-    }
-    mapModel() {
-        const modelMap = {
-            openai: this.config.model || 'gpt-4',
-            anthropic: this.config.model || 'claude-3-5-sonnet-20241022',
-            ollama: this.config.model || 'llama3.2',
-            openrouter: this.config.model || 'anthropic/claude-3.5-sonnet',
-            gemini: this.config.model || 'gemini-2.0-flash',
-            minimax: this.config.model || 'MiniMax-M2.7',
-            local: this.config.model || 'llama3.2'
-        };
-        return modelMap[this.provider];
-    }
-    async callOpenAI(messages, temperature, maxTokens) {
-        const apiKey = this.getApiKey();
-        if (!apiKey) {
-            throw new Error('OPENAI_API_KEY not set');
-        }
-        const response = await fetch(`${this.getBaseUrl()}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`
-            },
-            body: JSON.stringify({
-                model: this.mapModel(),
-                messages,
-                temperature,
-                max_tokens: maxTokens
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`OpenAI API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.choices?.[0]?.message?.content || '';
-    }
-    async callAnthropic(messages, temperature, maxTokens) {
-        const apiKey = this.getApiKey();
-        if (!apiKey) {
-            throw new Error('ANTHROPIC_API_KEY not set');
-        }
-        const systemMessage = messages.find(m => m.role === 'system')?.content || '';
-        const userMessages = messages.filter(m => m.role !== 'system');
-        const response = await fetch(`${this.getBaseUrl()}/messages`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': apiKey,
-                'anthropic-version': '2023-06-01',
-                'anthropic-dangerous-direct-browser-access': 'true'
-            },
-            body: JSON.stringify({
-                model: this.mapModel(),
-                messages: userMessages,
-                system: systemMessage,
-                temperature,
-                max_tokens: maxTokens
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`Anthropic API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.content?.[0]?.text || '';
-    }
-    async callOllama(messages, temperature) {
-        const response = await fetch(`${this.getBaseUrl()}/api/chat`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({
-                model: this.mapModel(),
-                messages,
-                temperature,
-                stream: false
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`Ollama API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.message?.content || '';
-    }
-    async callOpenRouter(messages, temperature, maxTokens) {
-        const apiKey = this.getApiKey();
-        if (!apiKey) {
-            throw new Error('OPENROUTER_API_KEY not set');
-        }
-        const response = await fetch(`${this.getBaseUrl()}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`,
-                'HTTP-Referer': 'https://openclaw.ai',
-                'X-Title': 'OpenClaw'
-            },
-            body: JSON.stringify({
-                model: this.mapModel(),
-                messages,
-                temperature,
-                max_tokens: maxTokens
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`OpenRouter API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.choices?.[0]?.message?.content || '';
-    }
-    async callGemini(messages, temperature, maxTokens) {
-        const apiKey = this.getApiKey();
-        if (!apiKey) {
-            throw new Error('GEMINI_API_KEY not set');
-        }
-        const contents = messages
-            .filter(m => m.role !== 'system')
-            .map(m => ({
-            role: m.role === 'assistant' ? 'model' : 'user',
-            parts: [{ text: m.content }]
-        }));
-        const systemInstruction = messages.find(m => m.role === 'system')?.content;
-        const response = await fetch(`${this.getBaseUrl()}/models/${this.mapModel()}:generateContent?key=${apiKey}`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({
-                contents,
-                systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : undefined,
-                generationConfig: {
-                    temperature,
-                    maxOutputTokens: maxTokens
-                }
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`Gemini API error: ${response.status}`);
-        }
-        const data = await response.json();
-        return data.candidates?.[0]?.content?.parts?.[0]?.text || '';
-    }
-    async callLocal(messages, temperature) {
-        return this.callOllama(messages, temperature);
-    }
-    buildSystemPrompt(context) {
-        const envDetails = this.getEnvironmentDetails();
-        return `You are a friendly AI assistant in a P2P document collaboration network.
-
-## User Working Directory
-${context || process.cwd()}
-
-## Environment
-${envDetails}`;
-    }
-    getEnvironmentDetails() {
-        return `
-## Available Workflows
-- read - Read documents
-- summarize - Summarize documents  
-- improve - Improve documents
-- collaborate - Multi-agent collaboration
-- query - Query status
-- report - Generate reports
-
-## System Capabilities
-- Document processing (Markdown, Text, PDF, DOCX)
-- Multi-agent collaboration (P2P network)
-- Workflow engine (constraint layer)
-- Quality assessment and auto-send
-
-## Current Time
-${new Date().toISOString()}`;
-    }
-    buildSummarizePrompt(text, context) {
-        const maxLength = 8000;
-        const truncatedText = text.length > maxLength ? text.substring(0, maxLength) + '...' : text;
-        let prompt = `Please generate a concise and accurate summary for the following document:
-
-${truncatedText}
-
-Please output in the following format:
-## Summary
-[Write summary here]
-
-## Quality Self-Assessment
-[Score 1-10, with reasoning]`;
-        if (context) {
-            prompt = `Context: ${context}
-
-${prompt}`;
-        }
-        return prompt;
-    }
-    buildImprovePrompt(content, requirements, context) {
-        const maxLength = 8000;
-        const truncatedContent = content.length > maxLength ? content.substring(0, maxLength) + '...' : content;
-        let prompt = `Please improve the document according to the following requirements:
-
-Requirements: ${requirements}
-
-Original Document:
-${truncatedContent}
-
-Please output only the improved document without additional explanation.`;
-        if (context) {
-            prompt = `Context: ${context}
-
-${prompt}`;
-        }
-        return prompt;
-    }
-    estimateQuality(original, summary) {
-        const coverageRatio = summary.length / Math.max(original.length, 1);
-        const hasKeyPoints = /\d+\s*[.。]/.test(summary);
-        const decentLength = summary.length > 100 && summary.length < original.length * 0.5;
-        let score = 0.5;
-        if (coverageRatio > 0.1 && coverageRatio < 0.5)
-            score += 0.2;
-        if (hasKeyPoints)
-            score += 0.15;
-        if (decentLength)
-            score += 0.15;
-        return Math.min(1, score);
-    }
-    async shouldAutoSend(qualityScore, threshold = 0.7) {
-        return qualityScore >= threshold;
-    }
-}
-let modelInstance = null;
-function detectProvider() {
-    if (process.env.OPENAI_API_KEY)
-        return 'openai';
-    if (process.env.ANTHROPIC_API_KEY)
-        return 'anthropic';
-    if (process.env.OPENROUTER_API_KEY)
-        return 'openrouter';
-    if (process.env.GEMINI_API_KEY)
-        return 'gemini';
-    if (process.env.OLLAMA_BASE_URL)
-        return 'ollama';
-    if (process.env.MINIMAX_API_KEY)
-        return 'minimax';
-    return 'openai';
-}
-function detectModel(provider) {
-    const defaults = {
-        openai: 'gpt-4',
-        anthropic: 'claude-3-5-sonnet-20241022',
-        ollama: 'llama3.2',
-        openrouter: 'anthropic/claude-3.5-sonnet',
-        gemini: 'gemini-2.0-flash',
-        minimax: 'MiniMax-M2.7',
-        local: 'llama3.2'
-    };
-    return defaults[provider];
-}
-export function initPiAI(config = {}) {
-    const provider = config.provider || detectProvider();
-    const model = config.model || detectModel(provider);
-    modelInstance = new PiAIModel({
-        provider,
-        apiKey: config.apiKey,
-        baseUrl: config.baseUrl,
-        model
-    });
-    return modelInstance;
-}
-export function getModel() {
-    if (!modelInstance) {
-        throw new Error('PiAI not initialized. Call initPiAI first.');
-    }
-    return modelInstance;
-}
-export function isModelAvailable() {
-    return modelInstance !== null;
-}
-export function getMinimax() {
-    return getModel();
-}
-export function initMinimax(config = {}) {
-    return initPiAI(config);
-}
-export { PiAIModel as MinimaxLLM };