@haoyiyin/workflow 0.2.11 → 0.3.0

package/src/router/namespace/domain/code-router.ts

@@ -0,0 +1,202 @@
+/**
+ * Code Router - Domain Layer
+ *
+ * 处理代码相关的复杂路由决策
+ * 包括：代码编写、重构、测试、审查
+ */
+
+import type {
+  NamespaceRouter,
+  RoutingContext,
+  RouteDecision,
+  NamespaceHealth,
+  AlternativeRoute,
+} from '../types.js'
+
+export class CodeRouter implements NamespaceRouter {
+  readonly name = 'code'
+  readonly layer = 'domain' as const
+  readonly priority = 65
+  readonly patterns = [
+    /code|代码/i,
+    /implement|实现/i,
+    /refactor|重构/i,
+    /write|写/i,
+    /function|函数|method|方法/i,
+    /class|类/i,
+    /component|组件/i,
+  ]
+
+  private routeCount = 0
+  private successCount = 0
+  private totalLatency = 0
+
+  async canRoute(context: RoutingContext): Promise<boolean> {
+    const text = context.request.text.toLowerCase()
+    return /code|代码|implement|实现|refactor|重构|write|写|function|函数|class|类|component|组件/.test(text)
+  }
+
+  async route(context: RoutingContext): Promise<RouteDecision> {
+    const startTime = Date.now()
+    const { state, request } = context
+
+    const decision = this.makeCodeDecision(state, request.text)
+
+    this.routeCount++
+    this.totalLatency += Date.now() - startTime
+    this.successCount++
+
+    return {
+      ...decision,
+      namespace: this.name,
+      metadata: {
+        layer: this.layer,
+        processingTime: Date.now() - startTime,
+        hops: 1,
+      },
+    }
+  }
+
+  private makeCodeDecision(
+    state: RoutingContext['state'],
+    requestText: string
+  ): Omit<RouteDecision, 'namespace' | 'metadata'> {
+    // 场景1: 编写测试
+    if (/test|测试|tdd|spec/i.test(requestText)) {
+      return {
+        skill: 'tdd',
+        confidence: 0.85,
+        reasoning: 'Code domain: test-related request',
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.3, reasoning: 'Quick test fix' },
+        ],
+      }
+    }
+
+    // 场景2: 重构代码
+    if (/refactor|重构|restructure|重组/i.test(requestText)) {
+      return {
+        skill: 'to-plan',
+        confidence: 0.8,
+        reasoning: 'Refactoring requires careful planning',
+        alternatives: [
+          { skill: 'review-diff', confidence: 0.4, reasoning: 'Review after refactor' },
+        ],
+      }
+    }
+
+    // 场景3: 修复代码错误
+    if (/fix.*code|修复.*代码|bug|fix.*error/i.test(requestText)) {
+      if (state.phase === 'executing') {
+        return {
+          skill: 'systematic-debugging',
+          confidence: 0.85,
+          reasoning: 'Code bug fix during execution',
+          alternatives: [
+            { skill: 'quick-task', confidence: 0.5, reasoning: 'Simple fix' },
+          ],
+        }
+      }
+      return {
+        skill: 'systematic-debugging',
+        confidence: 0.75,
+        reasoning: 'Code domain: debugging required',
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.4, reasoning: 'Quick fix attempt' },
+        ],
+      }
+    }
+
+    // 场景4: 新功能实现
+    if (/implement|实现|add.*feature|添加.*功能/i.test(requestText)) {
+      if (state.phase === 'executing') {
+        return {
+          skill: 'execute-plan',
+          confidence: 0.8,
+          reasoning: 'Code implementation during execution phase',
+          alternatives: [
+            { skill: 'tdd', confidence: 0.5, reasoning: 'Test-driven approach' },
+          ],
+        }
+      }
+
+      // 复杂实现需要计划
+      if (this.isComplexImplementation(requestText)) {
+        return {
+          skill: 'to-plan',
+          confidence: 0.75,
+          reasoning: 'Complex code implementation requires planning',
+          alternatives: [
+            { skill: 'tdd', confidence: 0.4, reasoning: 'TDD approach' },
+          ],
+        }
+      }
+
+      // 简单实现
+      return {
+        skill: 'quick-task',
+        confidence: 0.7,
+        reasoning: 'Simple code implementation',
+        alternatives: [
+          { skill: 'tdd', confidence: 0.5, reasoning: 'With tests' },
+        ],
+      }
+    }
+
+    // 场景5: 代码审查
+    if (/review.*code|审查.*代码|check.*code/i.test(requestText)) {
+      return {
+        skill: 'review-diff',
+        confidence: 0.85,
+        reasoning: 'Code review requested',
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.2, reasoning: 'Self-review' },
+        ],
+      }
+    }
+
+    // 默认
+    return {
+      skill: 'quick-task',
+      confidence: 0.4,
+      reasoning: 'Code domain: default to quick-task',
+      alternatives: [
+        { skill: 'tdd', confidence: 0.3, reasoning: 'With tests' },
+      ],
+    }
+  }
+
+  private isComplexImplementation(request: string): boolean {
+    const complexityMarkers = [
+      /multiple|多个/i,
+      /steps?|步骤/i,
+      /integration|集成/i,
+      /api|interface/i,
+      /database|数据库/i,
+      /state|状态/i,
+    ]
+
+    return complexityMarkers.filter((p) => p.test(request)).length >= 2
+  }
+
+  getSupportedSkills(): string[] {
+    return ['tdd', 'to-plan', 'execute-plan', 'systematic-debugging', 'quick-task', 'review-diff']
+  }
+
+  getHealth(): NamespaceHealth {
+    return {
+      name: this.name,
+      status: this.successRate() > 0.75 ? 'healthy' : 'degraded',
+      totalRoutes: this.routeCount,
+      successRate: this.successRate(),
+      avgLatency: this.routeCount > 0 ? this.totalLatency / this.routeCount : 0,
+    }
+  }
+
+  private successRate(): number {
+    return this.routeCount > 0 ? this.successCount / this.routeCount : 1.0
+  }
+}
+
+export const codeRouter = new CodeRouter()
+export default codeRouter

