@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/Routes/server.js

@@ -0,0 +1,202 @@
+import http from 'node:http';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { Router } from './router/Router.js';
+import { registerRoutes } from './routes/index.js';
+import { CLIController } from '../CLI/cli.js';
+import SseHub from './sse/SseHub.js';
+import FlexRunnerController from './controllers/FlexRunnerController.js';
+import OrchestratorController from './controllers/OrchestratorController.js';
+import BrainController from './controllers/BrainController.js';
+import LoopEngineController from './controllers/LoopEngineController.js';
+import { TestCheck } from '../TestCheck/index.js';
+import { createStorage } from '../DbUse/index.js';
+import { KnowledgeManager } from '../Knowledge/index.js';
+import KnowledgeImportController from './controllers/KnowledgeImportController.js';
+
+/**
+ * Server —— HTTP 服务入口
+ *
+ * 架构分层：
+ *   Router（路由匹配） → routes/index.js（路由注册） → controllers/*（业务逻辑）
+ *
+ * 职责：
+ *  - 创建并启动 HTTP 服务（仅绑定 127.0.0.1，同机回环）
+ *  - 组装共享依赖（CLIController 等单例）
+ *  - 将请求委派给 Router
+ *
+ * 用法：
+ *   import { createServer } from './Server/Routes/server.js';
+ *   const server = await createServer({ port: 3000 });
+ *
+ * 或直接运行：
+ *   node server.js --port 3000 --type opencode
+ */
+
+/**
+ * 创建并启动 HTTP 服务
+ * @param {object} [options]
+ * @param {number} [options.port=3000]          - 监听端口
+ * @param {string} [options.cliType='opencode'] - CLI 类型
+ * @param {object} [options.cliOptions={}]      - CLI 适配器配置
+ * @param {CLIController} [options.cli]         - 已存在的 CLI 实例（优先于 cliType/cliOptions）
+ * @returns {Promise<http.Server>}
+ */
+export async function createServer(options = {}) {
+    const {
+        port = 3000,
+        cliType = 'opencode',
+        cliOptions = {},
+        cli = null
+    } = options;
+
+    // ─── 组装共享依赖（单例，所有 Controller 复用）────────────────────
+    const cliInstance = cli || new CLIController(cliType, cliOptions);
+    const sseHub = new SseHub();
+    const storage = createStorage();
+
+    // OrchestratorController 同样有状态（管理多个编排器实例），需单例
+    // skillDirectory：默认 SKILL 根目录，taskDef 未指定时兜底（供 specifiedSkill 解析 / 自动匹配）
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const skillDirectory = path.resolve(__dirname, '..', 'Skills');
+    const orchestratorController = new OrchestratorController({
+        sseHub,
+        storage,
+        flexRunnerFactory: null,
+        skillDirectory
+    });
+
+    // FlexRunnerController 是有状态的（管理多个 FlexRunner 实例），需单例。
+    // 注入 orchestratorController 使其能查找编排器创建的 FlexRunner 实例。
+    // 注入 storage 使其在没有活跃 runner 时能直接读取 session 归档。
+    const flexRunnerController = new FlexRunnerController({ orchestratorController, storage });
+
+    // BrainController 管理 Brain 拆解实例（需单例，复用 LLM 连接）
+    const brainController = new BrainController({
+        sseHub,
+        storage,
+        orchestratorController,
+        skillDirectory
+    });
+
+    // TestCheck 准出审核引擎（需单例，复用 LLM 连接和 SkillSelector）
+    const testCheck = new TestCheck({
+        sseHub,
+        storage,
+        skillDirectory
+    });
+
+    // LoopEngineController 管理大循环实例（需单例，依赖 Brain + Orchestrator + TestCheck）
+    const loopEngineController = new LoopEngineController({
+        sseHub,
+        storage,
+        brainController,
+        orchestratorController,
+        testCheck,
+        skillDirectory
+    });
+
+    // KnowledgeManager 知识沉淀管理器（需单例，知识导入复用）
+    const knowledgeManager = new KnowledgeManager();
+    await knowledgeManager.init();
+
+    // KnowledgeImportController 知识导入控制器（需单例，复用 CLI + KnowledgeManager）
+    const knowledgeImportController = new KnowledgeImportController({
+        cli: cliInstance,
+        storage,
+        skillDirectory,
+        knowledgeManager,
+        sseHub
+    });
+
+    const dependencies = {
+        cli: cliInstance,
+        sseHub,
+        storage,
+        flexRunnerController,
+        orchestratorController,
+        brainController,
+        testCheck,
+        loopEngineController,
+        knowledgeManager,
+        knowledgeImportController,
+        skillDirectory
+    };
+
+    // ─── 初始化路由器并注册路由 ────────────────────────────────────────
+    const router = new Router();
+    registerRoutes(router, dependencies);
+
+    // ─── 创建 HTTP 服务 ───────────────────────────────────────────────
+    const server = http.createServer(async (req, res) => {
+        try {
+            const matched = await router.handle(req, res);
+            if (!matched) {
+                res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: 'Not Found', path: req.url }));
+            }
+        } catch (err) {
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
+                res.end(JSON.stringify({ error: `内部错误: ${err.message}` }));
+            }
+        }
+    });
+
+    return new Promise((resolve, reject) => {
+        server.on('error', reject);
+        server.listen(port, '127.0.0.1', async () => {
+            console.log(`[Server] 服务已启动: http://127.0.0.1:${port}`);
+            console.log(`[Server] 已注册路由:`);
+            for (const route of router.routes) {
+                console.log(`  ${route.method.padEnd(6)} ${route.path}`);
+            }
+
+            // ─── 从磁盘恢复持久化的编排任务 ────────────────────────────
+            try {
+                const { restored, failed } = await orchestratorController.restoreFromDisk();
+                if (restored.length > 0) {
+                    console.log(`[Server] 已恢复 ${restored.length} 个编排任务: ${restored.join(', ')}`);
+                }
+                if (failed.length > 0) {
+                    console.warn(`[Server] ${failed.length} 个编排任务恢复失败: ${failed.join(', ')}`);
+                }
+            } catch (err) {
+                console.warn(`[Server] 恢复编排任务异常: ${err.message}`);
+            }
+
+            resolve(server);
+        });
+
+        // ─── 优雅关闭：释放 SSE 连接 + 存储连接 ──────────────────────────
+        const shutdown = () => {
+            console.log('[Server] 正在关闭...');
+            sseHub.destroy();
+            server.close(() => {
+                if (storage && typeof storage.close === 'function') {
+                    storage.close().finally(() => process.exit(0));
+                } else {
+                    process.exit(0);
+                }
+            });
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+}
+
+// ─── 直接运行入口 ──────────────────────────────────────────────────────────
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const args = process.argv.slice(2);
+    const portIdx = args.indexOf('--port');
+    const typeIdx = args.indexOf('--type');
+    const port = portIdx !== -1 ? Number(args[portIdx + 1]) : 3000;
+    const cliType = typeIdx !== -1 ? args[typeIdx + 1] : 'opencode';
+
+    createServer({ port, cliType }).catch(err => {
+        console.error('[Server] 启动失败:', err);
+        process.exit(1);
+    });
+}
+
+export default createServer;

package/vendor/Server/Routes/sse/SseHub.js

@@ -0,0 +1,308 @@
+import { createLogger } from '../library/logger.js';
+
+const logger = createLogger('SseHub');
+
+/**
+ * SseHub —— Server-Sent Events 推送中心
+ *
+ * 职责：按 channel（通常是 taskId）分组管理 SSE 连接，提供事件广播能力。
+ * 与 HTTP 路由层解耦：路由层调用 subscribe/emit，业务层（Agent Loop）调用 emit。
+ *
+ * 设计要点（参考 AIWeb SSEEmitter）：
+ *  - 按 channel 分组：多用户订阅同一任务，互不干扰
+ *  - 全局单心跳：替代 N 个 per-channel 定时器，减少资源占用
+ *  - 僵尸连接清理：超时自动移除，防止连接泄漏
+ *  - 连接关闭感知：客户端断开时自动清理
+ *
+ * 事件格式（SSE 协议）：
+ *   id: <eventId>\n
+ *   event: <eventType>\n
+ *   data: <jsonString>\n\n
+ *
+ * 使用示例：
+ *   // 路由层（StreamController）
+ *   sseHub.subscribe(taskId, res, { userId: 'user1' });
+ *
+ *   // 业务层（Agent Loop）
+ *   sseHub.emit(taskId, 'step:status', { stepId, status: 'running' });
+ */
+
+/**
+ * @typedef {object} SseConnection
+ * @property {import('node:http').ServerResponse} res  - 原始响应对象
+ * @property {string} userId                            - 用户标识（用于限流）
+ * @property {number} createdAt                         - 创建时间戳
+ * @property {number} lastEventId                       - 最后推送的事件 ID
+ */
+
+const DEFAULT_HEARTBEAT_MS = 30000;    // 30 秒心跳
+const DEFAULT_TIMEOUT_MS = 1800000;    // 30 分钟超时
+const DEFAULT_CLEANUP_MS = 300000;     // 5 分钟清理一次
+const DEFAULT_MAX_PER_USER = 10;       // 单用户最大连接数
+
+class SseHub {
+    /**
+     * @param {object} [options]
+     * @param {number} [options.heartbeatMs]    - 心跳间隔
+     * @param {number} [options.timeoutMs]      - 连接超时
+     * @param {number} [options.cleanupMs]      - 清理周期
+     * @param {number} [options.maxPerUser]     - 单用户最大连接数
+     */
+    constructor(options = {}) {
+        /** @type {Map<string, Set<SseConnection>>} */
+        this._channels = new Map();
+        /** @type {Map<string, number>} 用户连接数反向索引 */
+        this._userCounts = new Map();
+        /** 自增事件 ID */
+        this._eventId = 0;
+
+        this._heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+        this._timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this._maxPerUser = options.maxPerUser ?? DEFAULT_MAX_PER_USER;
+
+        // 全局单心跳
+        this._heartbeatTimer = setInterval(
+            () => this._broadcastHeartbeat(),
+            this._heartbeatMs
+        );
+        this._heartbeatTimer.unref?.();
+
+        // 僵尸连接清理
+        this._cleanupTimer = setInterval(
+            () => this._cleanZombies(),
+            options.cleanupMs ?? DEFAULT_CLEANUP_MS
+        );
+        this._cleanupTimer.unref?.();
+
+        logger.info('SseHub 已初始化', {
+            heartbeatMs: this._heartbeatMs,
+            timeoutMs: this._timeoutMs,
+            maxPerUser: this._maxPerUser
+        });
+    }
+
+    // ─── 公开接口 ──────────────────────────────────────────────────────
+
+    /**
+     * 订阅 channel（注册 SSE 连接）
+     * @param {string} channel - 频道名（通常为 taskId）
+     * @param {import('node:http').ServerResponse} res
+     * @param {object} [options]
+     * @param {string} [options.userId='anonymous']
+     * @param {object} [options.initialData] - 连接建立后立即推送的数据
+     * @returns {{ ok: boolean, errorCode?: string, message?: string }}
+     */
+    subscribe(channel, res, options = {}) {
+        const { userId = 'anonymous', initialData = null } = options;
+
+        // 单用户限流
+        const userCount = this._userCounts.get(userId) ?? 0;
+        if (userCount >= this._maxPerUser) {
+            logger.warn('用户连接数已达上限', { userId, count: userCount });
+            return {
+                ok: false,
+                errorCode: 'E429_SSE_LIMIT',
+                message: `用户连接数已达上限（${this._maxPerUser}）`
+            };
+        }
+
+        const conn = {
+            res,
+            userId,
+            createdAt: Date.now(),
+            lastEventId: 0
+        };
+
+        // 注册到 channel
+        if (!this._channels.has(channel)) {
+            this._channels.set(channel, new Set());
+        }
+        this._channels.get(channel).add(conn);
+
+        // 更新用户连接计数
+        this._userCounts.set(userId, userCount + 1);
+
+        // 客户端断开时自动清理
+        res.on('close', () => {
+            this._removeConnection(channel, conn);
+        });
+
+        // 立即推送初始数据（如有）
+        if (initialData) {
+            this._write(conn, 'connected', initialData);
+        } else {
+            // 发送连接确认事件
+            this._write(conn, 'connected', { channel, timestamp: new Date().toISOString() });
+        }
+
+        return { ok: true };
+    }
+
+    /**
+     * 向 channel 的所有订阅者推送事件
+     * @param {string} channel  - 频道名
+     * @param {string} eventType - 事件类型（如 'step:status'）
+     * @param {object} data      - 事件数据（将被 JSON 序列化）
+     */
+    emit(channel, eventType, data) {
+        const subscribers = this._channels.get(channel);
+        if (!subscribers || subscribers.size === 0) {
+            return; // 无订阅者，跳过
+        }
+
+        const eventId = ++this._eventId;
+        const payload = this._formatSse(eventId, eventType, data);
+
+        let sent = 0;
+        for (const conn of subscribers) {
+            if (this._isAlive(conn)) {
+                conn.res.write(payload);
+                conn.lastEventId = eventId;
+                sent++;
+            }
+        }
+    }
+
+    /**
+     * 关闭 channel 的所有连接
+     * @param {string} channel
+     */
+    close(channel) {
+        const subscribers = this._channels.get(channel);
+        if (!subscribers) return;
+
+        for (const conn of subscribers) {
+            conn.res.end();
+        }
+        this._channels.delete(channel);
+        logger.info('SSE channel 已关闭', { channel });
+    }
+
+    /**
+     * 返回 channel 的当前订阅者数量
+     */
+    subscriberCount(channel) {
+        return this._channels.get(channel)?.size ?? 0;
+    }
+
+    /**
+     * 返回全局统计信息
+     */
+    getStats() {
+        let totalConnections = 0;
+        let channelCount = 0;
+        for (const [, subscribers] of this._channels) {
+            totalConnections += subscribers.size;
+            if (subscribers.size > 0) channelCount++;
+        }
+        return {
+            totalConnections,
+            channelCount,
+            totalUsers: this._userCounts.size,
+            lastEventId: this._eventId
+        };
+    }
+
+    /**
+     * 销毁 SseHub，释放所有定时器和连接
+     */
+    destroy() {
+        clearInterval(this._heartbeatTimer);
+        clearInterval(this._cleanupTimer);
+        for (const [channel] of this._channels) {
+            this.close(channel);
+        }
+        this._channels.clear();
+        this._userCounts.clear();
+        logger.info('SseHub 已销毁');
+    }
+
+    // ─── 内部方法 ──────────────────────────────────────────────────────
+
+    /**
+     * 向单个连接写入 SSE 数据
+     */
+    _write(conn, eventType, data) {
+        const eventId = ++this._eventId;
+        conn.res.write(this._formatSse(eventId, eventType, data));
+        conn.lastEventId = eventId;
+    }
+
+    /**
+     * 格式化 SSE 消息
+     */
+    _formatSse(eventId, eventType, data) {
+        const json = typeof data === 'string' ? data : JSON.stringify(data);
+        return `id: ${eventId}\nevent: ${eventType}\ndata: ${json}\n\n`;
+    }
+
+    /**
+     * 全局心跳：向所有连接发送注释行（保持连接活跃）
+     */
+    _broadcastHeartbeat() {
+        const heartbeat = `: heartbeat ${Date.now()}\n\n`;
+        for (const [channel, subscribers] of this._channels) {
+            for (const conn of subscribers) {
+                if (!this._isAlive(conn)) continue;
+                try {
+                    conn.res.write(heartbeat);
+                } catch (e) {
+                    // 写入失败说明连接已失效，立即清理，防止僵尸连接残留
+                    this._removeConnection(channel, conn);
+                    conn.res.end();
+                }
+            }
+        }
+    }
+
+    /**
+     * 清理超时僵尸连接
+     */
+    _cleanZombies() {
+        const now = Date.now();
+        for (const [channel, subscribers] of this._channels) {
+            for (const conn of subscribers) {
+                if (now - conn.createdAt > this._timeoutMs) {
+                    logger.warn('清理僵尸 SSE 连接', {
+                        channel,
+                        userId: conn.userId,
+                        age: now - conn.createdAt
+                    });
+                    this._removeConnection(channel, conn);
+                    conn.res.end();
+                }
+            }
+        }
+    }
+
+    /**
+     * 检查连接是否仍然存活
+     */
+    _isAlive(conn) {
+        return !conn.res.writableEnded && !conn.res.destroyed;
+    }
+
+    /**
+     * 移除连接并更新计数
+     */
+    _removeConnection(channel, conn) {
+        const subscribers = this._channels.get(channel);
+        if (!subscribers) return;
+        subscribers.delete(conn);
+
+        // 更新用户计数
+        const count = this._userCounts.get(conn.userId) ?? 1;
+        if (count <= 1) {
+            this._userCounts.delete(conn.userId);
+        } else {
+            this._userCounts.set(conn.userId, count - 1);
+        }
+
+        // channel 空了就移除
+        if (subscribers.size === 0) {
+            this._channels.delete(channel);
+        }
+    }
+}
+
+export default SseHub;

package/vendor/Server/Skills/acceptance-check/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: acceptance-check
+description: 对任务执行结果进行准出审核（验收测试），对照任务级验收标准逐条判断是否满足，生成结构化审核报告。当需要对任务产物进行最终验收检查、判断是否达到准出条件时调用。
+license: Apache-2.0
+compatibility: 需要访问任务工作目录、产物文件
+metadata:
+  author: LoopEngine
+  version: "1.0"
+---
+
+# acceptance-check SKILL — 任务准出审核
+
+## 任务参数
+
+| 参数 | 必需 | 说明 |
+|------|------|------|
+| `taskDescription` | ✅ | 审核任务描述（含原始任务、验收标准、编排结果） |
+| `skillDir` | ✅ | 本 SKILL 目录绝对路径 |
+| `workDir` | ✅ | 任务工作目录，包含所有步骤产物 |
+| `reportPath` | ✅ | 审核报告输出路径 |
+| `summaryPath` | ✅ | 审核摘要输出路径 |
+
+---
+
+## 工作流程概览
+
+```
+Phase 1: 产物收集 → Phase 2: 逐条标准评估 → Phase 3: 准出结论 → Phase 4: 报告生成
+```
+
+---
+
+## Phase 1：产物收集
+
+### 1.1 扫描工作目录
+
+读取 `workDir` 目录下所有步骤产物文件：
+
+- `stepId{N}_result_{loop}.md` — 各步骤的执行结果报告
+- `stepId{N}_Summary_{loop}.md` — 各步骤的执行摘要
+- 其他生成的文档/报告文件
+
+> 详细文件格式参见 [产物收集指南](references/PHASE1_ARTIFACT_COLLECTION.md)
+
+### 1.2 解析审核任务描述
+
+从 `taskDescription` 中提取：
+
+- **原始任务描述** — 任务的核心目标
+- **任务级验收标准** — 需要逐条验证的标准列表（含 id、criterion、type、verification）
+- **编排结果摘要** — 步骤执行状态、成功/失败统计
+
+### 1.3 汇总产物清单
+
+将所有步骤产物按 stepId 和 loopCount 排序，形成产物清单供后续评估使用。
+
+---
+
+## Phase 2：逐条标准评估
+
+### 2.1 对照验收标准
+
+对每个任务级验收标准，检查产物是否满足：
+
+```
+对于每个验收标准 [ac{id}]:
+  1. 读取该标准的内容 (criterion) 和验证方式 (verification)
+  2. 在产物中查找相关证据
+  3. 根据 verification 描述的验证方式执行检查
+  4. 记录评估结论：满足 / 未满足
+  5. 记录支持证据
+```
+
+### 2.2 验证方式分类
+
+根据标准的 `type` 字段采用不同验证策略：
+
+| type | 验证策略 |
+|------|---------|
+| `output` | 检查产物文件是否存在、内容是否完整 |
+| `quality` | 检查产物质量是否达标（如报告覆盖维度、分析深度） |
+| `performance` | 检查性能指标是否满足（如扫描覆盖率、执行时间） |
+| `compliance` | 检查是否符合规范标准（如编码规范、格式要求） |
+
+> 详细评估规则参见 [验收标准评估指南](references/PHASE2_CRITERIA_EVALUATION.md)
+
+---
+
+## Phase 3：准出结论
+
+### 3.1 汇总评估结果
+
+```
+准出结论 = 所有验收标准均满足 ? "通过" : "未通过"
+```
+
+### 3.2 生成改进建议
+
+如果准出未通过，针对每个未满足的标准生成改进建议：
+
+- 明确指出哪个标准未满足
+- 提供具体的修复方向
+- 建议需要重新执行或补充的步骤
+
+---
+
+## Phase 4：报告生成
+
+### 4.1 审核报告格式
+
+将审核结果写入 `reportPath` 指定的文件，格式如下：
+
+```markdown
+# 准出审核报告
+
+## 准出结论
+通过
+
+（或：未通过）
+
+## 审核概要
+- 任务 ID: {taskId}
+- 循环次数: 第 {loopCount+1} 次循环
+- 审核时间: {timestamp}
+- 验收标准总数: {N}
+- 满足数量: {M}
+- 未满足数量: {N-M}
+
+## 逐条标准评估
+
+### [ac1] (output) 验收标准描述
+- **结论**: 满足
+- **证据**: {在产物中找到的证据}
+- **说明**: {补充分析}
+
+### [ac2] (quality) 验收标准描述
+- **结论**: 未满足
+- **证据**: {缺失的内容或不达标的分析}
+- **说明**: {具体问题}
+
+...
+
+## 改进建议
+（仅在未通过时提供）
+1. {改进建议1}
+2. {改进建议2}
+```
+
+### 4.2 审核摘要格式
+
+将摘要写入 `summaryPath` 指定的文件：
+
+```markdown
+# 审核摘要
+
+## 结论
+{通过/未通过}
+
+## 关键发现
+{主要发现和结论}
+
+## 未满足标准
+（如有）
+- {未满足标准列表}
+```
+
+---
+
+## 输出要求
+
+1. 审核报告必须包含 `## 准出结论` 字段，值为 `通过` 或 `未通过`
+2. 审核报告必须逐条列出每个验收标准的评估结论
+3. 未通过时必须提供改进建议
+4. 报告和摘要文件必须写入指定路径