openmatrix 0.1.0

package/dist/storage/state-manager.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+const file_store_js_1 = require("./file-store.js");
+const DEFAULT_CONFIG = {
+    timeout: 120,
+    maxRetries: 3,
+    approvalPoints: ['plan', 'merge'],
+    maxConcurrentAgents: 3,
+    model: 'claude-sonnet-4-6'
+};
+class StateManager {
+    store;
+    stateCache = null;
+    constructor(basePath) {
+        this.store = new file_store_js_1.FileStore(basePath);
+    }
+    async initialize() {
+        const existing = await this.store.readJson('state.json');
+        if (!existing) {
+            const initialState = {
+                version: '1.0',
+                runId: this.generateRunId(),
+                status: 'initialized',
+                currentPhase: 'planning',
+                startedAt: new Date().toISOString(),
+                config: DEFAULT_CONFIG,
+                statistics: {
+                    totalTasks: 0,
+                    completed: 0,
+                    inProgress: 0,
+                    failed: 0,
+                    pending: 0
+                }
+            };
+            await this.store.writeJson('state.json', initialState);
+            this.stateCache = initialState;
+        }
+        else {
+            this.stateCache = existing;
+        }
+    }
+    async getState() {
+        if (!this.stateCache) {
+            this.stateCache = await this.store.readJson('state.json');
+        }
+        return this.stateCache;
+    }
+    async updateState(updates) {
+        const state = await this.getState();
+        const newState = { ...state, ...updates };
+        await this.store.writeJson('state.json', newState);
+        this.stateCache = newState;
+    }
+    async createTask(input) {
+        const taskId = this.generateTaskId();
+        const now = new Date().toISOString();
+        const task = {
+            id: taskId,
+            title: input.title,
+            description: input.description,
+            status: 'pending',
+            priority: input.priority,
+            timeout: input.timeout,
+            dependencies: input.dependencies,
+            assignedAgent: input.assignedAgent,
+            phases: {
+                develop: { status: 'pending', duration: null },
+                verify: { status: 'pending', duration: null },
+                accept: { status: 'pending', duration: null }
+            },
+            retryCount: 0,
+            error: null,
+            createdAt: now,
+            updatedAt: now
+        };
+        await this.store.writeJson(`tasks/${taskId}/task.json`, task);
+        // Update statistics
+        const state = await this.getState();
+        await this.updateState({
+            statistics: {
+                ...state.statistics,
+                totalTasks: state.statistics.totalTasks + 1,
+                pending: state.statistics.pending + 1
+            }
+        });
+        return task;
+    }
+    async getTask(taskId) {
+        return await this.store.readJson(`tasks/${taskId}/task.json`);
+    }
+    async updateTask(taskId, updates) {
+        const task = await this.getTask(taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        const oldStatus = task.status;
+        const updatedTask = {
+            ...task,
+            ...updates,
+            updatedAt: new Date().toISOString()
+        };
+        await this.store.writeJson(`tasks/${taskId}/task.json`, updatedTask);
+        // Update statistics if status changed
+        if (updates.status && updates.status !== oldStatus) {
+            await this.updateTaskStatistics(oldStatus, updates.status);
+        }
+    }
+    async listTasks() {
+        const dirs = await this.store.listDirs('tasks');
+        const tasks = [];
+        for (const dir of dirs) {
+            const task = await this.getTask(dir);
+            if (task)
+                tasks.push(task);
+        }
+        return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    async updateTaskStatistics(oldStatus, newStatus) {
+        const state = await this.getState();
+        const stats = { ...state.statistics };
+        // Decrement old status count
+        if (oldStatus === 'pending')
+            stats.pending--;
+        else if (oldStatus === 'in_progress')
+            stats.inProgress--;
+        else if (oldStatus === 'completed')
+            stats.completed--;
+        else if (oldStatus === 'failed')
+            stats.failed--;
+        // Increment new status count
+        if (newStatus === 'pending')
+            stats.pending++;
+        else if (newStatus === 'in_progress')
+            stats.inProgress++;
+        else if (newStatus === 'completed')
+            stats.completed++;
+        else if (newStatus === 'failed')
+            stats.failed++;
+        await this.updateState({ statistics: stats });
+    }
+    generateRunId() {
+        const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+        const rand = Math.random().toString(36).slice(2, 6);
+        return `run-${date}-${rand}`;
+    }
+    generateTaskId() {
+        const timestamp = Date.now().toString(36).toUpperCase();
+        const rand = Math.random().toString(36).slice(2, 4).toUpperCase();
+        return `TASK-${timestamp}${rand}`;
+    }
+    // ============ Approval Methods ============
+    async saveApproval(approval) {
+        await this.store.writeJson(`approvals/${approval.id}.json`, approval);
+    }
+    async getApproval(approvalId) {
+        return await this.store.readJson(`approvals/${approvalId}.json`);
+    }
+    async updateApproval(approval) {
+        await this.store.writeJson(`approvals/${approval.id}.json`, approval);
+    }
+    async getApprovalsByStatus(status) {
+        const files = await this.store.listFiles('approvals');
+        const approvals = [];
+        for (const file of files) {
+            const approval = await this.store.readJson(`approvals/${file}`);
+            if (approval && approval.status === status) {
+                approvals.push(approval);
+            }
+        }
+        return approvals.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    async getAllApprovals() {
+        const files = await this.store.listFiles('approvals');
+        const approvals = [];
+        for (const file of files) {
+            const approval = await this.store.readJson(`approvals/${file}`);
+            if (approval) {
+                approvals.push(approval);
+            }
+        }
+        return approvals.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    // ============ Meeting Methods ============
+    async saveMeeting(meeting) {
+        await this.store.writeJson(`meetings/${meeting.id}.json`, meeting);
+    }
+    async getMeeting(meetingId) {
+        return await this.store.readJson(`meetings/${meetingId}.json`);
+    }
+    async getMeetingsByStatus(status) {
+        const files = await this.store.listFiles('meetings');
+        const meetings = [];
+        for (const file of files) {
+            const meeting = await this.store.readJson(`meetings/${file}`);
+            if (meeting && meeting.status === status) {
+                meetings.push(meeting);
+            }
+        }
+        return meetings.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+}
+exports.StateManager = StateManager;

package/dist/types/index.d.ts

@@ -0,0 +1,193 @@
+export type TaskStatus = 'pending' | 'scheduled' | 'in_progress' | 'blocked' | 'waiting' | 'verify' | 'accept' | 'completed' | 'failed' | 'retry_queue';
+export type TaskPriority = 'P0' | 'P1' | 'P2' | 'P3';
+export interface TaskPhase {
+    status: TaskStatus;
+    duration: number | null;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface Task {
+    id: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    priority: TaskPriority;
+    timeout: number;
+    dependencies: string[];
+    assignedAgent: AgentType;
+    phases: {
+        develop: TaskPhase;
+        verify: TaskPhase;
+        accept: TaskPhase;
+    };
+    retryCount: number;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /** 验收标准 */
+    acceptanceCriteria?: string[];
+    /** 关联的测试任务 ID */
+    testTaskId?: string;
+    /** 任务所属阶段 */
+    phase?: 'design' | 'develop' | 'verify' | 'accept';
+}
+export type AgentType = 'planner' | 'coder' | 'tester' | 'reviewer' | 'researcher' | 'executor';
+export type AgentStatus = 'idle' | 'running' | 'completed' | 'failed';
+export interface AgentResult {
+    runId: string;
+    taskId: string;
+    agentType: AgentType;
+    status: AgentStatus;
+    output: string;
+    artifacts: string[];
+    needsApproval: boolean;
+    error?: string;
+    duration: number;
+    completedAt: string;
+}
+/**
+ * Claude Code Subagent 类型
+ */
+export type ClaudeCodeSubagentType = 'general-purpose' | 'Explore' | 'Plan';
+/**
+ * Subagent 任务配置 - 用于 Agent 工具调用
+ */
+export interface SubagentTask {
+    /** Subagent 类型 */
+    subagent_type: ClaudeCodeSubagentType;
+    /** 简短描述 (3-5 词) */
+    description: string;
+    /** 完整任务提示词 */
+    prompt: string;
+    /** 是否使用隔离 worktree */
+    isolation?: 'worktree';
+    /** 任务 ID (用于追踪) */
+    taskId: string;
+    /** 原始 Agent 类型 */
+    agentType: AgentType;
+    /** 超时时间 (ms) */
+    timeout: number;
+    /** 是否需要审批 */
+    needsApproval: boolean;
+}
+export type RunStatus = 'initialized' | 'running' | 'paused' | 'completed' | 'failed';
+export interface GlobalState {
+    version: string;
+    runId: string;
+    status: RunStatus;
+    currentPhase: 'planning' | 'execution' | 'verification' | 'acceptance';
+    startedAt: string;
+    config: AppConfig;
+    statistics: {
+        totalTasks: number;
+        completed: number;
+        inProgress: number;
+        failed: number;
+        pending: number;
+    };
+}
+export interface AppConfig {
+    timeout: number;
+    maxRetries: number;
+    approvalPoints: ('plan' | 'merge' | 'deploy')[];
+    maxConcurrentAgents: number;
+    model: string;
+    /** 质量配置 */
+    quality?: QualityConfig;
+}
+/**
+ * 质量配置 - 控制自动化质量门禁
+ */
+export interface QualityConfig {
+    /** 启用 TDD 模式 (先写测试再写代码) */
+    tdd: boolean;
+    /** 最低测试覆盖率 (%) */
+    minCoverage: number;
+    /** 严格 Lint (error 即失败) */
+    strictLint: boolean;
+    /** 安全扫描 */
+    securityScan: boolean;
+    /** 质量级别 */
+    level: 'fast' | 'balanced' | 'strict';
+}
+/**
+ * 质量报告 - Verify 阶段产出
+ */
+export interface QualityReport {
+    taskId: string;
+    timestamp: string;
+    /** 测试结果 */
+    tests: {
+        passed: number;
+        failed: number;
+        skipped: number;
+        coverage: number;
+        status: 'pass' | 'fail';
+    };
+    /** 构建结果 */
+    build: {
+        success: boolean;
+        errors: string[];
+        status: 'pass' | 'fail';
+    };
+    /** Lint 结果 */
+    lint: {
+        errors: number;
+        warnings: number;
+        status: 'pass' | 'fail' | 'warning';
+    };
+    /** 安全扫描结果 */
+    security: {
+        vulnerabilities: SecurityVulnerability[];
+        status: 'pass' | 'fail';
+    };
+    /** 验收标准检查 */
+    acceptance: {
+        total: number;
+        met: number;
+        details: AcceptanceCheck[];
+        status: 'pass' | 'fail';
+    };
+    /** 总体状态 */
+    overall: 'pass' | 'fail' | 'warning';
+}
+export interface SecurityVulnerability {
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    package: string;
+    description: string;
+}
+export interface AcceptanceCheck {
+    criterion: string;
+    met: boolean;
+    evidence?: string;
+}
+/**
+ * 预设质量配置
+ */
+export declare const QUALITY_PRESETS: Record<string, QualityConfig>;
+export type ApprovalStatus = 'pending' | 'approved' | 'rejected';
+export interface Approval {
+    id: string;
+    type: 'plan' | 'merge' | 'deploy' | 'meeting' | 'custom';
+    taskId: string;
+    title: string;
+    description: string;
+    content: string;
+    options: ApprovalOption[];
+    status: ApprovalStatus;
+    decision?: 'approve' | 'modify' | 'reject';
+    createdAt: string;
+    decidedAt?: string;
+}
+export interface ApprovalOption {
+    key: string;
+    label: string;
+}
+export interface ParsedTask {
+    title: string;
+    description: string;
+    goals: string[];
+    constraints: string[];
+    deliverables: string[];
+    rawContent: string;
+}

package/dist/types/index.js

@@ -0,0 +1,30 @@
+"use strict";
+// src/types/index.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUALITY_PRESETS = void 0;
+/**
+ * 预设质量配置
+ */
+exports.QUALITY_PRESETS = {
+    fast: {
+        tdd: false,
+        minCoverage: 0,
+        strictLint: false,
+        securityScan: false,
+        level: 'fast'
+    },
+    balanced: {
+        tdd: false,
+        minCoverage: 60,
+        strictLint: true,
+        securityScan: true,
+        level: 'balanced'
+    },
+    strict: {
+        tdd: true,
+        minCoverage: 80,
+        strictLint: true,
+        securityScan: true,
+        level: 'strict'
+    }
+};

package/dist/utils/logger.d.ts

@@ -0,0 +1,41 @@
+import winston from 'winston';
+export interface LoggerOptions {
+    level?: string;
+    logDir?: string;
+    console?: boolean;
+}
+/**
+ * 创建或获取默认 Logger
+ */
+export declare function createLogger(options?: LoggerOptions): winston.Logger;
+/**
+ * 获取默认 logger 实例
+ */
+export declare function getLogger(): winston.Logger;
+/**
+ * 设置默认 logger
+ */
+export declare function setLogger(logger: winston.Logger): void;
+/**
+ * 便捷方法: 直接记录日志
+ */
+export declare const logger: {
+    info: (message: string, meta?: any) => winston.Logger;
+    error: (message: string, meta?: any) => winston.Logger;
+    warn: (message: string, meta?: any) => winston.Logger;
+    debug: (message: string, meta?: any) => winston.Logger;
+    task: {
+        start: (taskId: string, title: string) => void;
+        complete: (taskId: string, duration?: number) => void;
+        fail: (taskId: string, error: string) => void;
+        retry: (taskId: string, attempt: number) => void;
+    };
+    agent: {
+        call: (agentType: string, taskId: string) => void;
+        result: (agentType: string, taskId: string, success: boolean) => void;
+    };
+    approval: {
+        request: (approvalId: string, type: string) => void;
+        decision: (approvalId: string, decision: string) => void;
+    };
+};

package/dist/utils/logger.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.createLogger = createLogger;
+exports.getLogger = getLogger;
+exports.setLogger = setLogger;
+// src/utils/logger.ts
+const winston_1 = __importDefault(require("winston"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * OpenMatrix Logger - 基于 Winston 的日志系统
+ *
+ * 特性:
+ * 1. 多级别日志 (error, warn, info, debug)
+ * 2. 文件滚动日志
+ * 3. 控制台彩色输出
+ * 4. 结构化 JSON 日志
+ */
+let defaultLogger = null;
+/**
+ * 创建或获取默认 Logger
+ */
+function createLogger(options = {}) {
+    const { level = process.env.OPENMATRIX_LOG_LEVEL || 'info', logDir = '.openmatrix/logs', console: enableConsole = true } = options;
+    // 确保日志目录存在
+    const absoluteLogDir = path.resolve(process.cwd(), logDir);
+    if (!fs.existsSync(absoluteLogDir)) {
+        fs.mkdirSync(absoluteLogDir, { recursive: true });
+    }
+    // 定义日志格式
+    const customFormat = winston_1.default.format.combine(winston_1.default.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston_1.default.format.errors({ stack: true }), winston_1.default.format.printf(({ level, message, timestamp, ...metadata }) => {
+        const metaStr = Object.keys(metadata).length ? JSON.stringify(metadata) : '';
+        return `${timestamp} [${level.toUpperCase()}] ${message} ${metaStr}`;
+    }));
+    // JSON 格式 (用于文件)
+    const jsonFormat = winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), winston_1.default.format.json());
+    // 控制台格式 (带颜色)
+    const consoleFormat = winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.timestamp({ format: 'HH:mm:ss' }), winston_1.default.format.printf(({ level, message, timestamp, ...metadata }) => {
+        const metaStr = Object.keys(metadata).length ? JSON.stringify(metadata) : '';
+        return `${timestamp} ${level} ${message} ${metaStr}`;
+    }));
+    // 创建 transports
+    const transports = [];
+    // 文件日志
+    transports.push(new winston_1.default.transports.File({
+        filename: path.join(absoluteLogDir, 'error.log'),
+        level: 'error',
+        format: jsonFormat,
+        maxsize: 5 * 1024 * 1024, // 5MB
+        maxFiles: 5
+    }));
+    transports.push(new winston_1.default.transports.File({
+        filename: path.join(absoluteLogDir, 'combined.log'),
+        format: jsonFormat,
+        maxsize: 10 * 1024 * 1024, // 10MB
+        maxFiles: 10
+    }));
+    // 控制台日志
+    if (enableConsole) {
+        transports.push(new winston_1.default.transports.Console({
+            format: consoleFormat,
+            level
+        }));
+    }
+    // 创建 logger
+    const logger = winston_1.default.createLogger({
+        level,
+        defaultMeta: { service: 'openmatrix' },
+        transports
+    });
+    return logger;
+}
+/**
+ * 获取默认 logger 实例
+ */
+function getLogger() {
+    if (!defaultLogger) {
+        defaultLogger = createLogger();
+    }
+    return defaultLogger;
+}
+/**
+ * 设置默认 logger
+ */
+function setLogger(logger) {
+    defaultLogger = logger;
+}
+/**
+ * 便捷方法: 直接记录日志
+ */
+exports.logger = {
+    info: (message, meta) => getLogger().info(message, meta),
+    error: (message, meta) => getLogger().error(message, meta),
+    warn: (message, meta) => getLogger().warn(message, meta),
+    debug: (message, meta) => getLogger().debug(message, meta),
+    // 任务相关日志
+    task: {
+        start: (taskId, title) => {
+            getLogger().info(`Task started: ${taskId}`, { taskId, title });
+        },
+        complete: (taskId, duration) => {
+            getLogger().info(`Task completed: ${taskId}`, { taskId, duration });
+        },
+        fail: (taskId, error) => {
+            getLogger().error(`Task failed: ${taskId}`, { taskId, error });
+        },
+        retry: (taskId, attempt) => {
+            getLogger().warn(`Task retry: ${taskId}`, { taskId, attempt });
+        }
+    },
+    // Agent 相关日志
+    agent: {
+        call: (agentType, taskId) => {
+            getLogger().info(`Agent called: ${agentType}`, { agentType, taskId });
+        },
+        result: (agentType, taskId, success) => {
+            getLogger().debug(`Agent result: ${agentType}`, { agentType, taskId, success });
+        }
+    },
+    // 审批相关日志
+    approval: {
+        request: (approvalId, type) => {
+            getLogger().info(`Approval requested: ${approvalId}`, { approvalId, type });
+        },
+        decision: (approvalId, decision) => {
+            getLogger().info(`Approval decision: ${approvalId}`, { approvalId, decision });
+        }
+    }
+};