openmatrix 0.1.0

package/dist/orchestrator/question-generator.d.ts

@@ -0,0 +1,22 @@
+import type { ParsedTask } from '../types/index.js';
+export interface Question {
+    id: string;
+    question: string;
+    type: 'single' | 'multiple' | 'text';
+    options?: QuestionOption[];
+    required: boolean;
+}
+export interface QuestionOption {
+    key: string;
+    label: string;
+    description?: string;
+}
+export declare class QuestionGenerator {
+    generate(parsedTask: ParsedTask): Question[];
+    private needsTechStackQuestion;
+    private createTechStackQuestion;
+    private createPriorityQuestion;
+    private createConstraintConfirmation;
+    private createDeliverableConfirmation;
+    private createTestQuestion;
+}

package/dist/orchestrator/question-generator.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionGenerator = void 0;
+class QuestionGenerator {
+    generate(parsedTask) {
+        const questions = [];
+        // 1. 技术栈选择
+        if (this.needsTechStackQuestion(parsedTask)) {
+            questions.push(this.createTechStackQuestion());
+        }
+        // 2. 优先级确认
+        if (parsedTask.goals.length > 1) {
+            questions.push(this.createPriorityQuestion(parsedTask.goals));
+        }
+        // 3. 约束条件确认
+        if (parsedTask.constraints.length > 0) {
+            questions.push(this.createConstraintConfirmation(parsedTask.constraints));
+        }
+        // 4. 交付物确认
+        if (parsedTask.deliverables.length > 0) {
+            questions.push(this.createDeliverableConfirmation(parsedTask.deliverables));
+        }
+        // 5. 测试要求
+        questions.push(this.createTestQuestion());
+        return questions;
+    }
+    needsTechStackQuestion(task) {
+        // 如果任务描述中没有明确提到技术栈，则需要询问
+        const techKeywords = ['TypeScript', 'JavaScript', 'React', 'Vue', 'Node', 'Python'];
+        const content = task.rawContent.toLowerCase();
+        return !techKeywords.some(kw => content.includes(kw.toLowerCase()));
+    }
+    createTechStackQuestion() {
+        return {
+            id: 'tech_stack',
+            question: '请选择项目使用的主要技术栈？',
+            type: 'multiple',
+            required: true,
+            options: [
+                { key: 'typescript', label: 'TypeScript', description: '类型安全的 JavaScript 超集' },
+                { key: 'javascript', label: 'JavaScript', description: '标准 JavaScript' },
+                { key: 'react', label: 'React', description: 'React 前端框架' },
+                { key: 'vue', label: 'Vue', description: 'Vue 前端框架' },
+                { key: 'node', label: 'Node.js', description: 'Node.js 后端运行时' },
+                { key: 'python', label: 'Python', description: 'Python 语言' }
+            ]
+        };
+    }
+    createPriorityQuestion(goals) {
+        return {
+            id: 'priority',
+            question: '以下目标中，哪些是核心必须完成的？（可多选）',
+            type: 'multiple',
+            required: true,
+            options: goals.map((goal, index) => ({
+                key: `goal_${index}`,
+                label: goal
+            }))
+        };
+    }
+    createConstraintConfirmation(constraints) {
+        return {
+            id: 'constraints_confirm',
+            question: '请确认以下约束条件是否正确？',
+            type: 'single',
+            required: true,
+            options: [
+                { key: 'confirm', label: '确认正确', description: '所有约束条件都符合预期' },
+                { key: 'modify', label: '需要修改', description: '部分约束需要调整' },
+                { key: 'ignore', label: '忽略约束', description: '不遵循这些约束条件' }
+            ]
+        };
+    }
+    createDeliverableConfirmation(deliverables) {
+        return {
+            id: 'deliverables_confirm',
+            question: `需要生成以下 ${deliverables.length} 个交付物，是否确认？`,
+            type: 'single',
+            required: true,
+            options: [
+                { key: 'confirm', label: '确认', description: '生成所有列出的交付物' },
+                { key: 'partial', label: '部分生成', description: '只生成部分交付物' },
+                { key: 'custom', label: '自定义', description: '添加或删除某些交付物' }
+            ]
+        };
+    }
+    createTestQuestion() {
+        return {
+            id: 'test_requirement',
+            question: '测试覆盖率要求？',
+            type: 'single',
+            required: false,
+            options: [
+                { key: 'high', label: '高 (>80%)', description: '完整的单元测试和集成测试' },
+                { key: 'medium', label: '中 (50-80%)', description: '核心功能的测试' },
+                { key: 'low', label: '低 (<50%)', description: '仅关键路径测试' },
+                { key: 'none', label: '不需要', description: '不生成测试代码' }
+            ]
+        };
+    }
+}
+exports.QuestionGenerator = QuestionGenerator;

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

