Add things

taskwarrior/models.go

@@ -54,7 +54,7 @@ type Task struct {
 	Depends     []string       `json:"depends,omitempty"`
 	DependsIds  string         `json:"-"`
 	Urgency     float32        `json:"urgency,omitempty"`
-	Parent      string         `json:"parent,omitempty"`
+	Parent      string         `json:"parenttask,omitempty"`
 	Due         string         `json:"due,omitempty"`
 	Wait        string         `json:"wait,omitempty"`
 	Scheduled   string         `json:"scheduled,omitempty"`
@@ -168,7 +168,7 @@ func (t *Task) GetString(fieldWFormat string) string {
 		}
 		return strings.Join(t.Tags, " ")
 
-	case "parent":
+	case "parenttask":
 		if format == "short" {
 			return t.Parent[:8]
 		}
@@ -317,7 +317,7 @@ func (t *Task) UnmarshalJSON(data []byte) error {
 	delete(m, "tags")
 	delete(m, "depends")
 	delete(m, "urgency")
-	delete(m, "parent")
+	delete(m, "parenttask")
 	delete(m, "due")
 	delete(m, "wait")
 	delete(m, "scheduled")

taskwarrior/taskwarrior.go

@@ -128,6 +128,10 @@ func NewTaskSquire(configLocation string) *TaskSquire {
 		mutex:          sync.Mutex{},
 	}
 	ts.config = ts.extractConfig()
+	if ts.config == nil {
+		slog.Error("Failed to extract config - taskwarrior commands are failing. Check your taskrc file for syntax errors.")
+		return nil
+	}
 	ts.reports = ts.extractReports()
 	ts.contexts = ts.extractContexts()
 
@@ -552,7 +556,7 @@ func (ts *TaskSquire) extractConfig() *TWConfig {
 	cmd := exec.Command(twBinary, append(ts.defaultArgs, []string{"_show"}...)...)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
-		slog.Error("Failed getting config:", err)
+		slog.Error("Failed getting config", "error", err, "output", string(output))
 		return nil
 	}
 
@@ -610,7 +614,7 @@ func (ts *TaskSquire) extractContexts() Contexts {
 
 	output, err := cmd.CombinedOutput()
 	if err != nil {
-		slog.Error("Failed getting contexts:", err)
+		slog.Error("Failed getting contexts", "error", err, "output", string(output))
 		return nil
 	}
 

taskwarrior/tree.go

@@ -0,0 +1,127 @@
+package taskwarrior
+
+import (
+	"log/slog"
+)
+
+// TaskNode represents a task in the tree structure
+type TaskNode struct {
+	Task     *Task
+	Children []*TaskNode
+	Parent   *TaskNode
+	Depth    int
+}
+
+// TaskTree manages the hierarchical task structure
+type TaskTree struct {
+	Nodes    map[string]*TaskNode // UUID -> TaskNode
+	Roots    []*TaskNode          // Top-level tasks (no parent)
+	FlatList []*TaskNode          // Flattened tree in display order
+}
+
+// BuildTaskTree constructs a tree from a flat list of tasks
+// Three-pass algorithm:
+// 1. Create all nodes
+// 2. Establish parent-child relationships
+// 3. Calculate depths and flatten tree
+func BuildTaskTree(tasks Tasks) *TaskTree {
+	tree := &TaskTree{
+		Nodes:    make(map[string]*TaskNode),
+		Roots:    make([]*TaskNode, 0),
+		FlatList: make([]*TaskNode, 0),
+	}
+
+	// Pass 1: Create all nodes
+	for _, task := range tasks {
+		node := &TaskNode{
+			Task:     task,
+			Children: make([]*TaskNode, 0),
+			Parent:   nil,
+			Depth:    0,
+		}
+		tree.Nodes[task.Uuid] = node
+	}
+
+	// Pass 2: Establish parent-child relationships
+	// Iterate over original tasks slice to preserve order
+	for _, task := range tasks {
+		node := tree.Nodes[task.Uuid]
+		parentUUID := getParentUUID(node.Task)
+		if parentUUID == "" {
+			// No parent, this is a root task
+			tree.Roots = append(tree.Roots, node)
+		} else {
+			// Find parent node
+			parentNode, exists := tree.Nodes[parentUUID]
+			if !exists {
+				// Orphaned task - missing parent
+				slog.Warn("Task has missing parent",
+					"task_uuid", node.Task.Uuid,
+					"parent_uuid", parentUUID,
+					"task_desc", node.Task.Description)
+				// Treat as root (graceful degradation)
+				tree.Roots = append(tree.Roots, node)
+			} else {
+				// Establish relationship
+				node.Parent = parentNode
+				parentNode.Children = append(parentNode.Children, node)
+			}
+		}
+	}
+
+	// Pass 3: Calculate depths and flatten tree
+	for _, root := range tree.Roots {
+		flattenNode(root, 0, &tree.FlatList)
+	}
+
+	return tree
+}
+
+// getParentUUID extracts the parent UUID from a task's UDAs
+func getParentUUID(task *Task) string {
+	if task.Udas == nil {
+		return ""
+	}
+
+	parentVal, exists := task.Udas["parenttask"]
+	if !exists {
+		return ""
+	}
+
+	// Parent UDA is stored as a string
+	if parentStr, ok := parentVal.(string); ok {
+		return parentStr
+	}
+
+	return ""
+}
+
+// flattenNode recursively flattens the tree in depth-first order
+func flattenNode(node *TaskNode, depth int, flatList *[]*TaskNode) {
+	node.Depth = depth
+	*flatList = append(*flatList, node)
+
+	// Recursively flatten children
+	for _, child := range node.Children {
+		flattenNode(child, depth+1, flatList)
+	}
+}
+
+// GetChildrenStatus returns completed/total counts for a parent task
+func (tn *TaskNode) GetChildrenStatus() (completed int, total int) {
+	total = len(tn.Children)
+	completed = 0
+
+	for _, child := range tn.Children {
+		if child.Task.Status == "completed" {
+			completed++
+		}
+	}
+
+	return completed, total
+}
+
+// HasChildren returns true if the node has any children
+func (tn *TaskNode) HasChildren() bool {
+	return len(tn.Children) > 0
+}

taskwarrior/tree_test.go

@@ -0,0 +1,345 @@
+package taskwarrior
+
+import (
+	"testing"
+)
+
+func TestBuildTaskTree_EmptyList(t *testing.T) {
+	tasks := Tasks{}
+	tree := BuildTaskTree(tasks)
+
+	if tree == nil {
+		t.Fatal("Expected tree to be non-nil")
+	}
+
+	if len(tree.Nodes) != 0 {
+		t.Errorf("Expected 0 nodes, got %d", len(tree.Nodes))
+	}
+
+	if len(tree.Roots) != 0 {
+		t.Errorf("Expected 0 roots, got %d", len(tree.Roots))
+	}
+
+	if len(tree.FlatList) != 0 {
+		t.Errorf("Expected 0 items in flat list, got %d", len(tree.FlatList))
+	}
+}
+
+func TestBuildTaskTree_NoParents(t *testing.T) {
+	tasks := Tasks{
+		{Uuid: "task1", Description: "Task 1", Status: "pending"},
+		{Uuid: "task2", Description: "Task 2", Status: "pending"},
+		{Uuid: "task3", Description: "Task 3", Status: "completed"},
+	}
+
+	tree := BuildTaskTree(tasks)
+
+	if len(tree.Nodes) != 3 {
+		t.Errorf("Expected 3 nodes, got %d", len(tree.Nodes))
+	}
+
+	if len(tree.Roots) != 3 {
+		t.Errorf("Expected 3 roots (all tasks have no parent), got %d", len(tree.Roots))
+	}
+
+	if len(tree.FlatList) != 3 {
+		t.Errorf("Expected 3 items in flat list, got %d", len(tree.FlatList))
+	}
+
+	// All tasks should have depth 0
+	for i, node := range tree.FlatList {
+		if node.Depth != 0 {
+			t.Errorf("Task %d expected depth 0, got %d", i, node.Depth)
+		}
+		if node.HasChildren() {
+			t.Errorf("Task %d should not have children", i)
+		}
+	}
+}
+
+func TestBuildTaskTree_SimpleParentChild(t *testing.T) {
+	tasks := Tasks{
+		{Uuid: "parent1", Description: "Parent Task", Status: "pending"},
+		{
+			Uuid:        "child1",
+			Description: "Child Task 1",
+			Status:      "pending",
+			Udas:        map[string]any{"parenttask": "parent1"},
+		},
+		{
+			Uuid:        "child2",
+			Description: "Child Task 2",
+			Status:      "completed",
+			Udas:        map[string]any{"parenttask": "parent1"},
+		},
+	}
+
+	tree := BuildTaskTree(tasks)
+
+	if len(tree.Nodes) != 3 {
+		t.Fatalf("Expected 3 nodes, got %d", len(tree.Nodes))
+	}
+
+	if len(tree.Roots) != 1 {
+		t.Fatalf("Expected 1 root, got %d", len(tree.Roots))
+	}
+
+	// Check root is the parent
+	root := tree.Roots[0]
+	if root.Task.Uuid != "parent1" {
+		t.Errorf("Expected root to be parent1, got %s", root.Task.Uuid)
+	}
+
+	// Check parent has 2 children
+	if len(root.Children) != 2 {
+		t.Fatalf("Expected parent to have 2 children, got %d", len(root.Children))
+	}
+
+	// Check children status
+	completed, total := root.GetChildrenStatus()
+	if total != 2 {
+		t.Errorf("Expected total children = 2, got %d", total)
+	}
+	if completed != 1 {
+		t.Errorf("Expected completed children = 1, got %d", completed)
+	}
+
+	// Check flat list order (parent first, then children)
+	if len(tree.FlatList) != 3 {
+		t.Fatalf("Expected 3 items in flat list, got %d", len(tree.FlatList))
+	}
+
+	if tree.FlatList[0].Task.Uuid != "parent1" {
+		t.Errorf("Expected first item to be parent, got %s", tree.FlatList[0].Task.Uuid)
+	}
+
+	if tree.FlatList[0].Depth != 0 {
+		t.Errorf("Expected parent depth = 0, got %d", tree.FlatList[0].Depth)
+	}
+
+	// Children should be at depth 1
+	for i := 1; i < 3; i++ {
+		if tree.FlatList[i].Depth != 1 {
+			t.Errorf("Expected child %d depth = 1, got %d", i, tree.FlatList[i].Depth)
+		}
+		if tree.FlatList[i].Parent == nil {
+			t.Errorf("Child %d should have a parent", i)
+		} else if tree.FlatList[i].Parent.Task.Uuid != "parent1" {
+			t.Errorf("Child %d parent should be parent1, got %s", i, tree.FlatList[i].Parent.Task.Uuid)
+		}
+	}
+}
+
+func TestBuildTaskTree_MultiLevel(t *testing.T) {
+	tasks := Tasks{
+		{Uuid: "grandparent", Description: "Grandparent", Status: "pending"},
+		{
+			Uuid:        "parent1",
+			Description: "Parent 1",
+			Status:      "pending",
+			Udas:        map[string]any{"parenttask": "grandparent"},
+		},
+		{
+			Uuid:        "parent2",
+			Description: "Parent 2",
+			Status:      "pending",
+			Udas:        map[string]any{"parenttask": "grandparent"},
+		},
+		{
+			Uuid:        "child1",
+			Description: "Child 1",
+			Status:      "pending",
+			Udas:        map[string]any{"parenttask": "parent1"},
+		},
+		{
+			Uuid:        "grandchild1",
+			Description: "Grandchild 1",
+			Status:      "completed",
+			Udas:        map[string]any{"parenttask": "child1"},
+		},
+	}
+
+	tree := BuildTaskTree(tasks)
+
+	if len(tree.Nodes) != 5 {
+		t.Fatalf("Expected 5 nodes, got %d", len(tree.Nodes))
+	}
+
+	if len(tree.Roots) != 1 {
+		t.Fatalf("Expected 1 root, got %d", len(tree.Roots))
+	}
+
+	// Find nodes by UUID
+	grandparentNode := tree.Nodes["grandparent"]
+	parent1Node := tree.Nodes["parent1"]
+	child1Node := tree.Nodes["child1"]
+	grandchildNode := tree.Nodes["grandchild1"]
+
+	// Check depths
+	if grandparentNode.Depth != 0 {
+		t.Errorf("Expected grandparent depth = 0, got %d", grandparentNode.Depth)
+	}
+	if parent1Node.Depth != 1 {
+		t.Errorf("Expected parent1 depth = 1, got %d", parent1Node.Depth)
+	}
+	if child1Node.Depth != 2 {
+		t.Errorf("Expected child1 depth = 2, got %d", child1Node.Depth)
+	}
+	if grandchildNode.Depth != 3 {
+		t.Errorf("Expected grandchild depth = 3, got %d", grandchildNode.Depth)
+	}
+
+	// Check parent-child relationships
+	if len(grandparentNode.Children) != 2 {
+		t.Errorf("Expected grandparent to have 2 children, got %d", len(grandparentNode.Children))
+	}
+
+	if len(parent1Node.Children) != 1 {
+		t.Errorf("Expected parent1 to have 1 child, got %d", len(parent1Node.Children))
+	}
+
+	if len(child1Node.Children) != 1 {
+		t.Errorf("Expected child1 to have 1 child, got %d", len(child1Node.Children))
+	}
+
+	if grandchildNode.HasChildren() {
+		t.Error("Expected grandchild to have no children")
+	}
+
+	// Check flat list maintains tree order
+	if len(tree.FlatList) != 5 {
+		t.Fatalf("Expected 5 items in flat list, got %d", len(tree.FlatList))
+	}
+
+	// Grandparent should be first
+	if tree.FlatList[0].Task.Uuid != "grandparent" {
+		t.Errorf("Expected first item to be grandparent, got %s", tree.FlatList[0].Task.Uuid)
+	}
+}
+
+func TestBuildTaskTree_OrphanedTask(t *testing.T) {
+	tasks := Tasks{
+		{Uuid: "task1", Description: "Normal Task", Status: "pending"},
+		{
+			Uuid:        "orphan",
+			Description: "Orphaned Task",
+			Status:      "pending",
+			Udas:        map[string]any{"parenttask": "nonexistent"},
+		},
+	}
+
+	tree := BuildTaskTree(tasks)
+
+	if len(tree.Nodes) != 2 {
+		t.Fatalf("Expected 2 nodes, got %d", len(tree.Nodes))
+	}
+
+	// Orphaned task should be treated as root
+	if len(tree.Roots) != 2 {
+		t.Errorf("Expected 2 roots (orphan should be treated as root), got %d", len(tree.Roots))
+	}
+
+	// Both should have depth 0
+	for _, node := range tree.FlatList {
+		if node.Depth != 0 {
+			t.Errorf("Expected all tasks to have depth 0, got %d for %s", node.Depth, node.Task.Description)
+		}
+	}
+}
+
+func TestTaskNode_GetChildrenStatus(t *testing.T) {
+	tests := []struct {
+		name      string
+		children  []*TaskNode
+		wantComp  int
+		wantTotal int
+	}{
+		{
+			name:      "no children",
+			children:  []*TaskNode{},
+			wantComp:  0,
+			wantTotal: 0,
+		},
+		{
+			name: "all pending",
+			children: []*TaskNode{
+				{Task: &Task{Status: "pending"}},
+				{Task: &Task{Status: "pending"}},
+			},
+			wantComp:  0,
+			wantTotal: 2,
+		},
+		{
+			name: "all completed",
+			children: []*TaskNode{
+				{Task: &Task{Status: "completed"}},
+				{Task: &Task{Status: "completed"}},
+				{Task: &Task{Status: "completed"}},
+			},
+			wantComp:  3,
+			wantTotal: 3,
+		},
+		{
+			name: "mixed status",
+			children: []*TaskNode{
+				{Task: &Task{Status: "completed"}},
+				{Task: &Task{Status: "pending"}},
+				{Task: &Task{Status: "completed"}},
+				{Task: &Task{Status: "pending"}},
+				{Task: &Task{Status: "completed"}},
+			},
+			wantComp:  3,
+			wantTotal: 5,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			node := &TaskNode{
+				Task:     &Task{},
+				Children: tt.children,
+			}
+
+			gotComp, gotTotal := node.GetChildrenStatus()
+
+			if gotComp != tt.wantComp {
+				t.Errorf("GetChildrenStatus() completed = %d, want %d", gotComp, tt.wantComp)
+			}
+			if gotTotal != tt.wantTotal {
+				t.Errorf("GetChildrenStatus() total = %d, want %d", gotTotal, tt.wantTotal)
+			}
+		})
+	}
+}
+
+func TestTaskNode_HasChildren(t *testing.T) {
+	tests := []struct {
+		name     string
+		children []*TaskNode
+		want     bool
+	}{
+		{
+			name:     "no children",
+			children: []*TaskNode{},
+			want:     false,
+		},
+		{
+			name:     "has children",
+			children: []*TaskNode{{Task: &Task{}}},
+			want:     true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			node := &TaskNode{
+				Task:     &Task{},
+				Children: tt.children,
+			}
+
+			if got := node.HasChildren(); got != tt.want {
+				t.Errorf("HasChildren() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}