@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/components/StructuredDiff/colorDiff.js

@@ -0,0 +1,26 @@
+import { ColorDiff, ColorFile, getSyntaxTheme as nativeGetSyntaxTheme, } from '../../native-ts/color-diff/index.js';
+import { isEnvDefinedFalsy } from '../../utils/envUtils.js';
+/**
+ * Returns a static reason why the color-diff module is unavailable, or null if available.
+ * 'env' = disabled via CLAUDE_CODE_SYNTAX_HIGHLIGHT
+ *
+ * The TS port of color-diff works in all build modes, so the only way to
+ * disable it is via the env var.
+ */
+export function getColorModuleUnavailableReason() {
+    if (isEnvDefinedFalsy(process.env.CLAUDE_CODE_SYNTAX_HIGHLIGHT)) {
+        return 'env';
+    }
+    return null;
+}
+export function expectColorDiff() {
+    return getColorModuleUnavailableReason() === null ? ColorDiff : null;
+}
+export function expectColorFile() {
+    return getColorModuleUnavailableReason() === null ? ColorFile : null;
+}
+export function getSyntaxTheme(themeName) {
+    return getColorModuleUnavailableReason() === null
+        ? nativeGetSyntaxTheme(themeName)
+        : null;
+}

package/dist/src/components/StructuredDiff.js

