blackroad-cli/internal/commands/tasks.go

package commands

import (
	"fmt"
	"os"

	"github.com/BlackRoad-OS/blackroad-cli/internal/api"
	"github.com/olekukonko/tablewriter"
	"github.com/spf13/cobra"
)

var tasksCmd = &cobra.Command{
	Use:   "tasks",
	Short: "Manage tasks",
	Long:  "List, dispatch, complete, and manage BlackRoad tasks.",
}

var tasksListCmd = &cobra.Command{
	Use:   "list",
	Short: "List tasks",
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		status, _ := cmd.Flags().GetString("status")
		priority, _ := cmd.Flags().GetString("priority")
		division, _ := cmd.Flags().GetString("division")

		tasks, err := client.ListTasks(status, priority, division)
		if err != nil {
			printError(err.Error())
			return
		}

		if len(tasks) == 0 {
			fmt.Println("No tasks found")
			return
		}

		table := tablewriter.NewWriter(os.Stdout)
		table.SetHeader([]string{"ID", "Title", "Status", "Priority", "Division"})
		table.SetBorder(false)
		table.SetHeaderColor(
			tablewriter.Colors{tablewriter.FgCyanColor},
			tablewriter.Colors{tablewriter.FgCyanColor},
			tablewriter.Colors{tablewriter.FgCyanColor},
			tablewriter.Colors{tablewriter.FgCyanColor},
			tablewriter.Colors{tablewriter.FgCyanColor},
		)

		for _, t := range tasks {
			div := t.Division
			if div == "" {
				div = "-"
			}
			title := t.Title
			if len(title) > 40 {
				title = title[:37] + "..."
			}
			table.Append([]string{
				t.ID[:12],
				title,
				t.Status,
				t.Priority,
				div,
			})
		}
		table.Render()
		fmt.Printf("\n%s %d tasks\n", cyan("Total:"), len(tasks))
	},
}

var tasksGetCmd = &cobra.Command{
	Use:   "get <task-id>",
	Short: "Get task details",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		task, err := client.GetTask(args[0])
		if err != nil {
			printError(err.Error())
			return
		}

		fmt.Printf("%s %s\n", bold("ID:"), task.ID)
		fmt.Printf("%s %s\n", bold("Title:"), task.Title)
		if task.Description != "" {
			fmt.Printf("%s %s\n", bold("Description:"), task.Description)
		}
		fmt.Printf("%s %s\n", bold("Status:"), task.Status)
		fmt.Printf("%s %s\n", bold("Priority:"), task.Priority)
		fmt.Printf("%s %s\n", bold("Division:"), task.Division)
		if task.AssignedAgent != "" {
			fmt.Printf("%s %s\n", bold("Assigned:"), task.AssignedAgent)
		}
		fmt.Printf("%s %s\n", bold("Created:"), task.CreatedAt.Format("2006-01-02 15:04:05"))
	},
}

var tasksDispatchCmd = &cobra.Command{
	Use:   "dispatch <title>",
	Short: "Dispatch a new task",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		description, _ := cmd.Flags().GetString("description")
		priority, _ := cmd.Flags().GetString("priority")
		division, _ := cmd.Flags().GetString("division")

		task, err := client.DispatchTask(args[0], description, priority, division)
		if err != nil {
			printError(err.Error())
			return
		}

		printSuccess(fmt.Sprintf("Task dispatched: %s", task.ID))
	},
}

var tasksCompleteCmd = &cobra.Command{
	Use:   "complete <task-id>",
	Short: "Complete a task",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		result, _ := cmd.Flags().GetString("result")

		task, err := client.CompleteTask(args[0], result)
		if err != nil {
			printError(err.Error())
			return
		}

		printSuccess(fmt.Sprintf("Task completed: %s", task.ID))
	},
}

var tasksAssignCmd = &cobra.Command{
	Use:   "assign <task-id> <agent-id>",
	Short: "Assign a task to an agent",
	Args:  cobra.ExactArgs(2),
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		task, err := client.AssignTask(args[0], args[1])
		if err != nil {
			printError(err.Error())
			return
		}

		printSuccess(fmt.Sprintf("Task assigned: %s -> %s", task.ID, args[1]))
	},
}

var tasksCancelCmd = &cobra.Command{
	Use:   "cancel <task-id>",
	Short: "Cancel a task",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		if err := client.CancelTask(args[0]); err != nil {
			printError(err.Error())
			return
		}

		printSuccess("Task cancelled")
	},
}

var tasksStatsCmd = &cobra.Command{
	Use:   "stats",
	Short: "Show task statistics",
	Run: func(cmd *cobra.Command, args []string) {
		client, err := api.NewClient()
		if err != nil {
			printError(err.Error())
			return
		}

		stats, err := client.TaskStats()
		if err != nil {
			printError(err.Error())
			return
		}

		fmt.Printf("%s\n", bold("Task Statistics"))
		fmt.Printf("%s %d\n", cyan("Total:"), stats.Total)
		fmt.Printf("%s %d\n", yellow("Pending:"), stats.Pending)
		fmt.Printf("%s %d\n", green("Completed:"), stats.Completed)
	},
}

func init() {
	tasksCmd.AddCommand(tasksListCmd)
	tasksCmd.AddCommand(tasksGetCmd)
	tasksCmd.AddCommand(tasksDispatchCmd)
	tasksCmd.AddCommand(tasksCompleteCmd)
	tasksCmd.AddCommand(tasksAssignCmd)
	tasksCmd.AddCommand(tasksCancelCmd)
	tasksCmd.AddCommand(tasksStatsCmd)

	// List flags
	tasksListCmd.Flags().StringP("status", "s", "", "Filter by status (pending, in_progress, completed)")
	tasksListCmd.Flags().StringP("priority", "p", "", "Filter by priority (low, medium, high, urgent)")
	tasksListCmd.Flags().StringP("division", "d", "", "Filter by division")

	// Dispatch flags
	tasksDispatchCmd.Flags().String("description", "", "Task description")
	tasksDispatchCmd.Flags().StringP("priority", "p", "medium", "Priority (low, medium, high, urgent)")
	tasksDispatchCmd.Flags().StringP("division", "d", "", "Target division")

	// Complete flags
	tasksCompleteCmd.Flags().StringP("result", "r", "", "Completion result")
}