Show source conversation task subtree

Author: Pyiner

desktop/garyx-desktop/src/renderer/src/app-shell/components/ThreadTaskTreePopover.tsx

@@ -1,7 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ListTree } from "lucide-react";
 
-import type { DesktopTaskForestTaskNode } from "@shared/contracts";
+import type {
+  DesktopTaskForestNode,
+  DesktopTaskForestTaskNode,
+} from "@shared/contracts";
 
 import { getDesktopApi } from "../../platform/desktop-api";
 import { useI18n } from "../../i18n";
@@ -16,7 +19,6 @@ import {
   taskStatusLabel,
   taskStatusTone,
   taskTreeBadgeCount,
-  visibleTaskTreeTasks,
 } from "./thread-task-tree-popover-model";
 
 const REFRESH_MS = 5000;
@@ -37,7 +39,7 @@ export function ThreadTaskTreePopover({
   onOpenThread,
 }: ThreadTaskTreePopoverProps) {
   const { t } = useI18n();
-  const [tasks, setTasks] = useState<DesktopTaskForestTaskNode[]>([]);
+  const [nodes, setNodes] = useState<DesktopTaskForestNode[]>([]);
   const mountedRef = useRef(true);
   const currentThreadRef = useRef<string | null>(threadId);
 
@@ -54,7 +56,7 @@ export function ThreadTaskTreePopover({
 
   const load = useCallback(async () => {
     if (!threadId) {
-      setTasks([]);
+      setNodes([]);
       return;
     }
     try {
@@ -64,7 +66,7 @@ export function ThreadTaskTreePopover({
       if (!mountedRef.current || currentThreadRef.current !== threadId) {
         return;
       }
-      setTasks(visibleTaskTreeTasks(page.tasks));
+      setNodes(page.tasks);
     } catch {
       /* leave previous state on transient errors */
     }
@@ -73,7 +75,7 @@ export function ThreadTaskTreePopover({
   // Reset + reload whenever the active thread changes so the list always
   // reflects the conversation currently open in the detail pane.
   useEffect(() => {
-    setTasks([]);
+    setNodes([]);
     void load();
   }, [load]);
 
@@ -82,11 +84,11 @@ export function ThreadTaskTreePopover({
     return () => window.clearInterval(interval);
   }, [load]);
 
-  const rows = useMemo(() => buildTaskRows(tasks), [tasks]);
-  const activeCount = useMemo(() => taskTreeBadgeCount(tasks), [tasks]);
+  const rows = useMemo(() => buildTaskRows(nodes), [nodes]);
+  const activeCount = useMemo(() => taskTreeBadgeCount(nodes), [nodes]);
 
   // Nothing to show when this conversation has no anchored active task tree.
-  if (!threadId || tasks.length === 0) {
+  if (!threadId || rows.length === 0) {
     return null;
   }
 

desktop/garyx-desktop/src/renderer/src/app-shell/components/thread-task-tree-popover-model.test.mjs

@@ -39,8 +39,8 @@ function task(overrides) {
   };
 }
 
-test("keeps task nodes regardless of status for server-pruned tree", () => {
-  const threadRoot = {
+function threadRoot(overrides = {}) {
+  return {
     kind: "thread",
     nodeId: "thread-root:thread::root",
     threadId: "thread::root",
@@ -54,7 +54,12 @@ test("keeps task nodes regardless of status for server-pruned tree", () => {
     runState: "idle",
     updatedAt: null,
     lastActiveAt: null,
+    ...overrides,
   };
+}
+
+test("keeps task nodes regardless of status for server-pruned tree", () => {
+  const root = threadRoot();
   const doneAncestor = task({ number: 1, status: "done" });
   const activeChild = task({
     number: 2,
@@ -65,14 +70,15 @@ test("keeps task nodes regardless of status for server-pruned tree", () => {
   });
 
   assert.deepEqual(
-    visibleTaskTreeTasks([threadRoot, doneAncestor, activeChild]),
+    visibleTaskTreeTasks([root, doneAncestor, activeChild]),
     [doneAncestor, activeChild],
   );
 });
 
 test("badge counts only active tasks", () => {
   assert.equal(
     taskTreeBadgeCount([
+      threadRoot(),
       task({ number: 1, status: "done" }),
       task({ number: 2, status: "in_progress" }),
       task({ number: 3, status: "in_review" }),
@@ -82,6 +88,34 @@ test("badge counts only active tasks", () => {
   );
 });
 
+test("rows build from mixed forest without rendering thread root row", () => {
+  const root = threadRoot();
+  const derivedRoot = task({
+    number: 1,
+    status: "in_progress",
+    parentNodeId: root.nodeId,
+    parentThreadId: root.threadId,
+  });
+  const grandchild = task({
+    number: 2,
+    status: "in_review",
+    parentNodeId: derivedRoot.nodeId,
+    parentTaskNumber: 1,
+    parentThreadId: derivedRoot.threadId,
+  });
+
+  assert.deepEqual(
+    buildTaskRows([root, derivedRoot, grandchild]).map(({ task, depth }) => [
+      task.number,
+      depth,
+    ]),
+    [
+      [1, 0],
+      [2, 1],
+    ],
+  );
+});
+
 test("current node is local to selected thread", () => {
   const current = task({ number: 2, threadId: "thread::current" });
   assert.equal(isCurrentTaskTreeNode(current, "thread::current"), true);

desktop/garyx-desktop/src/renderer/src/app-shell/components/thread-task-tree-popover-model.ts

@@ -22,8 +22,8 @@ export function isActiveTaskStatus(status: DesktopTaskStatus): boolean {
   return status === "in_progress" || status === "in_review";
 }
 
-export function taskTreeBadgeCount(tasks: DesktopTaskForestTaskNode[]): number {
-  return tasks.filter((task) => isActiveTaskStatus(task.status)).length;
+export function taskTreeBadgeCount(nodes: DesktopTaskForestNode[]): number {
+  return nodes.filter((node) => isTaskNode(node) && isActiveTaskStatus(node.status)).length;
 }
 
 export function isCurrentTaskTreeNode(
@@ -76,30 +76,48 @@ export function taskStatusLabel(status: DesktopTaskStatus): string {
 /** Depth-order the tasks into a tree via parentNodeId; nodes whose parent
  *  isn't in the set become roots (depth 0). */
 export function buildTaskRows(
-  tasks: DesktopTaskForestTaskNode[],
+  nodes: DesktopTaskForestNode[],
 ): TaskTreeRow[] {
-  const ids = new Set(tasks.map((task) => task.nodeId));
-  const childrenByParent = new Map<string, DesktopTaskForestTaskNode[]>();
-  for (const task of tasks) {
+  const ids = new Set(nodes.map((node) => node.nodeId));
+  const originalIndex = new Map(nodes.map((node, index) => [node.nodeId, index]));
+  const childrenByParent = new Map<string, DesktopTaskForestNode[]>();
+  for (const node of nodes) {
     const parent =
-      task.parentNodeId && ids.has(task.parentNodeId) ? task.parentNodeId : "";
+      node.kind === "task" && node.parentNodeId && ids.has(node.parentNodeId)
+        ? node.parentNodeId
+        : "";
     const list = childrenByParent.get(parent) ?? [];
-    list.push(task);
+    list.push(node);
     childrenByParent.set(parent, list);
   }
   for (const list of childrenByParent.values()) {
-    list.sort((a, b) => a.number - b.number);
+    list.sort((a, b) => {
+      if (a.kind === "task" && b.kind === "task") {
+        return a.number - b.number;
+      }
+      if (a.kind === "thread" && b.kind === "task") {
+        return -1;
+      }
+      if (a.kind === "task" && b.kind === "thread") {
+        return 1;
+      }
+      return (originalIndex.get(a.nodeId) ?? 0) - (originalIndex.get(b.nodeId) ?? 0);
+    });
   }
   const rows: TaskTreeRow[] = [];
   const visited = new Set<string>();
   const walk = (parent: string, depth: number) => {
-    for (const task of childrenByParent.get(parent) ?? []) {
-      if (visited.has(task.nodeId)) {
+    for (const node of childrenByParent.get(parent) ?? []) {
+      if (visited.has(node.nodeId)) {
         continue;
       }
-      visited.add(task.nodeId);
-      rows.push({ task, depth });
-      walk(task.nodeId, Math.min(depth + 1, 4));
+      visited.add(node.nodeId);
+      if (node.kind === "thread") {
+        walk(node.nodeId, depth);
+      } else {
+        rows.push({ task: node, depth });
+        walk(node.nodeId, Math.min(depth + 1, 4));
+      }
     }
   };
   walk("", 0);