@@ -0,0 +1,152 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { memo } from 'react';
+import { useSettings } from '../hooks/useSettings.js';
+import { Box, NoSelect, RawAnsi, useTheme } from '../ink.js';
+import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
+import sliceAnsi from '../utils/sliceAnsi.js';
+import { expectColorDiff } from './StructuredDiff/colorDiff.js';
+import { StructuredDiffFallback } from './StructuredDiff/Fallback.js';
+const RENDER_CACHE = new WeakMap();
+// Gutter width matches the Rust module's layout: marker (1) + space +
+// right-aligned line number (max_digits) + space. Depends only on patch
+// identity (the WeakMap key), so it's cacheable alongside the NAPI output.
+function computeGutterWidth(patch) {
+    const maxLineNumber = Math.max(patch.oldStart + patch.oldLines - 1, patch.newStart + patch.newLines - 1, 1);
+    return maxLineNumber.toString().length + 3; // marker + 2 padding spaces
+}
+function renderColorDiff(patch, firstLine, filePath, fileContent, theme, width, dim, splitGutter) {
+    const ColorDiff = expectColorDiff();
+    if (!ColorDiff)
+        return null;
+    // Defensive: if the gutter would eat the whole render width (narrow
+    // terminal), skip the split. Rust already wraps to `width` so the
+    // single-column output stays correct; we just lose noSelect. Without
+    // this, sliceAnsi(line, gutterWidth) would return empty content and
+    // RawAnsi(width<=0) is untested.
+    const rawGutterWidth = splitGutter ? computeGutterWidth(patch) : 0;
+    const gutterWidth = rawGutterWidth > 0 && rawGutterWidth < width ? rawGutterWidth : 0;
+    const key = `${theme}|${width}|${dim ? 1 : 0}|${gutterWidth}|${firstLine ?? ''}|${filePath}`;
+    let perHunk = RENDER_CACHE.get(patch);
+    const hit = perHunk?.get(key);
+    if (hit)
+        return hit;
+    const lines = new ColorDiff(patch, firstLine, filePath, fileContent).render(theme, width, dim);
+    if (lines === null)
+        return null;
+    // Pre-split the gutter column once (cold-cache). sliceAnsi preserves
+    // styles across the cut; the Rust module already pads the gutter to
+    // gutterWidth so the narrow RawAnsi column's width matches its cells.
+    let gutters = null;
+    let contents = null;
+    if (gutterWidth > 0) {
+        gutters = lines.map(l => sliceAnsi(l, 0, gutterWidth));
+        contents = lines.map(l => sliceAnsi(l, gutterWidth));
+    }
+    const entry = {
+        lines,
+        gutterWidth,
+        gutters,
+        contents
+    };
+    if (!perHunk) {
+        perHunk = new Map();
+        RENDER_CACHE.set(patch, perHunk);
+    }
+    // Cap the inner map: width is part of the key, so terminal resize while a
+    // diff is visible accumulates a full render copy per distinct width. Four
+    // variants (two widths × dim on/off) covers the steady state; beyond that
+    // the user is actively resizing and old widths are stale.
+    if (perHunk.size >= 4)
+        perHunk.clear();
+    perHunk.set(key, entry);
+    return entry;
+}
+export const StructuredDiff = memo(function StructuredDiff(t0) {
+    const $ = _c(26);
+    const { patch, dim, filePath, firstLine, fileContent, width, skipHighlighting: t1 } = t0;
+    const skipHighlighting = t1 === undefined ? false : t1;
+    const [theme] = useTheme();
+    const settings = useSettings();
+    const syntaxHighlightingDisabled = settings.syntaxHighlightingDisabled ?? false;
+    const safeWidth = Math.max(1, Math.floor(width));
+    let t2;
+    if ($[0] !== dim || $[1] !== fileContent || $[2] !== filePath || $[3] !== firstLine || $[4] !== patch || $[5] !== safeWidth || $[6] !== skipHighlighting || $[7] !== syntaxHighlightingDisabled || $[8] !== theme) {
+        const splitGutter = isFullscreenEnvEnabled();
+        t2 = skipHighlighting || syntaxHighlightingDisabled ? null : renderColorDiff(patch, firstLine, filePath, fileContent ?? null, theme, safeWidth, dim, splitGutter);
+        $[0] = dim;
+        $[1] = fileContent;
+        $[2] = filePath;
+        $[3] = firstLine;
+        $[4] = patch;
+        $[5] = safeWidth;
+        $[6] = skipHighlighting;
+        $[7] = syntaxHighlightingDisabled;
+        $[8] = theme;
+        $[9] = t2;
+    }
+    else {
+        t2 = $[9];
+    }
+    const cached = t2;
+    if (!cached) {
+        let t3;
+        if ($[10] !== dim || $[11] !== patch || $[12] !== width) {
+            t3 = _jsx(Box, { children: _jsx(StructuredDiffFallback, { patch: patch, dim: dim, width: width }) });
+            $[10] = dim;
+            $[11] = patch;
+            $[12] = width;
+            $[13] = t3;
+        }
+        else {
+            t3 = $[13];
+        }
+        return t3;
+    }
+    const { lines, gutterWidth, gutters, contents } = cached;
+    if (gutterWidth > 0 && gutters && contents) {
+        let t3;
+        if ($[14] !== gutterWidth || $[15] !== gutters) {
+            t3 = _jsx(NoSelect, { fromLeftEdge: true, children: _jsx(RawAnsi, { lines: gutters, width: gutterWidth }) });
+            $[14] = gutterWidth;
+            $[15] = gutters;
+            $[16] = t3;
+        }
+        else {
+            t3 = $[16];
+        }
+        const t4 = safeWidth - gutterWidth;
+        let t5;
+        if ($[17] !== contents || $[18] !== t4) {
+            t5 = _jsx(RawAnsi, { lines: contents, width: t4 });
+            $[17] = contents;
+            $[18] = t4;
+            $[19] = t5;
+        }
+        else {
+            t5 = $[19];
+        }
+        let t6;
+        if ($[20] !== t3 || $[21] !== t5) {
+            t6 = _jsxs(Box, { flexDirection: "row", children: [t3, t5] });
+            $[20] = t3;
+            $[21] = t5;
+            $[22] = t6;
+        }
+        else {
+            t6 = $[22];
+        }
+        return t6;
+    }
+    let t3;
+    if ($[23] !== lines || $[24] !== safeWidth) {
+        t3 = _jsx(Box, { children: _jsx(RawAnsi, { lines: lines, width: safeWidth }) });
+        $[23] = lines;
+        $[24] = safeWidth;
+        $[25] = t3;
+    }
+    else {
+        t3 = $[25];
+    }
+    return t3;
+});

package/dist/src/components/StructuredDiffList.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, NoSelect, Text } from '../ink.js';
+import { intersperse } from '../utils/array.js';
+import { StructuredDiff } from './StructuredDiff.js';
+/** Renders a list of diff hunks with ellipsis separators between them. */
+export function StructuredDiffList({ hunks, dim, width, filePath, firstLine, fileContent }) {
+    return intersperse(hunks.map(hunk => _jsx(Box, { flexDirection: "column", children: _jsx(StructuredDiff, { patch: hunk, dim: dim, width: width, filePath: filePath, firstLine: firstLine, fileContent: fileContent }) }, hunk.newStart)), i => _jsx(NoSelect, { fromLeftEdge: true, children: _jsx(Text, { dimColor: true, children: "..." }) }, `ellipsis-${i}`));
+}

