[Feature] Task Management Tool for CodingAgent (mpp-core)

[phodal]

Overview

Design and implement a Task Management system for CodingAgent in mpp-core, similar to Augment's task management capabilities. This will allow the AI agent to create, update, and track task plans during execution.

Background

Currently, the IDEA plugin has a planning system implemented in:

• core/src/main/kotlin/cc/unitmesh/devti/gui/planner/AutoDevPlannerToolWindow.kt - UI for displaying plans
• core/src/main/kotlin/cc/unitmesh/devti/observer/plan/MarkdownPlanParser.kt - Parses markdown plans
• core/src/main/kotlin/cc/unitmesh/devti/observer/plan/AgentTaskEntry.kt - Task data model
• core/src/main/resources/genius/en/code/plan.vm - Plan prompt template

The mpp-core already has a basic TaskBoundaryTool at mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl/TaskBoundaryTool.kt, but it lacks the full planning capabilities.

Requirements

1. Core Data Models (mpp-core)

Create multiplatform-compatible data models:

// mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/plan/

@Serializable
enum class TaskStatus {
    TODO,
    IN_PROGRESS,
    COMPLETED,
    FAILED,
    BLOCKED
}

@Serializable
enum class PlanPhase {
    PLAN,   // Planning phase
    DO,     // Execution phase  
    CHECK,  // Verification phase
    ACT     // Action phase
}

@Serializable
data class PlanStep(
    val id: String,
    val description: String,
    var status: TaskStatus = TaskStatus.TODO,
    val codeFileLinks: List<CodeFileLink> = emptyList()
)

@Serializable
data class PlanTask(
    val id: String,
    val title: String,
    val steps: List<PlanStep>,
    var status: TaskStatus = TaskStatus.TODO,
    var phase: PlanPhase = PlanPhase.PLAN
)

@Serializable
data class AgentPlan(
    val id: String,
    val tasks: MutableList<PlanTask>,
    val createdAt: Long,
    var updatedAt: Long
)

2. Plan Management Tool (mpp-core)

Create a new tool for plan management:

// mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl/PlanManagementTool.kt

@Serializable
data class PlanManagementParams(
    val action: String,  // "create", "update", "add_task", "update_task", "complete_step"
    val planId: String? = null,
    val taskId: String? = null,
    val stepId: String? = null,
    val title: String? = null,
    val description: String? = null,
    val status: String? = null,
    val tasks: List<PlanTaskInput>? = null
)

class PlanManagementTool : BaseExecutableTool<PlanManagementParams, ToolResult>() {
    override val name = "plan"
    override val description = """
        Manage task plans for complex multi-step work.
        
        Actions:
        - create: Create a new plan with tasks
        - add_task: Add a task to existing plan
        - update_task: Update task status/details
        - complete_step: Mark a step as completed
        - view: View current plan status
    """.trimIndent()
}

3. Markdown Plan Parser (mpp-core)

Port the MarkdownPlanParser to multiplatform:

// mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/plan/MarkdownPlanParser.kt

object MarkdownPlanParser {
    // Task markers: [✓] completed, [!] failed, [*] in-progress, [ ] todo
    private val TASK_PATTERN = Regex("^\\s*-\\s*\\[\\s*([xX!*✓]?)\\s*\\]\\s*(.*)")
    private val SECTION_PATTERN = Regex("^(\\d+)\\.\\s*(?:\\[([xX!*✓]?)\\]\\s*)?(.+?)")
    
    fun parse(content: String): List<PlanTask>
    fun formatToMarkdown(tasks: List<PlanTask>): String
}

4. Plan State Service (mpp-core)

// mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/plan/PlanStateService.kt

class PlanStateService {
    private var currentPlan: AgentPlan? = null
    private val listeners = mutableListOf<PlanUpdateListener>()
    
    fun createPlan(tasks: List<PlanTask>): AgentPlan
    fun updateTask(taskId: String, status: TaskStatus)
    fun completeStep(taskId: String, stepId: String)
    fun getCurrentPlan(): AgentPlan?
    fun addListener(listener: PlanUpdateListener)
}