@@ -0,0 +1,41 @@
+export interface RetryConfig {
+    maxRetries: number;
+    backoff: 'exponential' | 'linear' | 'fixed';
+    baseDelay: number;
+}
+export interface RetryItem {
+    taskId: string;
+    attempt: number;
+    nextRetryAt: number;
+    error: string;
+}
+export declare class RetryManager {
+    private queue;
+    private config;
+    constructor(config?: Partial<RetryConfig>);
+    /**
+     * Add a failed task to retry queue
+     */
+    addToQueue(taskId: string, error: string): void;
+    /**
+     * Get tasks ready for retry
+     */
+    getReadyTasks(): RetryItem[];
+    /**
+     * Remove a task from the queue
+     */
+    removeFromQueue(taskId: string): void;
+    /**
+     * Check if a task should be retried
+     */
+    shouldRetry(taskId: string): boolean;
+    /**
+     * Get queue status
+     */
+    getQueueStatus(): {
+        total: number;
+        ready: number;
+        pending: number;
+    };
+    private calculateDelay;
+}

package/dist/orchestrator/retry-manager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryManager = void 0;
+class RetryManager {
+    queue = [];
+    config;
+    constructor(config = {}) {
+        this.config = {
+            maxRetries: 3,
+            backoff: 'exponential',
+            baseDelay: 30000, // 30 seconds
+            ...config
+        };
+    }
+    /**
+     * Add a failed task to retry queue
+     */
+    addToQueue(taskId, error) {
+        const existing = this.queue.find(item => item.taskId === taskId);
+        if (existing) {
+            existing.attempt++;
+            existing.nextRetryAt = this.calculateDelay(existing.attempt);
+            existing.error = error;
+        }
+        else {
+            this.queue.push({
+                taskId,
+                attempt: 1,
+                nextRetryAt: Date.now() + this.calculateDelay(1),
+                error
+            });
+        }
+    }
+    /**
+     * Get tasks ready for retry
+     */
+    getReadyTasks() {
+        const now = Date.now();
+        return this.queue.filter(item => item.nextRetryAt <= now);
+    }
+    /**
+     * Remove a task from the queue
+     */
+    removeFromQueue(taskId) {
+        const index = this.queue.findIndex(item => item.taskId === taskId);
+        if (index !== -1) {
+            this.queue.splice(index, 1);
+        }
+    }
+    /**
+     * Check if a task should be retried
+     */
+    shouldRetry(taskId) {
+        const item = this.queue.find(item => item.taskId === taskId);
+        if (!item)
+            return false;
+        return item.attempt < this.config.maxRetries;
+    }
+    /**
+     * Get queue status
+     */
+    getQueueStatus() {
+        const now = Date.now();
+        return {
+            total: this.queue.length,
+            ready: this.getReadyTasks().length,
+            pending: this.queue.filter(item => item.nextRetryAt > now).length
+        };
+    }
+    calculateDelay(attempt) {
+        switch (this.config.backoff) {
+            case 'exponential':
+                return Math.min(this.config.baseDelay * Math.pow(2, attempt - 1), 300000 // Max 5 minutes
+                );
+            case 'linear':
+                return this.config.baseDelay * attempt;
+            case 'fixed':
+            default:
+                return this.config.baseDelay;
+        }
+    }
+}
+exports.RetryManager = RetryManager;

package/dist/orchestrator/scheduler.d.ts

