JSPM

  • Created
  • Published
  • Downloads 1219
  • Score
    100M100P100Q120750F
  • License MIT

AI Agent task orchestration system with Claude Code Skills integration

Package Exports

  • openmatrix
  • openmatrix/dist/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (openmatrix) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

OpenMatrix

唯一同时实现 TDD + 严格质量门禁 + 全自动执行的 AI 任务编排系统

自动化 ≠ 牺牲质量 | 高质量 ≠ 手动操作

npm version License: MIT Node Claude Code

中文文档 | English


中文文档

一句话介绍

/om:start 实现用户登录
# 第一个问题让你选择质量级别,然后全自动执行 + 严格质量保证

完整流程图

┌─────────────────────────────────────────────────────────────────────────────────┐
│                           OpenMatrix 完整执行流程                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

用户输入: /om:start 实现用户登录功能
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 0: 交互式问答                                                              │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  Q0: 选择质量级别?     ◀─── 最重要,第一个问                                     │
│  ├── 🚀 strict     →  TDD + 80%覆盖率 + 6道门禁 + AI验收                         │
│  ├── ⚖️ balanced   →  60%覆盖率 + 4道门禁 + AI验收                               │
│  └── ⚡ fast       →  无质量门禁                                                 │
│                                                                                 │
│  Q1: 任务目标?         (新功能/Bug修复/重构)                                     │
│  Q2: 技术栈?           (TypeScript/Python/Go...)                               │
│  Q3: 文档要求?         (完整/基础/最小/无)                                       │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 1: 任务规划 (Planner Agent)                                                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  输入: 用户回答 + 任务描述                                                        │
│  输出: 执行计划 + 子任务列表 + 依赖图                                             │
│                                                                                 │
│  📋 执行计划示例:                                                                │
│  ├── TASK-001: 数据模型设计 (Planner, 15min)                                    │
│  ├── TASK-002: API 接口实现 (Coder, 30min)                                      │
│  ├── TASK-003: 单元测试 (Tester, 20min)                                         │
│  └── TASK-004: 代码审查 (Reviewer, 10min)                                       │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 2: 任务执行 (根据质量级别)                                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │ strict 模式 (4阶段)                                                      │   │
│  │                                                                          │   │
│  │  ┌─────────┐     ┌─────────┐     ┌─────────┐     ┌─────────┐           │   │
│  │  │   TDD   │────▶│ Develop │────▶│  Verify │────▶│ Accept  │           │   │
│  │  │ 🧪 RED  │     │ ✨ GREEN│     │ ✅ 6门禁│     │ 🎉 AI   │           │   │
│  │  └─────────┘     └─────────┘     └─────────┘     └─────────┘           │   │
│  │       │               │               │               │                 │   │
│  │       ▼               ▼               ▼               ▼                 │   │
│  │   Tester 先写      Coder 写代码    6道质量门禁    Reviewer              │   │
│  │   测试(必须失败)   (测试必须通过)   (见下方)      最终验收                │   │
│  │                                                                          │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                                                                 │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │ balanced 模式 (3阶段)                                                    │   │
│  │                                                                          │   │
│  │  ┌─────────┐     ┌─────────┐     ┌─────────┐                            │   │
│  │  │ Develop │────▶│  Verify │────▶│ Accept  │                            │   │
│  │  │ ✨ 编码 │     │ ✅ 4门禁│     │ 🎉 AI   │                            │   │
│  │  └─────────┘     └─────────┘     └─────────┘                            │   │
│  │                                                                          │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                                                                 │
│  ┌─────────────────────────────────────────────────────────────────────────┐   │
│  │ fast 模式 (1阶段)                                                        │   │
│  │                                                                          │   │
│  │  ┌─────────┐     ┌─────────┐                                            │   │
│  │  │ Develop │────▶│  Done   │                                            │   │
│  │  │ ✨ 编码 │     │ 🏁 完成 │                                            │   │
│  │  └─────────┘     └─────────┘                                            │   │
│  │                                                                          │   │
│  └─────────────────────────────────────────────────────────────────────────┘   │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 3: 质量门禁 (Verify 阶段)                                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  ┌──────────────────────────────────────────────────────────────────────────┐  │
│  │                        6 Quality Gates                                    │  │
│  │                                                                          │  │
│  │  🚪 Gate 1: 编译检查                                                      │  │
│  │  │   $ npm run build                                                      │  │
│  │  └── → ✅ PASS (无编译错误) / ❌ FAIL (阻止继续)                           │  │
│  │                                                                          │  │
│  │  🚪 Gate 2: 测试运行                                                      │  │
│  │  │   $ npm test                                                           │  │
│  │  └── → ✅ PASS (所有测试通过) / ❌ FAIL (阻止继续)                         │  │
│  │                                                                          │  │
│  │  🚪 Gate 3: 覆盖率检查 (strict: 80%, balanced: 60%)                       │  │
│  │  │   $ npm test -- --coverage                                             │  │
│  │  └── → ✅ PASS (达标) / ⚠️ WARN (不达标但继续)                             │  │
│  │                                                                          │  │
│  │  🚪 Gate 4: Lint 检查 (strict: 无error, balanced: 无严重error)            │  │
│  │  │   $ npm run lint                                                       │  │
│  │  └── → ✅ PASS / ❌ FAIL (strict模式阻止)                                  │  │
│  │                                                                          │  │
│  │  🚪 Gate 5: 安全扫描                                                      │  │
│  │  │   $ npm audit --audit-level=high                                       │  │
│  │  └── → ✅ PASS (无高危漏洞) / ❌ FAIL (阻止继续)                           │  │
│  │                                                                          │  │
│  │  🚪 Gate 6: 验收标准                                                      │  │
│  │  │   逐项检查用户定义的验收标准                                            │  │
│  │  └── → ✅ PASS (全部满足) / ❌ FAIL (阻止继续)                             │  │
│  │                                                                          │  │
│  └──────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 4: AI 验收 (Accept 阶段)                                                   │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  Reviewer Agent 执行:                                                           │
│  ├── 📄 读取 verify-report.md                                                   │
│  ├── ✅ 验证所有验收标准已满足                                                    │
│  ├── 🔍 确认代码可以合并                                                         │
│  ├── 📊 生成质量报告 (quality-report.json)                                       │
│  └── 📝 生成验收报告 (accept-report.md)                                          │
│                                                                                 │
│  输出示例:                                                                       │
│  ┌──────────────────────────────────────────────────────────────────────────┐  │
│  │ ACCEPT_PASSED                                                             │  │
│  │ Quality Score: A                                                          │  │
│  │ ├── Tests:     ✅ 15/15 passed, 82% coverage                              │  │
│  │ ├── Build:     ✅ Success                                                 │  │
│  │ ├── Lint:      ✅ No errors (3 warnings)                                  │  │
│  │ ├── Security:  ✅ No vulnerabilities                                      │  │
│  │ └── Criteria:  ✅ 5/5 acceptance criteria met                             │  │
│  └──────────────────────────────────────────────────────────────────────────┘  │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 5: Meeting 处理 (如有阻塞)                                                  │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  执行过程中遇到阻塞 → 创建 Meeting → 继续执行其他任务                              │
│                                                                                 │
│  执行日志:                                                                       │
│  ├── TASK-001: ✅ 完成                                                          │
│  ├── TASK-002: ⚠️ 阻塞 → 创建 Meeting-001 → 跳过 ↷                              │
│  ├── TASK-003: ✅ 完成                                                          │
│  ├── TASK-004: ⚠️ 阻塞 → 创建 Meeting-002 → 跳过 ↷                              │
│  └── TASK-005: ✅ 完成                                                          │
│                                                                                 │
│  执行完成! 📋 有 2 个待处理 Meeting                                               │
│                                                                                 │
│  用户执行: /om:meeting                                                           │
│  ├── [1] Meeting-001: 数据库连接失败 (TASK-002)                                  │
│  │    ├── 💡 提供信息 → 重新执行 TASK-002 → ✅ 完成                              │
│  │    ├── ⏭️ 跳过任务 → 标记为 skipped                                          │
│  │    └── 🔄 重试 → 重新执行 TASK-002                                           │
│  └── [2] Meeting-002: API设计决策 (TASK-004)                                     │
│       ├── 💡 提供信息 → 重新执行 TASK-004 → ✅ 完成                              │
│       ├── ⏭️ 跳过任务 → 标记为 skipped                                          │
│       └── 🔄 重试 → 重新执行 TASK-004                                           │
│                                                                                 │
│  Meeting 处理完成后:                                                             │
│  └── 重新执行被阻塞的任务 (TASK-002, TASK-004)                                    │
│      └── 每个任务仍需经过完整的 Phase 流程 (Develop → Verify → Accept)            │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│  阶段 6: 最终报告                                                                │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                 │
│  /om:report                                                                     │
│                                                                                 │
│  📊 执行报告:                                                                    │
│  ├── 总任务: 5                                                                   │
│  ├── 完成: 5 (含 2 个 Meeting 处理后完成)                                         │
│  ├── 跳过: 0                                                                     │
│  ├── 质量评分: A                                                                 │
│  ├── 总耗时: 35 分钟 (含 Meeting 处理)                                            │
│  └── Git 提交: 5 commits                                                        │
│                                                                                 │
│  📁 产出文件:                                                                    │
│  ├── .openmatrix/state.json           # 全局状态                                │
│  ├── .openmatrix/tasks/TASK-001/      # 任务详情                                │
│  │   ├── task.json                    # 任务定义                                │
│  │   └── artifacts/                   # 产出物                                  │
│  │       ├── result.md                # 实现说明                                │
│  │       ├── verify-report.md         # 验证报告                                │
│  │       ├── quality-report.json      # 质量报告                                │
│  │       └── accept-report.md         # 验收报告                                │
│  └── .openmatrix/approvals/           # 审批记录 (含 Meeting)                   │
│                                                                                 │
└─────────────────────────────────────────────────────────────────────────────────┘

                                    🎉 完成!