package/dist/src/components/TagTabs.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { stringWidth } from '../ink/stringWidth.js';
+import { Box, Text } from '../ink.js';
+import { truncateToWidth } from '../utils/format.js';
+// Constants for width calculations - derived from actual rendered strings
+const ALL_TAB_LABEL = 'All';
+const TAB_PADDING = 2; // Space before and after tab text: " {tab} "
+const HASH_PREFIX_LENGTH = 1; // "#" prefix for non-All tabs
+const LEFT_ARROW_PREFIX = '← ';
+const RIGHT_HINT_WITH_COUNT_PREFIX = '→';
+const RIGHT_HINT_SUFFIX = ' (tab to cycle)';
+const RIGHT_HINT_NO_COUNT = '(tab to cycle)';
+const MAX_OVERFLOW_DIGITS = 2; // Assume max 99 hidden tabs for width calculation
+// Computed widths
+const LEFT_ARROW_WIDTH = LEFT_ARROW_PREFIX.length + MAX_OVERFLOW_DIGITS + 1; // "← NN " with gap
+const RIGHT_HINT_WIDTH_WITH_COUNT = RIGHT_HINT_WITH_COUNT_PREFIX.length + MAX_OVERFLOW_DIGITS + RIGHT_HINT_SUFFIX.length; // "→NN (tab to cycle)"
+const RIGHT_HINT_WIDTH_NO_COUNT = RIGHT_HINT_NO_COUNT.length;
+/**
+ * Calculate the display width of a tab
+ */
+function getTabWidth(tab, maxWidth) {
+    if (tab === ALL_TAB_LABEL) {
+        return ALL_TAB_LABEL.length + TAB_PADDING;
+    }
+    // For non-All tabs: " #{tag} " but truncate tag if needed
+    const tagWidth = stringWidth(tab);
+    const effectiveTagWidth = maxWidth ? Math.min(tagWidth, maxWidth - TAB_PADDING - HASH_PREFIX_LENGTH) : tagWidth;
+    return Math.max(0, effectiveTagWidth) + TAB_PADDING + HASH_PREFIX_LENGTH;
+}
+/**
+ * Truncate a tag to fit within maxWidth, accounting for padding and hash prefix
+ */
+function truncateTag(tag, maxWidth) {
+    // Available space for the tag text itself: maxWidth - " #" - " "
+    const availableForTag = maxWidth - TAB_PADDING - HASH_PREFIX_LENGTH;
+    if (stringWidth(tag) <= availableForTag) {
+        return tag;
+    }
+    if (availableForTag <= 1) {
+        return tag.charAt(0);
+    }
+    return truncateToWidth(tag, availableForTag);
+}
+export function TagTabs({ tabs, selectedIndex, availableWidth, showAllProjects = false }) {
+    const resumeLabel = showAllProjects ? 'Resume (All Projects)' : 'Resume';
+    const resumeLabelWidth = resumeLabel.length + 1; // +1 for gap
+    // Calculate how much space we have for tabs (use worst-case hint width)
+    const rightHintWidth = Math.max(RIGHT_HINT_WIDTH_WITH_COUNT, RIGHT_HINT_WIDTH_NO_COUNT);
+    const maxTabsWidth = availableWidth - resumeLabelWidth - rightHintWidth - 2; // 2 for gaps
+    // Clamp selectedIndex to valid range
+    const safeSelectedIndex = Math.max(0, Math.min(selectedIndex, tabs.length - 1));
+    // Calculate width of each tab, with truncation for very long tags
+    const maxSingleTabWidth = Math.max(20, Math.floor(maxTabsWidth / 2)); // At least show half the space for one tab
+    const tabWidths = tabs.map(tab => getTabWidth(tab, maxSingleTabWidth));
+    // Find a window of tabs that fits, centered around selectedIndex
+    let startIndex = 0;
+    let endIndex = tabs.length;
+    // Calculate total width of all tabs
+    const totalTabsWidth = tabWidths.reduce((sum, w, i) => sum + w + (i < tabWidths.length - 1 ? 1 : 0), 0); // +1 for gaps between tabs
+    if (totalTabsWidth > maxTabsWidth) {
+        // Need to show a subset - account for left arrow when not at start
+        const effectiveMaxWidth = maxTabsWidth - LEFT_ARROW_WIDTH;
+        // Start with the selected tab
+        let windowWidth = tabWidths[safeSelectedIndex] ?? 0;
+        startIndex = safeSelectedIndex;
+        endIndex = safeSelectedIndex + 1;
+        // Expand window to include more tabs
+        while (startIndex > 0 || endIndex < tabs.length) {
+            const canExpandLeft = startIndex > 0;
+            const canExpandRight = endIndex < tabs.length;
+            if (canExpandLeft) {
+                const leftWidth = (tabWidths[startIndex - 1] ?? 0) + 1; // +1 for gap
+                if (windowWidth + leftWidth <= effectiveMaxWidth) {
+                    startIndex--;
+                    windowWidth += leftWidth;
+                    continue;
+                }
+            }
+            if (canExpandRight) {
+                const rightWidth = (tabWidths[endIndex] ?? 0) + 1; // +1 for gap
+                if (windowWidth + rightWidth <= effectiveMaxWidth) {
+                    endIndex++;
+                    windowWidth += rightWidth;
+                    continue;
+                }
+            }
+            break;
+        }
+    }
+    const hiddenLeft = startIndex;
+    const hiddenRight = tabs.length - endIndex;
+    const visibleTabs = tabs.slice(startIndex, endIndex);
+    const visibleIndices = visibleTabs.map((_, i_0) => startIndex + i_0);
+    return _jsxs(Box, { flexDirection: "row", gap: 1, children: [_jsx(Text, { color: "suggestion", children: resumeLabel }), hiddenLeft > 0 && _jsxs(Text, { dimColor: true, children: [LEFT_ARROW_PREFIX, hiddenLeft] }), visibleTabs.map((tab_0, i_1) => {
+                const actualIndex = visibleIndices[i_1];
+                const isSelected = actualIndex === safeSelectedIndex;
+                const displayText = tab_0 === ALL_TAB_LABEL ? tab_0 : `#${truncateTag(tab_0, maxSingleTabWidth - TAB_PADDING)}`;
+                return _jsxs(Text, { backgroundColor: isSelected ? 'suggestion' : undefined, color: isSelected ? 'inverseText' : undefined, bold: isSelected, children: [' ', displayText, ' '] }, tab_0);
+            }), hiddenRight > 0 ? _jsxs(Text, { dimColor: true, children: [RIGHT_HINT_WITH_COUNT_PREFIX, hiddenRight, RIGHT_HINT_SUFFIX] }) : _jsx(Text, { dimColor: true, children: RIGHT_HINT_NO_COUNT })] });
+}

