openmatrix 0.1.0

package/dist/orchestrator/approval-manager.d.ts

@@ -0,0 +1,62 @@
+import type { Approval, ApprovalOption } from '../types/index.js';
+import { StateManager } from '../storage/state-manager.js';
+export type ApprovalType = 'plan' | 'merge' | 'deploy' | 'meeting' | 'custom';
+export interface CreateApprovalInput {
+    type: ApprovalType;
+    taskId: string;
+    title: string;
+    description: string;
+    content: string;
+    options?: ApprovalOption[];
+}
+export interface ApprovalDecision {
+    approvalId: string;
+    decision: 'approve' | 'modify' | 'reject';
+    comment?: string;
+    decidedBy: string;
+    decidedAt: string;
+}
+export declare class ApprovalManager {
+    private stateManager;
+    constructor(stateManager: StateManager);
+    /**
+     * 创建审批请求
+     */
+    createApproval(input: CreateApprovalInput): Promise<Approval>;
+    /**
+     * 获取待处理的审批
+     */
+    getPendingApprovals(): Promise<Approval[]>;
+    /**
+     * 获取指定审批
+     */
+    getApproval(approvalId: string): Promise<Approval | null>;
+    /**
+     * 处理审批决策
+     */
+    processDecision(decision: ApprovalDecision): Promise<Approval>;
+    /**
+     * 创建 Meeting 审批
+     */
+    createMeetingApproval(taskId: string, blockingReason: string, impactScope: string[]): Promise<Approval>;
+    /**
+     * 创建 Plan 审批
+     */
+    createPlanApproval(taskId: string, planContent: string): Promise<Approval>;
+    /**
+     * 创建 Merge 审批
+     */
+    createMergeApproval(taskId: string, changes: string): Promise<Approval>;
+    /**
+     * 创建 Deploy 审批
+     */
+    createDeployApproval(taskId: string, deployInfo: string): Promise<Approval>;
+    /**
+     * 检查是否有待处理的审批
+     */
+    hasPendingApprovals(): Promise<boolean>;
+    /**
+     * 获取审批历史
+     */
+    getApprovalHistory(limit?: number): Promise<Approval[]>;
+}

package/dist/orchestrator/approval-manager.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalManager = void 0;
+class ApprovalManager {
+    stateManager;
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+    }
+    /**
+     * 创建审批请求
+     */
+    async createApproval(input) {
+        const approvalId = `APPR-${Date.now().toString(36).toUpperCase()}`;
+        const defaultOptions = [
+            { key: 'approve', label: '✅ 批准' },
+            { key: 'modify', label: '✏️ 需要修改' },
+            { key: 'reject', label: '❌ 拒绝' }
+        ];
+        const approval = {
+            id: approvalId,
+            type: input.type,
+            taskId: input.taskId,
+            title: input.title,
+            description: input.description,
+            content: input.content,
+            options: input.options || defaultOptions,
+            status: 'pending',
+            createdAt: new Date().toISOString()
+        };
+        await this.stateManager.saveApproval(approval);
+        return approval;
+    }
+    /**
+     * 获取待处理的审批
+     */
+    async getPendingApprovals() {
+        return this.stateManager.getApprovalsByStatus('pending');
+    }
+    /**
+     * 获取指定审批
+     */
+    async getApproval(approvalId) {
+        return this.stateManager.getApproval(approvalId);
+    }
+    /**
+     * 处理审批决策
+     */
+    async processDecision(decision) {
+        const approval = await this.getApproval(decision.approvalId);
+        if (!approval) {
+            throw new Error(`审批 ${decision.approvalId} 不存在`);
+        }
+        if (approval.status !== 'pending') {
+            throw new Error(`审批 ${decision.approvalId} 已处理`);
+        }
+        // 更新审批状态
+        const updatedApproval = {
+            ...approval,
+            status: decision.decision === 'approve' ? 'approved' : 'rejected',
+            decision: decision.decision,
+            decidedAt: decision.decidedAt
+        };
+        await this.stateManager.updateApproval(updatedApproval);
+        // 如果是 meeting 类型且被批准，解除任务阻塞
+        if (approval.type === 'meeting' && decision.decision === 'approve') {
+            await this.stateManager.updateTask(approval.taskId, {
+                status: 'in_progress',
+                error: null
+            });
+        }
+        return updatedApproval;
+    }
+    /**
+     * 创建 Meeting 审批
+     */
+    async createMeetingApproval(taskId, blockingReason, impactScope) {
+        return this.createApproval({
+            type: 'meeting',
+            taskId,
+            title: `🔴 阻塞问题需要解决`,
+            description: `任务 ${taskId} 遇到阻塞问题`,
+            content: `
+## 阻塞原因
+
+${blockingReason}
+
+## 影响范围
+
+${impactScope.map(t => `- ${t}`).join('\n')}
+
+## 需要决策
+
+请选择解决方案或提供自定义方案：
+      `.trim(),
+            options: [
+                { key: 'approve', label: '✅ 问题已解决，继续执行' },
+                { key: 'modify', label: '🔄 跳过此任务' },
+                { key: 'reject', label: '❌ 终止任务链' }
+            ]
+        });
+    }
+    /**
+     * 创建 Plan 审批
+     */
+    async createPlanApproval(taskId, planContent) {
+        return this.createApproval({
+            type: 'plan',
+            taskId,
+            title: '📋 任务计划审批',
+            description: '请审批以下任务计划',
+            content: planContent
+        });
+    }
+    /**
+     * 创建 Merge 审批
+     */
+    async createMergeApproval(taskId, changes) {
+        return this.createApproval({
+            type: 'merge',
+            taskId,
+            title: '🔀 代码合并审批',
+            description: '请审批以下代码变更',
+            content: changes
+        });
+    }
+    /**
+     * 创建 Deploy 审批
+     */
+    async createDeployApproval(taskId, deployInfo) {
+        return this.createApproval({
+            type: 'deploy',
+            taskId,
+            title: '🚀 部署审批',
+            description: '请审批以下部署',
+            content: deployInfo,
+            options: [
+                { key: 'approve', label: '✅ 批准部署' },
+                { key: 'reject', label: '❌ 取消部署' }
+            ]
+        });
+    }
+    /**
+     * 检查是否有待处理的审批
+     */
+    async hasPendingApprovals() {
+        const pending = await this.getPendingApprovals();
+        return pending.length > 0;
+    }
+    /**
+     * 获取审批历史
+     */
+    async getApprovalHistory(limit = 10) {
+        const all = await this.stateManager.getAllApprovals();
+        return all
+            .filter(a => a.status !== 'pending')
+            .sort((a, b) => (b.decidedAt || b.createdAt).localeCompare(a.decidedAt || a.createdAt))
+            .slice(0, limit);
+    }
+}
+exports.ApprovalManager = ApprovalManager;