为什么选择 OpenMatrix?

与 superpowers / gsd 对比

特性 OpenMatrix superpowers gsd
100% 自动化 ✅ auto 模式 ❌ 50% ❌ 60%
TDD 内置 ✅ strict 模式 ❌ 需手动 ❌ 无
覆盖率强制 ✅ 60-80% ❌ 无 ❌ 无
安全扫描 ✅ npm audit ❌ 无 ❌ 无
AI 验收 ✅ Reviewer Agent ❌ 无 部分
阻塞不中断 ✅ Meeting 机制 ❌ 停止 ❌ 停止
质量报告 ✅ JSON + MD ❌ 无 部分
上手难度 ⚡ 一句话开始 中等 较高

快速开始

安装

# 克隆并安装
git clone https://github.com/bigfish1913/openmatrix.git
cd openmatrix && npm install && npm run build && npm link

# 复制 Skills
mkdir -p ~/.claude/commands/om
cp skills/*.md ~/.claude/commands/om/

第一次使用

/om:start 实现用户登录功能

# 系统会先问:
┌─────────────────────────────────────────────────────────┐
│ 问题 0: 选择质量级别                                     │
├─────────────────────────────────────────────────────────┤
│ 🚀 strict   → TDD + 80%覆盖率 + AI验收 (推荐生产代码)    │
│ ⚖️ balanced  → 60%覆盖率 + AI验收 (日常开发)            │
│ ⚡ fast      → 无质量门禁 (快速原型)                     │
└─────────────────────────────────────────────────────────┘

核心特性

1️⃣ 三级质量配置 (第一个问题就让你选)

级别 TDD 覆盖率 Lint 安全 AI验收 适用场景
strict 80% ✅ 严格 🏭 生产代码
balanced 60% 📦 日常开发
fast 0% 🏃 快速原型

2️⃣ 六道质量门禁 (Verify 阶段)

┌─────────────────────────────────────────────────────────────┐
│                    Verify 阶段 - 质量门禁                     │
├─────────────────────────────────────────────────────────────┤
│  🚪 Gate 1: 编译检查     npm run build     → 必须通过       │
│  🚪 Gate 2: 测试运行     npm test         → 必须通过       │
│  🚪 Gate 3: 覆盖率检查   >= 60%/80%       → 可配置         │
│  🚪 Gate 4: Lint 检查    无 error         → 可配置         │
│  🚪 Gate 5: 安全扫描     npm audit        → 无高危漏洞     │
│  🚪 Gate 6: 验收标准     用户定义         → 必须全部满足   │
└─────────────────────────────────────────────────────────────┘

3️⃣ TDD 模式 (strict 级别)

传统开发:  代码 → 测试 → Bug → 修复 → 回归 → ... (循环多次)

OpenMatrix TDD (strict):
  🧪 测试阶段: 先写测试 (RED - 测试必须失败)
  ✨ 开发阶段: 再写代码 (GREEN - 测试必须通过)
  ✅ 验证阶段: 6道质量门禁
  🎉 验收阶段: AI Reviewer 最终确认

结果: 第一次就写对,无需返工

4️⃣ Meeting 机制 (阻塞不中断)

❌ 其他方案:
   TASK-001 ✓ → TASK-002 阻塞 ⏸️ → 等用户... (浪费时间)

✅ OpenMatrix:
   TASK-001 ✓ → TASK-002 阻塞 → 创建Meeting → 跳过 ↷
   TASK-003 ✓ → TASK-004 ✓ → 完成!
   → 用户用 /om:meeting 统一处理所有阻塞

5️⃣ AI 验收 (Accept 阶段)

Accept 阶段由 Reviewer Agent 执行:
├── 检查 verify-report.md
├── 验证所有验收标准
├── 确认代码可合并
└── 生成 accept-report.md

执行流程

strict 模式 (推荐生产代码)

┌─────────┐     ┌─────────┐     ┌─────────┐     ┌─────────┐
│   TDD   │────▶│ Develop │────▶│  Verify │────▶│ Accept  │
│ 🧪 RED  │     │ ✨ GREEN│     │ ✅ 6门禁│     │ 🎉 AI   │
└─────────┘     └─────────┘     └─────────┘     └─────────┘

balanced 模式 (日常开发)

┌─────────┐     ┌─────────┐     ┌─────────┐
│ Develop │────▶│  Verify │────▶│ Accept  │
│ ✨ 编码 │     │ ✅ 4门禁│     │ 🎉 AI   │
└─────────┘     └─────────┘     └─────────┘

Skills 命令

命令 用途
/om:start 启动新任务 (第一个问题选质量级别)
/om:status 查看状态
/om:approve 审批决策
/om:meeting 处理阻塞问题
/om:resume 恢复中断
/om:retry 重试失败
/om:report 生成报告

质量报告

每个任务完成后生成:

{
  "taskId": "TASK-001",
  "overall": "pass",
  "tests": { "passed": 15, "failed": 0, "coverage": 82 },
  "build": { "success": true },
  "lint": { "errors": 0, "warnings": 3 },
  "security": { "vulnerabilities": [] },
  "acceptance": { "met": 5, "total": 5 }
}

常见问题

Q: 哪种质量级别适合我?

你的场景 推荐级别
🏭 生产代码、核心功能 strict
📦 日常功能开发 balanced
🏃 快速原型、POC fast

Q: OpenMatrix 和 superpowers 可以一起用吗?

A: 可以!OpenMatrix 自动执行任务,superpowers 提供额外技能。

Q: Meeting 是什么?

A: 遇到阻塞时创建记录,但不停止执行。最后用 /om:meeting 统一处理。


配置

.openmatrixrc.json:

{
  "quality": {
    "tdd": false,
    "minCoverage": 60,
    "strictLint": true,
    "securityScan": true
  },
  "approvalPoints": ["plan", "merge"],
  "agents": { "maxConcurrent": 3 }
}

开发

git clone https://github.com/bigfish1913/openmatrix.git
cd openmatrix && npm install && npm run build && npm test

Roadmap

  • TDD 模式
  • 6 道质量门禁
  • Meeting 机制
  • 质量报告
  • AI 验收
  • VSCode 扩展
  • Python/Go 支持
  • CI/CD 集成

如果觉得有用,请给个 ⭐ Star!

MIT © 2024 | Made by bigfish1913


English

OpenMatrix: High Quality + Full Automation

The only AI task orchestration with TDD + Quality Gates + 100% Automation.

Quick Start

# Install
git clone https://github.com/bigfish1913/openmatrix.git
cd openmatrix && npm install && npm run build && npm link
mkdir -p ~/.claude/commands/om && cp skills/*.md ~/.claude/commands/om/

# Use (first question asks quality level)
/om:start Implement user login

Quality Levels

Level TDD Coverage Gates Use Case
strict 80% 6 Production code
balanced 60% 4 Daily development
fast 0% 1 Prototypes

Key Features

  • Quality Level Selection - First question you answer
  • TDD Mode - strict level includes test-first
  • 6 Quality Gates - Build, Tests, Coverage, Lint, Security, Acceptance
  • AI Acceptance - Reviewer Agent validates final result
  • Meeting Mechanism - Blockers don't stop execution
  • Quality Reports - JSON format for every task

License

MIT