command_plan_list.go

package tasked

import (
	"fmt"

	"github.com/dhamidi/tasked/planner"
	"github.com/spf13/cobra"
)

var PlanListCmd = &cobra.Command{
	Use:   "list",
	Short: "List all plans grouped by context",
	Long: `List all existing plans showing their names, completion status (DONE/TODO),
and task count information. Plans are grouped by project context, and plans matching
the current directory context are highlighted.`,
	RunE: RunPlanList,
}

func RunPlanList(cmd *cobra.Command, args []string) error {
	// Get the database file path from settings
	dbPath := GlobalSettings.GetDatabaseFile()

	// Detect context
	currentCtx, err := GlobalSettings.GetOrCreateContext()
	if err != nil {
		fmt.Printf("Warning: could not detect current context: %v\n", err)
	}

	// Get current context path for comparison
	var currentContextPath string
	if currentCtx != nil {
		currentContextPath = currentCtx.CurrentPath
		if currentCtx.IsGitRepo {
			currentContextPath = currentCtx.GitRoot
		}
	}

	// Initialize the planner
	p, err := planner.New(dbPath)
	if err != nil {
		return fmt.Errorf("failed to initialize planner: %w", err)
	}
	defer p.Close()

	// Get all plans using the List method
	plans, err := p.List()
	if err != nil {
		return fmt.Errorf("failed to list plans: %w", err)
	}

	// Handle empty list gracefully
	if len(plans) == 0 {
		fmt.Println("No plans found.")
		return nil
	}

	// Group plans by context path and project name
	type groupKey struct {
		ContextPath string
		ProjectName string
	}
	plansByGroup := make(map[groupKey][]planner.PlanInfo)

	for _, plan := range plans {
		key := groupKey{
			ContextPath: plan.ContextPath,
			ProjectName: plan.ProjectName,
		}
		plansByGroup[key] = append(plansByGroup[key], plan)
	}

	// Display context info if available
	if currentCtx != nil {
		fmt.Printf("Current context: %s", currentCtx.CurrentPath)
		if currentCtx.IsGitRepo {
			fmt.Printf(" (git root: %s)", currentCtx.GitRoot)
		}
		fmt.Printf("\n\n")
	}

	// Determine which group is "current" (matches current context)
	var currentGroupKey groupKey
	if currentCtx != nil {
		currentGroupKey = groupKey{
			ContextPath: currentContextPath,
			ProjectName: currentCtx.ProjectName,
		}
	}

	// Display plans, with current context group first
	groupsToDisplay := make([]groupKey, 0, len(plansByGroup))

	// Add current context group first if it exists
	if _, ok := plansByGroup[currentGroupKey]; ok {
		groupsToDisplay = append(groupsToDisplay, currentGroupKey)
	}

	// Add remaining groups
	for key := range plansByGroup {
		if key == currentGroupKey {
			continue // Skip current group as it's already added
		}
		groupsToDisplay = append(groupsToDisplay, key)
	}

	// Display each group
	for _, group := range groupsToDisplay {
		groupPlans := plansByGroup[group]

		// Determine if this is the current context group
		var isCurrentContext bool
		if currentCtx != nil {
			isCurrentContext = (group.ContextPath == currentContextPath && group.ProjectName == currentCtx.ProjectName)
		} else {
			isCurrentContext = false
		}

		// Display group header
		if isCurrentContext && currentCtx != nil {
			fmt.Printf("%s context:\n", currentCtx.ProjectName)
		} else {
			fmt.Printf("%s context:\n", group.ProjectName)
		}

		// Display plans in this group
		for _, plan := range groupPlans {
			// Mark current context plans with *
			marker := "  "
			if isCurrentContext {
				marker = "* "
			}

			status := plan.Status
			if plan.TotalTasks == 0 {
				fmt.Printf("%s%s [%s] (no tasks)\n", marker, plan.Name, status)
			} else {
				fmt.Printf("%s%s [%s] (%d/%d tasks completed)\n",
					marker, plan.Name, status, plan.CompletedTasks, plan.TotalTasks)
			}
		}
		fmt.Println()
	}

	return nil
}