package/src/router/namespace/domain/debug-router.ts

@@ -0,0 +1,167 @@
+/**
+ * Debug Router - Domain Layer
+ *
+ * 处理调试相关的复杂路由决策
+ */
+
+import type {
+  NamespaceRouter,
+  RoutingContext,
+  RouteDecision,
+  NamespaceHealth,
+  AlternativeRoute,
+} from '../types.js'
+
+export class DebugRouter implements NamespaceRouter {
+  readonly name = 'debug'
+  readonly layer = 'domain' as const
+  readonly priority = 70
+  readonly patterns = [
+    /debug|调试/i,
+    /bug|错误|故障/i,
+    /error|异常/i,
+    /crash|崩溃/i,
+    /broken|损坏/i,
+    /not working|不工作/i,
+    /fail|失败/i,
+    /issue|问题/i,
+  ]
+
+  private routeCount = 0
+  private successCount = 0
+  private totalLatency = 0
+
+  async canRoute(context: RoutingContext): Promise<boolean> {
+    const text = context.request.text.toLowerCase()
+    return /debug|调试|bug|错误|error|异常|crash|崩溃|fail|失败|issue|问题|not working|不工作/.test(text)
+  }
+
+  async route(context: RoutingContext): Promise<RouteDecision> {
+    const startTime = Date.now()
+    const { state, request } = context
+
+    const decision = this.makeDebugDecision(state, request.text)
+
+    this.routeCount++
+    this.totalLatency += Date.now() - startTime
+    this.successCount++
+
+    return {
+      ...decision,
+      namespace: this.name,
+      metadata: {
+        layer: this.layer,
+        processingTime: Date.now() - startTime,
+        hops: 1,
+      },
+    }
+  }
+
+  private makeDebugDecision(
+    state: RoutingContext['state'],
+    requestText: string
+  ): Omit<RouteDecision, 'namespace' | 'metadata'> {
+    const urgency = this.calculateUrgency(requestText)
+
+    // 场景1: 系统性调试
+    if (/systematic|系统|root cause|根本原因|investigate|调查/i.test(requestText)) {
+      return {
+        skill: 'systematic-debugging',
+        confidence: 0.9,
+        reasoning: `Systematic debugging approach requested (urgency: ${urgency})`,
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.2, reasoning: 'Quick fix bypass' },
+        ],
+      }
+    }
+
+    // 场景2: 严重错误/崩溃
+    if (/crash|崩溃|critical|严重|production|生产/i.test(requestText)) {
+      return {
+        skill: 'systematic-debugging',
+        confidence: 0.95,
+        reasoning: `Critical issue detected: ${urgency} urgency`,
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.3, reasoning: 'Emergency fix' },
+        ],
+      }
+    }
+
+    // 场景3: 测试失败
+    if (/test.*fail|测试.*失败|failing test/i.test(requestText)) {
+      return {
+        skill: 'tdd',
+        confidence: 0.8,
+        reasoning: 'Test failure: TDD skill can help',
+        alternatives: [
+          { skill: 'systematic-debugging', confidence: 0.6, reasoning: 'Deep investigation' },
+        ],
+      }
+    }
+
+    // 场景4: 执行阶段的问题
+    if (state.phase === 'executing') {
+      return {
+        skill: 'systematic-debugging',
+        confidence: 0.85,
+        reasoning: `Debug during execution phase: ${state.phase}`,
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.4, reasoning: 'Quick workaround' },
+        ],
+      }
+    }
+
+    // 场景5: 验证阶段的问题
+    if (state.phase === 'verifying') {
+      return {
+        skill: 'systematic-debugging',
+        confidence: 0.85,
+        reasoning: 'Debug during verification phase',
+        alternatives: [
+          { skill: 'review-diff', confidence: 0.4, reasoning: 'Review first' },
+        ],
+      }
+    }
+
+    // 场景6: 一般性调试
+    return {
+      skill: 'systematic-debugging',
+      confidence: 0.75,
+      reasoning: `General debugging request (urgency: ${urgency})`,
+      alternatives: [
+        { skill: 'quick-task', confidence: 0.5, reasoning: 'Quick fix attempt' },
+        { skill: 'review-diff', confidence: 0.3, reasoning: 'Check recent changes' },
+      ],
+    }
+  }
+
+  private calculateUrgency(request: string): 'high' | 'medium' | 'low' {
+    const highUrgency = [/critical|严重|urgent|紧急|production|生产|crash|崩溃|outage|中断/i]
+    const mediumUrgency = [/bug|错误|error|异常|issue|问题|fail|失败/i]
+
+    if (highUrgency.some((p) => p.test(request))) return 'high'
+    if (mediumUrgency.some((p) => p.test(request))) return 'medium'
+    return 'low'
+  }
+
+  getSupportedSkills(): string[] {
+    return ['systematic-debugging', 'quick-task', 'tdd', 'review-diff']
+  }
+
+  getHealth(): NamespaceHealth {
+    return {
+      name: this.name,
+      status: this.successRate() > 0.8 ? 'healthy' : 'degraded',
+      totalRoutes: this.routeCount,
+      successRate: this.successRate(),
+      avgLatency: this.routeCount > 0 ? this.totalLatency / this.routeCount : 0,
+    }
+  }
+
+  private successRate(): number {
+    return this.routeCount > 0 ? this.successCount / this.routeCount : 1.0
+  }
+}
+
+export const debugRouter = new DebugRouter()
+export default debugRouter