@@ -0,0 +1,62 @@
+import type { Task, AgentType } from '../types/index.js';
+import { StateManager } from '../storage/state-manager.js';
+export interface SchedulerConfig {
+    maxConcurrentTasks: number;
+    taskTimeout: number;
+}
+export interface TaskAssignment {
+    taskId: string;
+    agentType: AgentType;
+    priority: number;
+    dependencies: string[];
+}
+export declare class Scheduler {
+    private stateManager;
+    private config;
+    private runningTasks;
+    constructor(stateManager: StateManager, config?: Partial<SchedulerConfig>);
+    /**
+     * 获取下一个可执行的任务
+     */
+    getNextTask(): Promise<Task | null>;
+    /**
+     * 检查任务是否可执行
+     */
+    private canExecute;
+    /**
+     * 获取优先级权重
+     */
+    private getPriorityWeight;
+    /**
+     * 标记任务开始执行
+     */
+    markTaskStarted(taskId: string): Promise<void>;
+    /**
+     * 标记任务完成
+     */
+    markTaskCompleted(taskId: string): Promise<void>;
+    /**
+     * 标记任务失败
+     */
+    markTaskFailed(taskId: string, error: string): Promise<void>;
+    /**
+     * 标记任务等待确认
+     */
+    markTaskWaiting(taskId: string): Promise<void>;
+    /**
+     * 标记任务阻塞（需要 Meeting）
+     */
+    markTaskBlocked(taskId: string, reason: string): Promise<void>;
+    /**
+     * 获取所有可并行执行的任务
+     */
+    getParallelTasks(): Promise<Task[]>;
+    /**
+     * 获取调度状态
+     */
+    getStatus(): {
+        running: number;
+        maxConcurrent: number;
+        runningTaskIds: string[];
+    };
+}

