pmat 3.11.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Core implementation methods for RoadmapTodoGenerator
// Included by generator.rs - shares parent module scope

impl RoadmapTodoGenerator {
    /// Create new generator with quality configuration
    #[must_use]
    pub fn new(quality_config: QualityGateConfig) -> Self {
        Self {
            pdmt_service: PdmtService::new(),
            quality_config,
        }
    }

    /// Generate todos from a single task
    pub fn generate_todos_from_task(
        &mut self,
        task: &RoadmapTask,
    ) -> Result<Vec<QualityEnforcedTodo>> {
        let mut todos = Vec::new();

        // Create main implementation todo
        let todo = self.create_quality_enforced_todo(task, 1);
        todos.push(todo);

        // Create additional testing tasks for complex work
        if task.estimated_hours > 4.0 {
            let test_todo = QualityEnforcedTodo {
                id: format!("{}-test", task.id),
                task_id: task.id.clone(),
                description: format!("Comprehensive testing for {}", task.title),
                implementation_spec: "Add comprehensive test coverage".to_string(),
                quality_requirements: QualityRequirements::default(),
                validation_commands: vec!["cargo test".to_string()],
                success_criteria: vec!["Test coverage >80%".to_string()],
                estimated_time: Duration::from_secs_f64(task.estimated_hours * 0.5 * 3600.0),
                dependencies: vec![task.id.clone()],
            };
            todos.push(test_todo);
        }

        Ok(todos)
    }

    /// Generate todos from entire sprint
    pub fn generate_todos_from_sprint(
        &mut self,
        sprint: &Sprint,
    ) -> Result<Vec<QualityEnforcedTodo>> {
        let mut all_todos = Vec::new();

        for task in &sprint.tasks {
            // Convert Task to RoadmapTask
            let roadmap_task = RoadmapTask {
                id: task.id.clone(),
                title: task.description.clone(),
                description: task.description.clone(),
                status: task.status,
                priority: task.priority,
                estimated_hours: match task.complexity {
                    Complexity::Low => 2.0,
                    Complexity::Medium => 4.0,
                    Complexity::High => 8.0,
                },
                assigned_to: task.assignee.clone(),
                dependencies: Vec::new(),
                tags: Vec::new(),
            };

            let task_todos = self.generate_todos_from_task(&roadmap_task)?;
            all_todos.extend(task_todos);
        }

        Ok(all_todos)
    }

    /// Create quality-enforced todo from task
    #[must_use]
    pub fn create_quality_enforced_todo(
        &self,
        task: &RoadmapTask,
        sequence: usize,
    ) -> QualityEnforcedTodo {
        QualityEnforcedTodo {
            id: format!("{}-{}", task.id, sequence),
            task_id: task.id.clone(),
            description: task.description.clone(),
            implementation_spec: format!("Implement {} with TDD methodology", task.title),
            quality_requirements: QualityRequirements::default(),
            validation_commands: self.generate_validation_commands(task),
            success_criteria: self.generate_success_criteria(task),
            estimated_time: Duration::from_secs_f64(task.estimated_hours * 3600.0),
            dependencies: task.dependencies.clone(),
        }
    }

    /// Generate validation commands for task
    #[must_use]
    pub fn generate_validation_commands(&self, task: &RoadmapTask) -> Vec<String> {
        let mut commands = vec![
            "cargo test".to_string(),
            "cargo clippy -- -D warnings".to_string(),
            "cargo fmt --check".to_string(),
        ];

        if task.tags.contains(&"backend".to_string()) {
            commands.push("cargo doc --no-deps".to_string());
        }

        if task.tags.contains(&"api".to_string()) {
            commands.push("cargo test --test integration".to_string());
        }

        commands
    }

    /// Generate success criteria for task
    #[must_use]
    pub fn generate_success_criteria(&self, task: &RoadmapTask) -> Vec<String> {
        let mut criteria = vec![
            "All tests pass".to_string(),
            "Code coverage >80%".to_string(),
            "Zero SATD violations".to_string(),
            "Lint checks pass".to_string(),
        ];

        if task.priority == Priority::P0 {
            criteria.push("Performance benchmarks pass".to_string());
        }

        if task.estimated_hours > 8.0 {
            criteria.push("Documentation updated".to_string());
            criteria.push("Integration tests pass".to_string());
        }

        criteria
    }
}