package/src/router/namespace/domain/plan-router.ts

@@ -0,0 +1,196 @@
+/**
+ * Plan Router - Domain Layer
+ *
+ * 处理计划相关的复杂路由决策
+ * 包括：创建计划、执行计划、验证计划
+ */
+
+import type {
+  NamespaceRouter,
+  RoutingContext,
+  RouteDecision,
+  NamespaceHealth,
+  AlternativeRoute,
+} from '../types.js'
+
+export class PlanRouter implements NamespaceRouter {
+  readonly name = 'plan'
+  readonly layer = 'domain' as const
+  readonly priority = 70
+  readonly patterns = [
+    /plan|计划/i,
+    /wave|波次/i,
+    /task|任务/i,
+    /milestone|里程碑/i,
+    /phase|阶段/i,
+  ]
+
+  private routeCount = 0
+  private successCount = 0
+  private totalLatency = 0
+
+  async canRoute(context: RoutingContext): Promise<boolean> {
+    // 如果涉及到 plan 相关操作
+    const text = context.request.text.toLowerCase()
+    return (
+      /plan|计划|wave|任务|milestone|阶段/.test(text) ||
+      context.plan !== null
+    )
+  }
+
+  async route(context: RoutingContext): Promise<RouteDecision> {
+    const startTime = Date.now()
+    const { state, plan, request } = context
+
+    const decision = this.makePlanDecision(state, plan, request.text)
+
+    this.routeCount++
+    this.totalLatency += Date.now() - startTime
+    this.successCount++
+
+    return {
+      ...decision,
+      namespace: this.name,
+      metadata: {
+        layer: this.layer,
+        processingTime: Date.now() - startTime,
+        hops: 1,
+      },
+    }
+  }
+
+  private makePlanDecision(
+    state: RoutingContext['state'],
+    plan: RoutingContext['plan'],
+    requestText: string
+  ): Omit<RouteDecision, 'namespace' | 'metadata'> {
+    const alternatives: AlternativeRoute[] = []
+
+    // 场景1: 创建新计划
+    if (/create.*plan|new.*plan|开始.*计划|创建.*计划/i.test(requestText)) {
+      return {
+        skill: 'to-plan',
+        confidence: 0.9,
+        reasoning: 'User explicitly requested to create a new plan',
+        alternatives: [
+          { skill: 'research', confidence: 0.3, reasoning: 'If need background research' },
+        ],
+      }
+    }
+
+    // 场景2: 执行现有计划
+    if (plan && /execute.*plan|run.*plan|执行.*计划|运行.*计划/i.test(requestText)) {
+      return {
+        skill: 'execute-plan',
+        confidence: 0.9,
+        reasoning: `Execute existing plan with ${plan.tasks?.length || 0} tasks`,
+        alternatives: [
+          { skill: 'review-diff', confidence: 0.2, reasoning: 'Review before execute' },
+        ],
+      }
+    }
+
+    // 场景3: 验证计划完成情况
+    if (plan && state.phase === 'verifying') {
+      const completed = state.completedTasks?.length || 0
+      const total = plan.tasks?.length || 0
+
+      if (completed >= total) {
+        return {
+          skill: 'review-diff',
+          confidence: 0.85,
+          reasoning: `Plan complete (${completed}/${total}), verification needed`,
+          alternatives: [
+            { skill: 'systematic-debugging', confidence: 0.3, reasoning: 'If issues found' },
+          ],
+        }
+      }
+    }
+
+    // 场景4: 计划执行中途
+    if (plan && state.phase === 'executing') {
+      const completed = state.completedTasks?.length || 0
+      const total = plan.tasks?.length || 0
+
+      return {
+        skill: 'execute-plan',
+        confidence: 0.85,
+        reasoning: `Continue execution: ${completed}/${total} tasks done`,
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.4, reasoning: 'Quick bypass' },
+        ],
+      }
+    }
+
+    // 场景5: 修改/更新计划
+    if (plan && /update.*plan|modify.*plan|revise|调整.*计划/i.test(requestText)) {
+      return {
+        skill: 'to-plan',
+        confidence: 0.8,
+        reasoning: 'Update existing plan based on user request',
+        alternatives: [
+          { skill: 'execute-plan', confidence: 0.3, reasoning: 'Continue with current plan' },
+        ],
+      }
+    }
+
+    // 场景6: 无计划但请求复杂
+    if (!plan && this.isPlanWorthy(requestText)) {
+      return {
+        skill: 'to-plan',
+        confidence: 0.75,
+        reasoning: 'No plan exists, request warrants planning',
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.4, reasoning: 'Direct approach' },
+          { skill: 'research', confidence: 0.3, reasoning: 'Gather info first' },
+        ],
+      }
+    }
+
+    // 默认
+    return {
+      skill: 'quick-task',
+      confidence: 0.3,
+      reasoning: 'Plan domain: no specific plan action matched',
+      alternatives: [],
+    }
+  }
+
+  /**
+   * 判断是否值得创建计划
+   */
+  private isPlanWorthy(request: string): boolean {
+    const indicators = [
+      /implement|实现/i,
+      /feature|功能/i,
+      /refactor|重构/i,
+      /migration|迁移/i,
+      /upgrade|升级/i,
+      /and|和|then|然后.*(add|create|fix|update)/i,
+    ]
+
+    const matches = indicators.filter((p) => p.test(request)).length
+    return matches >= 2 || request.length > 120
+  }
+
+  getSupportedSkills(): string[] {
+    return ['to-plan', 'execute-plan', 'quick-task', 'review-diff', 'research']
+  }
+
+  getHealth(): NamespaceHealth {
+    return {
+      name: this.name,
+      status: this.successRate() > 0.8 ? 'healthy' : 'degraded',
+      totalRoutes: this.routeCount,
+      successRate: this.successRate(),
+      avgLatency: this.routeCount > 0 ? this.totalLatency / this.routeCount : 0,
+    }
+  }
+
+  private successRate(): number {
+    return this.routeCount > 0 ? this.successCount / this.routeCount : 1.0
+  }
+}
+
+export const planRouter = new PlanRouter()
+export default planRouter

