openmatrix 0.2.3 → 0.2.4

package/dist/cli/commands/complete.js

@@ -40,6 +40,7 @@ const state_manager_js_1 = require("../../storage/state-manager.js");
 const git_commit_manager_js_1 = require("../../orchestrator/git-commit-manager.js");
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+const error_handler_js_1 = require("../../utils/error-handler.js");
 exports.completeCommand = new commander_1.Command('complete')
     .description('标记任务完成并更新全局统计')
     .argument('<taskId>', '任务ID (如 TASK-001)')
@@ -118,8 +119,9 @@ exports.completeCommand = new commander_1.Command('complete')
             // 原子追加写入全局 context.md（O_APPEND flag 保证并发安全）
             await fs.appendFile(contextFile, contextEntry, 'utf-8');
         }
-        catch {
-            // 忽略写入错误
+        catch (error) {
+            // 记录错误但不影响主流程
+            (0, error_handler_js_1.logError)(error, { operation: 'appendContextMd', file: contextFile, taskId });
         }
     }
     // 6. Git 自动提交

package/dist/orchestrator/executor.js

@@ -8,6 +8,7 @@ const state_machine_js_1 = require("./state-machine.js");
 const phase_executor_js_1 = require("./phase-executor.js");
 const retry_manager_js_1 = require("./retry-manager.js");
 const ai_reviewer_js_1 = require("./ai-reviewer.js");
+const logger_js_1 = require("../utils/logger.js");
 /**
  * OrchestratorExecutor - 执行循环核心
  *
@@ -27,11 +28,20 @@ class OrchestratorExecutor {
     constructor(stateManager, approvalManager, config) {
         this.stateManager = stateManager;
         this.approvalManager = approvalManager;
+        // 从 state.config 读取 taskTimeout，如果未定义则使用默认值
+        const stateConfig = stateManager.getState().then(s => s.config).catch(() => null);
+        const defaultTaskTimeout = 600000; // 10 分钟（毫秒）
         this.config = {
             maxConcurrent: 3,
-            taskTimeout: 600000, // 10 分钟
+            taskTimeout: defaultTaskTimeout,
             ...config
         };
+        // 异步获取配置并更新 taskTimeout
+        stateConfig.then(cfg => {
+            if (cfg?.taskTimeout) {
+                this.config.taskTimeout = cfg.taskTimeout;
+            }
+        });
         this.scheduler = new scheduler_js_1.Scheduler(stateManager, {
             maxConcurrentTasks: this.config.maxConcurrent,
             taskTimeout: this.config.taskTimeout
@@ -393,9 +403,11 @@ class OrchestratorExecutor {
      */
     setupTaskTimeout(taskId) {
         const timer = setTimeout(async () => {
-            console.error(`⏰ 任务超时: ${taskId} (${this.config.taskTimeout / 1000}s)`);
+            const timeoutSeconds = this.config.taskTimeout / 1000;
+            console.error(`⏰ 任务超时: ${taskId} (${timeoutSeconds}s)`);
+            logger_js_1.logger.task.timeout(taskId, timeoutSeconds);
             this.taskTimers.delete(taskId);
-            await this.scheduler.markTaskFailed(taskId, `Task timed out after ${this.config.taskTimeout / 1000}s`);
+            await this.scheduler.markTaskFailed(taskId, `Task timed out after ${timeoutSeconds}s`);
         }, this.config.taskTimeout);
         this.taskTimers.set(taskId, timer);
     }

package/dist/orchestrator/git-commit-manager.js

@@ -40,6 +40,7 @@ const util_1 = require("util");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs/promises"));
 const gitignore_js_1 = require("../utils/gitignore.js");
+const error_handler_js_1 = require("../utils/error-handler.js");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * GitCommitManager - Git 自动提交管理器
@@ -66,8 +67,9 @@ class GitCommitManager {
             const { stdout } = await execAsync('git rev-parse --show-toplevel', { cwd: this.repoPath });
             this.gitRoot = stdout.trim();
         }
-        catch {
+        catch (error) {
             // 不是 git 仓库，回退到 repoPath
+            (0, error_handler_js_1.logError)(error, { operation: 'getGitRoot', file: this.repoPath });
             this.gitRoot = this.repoPath;
         }
         return this.gitRoot;
@@ -86,7 +88,8 @@ class GitCommitManager {
             await execAsync('git rev-parse --is-inside-work-tree', { cwd: this.repoPath });
             return true;
         }
-        catch {
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'isGitRepo', file: this.repoPath });
             return false;
         }
     }