package/dist/orchestrator/scheduler.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+class Scheduler {
+    stateManager;
+    config;
+    runningTasks = new Set();
+    constructor(stateManager, config) {
+        this.stateManager = stateManager;
+        this.config = {
+            maxConcurrentTasks: 3,
+            taskTimeout: 120000,
+            ...config
+        };
+    }
+    /**
+     * 获取下一个可执行的任务
+     */
+    async getNextTask() {
+        const tasks = await this.stateManager.listTasks();
+        // 筛选可执行任务
+        const executable = tasks.filter(task => this.canExecute(task, tasks));
+        if (executable.length === 0) {
+            return null;
+        }
+        // 按优先级排序
+        executable.sort((a, b) => this.getPriorityWeight(b.priority) - this.getPriorityWeight(a.priority));
+        return executable[0];
+    }
+    /**
+     * 检查任务是否可执行
+     */
+    canExecute(task, allTasks) {
+        // 1. 状态必须是 pending 或 retry_queue
+        if (task.status !== 'pending' && task.status !== 'retry_queue') {
+            return false;
+        }
+        // 2. 检查并发限制
+        if (this.runningTasks.size >= this.config.maxConcurrentTasks) {
+            return false;
+        }
+        // 3. 检查依赖是否完成
+        if (task.dependencies && task.dependencies.length > 0) {
+            for (const depId of task.dependencies) {
+                const depTask = allTasks.find(t => t.id === depId);
+                if (!depTask || depTask.status !== 'completed') {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * 获取优先级权重
+     */
+    getPriorityWeight(priority) {
+        const weights = {
+            'P0': 4,
+            'P1': 3,
+            'P2': 2,
+            'P3': 1
+        };
+        return weights[priority] || 0;
+    }
+    /**
+     * 标记任务开始执行
+     */
+    async markTaskStarted(taskId) {
+        this.runningTasks.add(taskId);
+        await this.stateManager.updateTask(taskId, {
+            status: 'in_progress',
+            phases: {
+                develop: { status: 'in_progress', duration: null, startedAt: new Date().toISOString() },
+                verify: { status: 'pending', duration: null },
+                accept: { status: 'pending', duration: null }
+            }
+        });
+    }
+    /**
+     * 标记任务完成
+     */
+    async markTaskCompleted(taskId) {
+        this.runningTasks.delete(taskId);
+        const task = await this.stateManager.getTask(taskId);
+        if (task) {
+            await this.stateManager.updateTask(taskId, {
+                status: 'completed',
+                phases: {
+                    ...task.phases,
+                    accept: { status: 'completed', duration: 0, completedAt: new Date().toISOString() }
+                }
+            });
+        }
+    }
+    /**
+     * 标记任务失败
+     */
+    async markTaskFailed(taskId, error) {
+        this.runningTasks.delete(taskId);
+        await this.stateManager.updateTask(taskId, {
+            status: 'failed',
+            error,
+            retryCount: (await this.stateManager.getTask(taskId))?.retryCount || 0
+        });
+    }
+    /**
+     * 标记任务等待确认
+     */
+    async markTaskWaiting(taskId) {
+        await this.stateManager.updateTask(taskId, {
+            status: 'waiting'
+        });
+    }
+    /**
+     * 标记任务阻塞（需要 Meeting）
+     */
+    async markTaskBlocked(taskId, reason) {
+        this.runningTasks.delete(taskId);
+        await this.stateManager.updateTask(taskId, {
+            status: 'blocked',
+            error: reason
+        });
+    }
+    /**
+     * 获取所有可并行执行的任务
+     */
+    async getParallelTasks() {
+        const tasks = await this.stateManager.listTasks();
+        const available = [];
+        for (const task of tasks) {
+            if (this.canExecute(task, tasks) && available.length < this.config.maxConcurrentTasks) {
+                available.push(task);
+            }
+        }
+        return available;
+    }
+    /**
+     * 获取调度状态
+     */
+    getStatus() {
+        return {
+            running: this.runningTasks.size,
+            maxConcurrent: this.config.maxConcurrentTasks,
+            runningTaskIds: Array.from(this.runningTasks)
+        };
+    }
+}
+exports.Scheduler = Scheduler;

package/dist/orchestrator/state-machine.d.ts

@@ -0,0 +1,53 @@
+import type { Task, TaskStatus } from '../types/index.js';
+/**
+ * 任务状态转换规则
+ *
+ * pending → scheduled → in_progress → verify → accept → completed
+ *                │            │           │        │
+ *                │            ▼           ▼        ▼
+ *                │        blocked      failed   failed
+ *                │            │           │        │
+ *                │            ▼           └────────┘
+ *                │        waiting              │
+ *                │            │                ▼
+ *                └────────────┴──────────► retry_queue
+ */
+export type TransitionEvent = 'schedule' | 'start' | 'develop_done' | 'verify_done' | 'accept_done' | 'need_verify' | 'need_accept' | 'block' | 'unblock' | 'wait' | 'resume' | 'fail' | 'retry' | 'cancel';
+export interface TransitionResult {
+    success: boolean;
+    fromStatus: TaskStatus;
+    toStatus: TaskStatus;
+    event: TransitionEvent;
+    error?: string;
+}
+export interface StateTransition {
+    from: TaskStatus;
+    to: TaskStatus;
+    event: TransitionEvent;
+    condition?: (task: Task) => boolean;
+}
+export declare class StateMachine {
+    /**
+     * 尝试转换状态
+     */
+    transition(task: Task, event: TransitionEvent): TransitionResult;
+    /**
+     * 获取当前状态允许的转换
+     */
+    getAllowedTransitions(status: TaskStatus): {
+        event: TransitionEvent;
+        toStatus: TaskStatus;
+    }[];
+    /**
+     * 检查是否可以执行指定事件
+     */
+    canTransition(task: Task, event: TransitionEvent): boolean;
+    /**
+     * 获取状态描述
+     */
+    getStatusDescription(status: TaskStatus): string;
+    /**
+     * 获取事件描述
+     */
+    getEventDescription(event: TransitionEvent): string;
+}

package/dist/orchestrator/state-machine.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateMachine = void 0;
+// 定义允许的状态转换
+const TRANSITIONS = [
+    // pending → scheduled
+    { from: 'pending', to: 'scheduled', event: 'schedule' },
+    // scheduled → in_progress
+    { from: 'scheduled', to: 'in_progress', event: 'start' },
+    // in_progress → verify
+    { from: 'in_progress', to: 'verify', event: 'develop_done' },
+    // verify → accept
+    { from: 'verify', to: 'accept', event: 'verify_done' },
+    // accept → completed
+    { from: 'accept', to: 'completed', event: 'accept_done' },
+    // in_progress → blocked
+    { from: 'in_progress', to: 'blocked', event: 'block' },
+    // blocked → waiting (等待 Meeting)
+    { from: 'blocked', to: 'waiting', event: 'wait' },
+    // waiting → in_progress (Meeting 解决后)
+    { from: 'waiting', to: 'in_progress', event: 'resume' },
+    // any → failed
+    { from: 'in_progress', to: 'failed', event: 'fail' },
+    { from: 'verify', to: 'failed', event: 'fail' },
+    { from: 'accept', to: 'failed', event: 'fail' },
+    // failed → retry_queue
+    { from: 'failed', to: 'retry_queue', event: 'retry' },
+    // retry_queue → pending
+    { from: 'retry_queue', to: 'pending', event: 'retry' },
+    // any → pending (cancel and restart)
+    { from: 'scheduled', to: 'pending', event: 'cancel' },
+    { from: 'blocked', to: 'pending', event: 'cancel' },
+];
+class StateMachine {
+    /**
+     * 尝试转换状态
+     */
+    transition(task, event) {
+        const fromStatus = task.status;
+        // 查找允许的转换
+        const allowedTransition = TRANSITIONS.find(t => t.from === fromStatus && t.event === event);
+        if (!allowedTransition) {
+            return {
+                success: false,
+                fromStatus,
+                toStatus: fromStatus,
+                event,
+                error: `不允许的转换: ${fromStatus} --[${event}]--> ?`
+            };
+        }
+        // 检查条件
+        if (allowedTransition.condition && !allowedTransition.condition(task)) {
+            return {
+                success: false,
+                fromStatus,
+                toStatus: fromStatus,
+                event,
+                error: '转换条件不满足'
+            };
+        }
+        return {
+            success: true,
+            fromStatus,
+            toStatus: allowedTransition.to,
+            event
+        };
+    }
+    /**
+     * 获取当前状态允许的转换
+     */
+    getAllowedTransitions(status) {
+        return TRANSITIONS
+            .filter(t => t.from === status)
+            .map(t => ({ event: t.event, toStatus: t.to }));
+    }
+    /**
+     * 检查是否可以执行指定事件
+     */
+    canTransition(task, event) {
+        const result = this.transition(task, event);
+        return result.success;
+    }
+    /**
+     * 获取状态描述
+     */
+    getStatusDescription(status) {
+        const descriptions = {
+            'pending': '等待执行',
+            'scheduled': '已调度，等待 Agent',
+            'in_progress': '执行中',
+            'blocked': '被阻塞',
+            'waiting': '等待确认/Meeting',
+            'verify': '验证中',
+            'accept': '验收中',
+            'completed': '已完成',
+            'failed': '失败',
+            'retry_queue': '重试队列'
+        };
+        return descriptions[status] || status;
+    }
+    /**
+     * 获取事件描述
+     */
+    getEventDescription(event) {
+        const descriptions = {
+            'schedule': '调度任务',
+            'start': '开始执行',
+            'develop_done': '开发完成',
+            'verify_done': '验证完成',
+            'accept_done': '验收完成',
+            'need_verify': '需要验证',
+            'need_accept': '需要验收',
+            'block': '阻塞任务',
+            'unblock': '解除阻塞',
+            'wait': '等待外部',
+            'resume': '恢复执行',
+            'fail': '标记失败',
+            'retry': '重试任务',
+            'cancel': '取消任务'
+        };
+        return descriptions[event] || event;
+    }
+}
+exports.StateMachine = StateMachine;

package/dist/orchestrator/task-parser.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedTask } from '../types/index.js';
+export declare class TaskParser {
+    parse(content: string): ParsedTask;
+    private extractTitle;
+    private extractDescription;
+    private extractSection;
+}