package/src/router/namespace/domain/review-router.ts

@@ -0,0 +1,142 @@
+/**
+ * Review Router - Domain Layer
+ *
+ * 处理代码审查相关的复杂路由决策
+ */
+
+import type {
+  NamespaceRouter,
+  RoutingContext,
+  RouteDecision,
+  NamespaceHealth,
+  AlternativeRoute,
+} from '../types.js'
+
+export class ReviewRouter implements NamespaceRouter {
+  readonly name = 'review'
+  readonly layer = 'domain' as const
+  readonly priority = 65
+  readonly patterns = [
+    /review|审查/i,
+    /audit|审核/i,
+    /check|检查/i,
+    /quality|质量/i,
+    /code review|代码审查/i,
+    /pr|pull request/i,
+    /merge|合并/i,
+  ]
+
+  private routeCount = 0
+  private successCount = 0
+  private totalLatency = 0
+
+  async canRoute(context: RoutingContext): Promise<boolean> {
+    const text = context.request.text.toLowerCase()
+    return /review|审查|audit|审核|check|检查|quality|质量|code review|代码审查|pr|pull request|merge|合并/.test(text)
+  }
+
+  async route(context: RoutingContext): Promise<RouteDecision> {
+    const startTime = Date.now()
+    const { state, request } = context
+
+    const decision = this.makeReviewDecision(state, request.text)
+
+    this.routeCount++
+    this.totalLatency += Date.now() - startTime
+    this.successCount++
+
+    return {
+      ...decision,
+      namespace: this.name,
+      metadata: {
+        layer: this.layer,
+        processingTime: Date.now() - startTime,
+        hops: 1,
+      },
+    }
+  }
+
+  private makeReviewDecision(
+    state: RoutingContext['state'],
+    requestText: string
+  ): Omit<RouteDecision, 'namespace' | 'metadata'> {
+    // 场景1: PR 审查
+    if (/pr|pull request|merge|合并|review.*change/i.test(requestText)) {
+      return {
+        skill: 'review-diff',
+        confidence: 0.9,
+        reasoning: 'PR/Merge review request',
+        alternatives: [
+          { skill: 'quick-task', confidence: 0.2, reasoning: 'Quick approval' },
+        ],
+      }
+    }
+
+    // 场景2: 代码质量检查
+    if (/quality|质量|audit|审核|check.*code/i.test(requestText)) {
+      return {
+        skill: 'review-diff',
+        confidence: 0.85,
+        reasoning: 'Code quality audit',
+        alternatives: [
+          { skill: 'systematic-debugging', confidence: 0.3, reasoning: 'If issues found' },
+        ],
+      }
+    }
+
+    // 场景3: 验证阶段
+    if (state.phase === 'verifying') {
+      return {
+        skill: 'review-diff',
+        confidence: 0.9,
+        reasoning: 'Verification phase: code review required',
+        alternatives: [
+          { skill: 'systematic-debugging', confidence: 0.4, reasoning: 'Fix issues' },
+        ],
+      }
+    }
+
+    // 场景4: 完成阶段
+    if (state.phase === 'completed') {
+      return {
+        skill: 'review-diff',
+        confidence: 0.8,
+        reasoning: 'Final review before completion',
+        alternatives: [
+          { skill: 'agents-md', confidence: 0.3, reasoning: 'Update docs' },
+        ],
+      }
+    }
+
+    // 场景5: 一般性审查
+    return {
+      skill: 'review-diff',
+      confidence: 0.75,
+      reasoning: 'General review request',
+      alternatives: [
+        { skill: 'quick-task', confidence: 0.3, reasoning: 'Quick scan' },
+      ],
+    }
+  }
+
+  getSupportedSkills(): string[] {
+    return ['review-diff', 'quick-task', 'systematic-debugging', 'agents-md']
+  }
+
+  getHealth(): NamespaceHealth {
+    return {
+      name: this.name,
+      status: this.successRate() > 0.8 ? 'healthy' : 'degraded',
+      totalRoutes: this.routeCount,
+      successRate: this.successRate(),
+      avgLatency: this.routeCount > 0 ? this.totalLatency / this.routeCount : 0,
+    }
+  }
+
+  private successRate(): number {
+    return this.routeCount > 0 ? this.successCount / this.routeCount : 1.0
+  }
+}
+
+export const reviewRouter = new ReviewRouter()
+export default reviewRouter