@@ -108,7 +111,8 @@ class GitCommitManager {
                 .filter(line => line.trim())
                 .map(line => line.slice(3).trim());
         }
-        catch {
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'getUncommittedFiles', file: this.repoPath });
             return [];
         }
     }
@@ -134,7 +138,8 @@ class GitCommitManager {
                 return { status, path: filePath };
             });
         }
-        catch {
+        catch (error) {
+            (0, error_handler_js_1.logError)(error, { operation: 'getUncommittedFilesWithStatus', file: this.repoPath });
             return [];
         }
     }
@@ -158,8 +163,9 @@ class GitCommitManager {
                 }
             }
         }
-        catch {
-            // ignore
+        catch (error) {
+            // ignore diff stats errors
+            (0, error_handler_js_1.logError)(error, { operation: 'getDiffStats', file: this.repoPath });
         }
         return stats;
     }
@@ -358,7 +364,12 @@ class GitCommitManager {
             }
             if (filesToUnstage.length > 0) {
                 const unstageCmd = filesToUnstage.map(f => `"${f}"`).join(' ');
-                await execAsync(`git reset HEAD -- ${unstageCmd}`, { cwd: this.repoPath }).catch(() => { });
+                try {
+                    await execAsync(`git reset HEAD -- ${unstageCmd}`, { cwd: this.repoPath });
+                }
+                catch (error) {
+                    (0, error_handler_js_1.logError)(error, { operation: 'gitResetFiles', file: this.repoPath, metadata: { files: filesToUnstage } });
+                }
             }
             // 检查是否有文件被暂存（避免空提交）
             const { stdout: staged } = await execAsync('git diff --cached --name-only', { cwd: this.repoPath });
@@ -384,7 +395,12 @@ class GitCommitManager {
             }
             finally {
                 // 清理临时文件
-                await fs.unlink(tmpFile).catch(() => { });
+                try {
+                    await fs.unlink(tmpFile);
+                }
+                catch (error) {
+                    (0, error_handler_js_1.logError)(error, { operation: 'cleanupCommitMsgTmp', file: tmpFile });
+                }
             }
         }
         catch (error) {

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

@@ -1,32 +1,6 @@
 import { StateManager } from '../storage/state-manager.js';
 import { ApprovalManager } from './approval-manager.js';
-import type { Approval } from '../types/index.js';
-/**
- * Meeting 状态
- */
-export type MeetingStatus = 'pending' | 'in_progress' | 'resolved' | 'cancelled';
-/**
- * Meeting 类型
- */
-export type MeetingType = 'blocking' | 'decision' | 'review' | 'planning';
-/**
- * Meeting 记录
- */
-export interface Meeting {
-    id: string;
-    type: MeetingType;
-    status: MeetingStatus;
-    taskId: string;
-    title: string;
-    description: string;
-    blockingReason?: string;
-    impactScope: string[];
-    participants: string[];
-    resolution?: string;
-    createdAt: string;
-    startedAt?: string;
-    resolvedAt?: string;
-}
+import type { Approval, Meeting } from '../types/index.js';
 /**
  * MeetingManager - Meeting 管理器
  *

package/dist/orchestrator/meeting-manager.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MeetingManager = void 0;
+// Meeting 类型已在 types/index.ts 中定义，这里不再重复定义
 /**
  * MeetingManager - Meeting 管理器
  *

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

@@ -8,11 +8,22 @@ export interface RetryItem {
     attempt: number;
     nextRetryAt: number;
     error: string;
+    addedAt: string;
 }
 export declare class RetryManager {
     private queue;
     private config;
-    constructor(config?: Partial<RetryConfig>);
+    private store;
+    private queuePath;
+    constructor(config?: Partial<RetryConfig>, basePath?: string);
+    /**
+     * 从文件加载队列（进程重启恢复）
+     */
+    private loadQueue;
+    /**
+     * 持久化队列到文件
+     */
+    private persistQueue;
     /**
      * Add a failed task to retry queue
      */
@@ -37,5 +48,13 @@ export declare class RetryManager {
         ready: number;
         pending: number;
     };
+    /**
+     * 获取队列内容（用于测试和调试）
+     */
+    getQueue(): RetryItem[];
+    /**
+     * 清空队列
+     */
+    clearQueue(): void;
     private calculateDelay;
 }

