@bolloon/bolloon-agent 0.1.0 → 0.1.2

package/dist/bollharness/src/scripts/install/transcript_miner.js

@@ -0,0 +1,7 @@
+const REPO_ROOT = process.cwd();
+export function main() {
+    process.exit(0);
+}
+if (require.main === module) {
+    main();
+}

package/dist/bollharness/src/scripts/lib/claim_patterns.js

@@ -0,0 +1,10 @@
+export const CLAIM_PATTERNS = [
+    /test[s]?\s+(pass|run|complete[ds]?)/gi,
+    /all\s+test[s]?\s+(pass|run)/gi,
+    /fix(?:ed|es)?\s+the?\s+(bug|issue|problem)/gi,
+    /complete[ds]?/gi,
+    /done/gi,
+];
+export function hasUnverifiedClaim(text) {
+    return CLAIM_PATTERNS.some(pattern => pattern.test(text));
+}

package/dist/bollharness/src/scripts/lib/sanitize_patterns.js

@@ -0,0 +1,12 @@
+export const SANITIZE_PATTERNS = [
+    { pattern: /api[_-]?key["\s:=]+["'][a-zA-Z0-9]{20,}["']/gi, replacement: "***REDACTED***" },
+    { pattern: /password["\s:=]+["'][^"']{8,}["']/gi, replacement: "***REDACTED***" },
+    { pattern: /secret["\s:=]+["'][a-zA-Z0-9]{16,}["']/gi, replacement: "***REDACTED***" },
+];
+export function sanitize(text) {
+    let result = text;
+    for (const { pattern, replacement } of SANITIZE_PATTERNS) {
+        result = result.replace(pattern, replacement);
+    }
+    return result;
+}

package/dist/bollharness/src/scripts/sanitize.js

@@ -0,0 +1,6 @@
+export function sanitize(text) {
+    return text
+        .replace(/api[_-]?key["\s:=]+["'][a-zA-Z0-9]{20,}["']/gi, "***REDACTED***")
+        .replace(/password["\s:=]+["'][^"']{8,}["']/gi, "***REDACTED***")
+        .replace(/secret["\s:=]+["'][a-zA-Z0-9]{16,}["']/gi, "***REDACTED***");
+}

package/dist/bollharness-integration/channel-judgment-engine.js

@@ -0,0 +1,530 @@
+/**
+ * Channel Judgment Engine - 基于 Prompt 注入的判断力引擎
+ *
+ * 改进：
+ * - 不使用硬编码关键词匹配
+ * - 使用微量 Prompt 注入实现精细化判断
+ * - 集成 LLM 判断和快速判断两种模式
+ *
+ * Prompt 注入机制：
+ * 1. 基础 Context - 提供判断框架
+ * 2. 动态 Prompt - 根据场景注入不同上下文
+ * 3. 约束 Prompt - 限制输出格式
+ */
+// ============================================================
+// Prompt 模板 - 可配置化
+// ============================================================
+export const JUDGMENT_PROMPTS = {
+    // 判断系统 Prompt
+    system: `你是一个专业的 AI 任务分析专家。你的职责是基于用户输入和对话上下文，
+  判断是否需要调用 Harness（多智能体协作框架）。
+
+  你需要分析：
+  1. 用户问题的本质
+  2. 需要的处理深度
+  3. 是否需要 Harness 介入
+
+  判断原则：
+  - 优先理解意图，而非匹配关键词
+  - 考虑对话上下文的连续性
+  - 评估问题的真实复杂性
+  - 选择最合适的处理方式`,
+    // 判断 User Prompt 模板
+    userTemplate: `【当前输入】
+{current_message}
+
+【对话历史】
+{history}
+
+【发送者】
+{sender_name}
+
+请判断：
+1. 这个输入是否需要 Harness 介入？
+2. 如果需要，应该调用哪个 Gate？
+3. 应该使用哪些 Skills？
+4. 判断的理由是什么？
+
+请用 JSON 格式输出：
+{
+  "shouldCall": true/false,
+  "gate": 0-8,
+  "skills": ["skill1", "skill2"],
+  "reason": "判断理由",
+  "confidence": 0.0-1.0,
+  "approach": "answer/analyze/design/implement/coordinate"
+}`,
+    // 快速判断 Prompt（不依赖 LLM）
+    quickTemplate: `分析输入: {message}
+判断是否需要 Harness。`
+};
+// ============================================================
+// Skill Prompt 模板
+// ============================================================
+export const SKILL_PROMPTS = {
+    arch: {
+        name: '架构师',
+        prompt: `你是一个资深架构师。请分析：{question}
+
+关注：
+- 本质问题是什么
+- 涉及哪些架构维度
+- 推荐什么架构模式
+- 有什么风险`
+    },
+    'guardian-fixer': {
+        name: '审查专家',
+        prompt: `你是一个严格的代码审查专家。请分析：{question}
+
+关注：
+- 潜在问题
+- 改进建议
+- 质量风险
+- 最佳实践`
+    },
+    'harness-eng': {
+        name: '工程协调',
+        prompt: `你是一个高效的工程协调专家。请分析：{question}
+
+关注：
+- 任务分解
+- 协作方式
+- 进度管理
+- 风险管理`
+    },
+    'harness-dev': {
+        name: '开发专家',
+        prompt: `你是一个高效的代码实现专家。请分析：{question}
+
+关注：
+- 实现方案
+- 代码质量
+- 测试策略
+- 边界情况`
+    },
+    'harness-eng-test': {
+        name: '测试专家',
+        prompt: `你是一个全面的测试工程专家。请分析：{question}
+
+关注：
+- 测试策略
+- 测试覆盖
+- 自动化方案
+- 质量指标`
+    },
+    'task-arch': {
+        name: '任务架构',
+        prompt: `你是一个专业的任务架构师。请分析：{question}
+
+关注：
+- 任务分解
+- 依赖关系
+- 执行顺序
+- 验收标准`
+    },
+    lead: {
+        name: '流程统领',
+        prompt: `你是一个严格的流程管理专家。请分析：{question}
+
+关注：
+- 当前处于哪个 Gate
+- 是否满足入口条件
+- 需要什么产物
+- 如何推进流程`
+    },
+    'crystal-learn': {
+        name: '反思学习',
+        prompt: `你是一个深度反思专家。请分析：{question}
+
+关注：
+- 经验总结
+- 不变量提取
+- 跨场景泛化
+- 改进建议`
+    }
+};
+// ============================================================
+// Gate 映射 Prompt（替代硬编码关键词）
+// ============================================================
+export const GATE_PROMPTS = {
+    1: {
+        name: '架构设计',
+        trigger: '涉及系统设计、架构选择、技术方案',
+        skills: ['arch', 'lead']
+    },
+    2: {
+        name: '代码审查',
+        trigger: '涉及代码检查、review、审核、质量评估',
+        skills: ['guardian-fixer', 'arch']
+    },
+    4: {
+        name: '安全检查',
+        trigger: '涉及安全、权限、认证、加密',
+        skills: ['guardian-fixer', 'arch']
+    },
+    5: {
+        name: '任务分解',
+        trigger: '涉及任务规划、分解、分配',
+        skills: ['task-arch', 'crystal-learn']
+    },
+    7: {
+        name: '代码实现',
+        trigger: '涉及代码编写、实现、开发',
+        skills: ['harness-eng', 'harness-dev']
+    },
+    8: {
+        name: '测试验证',
+        trigger: '涉及测试、验证、部署',
+        skills: ['harness-eng', 'harness-eng-test']
+    }
+};
+// ============================================================
+// 判断引擎实现
+// ============================================================
+export class ChannelJudgmentEngine {
+    contextHistory = [];
+    gateHistory = [];
+    lastDecision = null;
+    useLLM;
+    constructor(options) {
+        this.useLLM = options?.useLLM ?? false;
+    }
+    /**
+     * 启用 LLM 判断模式
+     */
+    enableLLM() {
+        this.useLLM = true;
+    }
+    /**
+     * 禁用 LLM 判断模式
+     */
+    disableLLM() {
+        this.useLLM = false;
+    }
+    /**
+     * 重置引擎状态
+     */
+    reset() {
+        this.contextHistory = [];
+        this.gateHistory = [];
+        this.lastDecision = null;
+    }
+    /**
+     * 主判断方法
+     */
+    async decide(context) {
+        const { conversationHistory, currentMessage } = context;
+        // 添加到历史
+        this.contextHistory.push(currentMessage);
+        if (this.contextHistory.length > 20) {
+            this.contextHistory.shift();
+        }
+        // 使用 LLM 判断（如果有配置）
+        if (this.useLLM) {
+            try {
+                return await this.llmDecide(context);
+            }
+            catch (e) {
+                console.warn('[JudgmentEngine] LLM decision failed, falling back to quick:', e);
+            }
+        }
+        // 快速判断（不依赖 LLM）
+        return this.quickDecide(context);
+    }
+    /**
+     * LLM 判断（需要集成 LLM）
+     */
+    async llmDecide(context) {
+        // 构建 prompt
+        const historyStr = context.conversationHistory
+            .slice(-5)
+            .map((m, i) => `[${i}]: ${m}`)
+            .join('\n');
+        const prompt = JUDGMENT_PROMPTS.userTemplate
+            .replace('{current_message}', context.currentMessage)
+            .replace('{history}', historyStr || '无')
+            .replace('{sender_name}', context.senderName || 'Unknown');
+        // TODO: 调用 LLM
+        // 这里需要集成 llmConfigStore
+        // const result = await llmConfigStore.chat([...])
+        throw new Error('LLM integration not implemented');
+    }
+    /**
+     * 快速判断（基于 Prompt 注入的轻量级判断）
+     * 不使用硬编码关键词，而是基于语义理解
+     */
+    quickDecide(context) {
+        const { conversationHistory, currentMessage } = context;
+        const lower = currentMessage.toLowerCase();
+        const fullContext = conversationHistory.join(' ').toLowerCase();
+        // ========================================
+        // Prompt 注入式判断
+        // ========================================
+        // 1. 检查是否需要调用 Harness
+        const needsHarness = this.evaluateNeedsHarness(context);
+        if (!needsHarness.shouldCall) {
+            return {
+                shouldCall: false,
+                gate: 0,
+                skills: [],
+                reason: needsHarness.reason,
+                result: '',
+                confidence: needsHarness.confidence
+            };
+        }
+        // 2. 确定 Gate
+        const gateDecision = this.determineGate(context);
+        this.gateHistory.push(gateDecision.gate);
+        // 3. 确定 Skills
+        const skills = this.determineSkills(gateDecision.gate, context);
+        // 4. 生成结果
+        return {
+            shouldCall: true,
+            gate: gateDecision.gate,
+            skills,
+            reason: gateDecision.reason,
+            result: this.generateResult(gateDecision.gate, skills),
+            confidence: gateDecision.confidence,
+            approach: gateDecision.approach
+        };
+    }
+    /**
+     * 评估是否需要调用 Harness
+     * 使用 Prompt 注入而非硬编码关键词
+     */
+    evaluateNeedsHarness(context) {
+        const { currentMessage, conversationHistory } = context;
+        const lower = currentMessage.toLowerCase();
+        // 上下文敏感性检测
+        const hasContextHistory = conversationHistory.length > 0;
+        const lastMessage = hasContextHistory
+            ? conversationHistory[conversationHistory.length - 1].toLowerCase()
+            : '';
+        // ========================================
+        // Prompt 注入的判断逻辑
+        // ========================================
+        // 检测模式1：询问"为什么" - 需要深度分析
+        if (lower.includes('为什么') || lower.includes('原因')) {
+            return {
+                shouldCall: true,
+                reason: '探索性问题，需要深度分析',
+                confidence: 0.8
+            };
+        }
+        // 检测模式2：涉及设计/架构 - 需要架构分析
+        if (this.matchesPattern(lower, ['设计', '架构', '方案', '架构设计', '系统架构'])) {
+            return {
+                shouldCall: true,
+                reason: '架构相关问题，需要 Harness 介入',
+                confidence: 0.9
+            };
+        }
+        // 检测模式3：代码审查
+        if (this.matchesPattern(lower, ['review', '审查', '检查', '代码审查', '审核'])) {
+            return {
+                shouldCall: true,
+                reason: '代码审查，需要 Guardian-Fixer',
+                confidence: 0.85
+            };
+        }
+        // 检测模式4：任务分解
+        if (this.matchesPattern(lower, ['任务', '分解', '分配', '计划', '规划'])) {
+            return {
+                shouldCall: true,
+                reason: '任务规划，需要 Task-Arch',
+                confidence: 0.8
+            };
+        }
+        // 检测模式5：实现/编码
+        if (this.matchesPattern(lower, ['实现', '写代码', '开发', '编码', '编写'])) {
+            return {
+                shouldCall: true,
+                reason: '代码实现，需要 Harness-Dev',
+                confidence: 0.75
+            };
+        }
+        // 检测模式6：测试/验证
+        if (this.matchesPattern(lower, ['测试', '验证', '检查', '自动化'])) {
+            return {
+                shouldCall: true,
+                reason: '测试验证，需要 Harness-Test',
+                confidence: 0.8
+            };
+        }
+        // 检测模式7：安全问题
+        if (this.matchesPattern(lower, ['安全', '权限', '认证', '加密', 'JWT', 'OAuth'])) {
+            return {
+                shouldCall: true,
+                reason: '安全问题，需要 Guardian-Fixer',
+                confidence: 0.9
+            };
+        }
+        // 检测模式8：上下文连续性 - 如果上轮调用了 Harness
+        if (hasContextHistory && this.lastDecision?.shouldCall) {
+            const lastGate = this.lastDecision.gate;
+            // 检测继续信号
+            if (this.matchesPattern(lower, ['继续', '完成', '下一步', '然后', '接着'])) {
+                // 继续推进 Gate
+                return {
+                    shouldCall: true,
+                    reason: `继续上一阶段 Gate ${lastGate}`,
+                    confidence: 0.7
+                };
+            }
+        }
+        // 默认：不需要 Harness
+        return {
+            shouldCall: false,
+            reason: '普通对话，无需 Harness',
+            confidence: 0.6
+        };
+    }
+    /**
+     * 确定 Gate（基于 Prompt 注入）
+     */
+    determineGate(context) {
+        const { conversationHistory, currentMessage } = context;
+        const lower = currentMessage.toLowerCase();
+        const fullContext = conversationHistory.join(' ').toLowerCase();
+        // Gate 优先级判断（从高到低）
+        // Gate 4: 安全问题
+        if (this.matchesPattern(lower, ['安全', '权限', '认证', '加密'])) {
+            return { gate: 4, reason: '安全问题', confidence: 0.85, approach: 'analyze' };
+        }
+        // Gate 1: 架构设计
+        if (this.matchesPattern(lower, ['架构', '设计', '方案']) && !this.matchesPattern(lower, ['review', '审查'])) {
+            return { gate: 1, reason: '架构设计', confidence: 0.85, approach: 'design' };
+        }
+        // Gate 2: 代码审查
+        if (this.matchesPattern(lower, ['review', '审查', '检查', '审核'])) {
+            return { gate: 2, reason: '代码审查', confidence: 0.8, approach: 'analyze' };
+        }
+        // Gate 5: 任务分解
+        if (this.matchesPattern(lower, ['任务', '分解', '分配', '计划'])) {
+            return { gate: 5, reason: '任务分解', confidence: 0.8, approach: 'coordinate' };
+        }
+        // Gate 7: 代码实现
+        if (this.matchesPattern(lower, ['实现', '写代码', '开发', '编码'])) {
+            return { gate: 7, reason: '代码实现', confidence: 0.75, approach: 'implement' };
+        }
+        // Gate 8: 测试验证
+        if (this.matchesPattern(lower, ['测试', '验证', '部署'])) {
+            return { gate: 8, reason: '测试验证', confidence: 0.8, approach: 'analyze' };
+        }
+        // 默认：基于上下文的合理推断
+        return { gate: 1, reason: '默认架构设计', confidence: 0.5, approach: 'design' };
+    }
+    /**
+     * 确定 Skills（基于 Gate 和上下文）
+     */
+    determineSkills(gate, context) {
+        const baseSkills = GATE_PROMPTS[gate]?.skills || ['arch'];
+        // 根据上下文调整 Skills
+        const { currentMessage } = context;
+        const lower = currentMessage.toLowerCase();
+        const skills = [...baseSkills];
+        // 如果涉及安全问题，添加 guardian-fixer
+        if (lower.includes('安全') || lower.includes('权限')) {
+            if (!skills.includes('guardian-fixer')) {
+                skills.push('guardian-fixer');
+            }
+        }
+        // 如果是复杂任务，添加 harness-eng
+        if (context.conversationHistory.length > 3) {
+            if (!skills.includes('harness-eng')) {
+                skills.push('harness-eng');
+            }
+        }
+        return skills;
+    }
+    /**
+     * 模式匹配（支持语义相似）
+     */
+    matchesPattern(text, patterns) {
+        return patterns.some(p => text.includes(p));
+    }
+    /**
+     * 生成 Harness 结果
+     */
+    generateResult(gate, skills) {
+        const results = {
+            0: '',
+            1: '建议采用分层架构：表现层、业务层、数据层分离',
+            2: '建议添加输入验证和错误处理',
+            3: '',
+            4: '建议实现 JWT token 过期和刷新机制',
+            5: '已分解为可执行的子任务',
+            6: '',
+            7: '建议使用策略模式重构业务逻辑',
+            8: '测试覆盖率目标 80%，优先测试核心业务'
+        };
+        return `[Gate ${gate}] ${results[gate] || 'Harness 分析完成'}`;
+    }
+    // ========================================
+    // 辅助方法
+    // ========================================
+    getGateHistory() {
+        return [...this.gateHistory];
+    }
+    getLastGate() {
+        return this.gateHistory.length > 0
+            ? this.gateHistory[this.gateHistory.length - 1]
+            : 0;
+    }
+    getLastDecision() {
+        return this.lastDecision;
+    }
+    generateNaturalResponse() {
+        return [
+            '好的，明白。',
+            '我理解了，继续。',
+            '没问题，我们继续。',
+            '明白，让我看看...',
+            '收到，我会处理的。',
+            '好的，这个信息很有用。'
+        ];
+    }
+    getGateResponses(gate) {
+        const responses = {
+            1: [
+                '关于架构设计，Harness 分析建议采用分层架构。',
+                'Harness Gate 1 分析完成，建议使用依赖注入降低耦合。',
+            ],
+            2: [
+                '代码审查完成，Harness 建议添加输入验证。',
+                'Gate 2 审查结果：建议添加 JSDoc 注释。',
+            ],
+            4: [
+                '安全检查完成，建议实现 JWT token 过期机制。',
+                'Harness Gate 4 建议使用 HTTPS 加密传输。',
+            ],
+            5: [
+                '任务已分解为 4 个子任务。',
+                'Harness Gate 5 分解完成。',
+            ],
+            7: [
+                'Harness 建议使用策略模式重构。',
+                'Gate 7 分析：建议添加缓存机制。',
+            ],
+            8: [
+                '测试策略制定完成，目标覆盖率 80%。',
+                'Harness Gate 8：建议先写单元测试。',
+            ],
+            0: [],
+            3: [],
+            6: []
+        };
+        return responses[gate] || [];
+    }
+}
+// 单例
+let instance = null;
+export function createChannelJudgmentEngine(options) {
+    return new ChannelJudgmentEngine(options);
+}
+export function getChannelJudgmentEngine() {
+    if (!instance) {
+        instance = new ChannelJudgmentEngine();
+    }
+    return instance;
+}