interface PlanUpdateListener {
    fun onPlanUpdated(plan: AgentPlan)
    fun onTaskUpdated(task: PlanTask)
    fun onStepCompleted(taskId: String, stepId: String)
}

5. System Prompt Integration

Update CodingAgentPromptRenderer to include plan instructions:

// Add to system prompt
val planInstructions = """
<plan>
For complex tasks, create a plan using the plan tool:

1. Analyze the user's request and break it into tasks
2. Each task should have clear steps with status markers:
   - [ ] Todo step
   - [*] In-progress step  
   - [✓] Completed step
   - [!] Failed step

3. Update task status as you progress
4. Include file references: [FileName](filepath)

Example plan format:
```plan
1. Analyze existing code
   - [✓] Review project structure
   - [*] Identify relevant files
   - [ ] Document dependencies
2. Implement feature
   - [ ] Create new module
   - [ ] Add tests

""" ```

6. UI Components (mpp-ui)

6.1 Plan Sketch Renderer

// mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/sketch/PlanSketchRenderer.kt

@Composable
fun PlanSketchRenderer(
    plan: AgentPlan,
    onTaskClick: (PlanTask) -> Unit,
    onStepToggle: (String, String) -> Unit,
    modifier: Modifier = Modifier
)

6.2 Task Progress Indicator

@Composable
fun TaskProgressIndicator(
    task: PlanTask,
    modifier: Modifier = Modifier
) {
    val completedSteps = task.steps.count { it.status == TaskStatus.COMPLETED }
    val totalSteps = task.steps.size
    
    Row(verticalAlignment = Alignment.CenterVertically) {
        StatusIcon(task.status)
        Text("${task.title} ($completedSteps/$totalSteps)")
        LinearProgressIndicator(
            progress = completedSteps.toFloat() / totalSteps
        )
    }
}

6.3 Plan Panel Component

// mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/panel/PlanPanel.kt

@Composable
fun PlanPanel(
    planState: PlanStateService,
    isCollapsed: Boolean = false,
    onToggleCollapse: () -> Unit,
    modifier: Modifier = Modifier
)

Implementation Tasks

Phase 1: Core Data Models & Parser

• Create AgentPlan, PlanTask, PlanStep data models
• Port MarkdownPlanParser to multiplatform (without IntelliJ dependencies)
• Create PlanStateService for state management
• Add unit tests for parser and state service

Phase 2: Tool Implementation

• Implement PlanManagementTool with all actions
• Integrate with ToolRegistry
• Update CodingAgentPromptRenderer with plan instructions
• Add tool to CodingAgent initialization

Phase 3: UI Components (mpp-ui)

• Create PlanSketchRenderer Compose component
• Create TaskProgressIndicator component
• Create PlanPanel for sidebar display
• Integrate with ContentRenderer for plan code blocks

Phase 4: Integration & Testing

• Connect PlanStateService to UI via StateFlow
• Add real-time plan updates during agent execution
• Test on Desktop, JS/WASM platforms
• Add E2E tests for plan workflow

Design Considerations

Multiplatform Compatibility

• Use kotlinx.serialization for all data models
• Avoid platform-specific APIs in core module
• Use expect/actual for platform-specific implementations if needed

State Management

• Use StateFlow for reactive updates
• Support both push (agent updates) and pull (UI queries) patterns

UI/UX

• Collapsible plan panel to save space
• Real-time progress updates
• Click-to-navigate for file links
• Status icons with semantic colors

References

• Existing IDEA implementation: core/src/main/kotlin/cc/unitmesh/devti/gui/planner/
• TaskBoundaryTool: mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/tool/impl/TaskBoundaryTool.kt
• Plan prompt template: core/src/main/resources/genius/en/code/plan.vm
• Augment's task management as inspiration

Acceptance Criteria

1. Agent can create plans with multiple tasks and steps
2. Plans are displayed in UI with real-time updates
3. Task/step status can be updated programmatically
4. Markdown plan format is parsed correctly
5. Works on Desktop JVM, JS, and WASM platforms
6. Unit tests cover parser and state management

/cc @phodal