package/dist/orchestrator/executor.d.ts

@@ -0,0 +1,114 @@
+import { Scheduler } from './scheduler.js';
+import { AgentRunner, type SubagentTask } from '../agents/agent-runner.js';
+import { StateManager } from '../storage/state-manager.js';
+import { ApprovalManager } from './approval-manager.js';
+import { PhaseExecutor } from './phase-executor.js';
+export interface ExecutorConfig {
+    maxConcurrent: number;
+    taskTimeout: number;
+}
+export interface ExecutorStatus {
+    running: boolean;
+    currentPhase: string;
+    pendingTasks: number;
+    runningTasks: number;
+    waitingApprovals: number;
+}
+export interface ExecutionResult {
+    status: 'continue' | 'waiting_approval' | 'completed' | 'failed';
+    subagentTasks: SubagentTask[];
+    message: string;
+    statistics: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        pending: number;
+        failed: number;
+    };
+}
+/**
+ * OrchestratorExecutor - 执行循环核心
+ *
+ * 负责持续调度任务并返回 Subagent 任务列表供 Skills 执行
+ */
+export declare class OrchestratorExecutor {
+    private scheduler;
+    private agentRunner;
+    private stateManager;
+    private approvalManager;
+    private stateMachine;
+    private phaseExecutor;
+    private config;
+    constructor(stateManager: StateManager, approvalManager: ApprovalManager, config?: Partial<ExecutorConfig>);
+    /**
+     * 获取 PhaseExecutor 实例
+     */
+    getPhaseExecutor(): PhaseExecutor;
+    /**
+     * 执行一步 - 返回待执行的 Subagent 任务
+     *
+     * Skills 调用此方法获取任务，然后使用 Agent 工具执行
+     */
+    step(): Promise<ExecutionResult>;
+    /**
+     * 检查审批点
+     *
+     * 在 auto 模式下 (approvalPoints 为空数组)，跳过所有审批
+     * 仅在失败/异常时才暂停
+     */
+    private checkApprovals;
+    /**
+     * 检查是否所有任务完成
+     */
+    private checkAllCompleted;
+    /**
+     * 获取统计信息
+     */
+    private getStatistics;
+    /**
+     * 创建等待审批结果
+     */
+    private createWaitingResult;
+    /**
+     * 创建完成结果 - 检查是否有待处理的 Meeting
+     */
+    private createCompletedResult;
+    /**
+     * 创建需要重试结果
+     */
+    private createRetryNeededResult;
+    /**
+     * 处理阻塞任务 - 创建 Meeting 审批并跳过该任务
+     *
+     * 在 auto 模式下:
+     * 1. 标记任务为 blocked 状态
+     * 2. 创建 Meeting 审批记录
+     * 3. 跳过该任务，继续执行其他可执行任务
+     * 4. 所有 Meeting 留到最后统一处理
+     */
+    private handleBlockedTasks;
+    /**
+     * 标记任务完成
+     */
+    completeTask(taskId: string, result: {
+        success: boolean;
+        output?: string;
+        error?: string;
+    }): Promise<void>;
+    /**
+     * 获取当前阶段
+     */
+    private getCurrentPhase;
+    /**
+     * 获取执行器状态
+     */
+    getStatus(): Promise<ExecutorStatus>;
+    /**
+     * 获取 AgentRunner 实例
+     */
+    getAgentRunner(): AgentRunner;
+    /**
+     * 获取 Scheduler 实例
+     */
+    getScheduler(): Scheduler;
+}