package/dist/orchestrator/retry-manager.js

@@ -1,16 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryManager = void 0;
+const file_store_js_1 = require("../storage/file-store.js");
 class RetryManager {
     queue = [];
     config;
-    constructor(config = {}) {
+    store = null;
+    queuePath = 'retry-queue.json';
+    constructor(config = {}, basePath) {
         this.config = {
             maxRetries: 3,
             backoff: 'exponential',
             baseDelay: 30000, // 30 seconds
             ...config
         };
+        // 初始化持久化存储
+        if (basePath) {
+            this.store = new file_store_js_1.FileStore(basePath);
+            this.loadQueue();
+        }
+    }
+    /**
+     * 从文件加载队列（进程重启恢复）
+     */
+    loadQueue() {
+        if (!this.store)
+            return;
+        const data = this.store.readJsonSync(this.queuePath);
+        if (data?.queue) {
+            // 过滤掉已经过期的重试项（超过 maxRetries 或超过 24 小时）
+            const now = Date.now();
+            const maxAge = 24 * 60 * 60 * 1000; // 24 hours
+            this.queue = data.queue.filter(item => {
+                const addedTime = new Date(item.addedAt).getTime();
+                return item.attempt < this.config.maxRetries && (now - addedTime) < maxAge;
+            });
+        }
+    }
+    /**
+     * 持久化队列到文件
+     */
+    persistQueue() {
+        if (!this.store)
+            return;
+        this.store.writeJsonSync(this.queuePath, { queue: this.queue, updatedAt: new Date().toISOString() });
     }
     /**
      * Add a failed task to retry queue
@@ -19,7 +52,7 @@ class RetryManager {
         const existing = this.queue.find(item => item.taskId === taskId);
         if (existing) {
             existing.attempt++;
-            existing.nextRetryAt = this.calculateDelay(existing.attempt);
+            existing.nextRetryAt = Date.now() + this.calculateDelay(existing.attempt);
             existing.error = error;
         }
         else {
@@ -27,9 +60,11 @@ class RetryManager {
                 taskId,
                 attempt: 1,
                 nextRetryAt: Date.now() + this.calculateDelay(1),
-                error
+                error,
+                addedAt: new Date().toISOString()
             });
         }
+        this.persistQueue();
     }
     /**
      * Get tasks ready for retry
@@ -45,6 +80,7 @@ class RetryManager {
         const index = this.queue.findIndex(item => item.taskId === taskId);
         if (index !== -1) {
             this.queue.splice(index, 1);
+            this.persistQueue();
         }
     }
     /**
@@ -67,6 +103,19 @@ class RetryManager {
             pending: this.queue.filter(item => item.nextRetryAt > now).length
         };
     }
+    /**
+     * 获取队列内容（用于测试和调试）
+     */
+    getQueue() {
+        return [...this.queue];
+    }
+    /**
+     * 清空队列
+     */
+    clearQueue() {
+        this.queue = [];
+        this.persistQueue();
+    }
     calculateDelay(attempt) {
         switch (this.config.backoff) {
             case 'exponential':

package/dist/orchestrator/scheduler.d.ts

@@ -14,7 +14,17 @@ export declare class Scheduler {
     private stateManager;
     private stateMachine;
     private config;
+    private cycleCache;
+    private lastCycleCheck;
+    private cycleCheckTTL;
+    private cycleCacheKey;
+    /** 默认任务超时（毫秒） */
+    private static readonly DEFAULT_TASK_TIMEOUT;
     constructor(stateManager: StateManager, config?: Partial<SchedulerConfig>);
+    /**
+     * 计算任务列表的简单哈希（用于缓存键）
+     */
+    private computeTasksHash;
     /**
      * 获取当前正在执行的任务数（从持久化状态读取，非内存缓存）
      */
@@ -66,8 +76,17 @@ export declare class Scheduler {
     detectCircularDependencies(tasks: Task[]): string[][];
     /**
      * 检测循环依赖并将相关任务标记为 blocked
+     * 使用缓存避免重复计算
      */
     private handleCircularDependencies;
+    /**
+     * 获取任务的循环依赖缓存（用于调试）
+     */
+    getCycleCache(): Map<string, string[]>;
+    /**
+     * 清除循环依赖缓存
+     */
+    clearCycleCache(): void;
     /**
      * 获取调度状态（从持久化状态读取）
      */

package/dist/orchestrator/scheduler.js

@@ -6,15 +6,32 @@ class Scheduler {
     stateManager;
     stateMachine;
     config;
+    // 循环依赖检测缓存（避免重复计算）
+    cycleCache = new Map();
+    lastCycleCheck = 0;
+    cycleCheckTTL = 30000; // 30 秒缓存
+    cycleCacheKey = ''; // 任务列表哈希
+    /** 默认任务超时（毫秒） */
+    static DEFAULT_TASK_TIMEOUT = 600000; // 10 分钟
     constructor(stateManager, config) {
         this.stateManager = stateManager;
         this.stateMachine = new state_machine_js_1.StateMachine();
         this.config = {
             maxConcurrentTasks: 3,
-            taskTimeout: 600000, // 10 分钟
+            taskTimeout: Scheduler.DEFAULT_TASK_TIMEOUT,
             ...config
         };
     }
+    /**
+     * 计算任务列表的简单哈希（用于缓存键）
+     */
+    computeTasksHash(tasks) {
+        // 使用任务 ID + 状态 + 依赖的组合作为哈希
+        return tasks
+            .map(t => `${t.id}:${t.status}:${(t.dependencies || []).join(',')}`)
+            .sort()
+            .join('|');
+    }
     /**
      * 获取当前正在执行的任务数（从持久化状态读取，非内存缓存）
      */
@@ -223,9 +240,28 @@ class Scheduler {
     }
     /**
      * 检测循环依赖并将相关任务标记为 blocked
+     * 使用缓存避免重复计算
      */
     async handleCircularDependencies(tasks) {
+        const now = Date.now();
+        const hash = this.computeTasksHash(tasks);
+        // 检查缓存是否有效
+        if (hash === this.cycleCacheKey && now - this.lastCycleCheck < this.cycleCheckTTL) {
+            // 使用缓存结果，跳过重新检测
+            return;
+        }
+        // 缓存失效或任务列表变化，重新检测
         const cycles = this.detectCircularDependencies(tasks);
+        // 更新缓存
+        this.cycleCache.clear();
+        for (const cycle of cycles) {
+            for (const taskId of cycle) {
+                this.cycleCache.set(taskId, cycle);
+            }
+        }
+        this.cycleCacheKey = hash;
+        this.lastCycleCheck = now;
+        // 标记阻塞任务
         for (const cycle of cycles) {
             for (const taskId of cycle) {
                 const task = tasks.find(t => t.id === taskId);
@@ -238,6 +274,20 @@ class Scheduler {
             }
         }
     }
+    /**
+     * 获取任务的循环依赖缓存（用于调试）
+     */
+    getCycleCache() {
+        return this.cycleCache;
+    }
+    /**
+     * 清除循环依赖缓存
+     */
+    clearCycleCache() {
+        this.cycleCache.clear();
+        this.lastCycleCheck = 0;
+        this.cycleCacheKey = '';
+    }
     /**
      * 获取调度状态（从持久化状态读取）
      */

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

@@ -27,6 +27,17 @@ export interface ParsedPlan {
     /** 原始 plan 文本 */
     raw: string;
 }
+/** 从 plan 中提取的结构化信息（用于 fallback 时注入任务描述） */
+export interface PlanMetadata {
+    /** 技术栈 */
+    techStack: string[];
+    /** 接口/API 定义 */
+    interfaces: string[];
+    /** 数据模型/表 */
+    dataModels: string[];
+    /** 关键决策 */
+    keyDecisions: string[];
+}
 export interface TaskBreakdown {
     taskId: string;
     title: string;
@@ -77,6 +88,15 @@ export declare class TaskPlanner {
      * 解析 plan 文本，提取模块、技术栈、数据模型等结构化信息
      */
     parsePlan(planText: string): ParsedPlan;
+    /**
+     * 从 plan 中提取结构化信息（用于 fallback 时注入任务描述）
+     * 即使无法解析模块，也能保留关键技术信息
+     */
+    extractPlanMetadata(plan: string): PlanMetadata;
+    /**
+     * 从 goals 推断模块结构（当 plan 无法解析模块时使用）
+     */
+    inferModulesFromGoals(parsedTask: ParsedTask): PlanModule[];
     /**
      * 分析模块间依赖关系
      *