cqt-agent
Version:
332 lines (293 loc) • 13.2 kB
Markdown
# Task Grouping Analyzer
## ⚠️ CRITICAL EXECUTION NOTICE ⚠️
**THIS IS AN EXECUTABLE WORKFLOW - NOT REFERENCE MATERIAL**
When this task is invoked:
1. **RELATIONSHIP ANALYSIS** - Deep analysis of task dependencies and relationships
2. **INTELLIGENT GROUPING** - Create logical implementation groups for coordinated execution
3. **COORDINATION PLANNING** - Determine optimal agent assignment and execution order
4. **DEPENDENCY MAPPING** - Build complete dependency graph for workflow planning
## Overview
This workflow performs comprehensive analysis of imported tasks to create intelligent groupings that optimize implementation coordination, minimize dependencies conflicts, and ensure efficient agent utilization.
## Input Parameters
### Required Parameters
- **tasks_data**: Array of imported task objects with full Azure DevOps metadata
- **workflow_context**: Current workflow state and coordination requirements
### Optional Parameters
- **grouping_strategy**: "technical" | "functional" | "hybrid" (default: "hybrid")
- **max_group_size**: integer (default: 5) - Maximum tasks per group
- **coordination_complexity**: "simple" | "standard" | "complex" (default: "standard")
## Execution Steps
### Phase 1: Task Relationship Discovery
```yaml
step: relationship_analysis
description: Analyze all relationships between imported tasks
actions:
- link_analysis: Extract parent/child, predecessor/successor relationships
- epic_feature_mapping: Group tasks by Epic/Feature hierarchy
- work_item_type_analysis: Categorize by Task, Bug, User Story, etc.
- assignee_analysis: Identify team/developer assignments
- area_path_analysis: Group by product area or component
- iteration_analysis: Consider sprint/iteration assignments
relationship_types:
- hierarchical: "Parent-Child, Epic-Feature-Task relationships"
- sequential: "Predecessor-Successor, blocking dependencies"
- technical: "Same component, API contract dependencies"
- functional: "Same feature area, user journey relationships"
- team: "Same assignee, same team assignments"
output:
relationship_graph:
nodes: "List of all tasks with metadata"
edges: "Relationships with type and strength scoring"
clusters: "Preliminary grouping based on relationship strength"
```
### Phase 2: User Story & Domain Analysis
```yaml
step: user_story_domain_analysis
description: Analyze tasks by user stories and business domains for proper grouping
actions:
- user_story_extraction: Extract user stories and acceptance criteria from tasks
- domain_identification: Identify business domain and feature area
- user_journey_mapping: Map tasks to complete user journeys
- feature_scope_analysis: Determine feature boundaries and scope
- domain_expertise_requirements: Identify required domain knowledge
domain_based_grouping:
user_story_focus:
- primary_user_story: "Main user story being implemented"
- related_user_stories: "Connected user stories in same feature"
- user_journey_phase: "Which part of user journey this supports"
- acceptance_criteria: "User acceptance criteria defining success"
business_domain:
- domain_area: "Business domain (payments, user management, notifications, etc.)"
- feature_module: "Specific feature module within domain"
- stakeholder_group: "Primary stakeholders affected"
- business_value: "Business value delivered by this group"
technical_specialization:
- frontend_focus: "Frontend tasks grouped by user interface flows"
- backend_focus: "Backend tasks grouped by business logic domains"
- integration_focus: "Integration tasks grouped by data flow"
- testing_focus: "Testing tasks grouped by user scenario validation"
grouping_strategy:
- user_story_cohesion: "Group tasks that belong to same user story"
- domain_expertise: "Group tasks requiring same domain knowledge"
- frontend_user_flows: "Frontend tasks grouped by user interface flows"
- backend_business_logic: "Backend tasks grouped by business domain logic"
- end_to_end_features: "Complete features from frontend to backend"
```
### Phase 3: Intelligent Grouping Algorithm
```yaml
step: intelligent_grouping
description: Create optimal groups using hybrid algorithm
actions:
- dependency_graph_analysis: Build complete dependency graph
- critical_path_identification: Identify critical path through dependencies
- coordination_minimization: Group to minimize cross-group coordination
- agent_workload_balancing: Distribute work evenly across agents
- implementation_order_optimization: Order groups for optimal execution flow
grouping_algorithm:
1. primary_clustering: "Group by strongest relationships (Epic/Feature)"
2. technical_separation: "Separate by technical stack to avoid conflicts"
3. dependency_ordering: "Order groups by dependency requirements"
4. coordination_optimization: "Minimize required cross-group communication"
5. size_balancing: "Balance group sizes for parallel execution"
6. complexity_distribution: "Distribute complexity evenly across groups"
group_validation:
- dependency_conflicts: "Ensure no circular dependencies between groups"
- coordination_feasibility: "Verify coordination requirements are manageable"
- implementation_feasibility: "Confirm groups can be implemented by assigned agents"
- size_constraints: "Ensure groups fit within size limits"
```
### Phase 4: Coordination Planning
```yaml
step: coordination_planning
description: Plan agent coordination and execution sequence
actions:
- execution_sequence: Determine optimal group execution order
- agent_assignment: Assign primary and supporting agents to each group
- handoff_planning: Plan data handoffs between groups and agents
- coordination_checkpoints: Identify points requiring coordination
- parallel_execution_opportunities: Identify groups that can run in parallel
coordination_strategy:
sequential_groups:
- dependencies: "Groups with hard dependencies must execute in sequence"
- data_flow: "Groups that produce data for other groups"
- validation_gates: "Groups requiring validation before subsequent groups"
parallel_groups:
- independent: "Groups with no dependencies can run in parallel"
- different_stacks: "Frontend and backend groups can often run in parallel"
- separate_components: "Different product areas can run in parallel"
agent_coordination:
primary_agent: "Main agent responsible for group implementation"
supporting_agents: "Agents providing assistance or validation"
coordination_agent: "Agent managing handoffs and integration"
```
### Phase 5: Group Optimization
```yaml
step: group_optimization
description: Optimize groups for maximum efficiency and coordination
actions:
- dependency_minimization: Reduce cross-group dependencies where possible
- coordination_simplification: Simplify coordination requirements
- parallelization_maximization: Increase opportunities for parallel execution
- resource_optimization: Optimize agent utilization and workload distribution
optimization_criteria:
- minimize_dependencies: "Reduce number of cross-group dependencies"
- maximize_parallelism: "Increase groups that can execute in parallel"
- balance_complexity: "Distribute implementation complexity evenly"
- optimize_coordination: "Minimize required coordination overhead"
- ensure_quality: "Maintain quality standards and validation gates"
validation_checks:
- dependency_integrity: "Verify all dependencies are properly handled"
- coordination_feasibility: "Ensure coordination plan is executable"
- quality_standards: "Confirm all groups meet Hubtel quality standards"
- agent_capability: "Verify assigned agents can handle group requirements"
```
## Output Format
### Group Analysis Results
```yaml
grouping_results:
summary:
total_tasks: 4
groups_created: 3
dependency_chains: 2
parallel_opportunities: 1
coordination_complexity: "standard"
groups:
- group_id: "backend-api-implementation"
tasks: ["AZ-123", "AZ-125"]
category: "backend"
complexity: 4
estimated_effort: "2 hours"
primary_agent: "hubtel-backend-dev"
supporting_agents: []
coordination_agent: "hubtel-integration-coordinator"
dependencies: []
provides_data_to: ["frontend-ui-implementation", "testing-validation"]
technical_scope:
- "REST API endpoints"
- "Entity Framework models"
- "Database migrations"
- "Karate API tests"
coordination_requirements:
- "API contract definition for frontend"
- "Database schema coordination"
- "OpenTelemetry configuration"
- group_id: "frontend-ui-implementation"
tasks: ["AZ-124"]
category: "frontend"
complexity: 3
estimated_effort: "1 hour"
primary_agent: "hubtel-frontend-dev"
supporting_agents: []
coordination_agent: "hubtel-integration-coordinator"
dependencies: ["backend-api-implementation"]
provides_data_to: ["testing-validation"]
technical_scope:
- "Next.js/Nuxt.js components"
- "API integration"
- "Responsive design"
- "Vitest unit tests"
coordination_requirements:
- "API contract consumption"
- "UI/UX consistency"
- "State management integration"
- group_id: "testing-validation"
tasks: ["AZ-126"]
category: "testing"
complexity: 2
estimated_effort: "1 hour"
primary_agent: "hubtel-test-engineer"
supporting_agents: ["hubtel-backend-dev", "hubtel-frontend-dev"]
coordination_agent: "hubtel-test-engineer"
dependencies: ["backend-api-implementation", "frontend-ui-implementation"]
provides_data_to: []
technical_scope:
- "Integration test suite"
- "E2E Playwright tests"
- "Coverage validation"
- "Quality gates"
coordination_requirements:
- "Test data coordination"
- "Environment setup"
- "Coverage reporting"
```
### Coordination Plan
```yaml
coordination_plan:
execution_sequence:
phase_1:
groups: ["backend-api-implementation"]
parallel: false
rationale: "Foundation APIs required for other groups"
coordination_checkpoints:
- "API contract finalization"
- "Database schema validation"
phase_2:
groups: ["frontend-ui-implementation"]
parallel: false
rationale: "Depends on API contracts from phase 1"
coordination_checkpoints:
- "API integration validation"
- "UI component completion"
phase_3:
groups: ["testing-validation"]
parallel: false
rationale: "Requires completed implementation from phases 1 & 2"
coordination_checkpoints:
- "Test suite execution"
- "Coverage validation"
- "Quality gate completion"
agent_handoffs:
- from_agent: "batch-azure-processor"
to_agent: "hubtel-task-processor"
data_package: "Enhanced task definitions with group context"
trigger: "Grouping analysis complete"
- from_agent: "hubtel-task-processor"
to_agent: "hubtel-backend-dev"
data_package: "Backend group tasks with implementation details"
trigger: "Task enhancement complete"
- from_agent: "hubtel-backend-dev"
to_agent: "hubtel-integration-coordinator"
data_package: "API contracts and database schema"
trigger: "Backend implementation complete"
```
### Dependency Graph
```yaml
dependency_graph:
nodes:
- id: "AZ-123"
type: "backend_task"
group: "backend-api-implementation"
dependencies: []
dependents: ["AZ-124", "AZ-126"]
- id: "AZ-124"
type: "frontend_task"
group: "frontend-ui-implementation"
dependencies: ["AZ-123"]
dependents: ["AZ-126"]
- id: "AZ-125"
type: "backend_task"
group: "backend-api-implementation"
dependencies: []
dependents: ["AZ-126"]
- id: "AZ-126"
type: "testing_task"
group: "testing-validation"
dependencies: ["AZ-123", "AZ-124", "AZ-125"]
dependents: []
critical_path: ["AZ-123", "AZ-124", "AZ-126"]
parallel_opportunities: [["AZ-123", "AZ-125"]]
coordination_points: ["API_contract_definition", "Integration_validation", "Testing_coordination"]
```
## Integration Points
### Workflow Integration
- **Input source**: `batch-azure-processor` provides raw task data
- **Output target**: `workflow-orchestrator` receives optimized groups
- **Coordination**: Seamless handoff with complete group context
### Agent Coordination
- **Group assignments**: Each group assigned to optimal specialized agent
- **Coordination agents**: Integration coordinator manages cross-group coordination
- **Handoff data**: Complete implementation context provided to each agent
### Quality Assurance
- **Dependency validation**: All dependencies properly mapped and validated
- **Coordination feasibility**: All coordination requirements verified as manageable
- **Implementation readiness**: Groups ready for immediate implementation by assigned agents