package/dist/orchestrator/executor.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestratorExecutor = void 0;
+// src/orchestrator/executor.ts
+const scheduler_js_1 = require("./scheduler.js");
+const agent_runner_js_1 = require("../agents/agent-runner.js");
+const state_machine_js_1 = require("./state-machine.js");
+const phase_executor_js_1 = require("./phase-executor.js");
+/**
+ * OrchestratorExecutor - 执行循环核心
+ *
+ * 负责持续调度任务并返回 Subagent 任务列表供 Skills 执行
+ */
+class OrchestratorExecutor {
+    scheduler;
+    agentRunner;
+    stateManager;
+    approvalManager;
+    stateMachine;
+    phaseExecutor;
+    config;
+    constructor(stateManager, approvalManager, config) {
+        this.stateManager = stateManager;
+        this.approvalManager = approvalManager;
+        this.config = {
+            maxConcurrent: 3,
+            taskTimeout: 120000,
+            ...config
+        };
+        this.scheduler = new scheduler_js_1.Scheduler(stateManager, {
+            maxConcurrentTasks: this.config.maxConcurrent,
+            taskTimeout: this.config.taskTimeout
+        });
+        this.agentRunner = new agent_runner_js_1.AgentRunner(stateManager, approvalManager, {
+            maxConcurrent: this.config.maxConcurrent,
+            taskTimeout: this.config.taskTimeout
+        });
+        this.stateMachine = new state_machine_js_1.StateMachine();
+        this.phaseExecutor = new phase_executor_js_1.PhaseExecutor(stateManager, approvalManager);
+    }
+    /**
+     * 获取 PhaseExecutor 实例
+     */
+    getPhaseExecutor() {
+        return this.phaseExecutor;
+    }
+    /**
+     * 执行一步 - 返回待执行的 Subagent 任务
+     *
+     * Skills 调用此方法获取任务，然后使用 Agent 工具执行
+     */
+    async step() {
+        const state = await this.stateManager.getState();
+        // 1. 检查是否需要审批
+        const pendingApprovals = await this.checkApprovals(state);
+        if (pendingApprovals.length > 0) {
+            return this.createWaitingResult(pendingApprovals, state);
+        }
+        // 2. 获取可执行任务
+        const executableTasks = await this.scheduler.getParallelTasks();
+        if (executableTasks.length === 0) {
+            // 3. 获取所有任务
+            const allTasks = await this.stateManager.listTasks();
+            // 4. 检查是否有失败任务需要重试
+            const failedTasks = allTasks.filter(t => t.status === 'failed');
+            if (failedTasks.length > 0) {
+                return this.createRetryNeededResult(failedTasks, state);
+            }
+            // 5. 检查是否有阻塞任务
+            const blockedTasks = allTasks.filter(t => t.status === 'blocked');
+            // 6. 检查剩余可执行任务（排除 blocked/failed/completed）
+            const remainingTasks = allTasks.filter(t => t.status !== 'blocked' &&
+                t.status !== 'failed' &&
+                t.status !== 'completed');
+            // 7. 如果只剩下阻塞任务或没有剩余任务，算完成
+            if (remainingTasks.length === 0) {
+                return await this.createCompletedResult(state);
+            }
+            // 8. 如果有阻塞任务
+            if (blockedTasks.length > 0) {
+                return await this.handleBlockedTasks(blockedTasks, state);
+            }
+            // 9. 无任务可执行，等待中
+            return this.createWaitingResult([], state);
+        }
+        // 10. 准备 Subagent 任务
+        const subagentTasks = await this.agentRunner.prepareSubagentTasks(executableTasks);
+        // 8. 更新任务状态为 scheduled
+        for (const task of executableTasks) {
+            await this.scheduler.markTaskStarted(task.id);
+        }
+        return {
+            status: 'continue',
+            subagentTasks,
+            message: `准备执行 ${subagentTasks.length} 个任务`,
+            statistics: this.getStatistics(state)
+        };
+    }
+    /**
+     * 检查审批点
+     *
+     * 在 auto 模式下 (approvalPoints 为空数组)，跳过所有审批
+     * 仅在失败/异常时才暂停
+     */
+    async checkApprovals(state) {
+        // auto 模式: approvalPoints 为空
+        if (state.config.approvalPoints.length === 0) {
+            // 只自动批准非 meeting 类型
+            // meeting 类型保持 pending，供最后统一处理
+            const pendingApprovals = await this.stateManager.getApprovalsByStatus('pending');
+            for (const approval of pendingApprovals) {
+                // meeting 类型不自动批准，保持 pending 状态
+                if (approval.type !== 'meeting') {
+                    await this.approvalManager.processDecision({
+                        approvalId: approval.id,
+                        decision: 'approve',
+                        comment: 'Auto-approved in fully automatic mode',
+                        decidedBy: 'system',
+                        decidedAt: new Date().toISOString()
+                    });
+                }
+            }
+            // 返回非 meeting 类型的 pending 审批（应该已经处理完了）
+            return pendingApprovals.filter(a => a.type !== 'meeting');
+        }
+        const pendingApprovals = await this.stateManager.getApprovalsByStatus('pending');
+        // 过滤出当前需要处理的审批
+        return pendingApprovals.filter(approval => {
+            const approvalPoint = approval.type;
+            return state.config.approvalPoints.includes(approvalPoint);
+        });
+    }
+    /**
+     * 检查是否所有任务完成
+     */
+    checkAllCompleted(tasks) {
+        if (tasks.length === 0)
+            return true;
+        return tasks.every(task => task.status === 'completed');
+    }
+    /**
+     * 获取统计信息
+     */
+    getStatistics(state) {
+        return {
+            total: state.statistics.totalTasks,
+            completed: state.statistics.completed,
+            inProgress: state.statistics.inProgress,
+            pending: state.statistics.pending,
+            failed: state.statistics.failed
+        };
+    }
+    /**
+     * 创建等待审批结果
+     */
+    createWaitingResult(approvals, state) {
+        return {
+            status: 'waiting_approval',
+            subagentTasks: [],
+            message: approvals.length > 0
+                ? `等待 ${approvals.length} 个审批`
+                : '等待中...',
+            statistics: this.getStatistics(state)
+        };
+    }
+    /**
+     * 创建完成结果 - 检查是否有待处理的 Meeting
+     */
+    async createCompletedResult(state) {
+        // 检查是否有待处理的 meeting 审批
+        const pendingApprovals = await this.stateManager.getApprovalsByStatus('pending');
+        const pendingMeetings = pendingApprovals.filter(a => a.type === 'meeting');
+        if (pendingMeetings.length > 0) {
+            return {
+                status: 'waiting_approval',
+                subagentTasks: [],
+                message: `✅ 所有非阻塞任务已完成！\n\n📋 有待确认的 Meeting (${pendingMeetings.length}个):\n${pendingMeetings.map(m => `  - ${m.taskId}: ${m.title}`).join('\n')}\n\n请使用 /om:approve 确认或处理这些阻塞问题`,
+                statistics: this.getStatistics(state)
+            };
+        }
+        return {
+            status: 'completed',
+            subagentTasks: [],
+            message: '所有任务已完成！',
+            statistics: this.getStatistics(state)
+        };
+    }
+    /**
+     * 创建需要重试结果
+     */
+    createRetryNeededResult(failedTasks, state) {
+        return {
+            status: 'failed',
+            subagentTasks: [],
+            message: `${failedTasks.length} 个任务失败，需要重试`,
+            statistics: this.getStatistics(state)
+        };
+    }
+    /**
+     * 处理阻塞任务 - 创建 Meeting 审批并跳过该任务
+     *
+     * 在 auto 模式下:
+     * 1. 标记任务为 blocked 状态
+     * 2. 创建 Meeting 审批记录
+     * 3. 跳过该任务，继续执行其他可执行任务
+     * 4. 所有 Meeting 留到最后统一处理
+     */
+    async handleBlockedTasks(blockedTasks, state) {
+        const reasons = blockedTasks.map(t => t.error || '未知原因').join('; ');
+        for (const task of blockedTasks) {
+            // 1. 标记任务为 blocked
+            await this.scheduler.markTaskBlocked(task.id, task.error || '未知原因');
+            // 2. 检查是否已有该任务的 pending meeting 审批
+            const existingApprovals = await this.stateManager.getApprovalsByStatus('pending');
+            const hasExistingMeeting = existingApprovals.some(a => a.taskId === task.id && a.type === 'meeting');
+            if (!hasExistingMeeting) {
+                // 3. 创建 Meeting 审批（但不暂停执行）
+                const allTasks = await this.stateManager.listTasks();
+                const impactedTasks = allTasks
+                    .filter(t => t.dependencies.includes(task.id))
+                    .map(t => `${t.id}: ${t.title}`);
+                await this.approvalManager.createMeetingApproval(task.id, task.error || '未知原因', impactedTasks.length > 0 ? impactedTasks : ['无下游任务受影响']);
+                console.log(`🔴 任务阻塞，已创建 Meeting: ${task.id} - ${task.error}`);
+            }
+        }
+        // 4. 返回 continue，继续执行其他任务
+        // 阻塞的任务被标记为 blocked，调度器会自动跳过它们
+        return {
+            status: 'continue',
+            subagentTasks: [],
+            message: `${blockedTasks.length} 个任务被阻塞，已跳过，继续执行其他任务。Meeting 记录待最后统一处理。原因: ${reasons}`,
+            statistics: this.getStatistics(state)
+        };
+    }
+    /**
+     * 标记任务完成
+     */
+    async completeTask(taskId, result) {
+        const task = await this.stateManager.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        if (result.success) {
+            // 更新阶段状态
+            const currentPhase = this.getCurrentPhase(task);
+            const updatedPhases = { ...task.phases };
+            if (currentPhase === 'develop') {
+                updatedPhases.develop = {
+                    status: 'completed',
+                    duration: 0,
+                    completedAt: new Date().toISOString()
+                };
+                updatedPhases.verify = {
+                    status: 'in_progress',
+                    duration: null,
+                    startedAt: new Date().toISOString()
+                };
+                await this.stateManager.updateTask(taskId, {
+                    phases: updatedPhases,
+                    status: 'verify'
+                });
+            }
+            else if (currentPhase === 'verify') {
+                updatedPhases.verify = {
+                    status: 'completed',
+                    duration: 0,
+                    completedAt: new Date().toISOString()
+                };
+                updatedPhases.accept = {
+                    status: 'in_progress',
+                    duration: null,
+                    startedAt: new Date().toISOString()
+                };
+                await this.stateManager.updateTask(taskId, {
+                    phases: updatedPhases,
+                    status: 'accept'
+                });
+            }
+            else if (currentPhase === 'accept') {
+                await this.scheduler.markTaskCompleted(taskId);
+            }
+        }
+        else {
+            await this.scheduler.markTaskFailed(taskId, result.error || 'Unknown error');
+        }
+    }
+    /**
+     * 获取当前阶段
+     */
+    getCurrentPhase(task) {
+        if (task.phases.develop.status !== 'completed')
+            return 'develop';
+        if (task.phases.verify.status !== 'completed')
+            return 'verify';
+        return 'accept';
+    }
+    /**
+     * 获取执行器状态
+     */
+    async getStatus() {
+        const state = await this.stateManager.getState();
+        const pendingApprovals = await this.stateManager.getApprovalsByStatus('pending');
+        const tasks = await this.stateManager.listTasks();
+        return {
+            running: state.status === 'running',
+            currentPhase: state.currentPhase,
+            pendingTasks: tasks.filter(t => t.status === 'pending').length,
+            runningTasks: tasks.filter(t => t.status === 'in_progress').length,
+            waitingApprovals: pendingApprovals.length
+        };
+    }
+    /**
+     * 获取 AgentRunner 实例
+     */
+    getAgentRunner() {
+        return this.agentRunner;
+    }
+    /**
+     * 获取 Scheduler 实例
+     */
+    getScheduler() {
+        return this.scheduler;
+    }
+}
+exports.OrchestratorExecutor = OrchestratorExecutor;