package/dist/src/components/TaskListV2.js

@@ -0,0 +1,333 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import * as React from 'react';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { stringWidth } from '../ink/stringWidth.js';
+import { Box, Text } from '../ink.js';
+import { useAppState } from '../state/AppState.js';
+import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js';
+import { AGENT_COLOR_TO_THEME_COLOR } from '../tools/AgentTool/agentColorManager.js';
+import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
+import { count } from '../utils/array.js';
+import { summarizeRecentActivities } from '../utils/collapseReadSearch.js';
+import { truncateToWidth } from '../utils/format.js';
+import { isTodoV2Enabled } from '../utils/tasks.js';
+import ThemedText from './design-system/ThemedText.js';
+const RECENT_COMPLETED_TTL_MS = 30_000;
+function byIdAsc(a, b) {
+    const aNum = parseInt(a.id, 10);
+    const bNum = parseInt(b.id, 10);
+    if (!isNaN(aNum) && !isNaN(bNum)) {
+        return aNum - bNum;
+    }
+    return a.id.localeCompare(b.id);
+}
+export function TaskListV2({ tasks, isStandalone = false }) {
+    const teamContext = useAppState(s => s.teamContext);
+    const appStateTasks = useAppState(s_0 => s_0.tasks);
+    const [, forceUpdate] = React.useState(0);
+    const { rows, columns } = useTerminalSize();
+    // Track when each task was last observed transitioning to completed
+    const completionTimestampsRef = React.useRef(new Map());
+    const previousCompletedIdsRef = React.useRef(null);
+    if (previousCompletedIdsRef.current === null) {
+        previousCompletedIdsRef.current = new Set(tasks.filter(t => t.status === 'completed').map(t_0 => t_0.id));
+    }
+    const maxDisplay = rows <= 10 ? 0 : Math.min(10, Math.max(3, rows - 14));
+    // Update completion timestamps: reset when a task transitions to completed
+    const currentCompletedIds = new Set(tasks.filter(t_1 => t_1.status === 'completed').map(t_2 => t_2.id));
+    const now = Date.now();
+    for (const id of currentCompletedIds) {
+        if (!previousCompletedIdsRef.current.has(id)) {
+            completionTimestampsRef.current.set(id, now);
+        }
+    }
+    for (const id_0 of completionTimestampsRef.current.keys()) {
+        if (!currentCompletedIds.has(id_0)) {
+            completionTimestampsRef.current.delete(id_0);
+        }
+    }
+    previousCompletedIdsRef.current = currentCompletedIds;
+    // Schedule re-render when the next recent completion expires.
+    // Depend on `tasks` so the timer is only reset when the task list changes,
+    // not on every render (which was causing unnecessary work).
+    React.useEffect(() => {
+        if (completionTimestampsRef.current.size === 0) {
+            return;
+        }
+        const currentNow = Date.now();
+        let earliestExpiry = Infinity;
+        for (const ts of completionTimestampsRef.current.values()) {
+            const expiry = ts + RECENT_COMPLETED_TTL_MS;
+            if (expiry > currentNow && expiry < earliestExpiry) {
+                earliestExpiry = expiry;
+            }
+        }
+        if (earliestExpiry === Infinity) {
+            return;
+        }
+        const timer = setTimeout(forceUpdate_0 => forceUpdate_0((n) => n + 1), earliestExpiry - currentNow, forceUpdate);
+        return () => clearTimeout(timer);
+    }, [tasks]);
+    if (!isTodoV2Enabled()) {
+        return null;
+    }
+    if (tasks.length === 0) {
+        return null;
+    }
+    // Build a map of teammate name -> theme color
+    const teammateColors = {};
+    if (isAgentSwarmsEnabled() && teamContext?.teammates) {
+        for (const teammate of Object.values(teamContext.teammates)) {
+            if (teammate.color) {
+                const themeColor = AGENT_COLOR_TO_THEME_COLOR[teammate.color];
+                if (themeColor) {
+                    teammateColors[teammate.name] = themeColor;
+                }
+            }
+        }
+    }
+    // Build a map of teammate name -> current activity description
+    // Map both agentName ("researcher") and agentId ("researcher@team") so
+    // task owners match regardless of which format the model used.
+    // Rolls up consecutive search/read tool uses into a compact summary.
+    // Also track which teammates are still running (not shut down).
+    const teammateActivity = {};
+    const activeTeammates = new Set();
+    if (isAgentSwarmsEnabled()) {
+        for (const bgTask of Object.values(appStateTasks)) {
+            if (isInProcessTeammateTask(bgTask) && bgTask.status === 'running') {
+                activeTeammates.add(bgTask.identity.agentName);
+                activeTeammates.add(bgTask.identity.agentId);
+                const activities = bgTask.progress?.recentActivities;
+                const desc = (activities && summarizeRecentActivities(activities)) ?? bgTask.progress?.lastActivity?.activityDescription;
+                if (desc) {
+                    teammateActivity[bgTask.identity.agentName] = desc;
+                    teammateActivity[bgTask.identity.agentId] = desc;
+                }
+            }
+        }
+    }
+    // Get task counts for display
+    const completedCount = count(tasks, t_3 => t_3.status === 'completed');
+    const pendingCount = count(tasks, t_4 => t_4.status === 'pending');
+    const inProgressCount = tasks.length - completedCount - pendingCount;
+    // Unresolved tasks (open or in_progress) block dependent tasks
+    const unresolvedTaskIds = new Set(tasks.filter(t_5 => t_5.status !== 'completed').map(t_6 => t_6.id));
+    // Check if we need to truncate
+    const needsTruncation = tasks.length > maxDisplay;
+    let visibleTasks;
+    let hiddenTasks;
+    if (needsTruncation) {
+        // Prioritize: recently completed (within 30s), in-progress, pending, older completed
+        const recentCompleted = [];
+        const olderCompleted = [];
+        for (const task of tasks.filter(t_7 => t_7.status === 'completed')) {
+            const ts_0 = completionTimestampsRef.current.get(task.id);
+            if (ts_0 && now - ts_0 < RECENT_COMPLETED_TTL_MS) {
+                recentCompleted.push(task);
+            }
+            else {
+                olderCompleted.push(task);
+            }
+        }
+        recentCompleted.sort(byIdAsc);
+        olderCompleted.sort(byIdAsc);
+        const inProgress = tasks.filter(t_8 => t_8.status === 'in_progress').sort(byIdAsc);
+        const pending = tasks.filter(t_9 => t_9.status === 'pending').sort((a, b) => {
+            const aBlocked = a.blockedBy.some(id_1 => unresolvedTaskIds.has(id_1));
+            const bBlocked = b.blockedBy.some(id_2 => unresolvedTaskIds.has(id_2));
+            if (aBlocked !== bBlocked) {
+                return aBlocked ? 1 : -1;
+            }
+            return byIdAsc(a, b);
+        });
+        const prioritized = [...recentCompleted, ...inProgress, ...pending, ...olderCompleted];
+        visibleTasks = prioritized.slice(0, maxDisplay);
+        hiddenTasks = prioritized.slice(maxDisplay);
+    }
+    else {
+        // No truncation needed — sort by ID for stable ordering
+        visibleTasks = [...tasks].sort(byIdAsc);
+        hiddenTasks = [];
+    }
+    let hiddenSummary = '';
+    if (hiddenTasks.length > 0) {
+        const parts = [];
+        const hiddenPending = count(hiddenTasks, t_10 => t_10.status === 'pending');
+        const hiddenInProgress = count(hiddenTasks, t_11 => t_11.status === 'in_progress');
+        const hiddenCompleted = count(hiddenTasks, t_12 => t_12.status === 'completed');
+        if (hiddenInProgress > 0) {
+            parts.push(`${hiddenInProgress} in progress`);
+        }
+        if (hiddenPending > 0) {
+            parts.push(`${hiddenPending} pending`);
+        }
+        if (hiddenCompleted > 0) {
+            parts.push(`${hiddenCompleted} completed`);
+        }
+        hiddenSummary = ` … +${parts.join(', ')}`;
+    }
+    const content = _jsxs(_Fragment, { children: [visibleTasks.map(task_0 => _jsx(TaskItem, { task: task_0, ownerColor: task_0.owner ? teammateColors[task_0.owner] : undefined, openBlockers: task_0.blockedBy.filter(id_3 => unresolvedTaskIds.has(id_3)), activity: task_0.owner ? teammateActivity[task_0.owner] : undefined, ownerActive: task_0.owner ? activeTeammates.has(task_0.owner) : false, columns: columns }, task_0.id)), maxDisplay > 0 && hiddenSummary && _jsx(Text, { dimColor: true, children: hiddenSummary })] });
+    if (isStandalone) {
+        return _jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: [_jsx(Text, { bold: true, children: tasks.length }), ' tasks (', _jsx(Text, { bold: true, children: completedCount }), ' done, ', inProgressCount > 0 && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: inProgressCount }), ' in progress, '] }), _jsx(Text, { bold: true, children: pendingCount }), ' open)'] }) }), content] });
+    }
+    return _jsx(Box, { flexDirection: "column", children: content });
+}
+function getTaskIcon(status) {
+    switch (status) {
+        case 'completed':
+            return {
+                icon: figures.tick,
+                color: 'success'
+            };
+        case 'in_progress':
+            return {
+                icon: figures.squareSmallFilled,
+                color: 'claude'
+            };
+        case 'pending':
+            return {
+                icon: figures.squareSmall,
+                color: undefined
+            };
+    }
+}
+function TaskItem(t0) {
+    const $ = _c(37);
+    const { task, ownerColor, openBlockers, activity, ownerActive, columns } = t0;
+    const isCompleted = task.status === "completed";
+    const isInProgress = task.status === "in_progress";
+    const isBlocked = openBlockers.length > 0;
+    let t1;
+    if ($[0] !== task.status) {
+        t1 = getTaskIcon(task.status);
+        $[0] = task.status;
+        $[1] = t1;
+    }
+    else {
+        t1 = $[1];
+    }
+    const { icon, color } = t1;
+    const showActivity = isInProgress && !isBlocked && activity;
+    const showOwner = columns >= 60 && task.owner && ownerActive;
+    let t2;
+    if ($[2] !== showOwner || $[3] !== task.owner) {
+        t2 = showOwner ? stringWidth(` (@${task.owner})`) : 0;
+        $[2] = showOwner;
+        $[3] = task.owner;
+        $[4] = t2;
+    }
+    else {
+        t2 = $[4];
+    }
+    const ownerWidth = t2;
+    const maxSubjectWidth = Math.max(15, columns - 15 - ownerWidth);
+    let t3;
+    if ($[5] !== maxSubjectWidth || $[6] !== task.subject) {
+        t3 = truncateToWidth(task.subject, maxSubjectWidth);
+        $[5] = maxSubjectWidth;
+        $[6] = task.subject;
+        $[7] = t3;
+    }
+    else {
+        t3 = $[7];
+    }
+    const displaySubject = t3;
+    const maxActivityWidth = Math.max(15, columns - 15);
+    let t4;
+    if ($[8] !== activity || $[9] !== maxActivityWidth) {
+        t4 = activity ? truncateToWidth(activity, maxActivityWidth) : undefined;
+        $[8] = activity;
+        $[9] = maxActivityWidth;
+        $[10] = t4;
+    }
+    else {
+        t4 = $[10];
+    }
+    const displayActivity = t4;
+    let t5;
+    if ($[11] !== color || $[12] !== icon) {
+        t5 = _jsxs(Text, { color: color, children: [icon, " "] });
+        $[11] = color;
+        $[12] = icon;
+        $[13] = t5;
+    }
+    else {
+        t5 = $[13];
+    }
+    const t6 = isCompleted || isBlocked;
+    let t7;
+    if ($[14] !== displaySubject || $[15] !== isCompleted || $[16] !== isInProgress || $[17] !== t6) {
+        t7 = _jsx(Text, { bold: isInProgress, strikethrough: isCompleted, dimColor: t6, children: displaySubject });
+        $[14] = displaySubject;
+        $[15] = isCompleted;
+        $[16] = isInProgress;
+        $[17] = t6;
+        $[18] = t7;
+    }
+    else {
+        t7 = $[18];
+    }
+    let t8;
+    if ($[19] !== ownerColor || $[20] !== showOwner || $[21] !== task.owner) {
+        t8 = showOwner && _jsxs(Text, { dimColor: true, children: [" (", ownerColor ? _jsxs(ThemedText, { color: ownerColor, children: ["@", task.owner] }) : `@${task.owner}`, ")"] });
+        $[19] = ownerColor;
+        $[20] = showOwner;
+        $[21] = task.owner;
+        $[22] = t8;
+    }
+    else {
+        t8 = $[22];
+    }
+    let t9;
+    if ($[23] !== isBlocked || $[24] !== openBlockers) {
+        t9 = isBlocked && _jsxs(Text, { dimColor: true, children: [" ", figures.pointerSmall, " blocked by", " ", [...openBlockers].sort(_temp).map(_temp2).join(", ")] });
+        $[23] = isBlocked;
+        $[24] = openBlockers;
+        $[25] = t9;
+    }
+    else {
+        t9 = $[25];
+    }
+    let t10;
+    if ($[26] !== t5 || $[27] !== t7 || $[28] !== t8 || $[29] !== t9) {
+        t10 = _jsxs(Box, { children: [t5, t7, t8, t9] });
+        $[26] = t5;
+        $[27] = t7;
+        $[28] = t8;
+        $[29] = t9;
+        $[30] = t10;
+    }
+    else {
+        t10 = $[30];
+    }
+    let t11;
+    if ($[31] !== displayActivity || $[32] !== showActivity) {
+        t11 = showActivity && displayActivity && _jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["  ", displayActivity, figures.ellipsis] }) });
+        $[31] = displayActivity;
+        $[32] = showActivity;
+        $[33] = t11;
+    }
+    else {
+        t11 = $[33];
+    }
+    let t12;
+    if ($[34] !== t10 || $[35] !== t11) {
+        t12 = _jsxs(Box, { flexDirection: "column", children: [t10, t11] });
+        $[34] = t10;
+        $[35] = t11;
+        $[36] = t12;
+    }
+    else {
+        t12 = $[36];
+    }
+    return t12;
+}
+function _temp2(id) {
+    return `#${id}`;
+}
+function _temp(a, b) {
+    return parseInt(a, 10) - parseInt(b, 10);
+}